Dela via

Operatorer för X++

Anmärkning

Intressegrupper för communityn har nu flyttat från Yammer till Microsoft Viva Engage. Om du vill gå med i en Viva Engage-community och delta i de senaste diskussionerna fyller du i formuläret Begär åtkomst till Finance and Operations Viva Engage Community och väljer den community som du vill ansluta till.

I den här artikeln beskrivs de operatorer som stöds i X++.

Tilldelningsoperatorer

En tilldelning ändrar värdet för en variabel eller ett fält. I följande tabell visas X++-tilldelningsoperatorerna. Det finns ingen skillnad mellan prefix- och postfixoperatorer.

Operator Description
= Tilldela uttrycket till höger om likhetstecknet till variabeln till vänster.
+= Tilldela det aktuella variabelvärdet plus uttrycket till höger till variabeln till vänster.
++ Öka variabeln med 1.
-= Tilldela det aktuella variabelvärdet minus uttrycket till höger till variabeln till vänster.
-- Minska variabeln med 1.

Kodexempel för tilldelningsoperatorer

// 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. 
}

Aritmetiska operatorer

Du använder aritmetiska operatorer för att utföra numeriska beräkningar. De flesta operatorerna är binära och tar två operander. Men operatorn inte (~) är unary och tar bara en operand. Syntax för binära operatorer: expression1ArithmeticOperatorexpression2 Syntax för unary operatorer: ArithmeticOperatorexpression1

Operator Description
<< Operatorn för vänster skift utför expression2 left shift (multiplikation med 2) på expression1.
>> Höger skiftoperator utför expression2 right shift (division by 2) på expression1.
* Multiplikationsoperatorn multiplicerar uttryck1 med uttryck2.
/ Dividera operatorn delar uttryck1 med uttryck2.
DIV Heltalsdivisionsoperatorn utför en heltalsdivision av expression1 efter expression2.
MOD Heltals restoperatorn returnerar resten av en heltalsdivision av expression1 efter expression2.
~ Operatorn not , or unary, utför en binär icke-åtgärd.
& Den binära AND-operatorn utför en binär och åtgärd på expression1 och expression2.
^ Den binära XOR-operatorn utför en binär XOR-åtgärd på expression1 och expression2.
| Operatorn binary OR utför en binär eller åtgärd på expression1 och expression2.
+ Plusoperatorn lägger till expression1 i expression2.
- Minusoperatorn subtraherar expression2 från expression1.
? Operatorn ternary tar tre uttryck: expression1 ? expression2 : expression3. Om expression1 är sant returneras expression2 . Annars returneras expression3 .

Kodexempel för aritmetiska operatorer

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.

Uttrycksoperatorer

Operatorerna as och is uttrycken styr nedslagna tilldelningar. Nedcastade tilldelningar omfattar klass- eller tabellarv. Tilldelningsuttryck som implicit nedarbetas kan orsaka fel som är svåra att förutsäga och diagnostisera. Du kan använda nyckelordet as för att göra nedslagen explicita. Du kan använda nyckelordet is för att testa om en nedslagen är giltig vid körning.

Nyckelordet som

Använd nyckelordet as för tilldelningar som nedarbetas från en basklassvariabel till en härledd klassvariabel. Nyckelordet as talar om för andra programmerare och kompilatorn att du tror att nedslaget kommer att vara giltigt under körningen.

  • Kompilatorn rapporterar ett fel för nedarbetade tilldelningsinstruktioner som saknar nyckelordet as .
  • Vid körningen gör nyckelordet as att instruktionen för nedarbetad tilldelning tilldelas null om nedslaget inte är giltigt.
  • Det här is nyckelordet används ofta för att på ett säkert sätt testa om nyckelordet as fungerar.

Kodexempel för nyckelordet som

