X++-Operatoren

Hinweis

Community-Interessensgruppen sind jetzt von Yammer zu Microsoft Viva Engage gewechselt. Um an einer Viva Engage-Community teilzunehmen und an den neuesten Diskussionen teilzunehmen, füllen Sie das Formular "Anfordern des Zugriffs auf Finance and Operations Viva Engage Community" aus , und wählen Sie die Community aus, der Sie beitreten möchten.

In diesem Artikel werden die in X++ unterstützten Operatoren beschrieben.

Zuweisungsoperatoren

Eine Zuordnung ändert den Wert einer Variablen oder eines Felds. Die folgende Tabelle zeigt die X++-Zuordnungsoperatoren. Es gibt keinen Unterschied zwischen Präfix- und Postfixoperatoren.

Bediener	Description
`=`	Weisen Sie den Ausdruck rechts neben dem Gleichheitszeichen der Variablen auf der linken Seite zu.
`+=`	Weisen Sie den aktuellen Variablenwert plus dem Ausdruck auf der rechten Seite der Variablen auf der linken Seite zu.
`++`	Erhöhen Sie die Variable um 1.
`-=`	Weisen Sie den aktuellen Variablenwert minus dem Ausdruck auf der rechten Seite der Variablen auf der linken Seite zu.
`--`	Erhöhen Sie die Variable um 1.

Codebeispiele für Zuordnungsoperatoren

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

Arithmetische operatoren

Sie verwenden arithmetische Operatoren, um numerische Berechnungen durchzuführen. Die meisten Operatoren sind binär und nehmen zwei Operanden. Der Operator nicht (~) ist jedoch unär und akzeptiert nur einen Operanden. Syntax für binäre Operatoren: expression1ArithmeticOperatorexpression2 Syntax für unäre Operatoren: ArithmeeticOperatorexpression1

Bediener	Description
`<<`	Der Operator für die linke Schicht führt expression2 linke Schicht (Multiplikation mit 2) für Ausdruck1 aus.
`>>`	Der Operator für die rechte Schicht führt expression2 die rechte Umschalttaste (Division um 2) für Ausdruck1 aus.
`*`	Der Multiplizieroperator multipliziert Ausdruck1 mit Ausdruck2.
`/`	Der Trennoperator dividiertExpression1 durch Ausdruck2.
`DIV`	Der Ganzzahlteilungsoperator führt eine ganzzahlige Division von Expression1 durch Expression2 aus.
`MOD`	Der ganzzahlige Restoperator gibt den Rest einer ganzzahligen Division von Expression1 nach Expression2 zurück.
`~`	Der Nichtoperator oder der nichtäre Operator führt einen binär nicht ausgeführten Vorgang aus.
`&`	Der binäre AND-Operator führt eine Binärdatei und einen Vorgang für Ausdruck1 und Ausdruck2 aus.
`^`	Der binäre XOR-Operator führt einen binären XOR-Vorgang für Expression1 und Expression2 aus.
`\|`	Der binäre OR-Operator führt eine Binär - oder Operation für Ausdruck1 und Ausdruck2 aus.
`+`	Der Plusoperator fügt expression1 zu Expression2 hinzu.
`-`	Der Minusoperator subtrahiert Expression2 von Expression1.
`?`	Der ternäre Operator akzeptiert drei Ausdrücke: expression1 ? Ausdruck2 : Ausdruck3. Wenn Ausdruck1 wahr ist, wird Expression2 zurückgegeben. Andernfalls wird Expression3 zurückgegeben.

Codebeispiele für arithmetische 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.

Ausdrucksoperatoren

Die as Operatoren und is Ausdruck steuern Downcastzuweisungen. Downcastzuweisungen umfassen die Klassen- oder Tabellenvererbung. Zuordnungsanweisungen, die implizit downcast sind, können Fehler verursachen, die schwer vorhergesagt und diagnostiziert werden können. Sie können das as Schlüsselwort verwenden, um Ihre Downcasts explizit zu machen. Sie können das is Schlüsselwort verwenden, um zu testen, ob eine Downcast zur Laufzeit gültig ist.

