X++ operátory

Poznámka:

Skupiny zájmu komunity se teď přesunuly z Yammeru na Microsoft Viva Engage. Pokud se chcete připojit k komunitě Viva Engage a účastnit se nejnovějších diskuzí, vyplňte formulář Žádost o přístup k aplikaci Finance and Operations Viva Engage Community a zvolte komunitu, ke které se chcete připojit.

Tento článek popisuje operátory podporované v X++.

Operátory přiřazení

Přiřazení změní hodnotu proměnné nebo pole. Následující tabulka ukazuje operátory přiřazení X++. Mezi operátory předpony a přípony není žádný rozdíl.

Operator	Description
=	Přiřaďte výraz vpravo od symbolu rovná se proměnné na levé straně.
+=	Přiřaďte aktuální hodnotu proměnné plus výraz vpravo k proměnné vlevo.
++	Zvýší proměnnou o 1.
-=	Přiřaďte aktuální hodnotu proměnné minus výraz vpravo k proměnné vlevo.
--	Dekrementace proměnné o 1.

Příklady kódu pro operátory přiřazení

// An example of assignment operators and their output. 
static void Example1()
{
    int i = 1;
    // Using the = operator. i is assigned the value of i, plus 1. i = 2.
    i = i + 1;
    info(strFmt("Example 1: The result is "), i); // The result is 2.
}

static void Example2()
{
    int i = 1;
    // Using the += operator. i is assigned the value of i, plus 1. 
    // i = 2 (i = i + 1).
    i += 1;
    info(strFmt("Example 2: The result is "), i); // The result is 2. 
}

static void Example3()
{
    int i = 1;
    // Using the ++ operator. i is incremented by 1, and then 
    // by 1 again in the second statement. The final value of i is 3.
    i++;
    ++i;
    info(strFmt("Example 3: The result is "), i); // The result is 3. 
}

static void Example4()
{
    int i = 1;
    // Using the -= operator. i is assigned the value of i minus 1. 
    // i = 0 (i = i - 1).
    i -= 1;
    info(strFmt("Example 4: The result is "), i); // The result is 0. 
}

static void Example5()
{
    int i = 1;
    // Using the -- operator. i is decremented by 1, and then by 
    // 1 again in the second statement. The final value of i is -1.
    i--;
    --i;
    info(strFmt("Example 5: The result is "), i); // The result is -1. 
}

Aritmetické operátory

K provádění číselných výpočtů se používají aritmetické operátory. Většina operátorů je binární a má dva operandy. Operátor not (~) je však unární a přijímá pouze jeden operand. Syntaxe binárních operátorů: výraz1AritmeticOperatorexpression2 Syntaxe pro unární operátory: AritmeticOperatorexpression1

Operator	Description
<<	Operátor levého posunu provádí výraz 2 levý posun (násobení 2) ve výrazu 1.
>>	Operátor pravého posunu provádí výraz2 pravý posun (dělení o 2) ve výrazu 1.
*	Operátor násobení vynásobí výraz1 výrazem expression2.
/	Operátor dělení vydělí výraz 1 výrazem 2.
DIV	Operátor dělení celého čísla provádí celočíselné dělení výrazu1 podle výrazu2.
MOD	Operátor zbytku celého čísla vrátí zbytek celočíselného dělení výrazu 1 podle výrazu2.
~	Operátor not nebo unární operátor provádí binární operaci, nikoli operaci.
&	Binární operátor AND provede binární a operaci s výrazem expression1 a expression2.
^	Binární operátor XOR provádí binární operaci XOR ve výrazu1 a výraz2.
|	Binární operátor OR provádí binární nebo operaci s výrazem expression1 a expression2.
+	Operátor plus přidá výraz1 do výrazu 2.
-	Operátor minus odečte výraz2 od výrazu 1.
?	Ternární operátor přebírá tři výrazy: expression1 ? výraz2 : výraz3. Pokud je výraz1 pravdivý, vrátí se výraz 2 . V opačném případě se vrátí výraz 3 .

Příklady kódu pro aritmetické operátory

int a = 1 << 4;      // Perform four left shifts on 1 (1*2*2*2*2). a=16.
int b = 16 >> 4;     // Perform four right shifts on 16 (16/2/2/2/2). b=1.
int c = 4 * 5;       // Multiply 4 by 5. c=20.
int d = 20 / 5;      // Divide 20 by 5. d=4.
int e = 100 div 21;  // Return the integer division of 100 by 21. e=4 (4*21 = 84, remainder 16).
int f = 100 mod 21;  // Return the remainder of the integer division of 100 by 21. f=16.
int g = ~1;          // Binary negate 1 (all bits are reversed). g=-2.
int h = 1 & 3;       // Binary AND. Return the bits that are in common in the two integers. h=1.
int i = 1 | 3;       // Binary OR. Return the bits that are set in either 1 or 3. i=3.
int j = 1 ^ 3;       // Binary XOR. Return the bits that are set in 1 and NOT set in 3, and vice versa. j=2.
int k = 1 + 3;       // Add 1 and 3. k=4.
int l = 3 - 1;       // Subtract 1 from 3. l=2.
int m = (400 > 4) ? 1 : 5;  // If 400>4, 1 is returned. Otherwise, 5 is returned. Because 400>4, 1 is returned. m=1.

