Delen via

X++-operatoren

Opmerking

Community-belangengroepen zijn nu verplaatst van Yammer naar Microsoft Viva Engage. Als u wilt deelnemen aan een Viva Engage-community en deel wilt nemen aan de meest recente discussies, vult u het formulier Toegang aanvragen tot Finance and Operations Viva Engage Community in en kiest u de community waaraan u wilt deelnemen.

In dit artikel worden de operators beschreven die worden ondersteund in X++.

Toewijzingsoperatoren

Een toewijzing wijzigt de waarde van een variabele of veld. In de volgende tabel ziet u de X++-toewijzingsoperatoren. Er is geen verschil tussen voor- en navoegseloperators.

Operator Description
= Wijs de expressie rechts van het gelijkteken toe aan de variabele aan de linkerkant.
+= Wijs de huidige variabelewaarde plus de expressie aan de rechterkant toe aan de variabele aan de linkerkant.
++ Verhoog de variabele met 1.
-= Wijs de huidige variabelewaarde toe min de expressie aan de rechterkant van de variabele aan de linkerkant.
-- De variabele met 1 verlagen.

Codevoorbeelden voor toewijzingsoperatoren

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

Rekenkundige operators

U gebruikt rekenkundige operatoren om numerieke berekeningen uit te voeren. De meeste operators zijn binair en nemen twee operanden. De operator not (~) is echter unaire en neemt slechts één operand. Syntaxis voor binaire operatoren: expression1ArithmeticOperatorexpression2 Syntaxis voor unaire operators: ArithmeticOperatorexpression1

Operator Description
<< De operator voor linkerdienst voert expressie2 linker shift (vermenigvuldiging met 2) uit op expressie1.
>> De rechter shift-operator voert expressie2 rechter shift (deling door 2) uit op expressie1.
* De vermenigvuldigingsoperator vermenigvuldigt expressie1 met expressie2.
/ De scheidingsoperator deelt expressie1 door expressie2.
DIV De operator voor het delen van gehele getallen voert een geheel getal van expressie1 uit op expressie2.
MOD De operator voor de rest van het gehele getal retourneert de rest van een geheel getal van expressie1 op expressie2.
~ De operator die geen operator of unaire operator is, voert een binaire not-bewerking uit.
& De binaire AND-operator voert een binaire bewerking uit op expressie1 en expressie2.
^ De binaire XOR-operator voert een binaire XOR-bewerking uit op expressie1 en expressie2.
| De binaire OF-operator voert een binaire bewerking uit op expressie1 en expressie2.
+ De plus-operator voegt expressie1 toe aan expressie2.
- Met de min-operator wordt expressie2 afgetrokken van expressie1.
? De ternaire operator heeft drie expressies: expression1 ? expressie2 : expressie3. Als expressie1 waar is, wordt expressie2 geretourneerd. Anders wordt expressie3 geretourneerd.

Codevoorbeelden voor rekenkundige operatoren

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.

Operatoren voor expressies

De as operators en is expressies beheren downcast-toewijzingen. Downcast-toewijzingen hebben betrekking op overname van klassen of tabellen. Toewijzingsinstructies die impliciet downcasten kunnen leiden tot fouten die moeilijk te voorspellen en diagnosticeren zijn. U kunt het as trefwoord gebruiken om uw downcasts expliciet te maken. U kunt het is trefwoord gebruiken om te testen of een downcast tijdens runtime geldig is.

Het als-trefwoord

Gebruik het as trefwoord voor toewijzingen die downcasten van een basisklassevariabele naar een afgeleide klassevariabele. Het as trefwoord vertelt andere programmeurs en de compiler dat u denkt dat de downcast tijdens de runtime geldig is.

  • De compiler rapporteert een fout voor downcast-toewijzingsinstructies die het as trefwoord ontbreken.
  • Tijdens runtime zorgt het as trefwoord ervoor dat de downcast-toewijzingsinstructie wordt toegewezen null als de downcast niet geldig is.
  • Dit is trefwoord wordt vaak gebruikt om veilig te testen of het as trefwoord werkt.

Codevoorbeeld voor het als trefwoord

In het volgende codevoorbeeld breidt de klasse DerivedClass de BaseClass-klasse uit. Het codevoorbeeld bevat twee geldige toewijzingen tussen de basec - en afgeleide variabelen . Voor de upcast-toewijzing naar as is geen trefwoord vereist, maar de downcast-toewijzing aan afgeleidec vereist wel het as trefwoord. Met de volgende code wordt zonder fouten gecompileerd en uitgevoerd.

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