I följande kodexempel utökar klassen DerivedClass klassen BaseClass . Kodexemplet innehåller två giltiga tilldelningar mellan dess basec - och derivedc-variabler . Den uppcastade tilldelningen till basec kräver inte nyckelordet as , men den nedslagna tilldelningen till derivedc kräver nyckelordet as . Följande kod kompileras och körs utan fel.

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;
}

är nyckelordet

Nyckelordet is verifierar om ett objekt är en undertyp av en angiven klass. Uttrycket is returnerar sant om objektet är en undertyp av klassen, eller om objektet är av samma typ som klassen. Kompilatorn rapporterar ett fel om ett is nyckelordsuttryck jämför två typer, men ingen av typerna är en undertyp av den andra, och de är inte av samma typ. Kompilatorn rapporterar ett liknande fel för en vanlig tilldelningssats mellan två typer, där ingen av typerna är en undertyp av den andra och de inte är av samma typ. Vid körning är den typ av variabel som refererar till det underliggande objektet irrelevant för nyckelordet is . Nyckelordet is gör att systemet verifierar objektet som variabeln refererar till, inte den deklarerade typen av variabel som refererar till objektet.

Kodexempel för är nyckelordet

Följande kodexempel illustrerar de villkor som styr om ett is uttryck returnerar sant eller falskt. Kodexemplen beror på att klassen Form och klassen Query båda utökar klassen TreeNode .

// 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)));

Kodexempel för är och som nyckelord

Följande kodexempel innehåller en typisk användning av nyckelordet is . Nyckelordet as används när nyckelordet is verifierar att nyckelordet as lyckas. I det här exemplet är nyckelorden is och as versaler för att göra dem mer synliga.

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.

Objektklass som specialfall

Klassen Object kan visas som ett specialfall i arvsfunktionen. Kompilatorn kringgår typkontroll för tilldelningar till och från variabler som deklareras vara av typen Objekt. Vissa klasser ärver från klassen Object , vissa klasser ärver från en annan klass och vissa klasser ärver inte från någon klass. Även om klassen Dialog inte ärver från någon klass fungerar tilldelnings- och anropsinstruktionerna i följande kodexempel. Men om tilldelningen är bank4 = dlog3;misslyckas den vid kompileringstillfället eftersom klasserna Bank och Dialog inte har någon arvsrelation till varandra. Kompilatorn utför bara en liten validering av tilldelningar till en variabel som deklareras vara av klassen Object . Kompilatorn verifierar att objektet som tilldelas till objektvariabeln är en instans av en klass. Kompilatorn tillåter inte att en instans av en tabellbuffert tilldelas till objektvariabeln . Kompilatorn tillåter inte heller att primitiva datatyper, till exempel int eller str, tilldelas till objektvariabeln .

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

Alla tabeller ärver direkt från common-systemtabellen, såvida de inte uttryckligen ärver från en annan tabell. Det går inte att instansiera common-tabellen. Den finns inte i den underliggande fysiska databasen. Common-tabellen ärver från klassen xRecord , men på ett speciellt sätt som inte är lämpligt för nyckelordet is eller nyckelordet as . När nyckelordet as används för att utföra ett ogiltigt nedkast mellan tabeller refererar målvariabeln till en oanvändbar icke-null-entitet. Alla försök att avreferenser till målvariabeln orsakar ett fel som stoppar programmet.

är och som nyckelord och utökade datatyper

Varje utökad datatyp har en extends-egenskap . Arvsformatet som den här egenskapen styr skiljer sig från den arvsstil som nyckelorden is och as är utformade för.

Relationsoperatorer

I följande tabell visas de relationsoperatorer som kan användas i X++. De flesta operatorerna är binära och tar två operander. Men operatorn inte (!) är unary och tar bara en operand. Syntax för binära operatorer: expression1relationalOperatorexpression2 Syntax för unary operatorer: relationalOperatorexpression1