Operátory výrazů

Operátory výrazů asis řídí přiřazení downcastu. Přiřazení downcastu zahrnují dědičnost tříd nebo tabulek. Příkazy přiřazení, které implicitně downcastují, můžou způsobit chyby, které se obtížně predikují a diagnostikují. Pomocí klíčového as slova můžete nastavit explicitní downcasty. Klíčové slovo můžete použít is k otestování platnosti downcastu za běhu.

Klíčové slovo As

as Klíčové slovo použijte pro přiřazení, která jsou mimosměrová z proměnné základní třídy na odvozenou proměnnou třídy. Klíčové as slovo říká ostatním programátorům a kompilátoru, že se domníváte, že downcast bude platný během běhu.

• Kompilátor hlásí chybu pro příkazy přiřazení downcastu, které nemají as klíčové slovo.
• V době běhu klíčové slovo způsobí, as že příkaz přiřazení downcastu přiřadí null , pokud downcast není platný.
• Toto is klíčové slovo se často používá k bezpečnému testování, jestli as bude klíčové slovo fungovat.

Příklad kódu pro klíčové slovo

V následujícím příkladu kódu třída DerivedClass rozšiřuje Třídu BaseClass . Příklad kódu obsahuje dvě platná přiřazení mezi jeho základní a odvozené proměnné. Přiřazení upcastu k basec nevyžaduje as klíčové slovo, ale přiřazení downcastu k as sadě vyžaduje klíčové slovo. Následující kód se zkompiluje a spustí bez chyb.

static void AsKeywordExample()
{
    // DerivedClass extends BaseClass.
    BaseClass basec;
    DerivedClass derivedc;
    // BottomClass extends DerivedClass.
    BottomClass bottomc;
    derivedc = new DerivedClass();
    // AS is not required for an upcast assignment like this.
    basec = derivedc;
    // AS is required for a downcast assignment like this.
    derivedc = basec as DerivedClass;
    bottomc = new BottomClass();
    // AS causes this invalid downcast to assign null.
    bottomc = basec as DerivedClass;
}

Klíčové slovo

Klíčové is slovo ověřuje, zda je objekt podtyp zadané třídy. Výraz is vrátí hodnotu true , pokud je objekt podtyp třídy, nebo pokud je objekt stejného typu jako třída. Kompilátor hlásí chybu, pokud výraz klíčového is slova porovnává dva typy, ale ani jeden typ není podtyp druhého typu a nejsou stejného typu. Kompilátor hlásí podobnou chybu pro jakýkoli příkaz prostého přiřazení mezi dvěma typy, kde ani jeden typ není podtyp druhého typu a nejsou stejného typu. V době běhu je typ proměnné, která odkazuje na podkladový objekt, pro klíčové slovo irelevantní is . Klíčové is slovo způsobí, že systém ověří objekt, že proměnná odkazuje, nikoli deklarovaný typ proměnné, která odkazuje na objekt.

Příklady kódu pro klíčové slovo

Následující příklady kódu ilustrují podmínky, které řídí, zda is výraz vrátí hodnotu true nebo false. Příklady kódu závisí na skutečnosti, že Form třída a Query třídy obě rozšiřují TreeNode třídy.

// The compiler issues an error for the following code. 
// The compiler ascertains that the Form class and the Query class are not 
// part of the same inheritance hierarchy. Both the Form class and the Query class
// extend the TreeNode class, but neither Form nor Query is a subtype of the other.
Form myForm = new Form();
info(strFmt("%1", (myForm is Query)));

// The Infolog displays 0 during run time, where 0 means false. No supertype 
// object can be considered to also be of its subtype class.
TreeNode myTreeNode = new TreeNode();
info(strFmt("%1", (myTreeNode is Form)));

// The Infolog displays 0 during run time, where 0 means false. A null 
// reference causes the is expression to return false.
Form myForm;
info(strFmt("%1", (myForm is Form)));

// The Infolog displays 1 during run time, where 1 means true. 
// An object is an instance of its own class type.
Form myForm = new Form();
info(strFmt("%1", (myForm is Form)));

