Opérateurs X++

Cet article décrit les opérateurs pris en charge dans X++.

Opérateurs d'assignation

Une affectation modifie la valeur d’une variable ou d’un champ. Le tableau suivant montre les opérateurs d’affectation X++. Il n’existe aucune différence entre les opérateurs de préfixe et de postfix.

Exemples de code pour les opérateurs d’affectation

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

Opérateurs arithmétiques

Vous utilisez des opérateurs arithmétiques pour effectuer des calculs numériques. La plupart des opérateurs sont binaires et prennent deux opérandes. Toutefois, l’opérateur non () ~ unaire et ne prend qu’un opérande. Syntaxe pour les opérateurs binaires : expression1ArithmeticOperatorexpression2 Syntax for unary operator : ArithmeticOperatorexpression1

Exemples de code pour les opérateurs arithmétiques

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.

Opérateurs d’expression

Les as opérateurs et is les opérateurs d’expression contrôlent les affectations de basdiffusion. Les affectations de mise en panne impliquent l’héritage de classe ou de table. Les instructions d’affectation qui sont implicitement en panne peuvent entraîner des erreurs difficiles à prédire et diagnostiquer. Vous pouvez utiliser le as mot clé pour rendre vos downcasts explicites. Vous pouvez utiliser le is mot clé pour tester si une mise en panne est valide au moment de l’exécution.

Le mot clé en tant que mot clé

Utilisez le as mot clé pour les affectations qui descendent d’une variable de classe de base vers une variable de classe dérivée. Le as mot clé indique à d’autres programmeurs et au compilateur que vous pensez que la baisse sera valide pendant l’exécution.

• Le compilateur signale une erreur pour les instructions d’affectation de mise en panne qui n’ont pas le as mot clé.
• Au moment de l’exécution, le as mot clé entraîne l’affectation null de l’instruction d’affectation de downcast si la baisse n’est pas valide.
• Ce is mot clé est souvent utilisé pour tester en toute sécurité si le as mot clé fonctionnera.

Exemple de code pour le mot clé

Dans l’exemple de code suivant, la classe DerivedClass étend la classe BaseClass . L’exemple de code contient deux affectations valides entre ses variables basec et dérivées . L’attribution de mise en service vers basec ne nécessite pas le as mot clé, mais l’affectation de mise en panne à dérivée nécessite le as mot clé. Le code suivant compile et s’exécute sans erreur.

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

Le mot clé est

Le is mot clé vérifie si un objet est un sous-type d’une classe spécifiée. L’expression is retourne true si l’objet est un sous-type de la classe, ou si l’objet est le même type que la classe. Le compilateur signale une erreur si une is expression de mot clé compare deux types, mais aucun type n’est un sous-type de l’autre, et ils ne sont pas du même type. Le compilateur signale une erreur similaire pour toute instruction d’affectation simple entre deux types, où aucun type n’est un sous-type de l’autre et qu’il ne s’agit pas du même type. Au moment de l’exécution, le type de variable qui fait référence à l’objet sous-jacent n’est pas pertinent pour le is mot clé. Le is mot clé fait en sorte que le système vérifie l’objet que la variable fait référence, et non le type déclaré de la variable qui fait référence à l’objet.

Exemples de code pour le mot clé

Les exemples de code suivants illustrent les conditions qui contrôlent si une is expression retourne true ou false. Les exemples de code dépendent du fait que la classe Form et la classe Query étendent la classe 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)));

Exemple de code pour les mots clés et

L’exemple de code suivant contient une utilisation classique du is mot clé. Le as mot clé est utilisé après que le is mot clé vérifie que le as mot clé réussit. Dans cet exemple, les mots clés et is les as mots clés sont en majuscules pour les rendre plus visibles.

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.

Classe d’objet en tant que cas spécial

La classe Object peut apparaître comme un cas spécial dans la fonctionnalité d’héritage. Le compilateur contourne la vérification de type pour les affectations vers et à partir de variables déclarées comme de type Object. Certaines classes héritent de la classe Object , certaines classes héritent d’une autre classe, et certaines classes n’héritent d’aucune classe. Bien que la classe Dialog n’hérite d’aucune classe, les instructions d’affectation et d’appel dans l’exemple de code suivant fonctionnent. Toutefois, si l’affectation est bank4 = dlog3;, elle échouera au moment de la compilation, car les classes Bank et Dialog n’ont aucune relation d’héritage entre elles. Le compilateur effectue une seule petite validation sur les affectations à une variable déclarée comme appartenant à la classe Object . Le compilateur vérifie que l’élément affecté à la variable Object est une instance d’une classe. Le compilateur n’autorise pas l’affectation d’une instance d’une mémoire tampon de table à la variable Object . En outre, le compilateur n’autorise pas les types de données primitifs, tels que int ou str, à affecter à la variable 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