Het trefwoord is

Het is trefwoord controleert of een object een subtype van een opgegeven klasse is. De is expressie retourneert true als het object een subtype van de klasse is of als het object hetzelfde type is als de klasse. De compiler rapporteert een fout als een is trefwoordexpressie twee typen vergelijkt, maar geen van beide typen een subtype van het andere is en ze niet van hetzelfde type zijn. De compiler rapporteert een vergelijkbare fout voor een toewijzingsinstructie zonder opmaak tussen twee typen, waarbij geen van beide typen een subtype van het andere is en ze niet van hetzelfde type zijn. Tijdens runtime is het type variabele dat verwijst naar het onderliggende object niet relevant voor het is trefwoord. Het is trefwoord zorgt ervoor dat het systeem het object verifieert waarnaar de variabele verwijst, niet het gedeclareerde type van de variabele die verwijst naar het object.

Codevoorbeelden voor het is trefwoord

In de volgende codevoorbeelden ziet u de voorwaarden die bepalen of een is expressie waar of onwaar retourneert. De codevoorbeelden zijn afhankelijk van het feit dat de formulierklasse en de queryklasse beide de TreeNode-klasse uitbreiden.

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

Codevoorbeeld voor is en als trefwoorden

Het volgende codevoorbeeld bevat een typisch gebruik van het is trefwoord. Het as trefwoord wordt gebruikt nadat het is trefwoord controleert of het as trefwoord slaagt. In dit voorbeeld zijn de is en as trefwoorden hoofdletters om ze beter zichtbaar te maken.

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.

Objectklasse als een speciaal geval

De objectklasse kan worden weergegeven als een speciaal geval in overnamefunctionaliteit. De compiler omzeilt typecontrole voor toewijzingen van en naar variabelen die zijn gedeclareerd als type Object. Sommige klassen nemen over van de objectklasse , sommige klassen nemen over van een andere klasse en sommige klassen nemen geen gegevens over van een klasse. Hoewel de dialoogvensterklasse niet wordt overgenomen van een klasse, werken de toewijzings- en aanroepinstructies in het volgende codevoorbeeld. Als de toewijzing echter is bank4 = dlog3;, mislukt deze tijdens het compileren, omdat de klassen Bank en Dialoogvenster geen overnamerelatie met elkaar hebben. De compiler voert slechts één kleine validatie uit voor toewijzingen aan een variabele die als objectklasse wordt gedeclareerd. De compiler controleert of het item dat wordt toegewezen aan de objectvariabele een exemplaar van een klasse is. De compiler staat niet toe dat een exemplaar van een tabelbuffer wordt toegewezen aan de objectvariabele . Daarnaast staat de compiler niet toe dat primitieve gegevenstypen, zoals int ofstr, worden toegewezen aan de objectvariabele.

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

Alle tabellen nemen rechtstreeks over van de algemene systeemtabel, tenzij ze expliciet overnemen van een andere tabel. De algemene tabel kan niet worden geïnstantieerd. Deze bestaat niet in de onderliggende fysieke database. De algemene tabel neemt over van de klasse xRecord , maar op een speciale manier die niet geschikt is voor het is trefwoord of het as trefwoord. Wanneer het as trefwoord wordt gebruikt om een ongeldige downcast uit te voeren tussen tabellen, verwijst de doelvariabele naar een onbruikbare niet-null-entiteit. Elke poging om de verwijzing naar de doelvariabele ongedaan te maken, veroorzaakt een fout waardoor het programma wordt gestopt.

De is en als trefwoorden en uitgebreide gegevenstypen

Elk uitgebreid gegevenstype heeft een uitbreidingseigenschap . De stijl van overname die door deze eigenschap wordt gebruikt, verschilt van de stijl van overname waarvoor de is en as trefwoorden zijn ontworpen.

Relationele operators

De volgende tabel bevat de relationele operators die kunnen worden gebruikt in X++. De meeste operators zijn binair en nemen twee operanden. De operator not (!) is echter unaire en neemt slechts één operand. Syntaxis voor binaire operators: expression1relationalOperatorexpression2 Syntaxis voor unaire operators: relationalOperatorexpression1