// The Infolog displays 1 during run time, where 1 means true. 
// Every subtype is also of its supertype.
Form myForm = new Form();
info(strFmt("%1", (myForm is TreeNode)));

// The Infolog displays 1 during run time, where 1 means true. 
// The type of the underlying object matters in the is expression,
// not the type of the variable that references the object.
Form myForm = new Form();
TreeNode myTreeNode;
myTreeNode = myForm; // Upcast.
info(strFmt("%1", (myTreeNode is Form)));

Příklad kódu je a jako klíčová slova

Následující příklad kódu obsahuje typické použití klíčového is slova. Klíčové as slovo se použije poté, co is klíčové slovo ověří, že as klíčové slovo bude úspěšné. V tomto příkladu isas jsou klíčová slova velká písmena, aby byly viditelné.

static void IsKeywordExample() 
{
    DerivedClass derivedc;
    BaseClass basec;
    basec = new DerivedClass();  // An upcast.
    if (basec IS DerivedClass)
    {
        info("Test 1: (basec IS DerivedClass) is true. Good.");
        derivedc = basec AS DerivedClass;
    }
    basec = new BaseClass();
    if (!(basec IS DerivedClass))
    {
        info("Test 2: !(basec IS DerivedClass) is true. Good.");
    }
}

//Output to the Infolog
Test 1: (basec IS DerivedClass) is true. Good.
Test 2: (!(basec IS DerivedClass)) is true. Good.

Třída objektu jako speciální případ

Třída Object se může objevit jako zvláštní případ v dědičnosti funkce. Kompilátor obchází kontrolu typů přiřazení k proměnným, které jsou deklarovány jako typ Object. Některé třídy dědí z třídy Object , některé třídy dědí z jiné třídy a některé třídy nedědí z žádné třídy. Ačkoli dialog třída nedědí z žádné třídy, přiřazení a volání příkazy v následujícím příkladu kódu fungují. Pokud je bank4 = dlog3;však přiřazení , selže v době kompilace, protože třídy Bank and Dialog nemají žádný vztah dědičnosti k sobě. Kompilátor provádí pouze jedno malé ověření přiřazení k proměnné, která je deklarována jako třída Object . Kompilátor ověří, že položka, která je přiřazena k proměnné Object je instance třídy. Kompilátor neumožňuje přiřazení instance vyrovnávací paměti tabulky k proměnné Object . Kompilátor navíc neumožňuje přiřazení primitivních datových typů, například int nebo str, k proměnné Object .

static void ObjectExample()
{
    Bank bank4;
    Object obj2;
    Dialog dlog3 = new Dialog("Test 4.");
    obj2 = dlog3;  // The assignment does work.
    obj2.run(false);  // The call causes the dialog to appear.
    info("Test 4a is finished.");
}

Tables

Všechny tabulky dědí přímo ze systémové tabulky Common, pokud explicitně nedědí z jiné tabulky. Tabulku Common nelze vytvořit. V podkladové fyzické databázi neexistuje. Tabulka Common dědí z třídy xRecord , ale zvláštním způsobem, který není vhodný pro is klíčové slovo nebo as klíčové slovo. as Pokud se klíčové slovo používá k provedení neplatného downcastu mezi tabulkami, cílová proměnná odkazuje na nepoužitelnou entitu, která není null. Jakýkoli pokus o zrušení odkazu na cílovou proměnnou způsobí chybu, která program zastaví.

Jedná se o klíčová slova a rozšířené datové typy.

Každý rozšířený datový typ má vlastnost Extends . Styl dědičnosti, pro kterou tato vlastnost řídí, se liší od stylu dědičnosti, pro kterou isas jsou tato klíčová slova navržena.

Relační operátory

Následující tabulka uvádí relační operátory, které lze použít v X++. Většina operátorů je binární a má dva operandy. Operátor not (!) je však unární a přijímá pouze jeden operand. Syntaxe binárních operátorů: expression1relationalOperatorexpression2 Syntaxe pro unární operátory: relationalOperatorexpression1

Operator	Description
like	Relační operátor like vrátí hodnotu true , pokud je výraz1 podobný výrazu 2.
==	Relační operátor rovná se vrátí true , pokud jsou oba výrazy stejné.
>=	Relační operátor vrátí hodnotu true, pokud je výraz1 větší nebo roven výrazu 2.
<=	Relační operátor vrátí hodnotu true, pokud je výraz1 menší nebo roven výrazu 2.
>	Relační operátor vrátí hodnotu true, pokud je výraz1 větší než výraz2.
<	Relační operátor vrátí hodnotu true, pokud je výraz1 menší než výraz2.
!=	Nerelační operátor nerovná se vrátí true , pokud se výraz1 liší od výrazu (to znamená, že není rovno) výrazu 2.
&&	Relační operátor vrátí hodnotu true, pokud je pravdivý výraz1 i výraz2.
||	Relační operátor vrátí hodnotu true, pokud je výraz1 nebo výraz2 pravdivý, nebo pokud jsou splněné oba.
!	Ne nebo unární relační operátor neguje výraz. Vrátí hodnotu true , pokud je výraz false a false , pokud je výraz pravdivý.