Operator Description
like Operatorn like relational returnerar true om expression1 är som expression2.
== Relationsoperatorn equal returnerar true om båda uttrycken är lika.
>= Den större än eller lika med relationsoperatorn returnerar sant om expression1 är större än eller lika med expression2.
<= Den mindre än eller lika med relationsoperatorn returnerar sant om uttrycket1 är mindre än eller lika med expression2.
> Den större än relationsoperatorn returnerar true om expression1 är större än expression2.
< Den mindre än relationsoperatorn returnerar true om expression1 är mindre än expression2.
!= Den inte lika med relationsoperatorn returnerar true om expression1 skiljer sig från (dvs. om det inte är lika med) uttryck2.
&& Relationsoperatorn och returnerar sant om både expression1 och expression2 är sanna.
|| Relationsoperatorn eller returnerar sant om expression1 eller expression2 är sant, eller om båda är sanna.
! Den inte eller unary relationsoperatorn negerar uttrycket. Det returnerar sant om uttrycket är falskt och falskt om uttrycket är sant.

Like-operatorn

Operatorn like kan använda * som jokertecken för noll eller fler tecken och ? som jokertecken för ett tecken. Operandernas maximala längd är 1 000 tecken. Operatorn like utvärderas av den underliggande SQL-filen, så resultatet kan skilja sig åt vid olika installationer. Om de uttryck som du jämför innehåller en filsökväg måste du inkludera fyra omvänt snedstreck mellan varje element, enligt följande exempel.

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

Operatorn lika med (==)

När du använder operatorn equal (==) för att jämföra objekt jämförs objektreferenserna, inte själva objekten. Det här beteendet kan orsaka problem om du jämför två objekt, varav ett finns på servern och det andra finns på klienten. I dessa fall bör du använda samma metod i klassen Object . Du kan åsidosätta den här metoden för att ange vad det innebär för två objekt att vara lika med. Om du inte åsidosätter likhetsmetoden är jämförelsen identisk med jämförelsen som utförs av operatorn equal (==).

Kodexempel för relationsoperatorer

"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.

Operatorernas prioritet

Ordningen som ett sammansatt uttryck utvärderas i kan vara viktig. Ger till exempel (x + y / 100) ett annat resultat, beroende på om tillägget eller divisionen görs först. Du kan använda parenteser (()) för att uttryckligen tala om för kompilatorn hur det ska utvärdera ett uttryck. Du kan till exempel ange (x + y) / 100. Om du inte uttryckligen meddelar kompilatorn den ordning som du vill att åtgärder ska utföras i baseras ordningen på prioriteten som tilldelas operatorerna. Till exempel har divisionsoperatorn högre prioritet än additionsoperatorn. Därför utvärderas x + y / 100 kompilatorn först för uttryckety / 100. Med andra ord x + y / 100 motsvarar x + (y / 100). Var explicit för att göra koden enkel att läsa och underhålla. Använd parenteser för att ange vilka operatorer som ska utvärderas först. I följande tabell visas operatorerna i prioritetsordning. Desto högre en operator visas i tabellen, desto högre prioritet. Operatorer som har högre prioritet utvärderas före operatorer som har lägre prioritet. Observera att operatorprioriteten för X++ inte är samma som operatorprioriteten för andra språk, till exempel C# och Java.

Operatorgrupper i prioritetsordning Operatörer
Unary - ~ !
Multiplicativ, skift, bitvis OCH, bitvis exklusiv ELLER * / % DIV << >> & ^
Additiv, bitvis inkluderande ELLER + - |
Relationell, likhet < <= == != > >= like as is
Logiska (OCH, ELLER) && ||
Villkorlig ? :

Operatorer på samma rad har samma prioritet. Om ett uttryck innehåller fler än en av dessa operatorer utvärderas det från vänster till höger, såvida inte tilldelningsoperatorer används. (Tilldelningsoperatorer utvärderas från höger till vänster.) Till exempel && har (logiska AND) och || (logiska OR) samma prioritet och utvärderas från vänster till höger. Therefore:

  • 0 && 0 || 1 är lika med 1
  • 1 || 0 && 0 är lika med 0.
  • Last updated on