Toutes les tables héritent directement de la table système commune, sauf si elles héritent explicitement d’une autre table. La table commune ne peut pas être instanciée. Il n’existe pas dans la base de données physique sous-jacente. La table Common hérite de la classe xRecord , mais d’une manière spéciale qui n’est pas appropriée pour le is mot clé ou le as mot clé. Lorsque le as mot clé est utilisé pour effectuer une baisse non valide entre les tables, la variable cible fait référence à une entité non null inutilisable. Toute tentative de référencer la variable cible entraîne une erreur qui arrête le programme.

Les mots clés et les types de données étendus sont les suivants :

Chaque type de données étendu a une propriété Extends . Le style d’héritage pour lequel cette propriété contrôle diffère du style d’héritage pour lequel les mots clés et is les as mots clés sont conçus.

Opérateurs relationnels

Le tableau suivant répertorie les opérateurs relationnels qui peuvent être utilisés dans X++. La plupart des opérateurs sont binaires et prennent deux opérandes. Toutefois, l’opérateur non () ! unaire et ne prend qu’un opérande. Syntaxe pour les opérateurs binaires : expression1relationalOperatorexpression2 Syntaxe pour les opérateurs unaires : expression relationalOperator1

Opérateur semblable

L’opérateur like peut utiliser * comme caractère générique pour zéro ou plusieurs caractères, et ? comme caractère générique pour un caractère. La longueur maximale de l’opérande est de 1 000 caractères. L’opérateur like est évalué par le sql sous-jacent, de sorte que le résultat peut différer sur différentes installations. Si les expressions que vous comparez contiennent un chemin d’accès de fichier, vous devez inclure quatre barres obliques inverses entre chaque élément, comme illustré dans l’exemple suivant.

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

Opérateur égal (==)

Lorsque vous utilisez l’opérateur égal (==) pour comparer des objets, les références d’objet sont comparées, et non les objets eux-mêmes. Ce comportement peut entraîner des problèmes si vous comparez deux objets, dont l’un se trouve sur le serveur et l’autre situé sur le client. Dans ces cas, vous devez utiliser la méthode égale dans la classe Object . Vous pouvez remplacer cette méthode pour spécifier ce qu’elle signifie pour que deux objets soient égaux. Si vous ne remplacez pas la méthode égale , la comparaison est identique à la comparaison effectuée par l’opérateur égal (==).

Exemples de code pour les opérateurs relationnels

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

Précédence des opérateurs

L’ordre dans lequel une expression composée est évaluée peut être important. Par exemple, (x + y / 100) donne un résultat différent, selon que l’ajout ou la division est effectué en premier. Vous pouvez utiliser des parenthèses (()) pour indiquer explicitement au compilateur comment il doit évaluer une expression. Par exemple, vous pouvez spécifier (x + y) / 100. Si vous n’indiquez pas explicitement au compilateur l’ordre dans lequel vous souhaitez que les opérations soient effectuées, l’ordre est basé sur la priorité affectée aux opérateurs. Par exemple, l’opérateur de division a une priorité plus élevée que l’opérateur d’ajout. Par conséquent, pour l’expression x + y / 100, le compilateur évalue y / 100 en premier. En d’autres termes, x + y / 100 équivaut à x + (y / 100). Pour faciliter la lecture et la maintenance de votre code, soyez explicite. Utilisez des parenthèses pour indiquer d’abord quels opérateurs doivent être évalués. Le tableau suivant répertorie les opérateurs dans l’ordre de priorité. Plus un opérateur apparaît dans la table, plus sa priorité est élevée. Les opérateurs ayant une priorité plus élevée sont évalués avant les opérateurs ayant une priorité inférieure. Notez que la précédence de l’opérateur X++ n’est pas la même que celle des autres langages, tels que C# et Java.

Les opérateurs sur la même ligne ont une priorité égale. Si une expression inclut plusieurs de ces opérateurs, elle est évaluée de gauche à droite, sauf si des opérateurs d’affectation sont utilisés. (Les opérateurs d’affectation sont évalués de droite à gauche.) Par exemple, && (logique) et AND (logique||OR) ont la même priorité et sont évalués de gauche à droite. Therefore:

• 0 && 0 || 1 est égal à 1
• 1 || 0 && 0 est égal à 0.