Das Schlüsselwort

Verwenden Sie das as Schlüsselwort für Zuordnungen, die von einer Basisklassenvariablen zu einer abgeleiteten Klassenvariable abgeschrieben werden. Das as Schlüsselwort teilt anderen Programmierern und dem Compiler mit, dass die Downcast während der Laufzeit gültig ist.

Der Compiler meldet einen Fehler für Downcast-Zuweisungsanweisungen, für die das as Schlüsselwort fehlt.
Zur Laufzeit bewirkt das as Schlüsselwort, dass die Downcast-Zuweisungsanweisung zugewiesen null wird, wenn der Downcast ungültig ist.
Dieses is Schlüsselwort wird häufig verwendet, um sicher zu testen, ob das as Schlüsselwort funktioniert.

Codebeispiel für das Schlüsselwort

Im folgenden Codebeispiel erweitert die DerivedClass-Klasse die BaseClass-Klasse. Das Codebeispiel enthält zwei gültige Zuordnungen zwischen den Basec- und abgeleiteten Variablen. Für die Upcast-Zuordnung zu basec ist das Schlüsselwort nicht erforderlich as , die Downcastzuweisung für abgeleitete Elemente erfordert jedoch das as Schlüsselwort. Der folgende Code wird kompiliert und ohne Fehler ausgeführt.

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

Das Schlüsselwort ist

Das is Schlüsselwort überprüft, ob ein Objekt ein Untertyp einer angegebenen Klasse ist. Der is Ausdruck gibt "true " zurück, wenn das Objekt ein Untertyp der Klasse ist oder wenn das Objekt derselbe Typ wie die Klasse ist. Der Compiler meldet einen Fehler, wenn ein is Schlüsselwortausdruck zwei Typen vergleicht, aber kein Typ ein Untertyp des anderen ist und sie nicht vom gleichen Typ sind. Der Compiler meldet einen ähnlichen Fehler für jede einfache Zuordnungsanweisung zwischen zwei Typen, wobei kein Typ ein Untertyp des anderen ist und sie nicht vom gleichen Typ sind. Zur Laufzeit ist der Typ der Variablen, die auf das zugrunde liegende Objekt verweist, für das is Schlüsselwort irrelevant. Das is Schlüsselwort bewirkt, dass das System das Objekt überprüft, auf das die Variable verweist, nicht den deklarierten Typ der Variablen, die auf das Objekt verweist.

Codebeispiele für das Schlüsselwort

Die folgenden Codebeispiele veranschaulichen die Bedingungen, die steuern, ob ein is Ausdruck wahr oder falsch zurückgibt. Die Codebeispiele hängen davon ab, dass die Form-Klasse und die Query-Klasse beide die TreeNode-Klasse erweitern.

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

Codebeispiel für das Ist und als Schlüsselwörter

Das folgende Codebeispiel enthält eine typische Verwendung des is Schlüsselworts. Das as Schlüsselwort wird verwendet, nachdem das is Schlüsselwort überprüft hat, ob das as Schlüsselwort erfolgreich ist. In diesem Beispiel sind die is Schlüsselwörter großgeschrieben as , um sie sichtbarer zu machen.

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.

Objektklasse als Sonderfall