Operátor like

Operátor like může použít * jako zástupný znak pro nula nebo více znaků a ? jako zástupný znak pro jeden znak. Maximální délka operandu je 1 000 znaků. Operátor like se vyhodnocuje pomocí základního SQL, takže se výsledek může lišit v různých instalacích. Pokud výrazy, které porovnáváte, obsahují cestu k souboru, musíte mezi každým prvkem zahrnout čtyři zpětná lomítka, jak je znázorněno v následujícím příkladu.

select * from xRefpaths
where xRefPaths.Path like "\\\\Classes\\\\AddressSelectForm"

Operátor rovná se (==)

Při použití operátoru rovná se (==) k porovnání objektů jsou porovnávány odkazy na objekty, nikoli samotné objekty. Toto chování může způsobit problémy, pokud porovnáte dva objekty, jeden z nich se nachází na serveru a druhý z nich se nachází v klientovi. V těchto případech byste měli použít stejnou metodu ve třídě Object . Tuto metodu můžete přepsat, abyste určili, co znamená pro dva objekty, které se mají rovnat. Pokud nepřepíšete stejnou metodu, je porovnání stejné jako porovnání, které provádí operátor rovná se (==).

Příklady kódu pro relační operátory

"Jones" like "Jo?es"  // Returns true, because the ? is equal to any single character.
"Fabrikam, Inc." like "Fa*"  // Returns true, because the * is equal to zero or more characters.
(( 42 * 2) == 84)  // Returns true, because 42*2 is equal to 84.
today() >= 1\1\1980  // Returns true, because today is later than January 1, 1980.
((11 div 10) >= 1)  // Returns true, because 11 div 10 is 1 (therefore, >= 1 is true).
(11<= 12)  // Returns true, because 11 is less than 12.
((11 div 10) > 1)  // Returns false, because 11 div 10 is 1.
(11 div 10) < 1)  // Returns false, because 11 div 10 is 1.
(11 != 12)  // Returns true, because 11 is not equal to 12.
(1 == 1) && (3 > 1)  // Returns true, because both expressions are true.

Priorita operátorů

Pořadí, ve které je složený výraz vyhodnocen, může být důležité. (x + y / 100) Například dává jiný výsledek v závislosti na tom, jestli se sčítání nebo dělení provádí jako první. Pomocí závorek (()) můžete kompilátoru explicitně sdělit, jak by měl výraz vyhodnotit. Můžete například zadat (x + y) / 100. Pokud kompilátoru explicitně neřeknete pořadí, ve které chcete provádět operace, je pořadí založeno na prioritě přiřazené operátorům. Operátor dělení má například vyšší prioritu než operátor sčítání. Proto pro výraz x + y / 100kompilátor vyhodnotí y / 100 jako první. Jinými slovy, x + y / 100 je ekvivalentní x + (y / 100). Aby byl kód snadno čitelný a udržovatelný, buďte explicitní. Pomocí závorek označte, které operátory se mají vyhodnotit jako první. Následující tabulka uvádí operátory v pořadí podle priority. Čím vyšší je operátor v tabulce, tím vyšší má přednost. Operátory s vyšší prioritou se vyhodnocují před operátory, které mají nižší prioritu. Všimněte si, že priorita operátoru X++ není stejná jako priorita operátoru v jiných jazycích, jako je C# a Java.

Skupiny operátorů v pořadí podle priority	Operátoři
Unary	- ~ !
Multiplikativní, posun, bitový operátor AND, bitový exkluzivní operátor OR	* / % DIV << >> & ^
Přídatná, bitové inkluzivní OR	+ - |
Relační, rovnost	< <= == != > >= like as is
Logická hodnota (AND, OR)	&& ||
Podmíněný	? :

Operátory na stejném řádku mají stejnou prioritu. Pokud výraz obsahuje více než jeden z těchto operátorů, vyhodnotí se zleva doprava, pokud se nepoužívají operátory přiřazení. (Operátory přiřazení se vyhodnocují zprava doleva.) Například && (logická) a AND (logická||OR) mají stejnou prioritu a vyhodnocují se zleva doprava. Therefore:

• 0 && 0 || 1 rovná se 1
• 1 || 0 && 0 je rovno 0.