Operator Description
like De achtige relationele operator retourneert true als expressie1 lijkt op expressie2.
== De gelijk-relationele operator retourneert true als beide expressies gelijk zijn.
>= De operator groter dan of gelijk aan relationele operator retourneert true als expressie1 groter is dan of gelijk is aan expressie2.
<= De minder dan of gelijk aan relationele operator retourneert true als expressie1 kleiner is dan of gelijk is aan expressie2.
> De operator groter dan relationeel retourneert waar als expressie1 groter is dan expressie2.
< De minder dan relationele operator retourneert waar als expressie1 kleiner is dan expressie2.
!= De niet-gelijke relationele operator retourneert true als expressie1 verschilt van (dat wil gezegd, als deze niet gelijk is aan) expressie2.
&& De en relationele operator retourneert waar als zowel expressie1 als expressie2 waar zijn.
|| De of relationele operator retourneert true als expressie1 of expressie2 waar is, of als beide waar zijn.
! De not - of unaire relationele operator ontkent de expressie. De waarde retourneert waar als de expressie onwaar en onwaar is als de expressie waar is.

De operator Like

De like operator kan worden gebruikt * als jokerteken voor nul of meer tekens en ? als jokerteken voor één teken. De maximale lengte van de operand is 1000 tekens. De like operator wordt geëvalueerd door de onderliggende SQL, zodat het resultaat van verschillende installaties kan verschillen. Als de expressies die u vergelijkt een bestandspad bevatten, moet u vier backslashes tussen elk element opnemen, zoals wordt weergegeven in het volgende voorbeeld.

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

De gelijk -operator (==)

Wanneer u de operator gelijk (==) gebruikt om objecten te vergelijken, worden de objectverwijzingen vergeleken, niet de objecten zelf. Dit gedrag kan problemen veroorzaken als u twee objecten vergelijkt, waarvan een zich op de server bevindt en de andere zich op de client bevindt. In deze gevallen moet u de gelijke methode in de klasse Object gebruiken. U kunt deze methode overschrijven om op te geven wat dit betekent voor twee objecten die gelijk moeten zijn. Als u de gelijke methode niet overschrijft, is de vergelijking identiek aan de vergelijking die wordt uitgevoerd door de gelijk-operator (==).

Codevoorbeelden voor relationele operators

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

Operatorprioriteit

De volgorde waarin een samengestelde expressie wordt geëvalueerd, kan belangrijk zijn. Geeft bijvoorbeeld een ander resultaat, (x + y / 100) afhankelijk van of de optelling of de deling eerst wordt uitgevoerd. U kunt haakjes (()) gebruiken om de compiler expliciet te laten weten hoe een expressie moet worden geëvalueerd. U kunt bijvoorbeeld opgeven (x + y) / 100. Als u de compiler niet expliciet de volgorde vertelt waarin u bewerkingen wilt uitvoeren, is de volgorde gebaseerd op de prioriteit die aan de operators is toegewezen. De operator voor delen heeft bijvoorbeeld een hogere prioriteit dan de operator voor optellen. Daarom evalueert x + y / 100 de compiler voor de expressie y / 100eerst. Met andere woorden, x + y / 100 is gelijk aan x + (y / 100). Om uw code gemakkelijk te lezen en te onderhouden, moet u expliciet zijn. Gebruik haakjes om aan te geven welke operators eerst moeten worden geëvalueerd. De volgende tabel bevat de operators in volgorde van prioriteit. Hoe hoger een operator wordt weergegeven in de tabel, hoe hoger de prioriteit ervan. Operators met een hogere prioriteit worden geëvalueerd voor operators met een lagere prioriteit. Houd er rekening mee dat de operatorprioriteit van X++ niet hetzelfde is als de operatorprioriteit van andere talen, zoals C# en Java.

Operatorgroepen, in volgorde van prioriteit Bedieners
Unary - ~ !
Multiplicative, shift, bitwise AND, bitwise exclusieve OR * / % DIV << >> & ^
Additief, bitwise inclusief OF + - |
Relationeel, gelijkheid < <= == != > >= like as is
Logisch (EN, OF) && ||
Conditional ? :

Operators op dezelfde regel hebben gelijke prioriteit. Als een expressie meer dan een van deze operators bevat, wordt deze geëvalueerd van links naar rechts, tenzij toewijzingsoperatoren worden gebruikt. (Toewijzingsoperatoren worden van rechts naar links geëvalueerd.) (logisch&&) en AND (logisch||) hebben bijvoorbeeld OR dezelfde prioriteit en worden van links naar rechts geëvalueerd. Therefore:

  • 0 && 0 || 1 is gelijk aan 1
  • 1 || 0 && 0 is gelijk aan 0.
  • Last updated on