Die Object-Klasse kann als Sonderfall in der Vererbungsfunktion angezeigt werden. Der Compiler umgeht die Typüberprüfung auf Zuordnungen zu und von Variablen, die als Objekttyp deklariert sind. Einige Klassen erben von der Object-Klasse , einige Klassen erben von einer anderen Klasse, und einige Klassen erben nicht von einer Klasse. Obwohl die Dialog-Klasse nicht von einer Klasse erbt, funktionieren die Zuweisungs- und Aufrufanweisungen im folgenden Codebeispiel. Wenn die Zuordnung jedoch lautet bank4 = dlog3;, schlägt sie zur Kompilierungszeit fehl, da die Bank - und Dialogklassen keine Vererbungsbeziehung zueinander haben. Der Compiler führt nur eine kleine Überprüfung für Zuordnungen zu einer Variablen durch, die als Objektklasse deklariert ist. Der Compiler überprüft, ob das Element, das der Objektvariablen zugewiesen wird, eine Instanz einer Klasse ist. Der Compiler lässt nicht zu, dass eine Instanz eines Tabellenpuffers der Objektvariablen zugewiesen wird. Darüber hinaus lässt der Compiler nicht zu, dass primitive Datentypen, z int . B. oder str, der Objektvariablen zugewiesen werden.

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.");
}

Tabellen

Alle Tabellen erben direkt von der Allgemeinen Systemtabelle, es sei denn, sie erben explizit von einer anderen Tabelle. Die allgemeine Tabelle kann nicht instanziiert werden. Sie ist in der zugrunde liegenden physischen Datenbank nicht vorhanden. Die allgemeine Tabelle erbt von der xRecord-Klasse , aber auf eine besondere Weise, die nicht für das is Schlüsselwort oder das as Schlüsselwort geeignet ist. Wenn das as Schlüsselwort verwendet wird, um eine ungültige Downcast zwischen Tabellen auszuführen, verweist die Zielvariable auf eine nicht verwendbare Nicht-Null-Entität. Jeder Versuch, auf die Zielvariable zu verweisen, verursacht einen Fehler, der das Programm beendet.

Dies ist und als Schlüsselwörter und erweiterte Datentypen

Jeder erweiterte Datentyp verfügt über eine Extended-Eigenschaft . Die Art der Vererbung, für die diese Eigenschaft steuert, unterscheidet sich von der Art der Vererbung, für die die und is die as Schlüsselwörter entworfen wurden.

Relationale Operatoren

In der folgenden Tabelle sind die relationalen Operatoren aufgeführt, die in X++ verwendet werden können. Die meisten Operatoren sind binär und nehmen zwei Operanden. Der Operator nicht (!) ist jedoch unär und akzeptiert nur einen Operanden. Syntax für binäre Operatoren: expression1relationalOperatorexpression2 Syntax für unäre Operatoren: relationalOperatorexpression1

Bediener	Description
`like`	Der ähnliche relationale Operator gibt "true " zurück, wenn Ausdruck1 wie "expression2" ist.
`==`	Der gleich relationale Operator gibt "true " zurück, wenn beide Ausdrücke gleich sind.
`>=`	Der Wert größer oder gleich dem relationalen Operator gibt "true " zurück, wenn "Expression1 " größer oder gleich "Expression2" ist.
`<=`	Der kleiner als oder gleich relationale Operator gibt "true " zurück, wenn "Expression1 " kleiner oder gleich "Expression2" ist.
`>`	Der größer als relationale Operator gibt "true " zurück, wenn "expression1 " größer als "expression2" ist.
`<`	Der kleiner als relationale Operator gibt "true " zurück, wenn "expression1 " kleiner als "expression2" ist.
`!=`	Der nicht gleich relationale Operator gibt "true " zurück, wenn "expression1 " sich von Ausdruck 2 unterscheidet (d. h. wenn er nicht gleich ist).
`&&`	Der und der relationale Operator gibt "true " zurück, wenn "Expression1 " und "expression2 " wahr sind.
`\|\|`	The or relational operator returns true if expression1 or expression2 is true, or if both are true.
`!`	Der nichtoder unäre relationale Operator negiert den Ausdruck. Er gibt "true " zurück, wenn der Ausdruck "false" und " false " ist, wenn der Ausdruck "true" ist.

Der Like-Operator

Der like Operator kann als Wildcardzeichen für null oder mehr Zeichen und * als Wildcardzeichen für ein Zeichen verwendet ? werden. Die maximale Länge des Operanden beträgt 1.000 Zeichen. Der like Operator wird von der zugrunde liegenden SQL ausgewertet, sodass sich das Ergebnis bei verschiedenen Installationen unterscheiden kann. Wenn die ausdrücke, die Sie vergleichen, einen Dateipfad enthalten, müssen Sie vier umgekehrte Schrägstriche zwischen den einzelnen Elementen einschließen, wie im folgenden Beispiel gezeigt.

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

Der Gleichheitsoperator (==)

Wenn Sie den Operator gleich (==) verwenden, um Objekte zu vergleichen, werden die Objektverweise verglichen, nicht die Objekte selbst. Dieses Verhalten kann zu Problemen führen, wenn Sie zwei Objekte vergleichen, die sich auf dem Server befinden und die sich auf dem Client befinden. In diesen Fällen sollten Sie die gleiche Methode in der Object-Klasse verwenden. Sie können diese Methode überschreiben, um anzugeben, was sie bedeutet, damit zwei Objekte gleich sind. Wenn Sie die Gleichheitsmethode nicht außer Kraft setzen, ist der Vergleich mit dem Vergleich identisch, der vom Gleichheitsoperator (==) durchgeführt wird.

Codebeispiele für relationale Operatoren

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

Rangfolge der Operatoren

Die Reihenfolge, in der ein zusammengesetzter Ausdruck ausgewertet wird, kann wichtig sein. Gibt beispielsweise ein anderes Ergebnis an, je nachdem, (x + y / 100) ob die Hinzufügung oder die Division zuerst erfolgt. Sie können Klammern (()) verwenden, um dem Compiler explizit mitzuteilen, wie ein Ausdruck ausgewertet werden soll. Sie können z. B. angeben (x + y) / 100. Wenn Sie dem Compiler nicht explizit die Reihenfolge mitteilen, in der Vorgänge ausgeführt werden sollen, basiert die Reihenfolge auf der Rangfolge, die den Operatoren zugewiesen ist. Beispielsweise hat der Abteilungsoperator eine höhere Priorität als der Additionsoperator. Daher wird der Compiler für den Ausdruck x + y / 100zuerst ausgewertet y / 100 . Das heißt, x + y / 100 das entspricht x + (y / 100). Damit Ihr Code einfach zu lesen und verwaltet werden kann, müssen Sie explizit sein. Verwenden Sie Klammern, um anzugeben, welche Operatoren zuerst ausgewertet werden sollen. In der folgenden Tabelle sind die Operatoren in der Reihenfolge der Rangfolge aufgeführt. Je höher ein Operator in der Tabelle angezeigt wird, desto höher ist die Rangfolge. Operatoren mit höherer Rangfolge werden vor Operatoren ausgewertet, die eine niedrigere Rangfolge haben. Beachten Sie, dass die Rangfolge des Operators von X++ nicht mit der Rangfolge anderer Sprachen, z. B. C# und Java, identisch ist.

Operatorgruppen in Der Reihenfolge der Rangfolge	Betriebspersonal
Unary	`- ~ !`
Multiplizieren, Umschalten, Bitweise UND, bitweise exklusiv ODER	`* / % DIV << >> & ^`
Additive, bitweise inklusive OR	`+ - \|`
Relational, Gleichheit	`< <= == != > >= like as is`
Logisch (UND, ODER)	`&&` `\|\|`
Bedingt	`? :`

Operatoren in derselben Zeile haben die gleiche Rangfolge. Wenn ein Ausdruck mehrere dieser Operatoren enthält, wird er von links nach rechts ausgewertet, es sei denn, Zuordnungsoperatoren werden verwendet. (Zuordnungsoperatoren werden von rechts nach links ausgewertet.) Beispielsweise && haben (wahrheitslogisch) und AND (logisch||OR) die gleiche Rangfolge und werden von links nach rechts ausgewertet. Therefore:

0 && 0 || 1 ist gleich 1
1 || 0 && 0 ist gleich 0.

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-07