X++ operators

Šiame straipsnyje aprašomi X++palaikomi operatoriai.

Assignment operators

Priskyrimo operatorius pakeičia kintamojo arba lauko reikšmę. Šioje lentelėje rodomi X++ priskyrimo operatoriai. Tarp prefikso ir postfikso operatorių nėra skirtumo.

Operator	Description
=	Priskirkite reiškinį dešinėje lygybės ženklo pusėje kintamajam kairėje.
+=	Priskirkite dabartinę kintamojo reikšmę ir dešinėje esantį reiškinį kintamajam kairėje.
++	Padidinkite kintamąjį 1.
-=	Priskirkite dabartinę kintamojo reikšmę, atėmus reiškinį dešinėje, kintamajam kairėje.
--	Kintamojo išsekite iš 1.

Užduočių operatorių kodų pavyzdžiai

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

Arithmetic operators

Naudokite aritmetinius operatorius, kad atliktumėte skaitinius skaičiavimus. Dauguma operatorių yra dvejetainiai ir užima du operandus. Tačiau operatorius ne (~) yra neįskaitęs ir užima tik vieną operandą. Dvejetainių operatorių sintaksė: reiškinys1Aritmetiniooperatoroišraiška2 Nearitmetinių operatorių sintaksė: Aritmetiniooperatoroišraiška1

Operator	Description
<<	Kairysis poslinkio operatorius atlieka išraišką2 kairįjį poslinkį (daugyba iš 2) reiškinyje1.
>>	Dešiniojo poslinkio operatorius atlieka išraišką2 dešinįjį poslinkį (dalyba iš 2) reiškinyje1.
*	Daugybos operatorius sudaugina išraišką1 iš reiškinio2.
/	Dalybos operatorius dalija išraišką1 iš išraiškos2.
DIV	Sveikojo skaičiaus dalybos operatorius atlieka sveikojo skaičiaus reiškinio1 dalybos pagal išraišką2.
MOD	Sveikojo skaičiaus liekanų operatorius grąžina reiškinio1 sveikojo skaičiaus dalybos liekaną iš reiškinio2.
~	Operatorius not arba unary atlieka dvejetainę ne operaciją.
&	Dvejetainis AND operatorius atlieka dvejetainį ir operaciją su išraiška1 ir išraiška2.
^	Dvejetainis XOR operatorius atlieka Dvejetainę XOR operaciją su išraiška1 ir išraiška2.
|	Dvejetainis OR operatorius atlieka dvejetainę arba operaciją su išraiška1 ir išraiška2.
+	Pliuso operatorius įtraukia išraišką1 į išraišką2.
-	Minuso operatorius atima reiškinį2 iš reiškinio1.
?	Tarpinis operatorius priima tris išraiškas: reiškinys1 ? reiškinys2 : reiškinys3. Jei reiškinys1 yra teisingas, pateikiama išraiška2 . Kitu atveju pateikiama išraiška3 .

Aritmetinių operatorių kodų pavyzdžiai

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.

Expression operators

as is Reiškinio operatoriai valdo testavimo žemyn užduotis. Downcast užduotis įtraukti klasės arba lentelės paveldėjimas. Priskyrimo sakiniai, kurie netiesiogiai gali sukelti klaidų, kurias sunku nuspėti ir diagnozuoti. as Naudokite raktažodį, kad išsaiškaustumėte savo testavimus. is Naudokite raktažodį, kad patikrintumėte, ar testavimas žemyn galioja vykdymo metu.

Raktinis žodis kaip

as Naudokite raktažodį užduotims, kurios prastinamas iš bazinio klasės kintamojo į išvestinės klasės kintamąjį. Raktinis as žodis nurodo kitiems programuotojams ir kompiliatorius, kad manote, jog testavimas žemyn galioja vykdymo metu.

• Kompiliatorius praneša apie downcast priskyrimo sakinių, kurie neturi raktažodžio as , klaidą.
• Vykdymo metu, raktažodžio as sukelia downcast priskyrimas sakinys priskirti null , jei downcast yra negaliojantis.
• is Naudokite raktažodį, kad saugiai patikrintumėte, ar raktinis as žodis veikia.

Raktinio žodžio kaip kodo pavyzdys

Toliau pateiktame kodo pavyzdyje DerivedClass klasė išplečia BaseClass klasę. Kodo pavyzdyje yra du leistini priskyrimai tarp jo pagrindo ir išvestinių kintamųjų. Transliuojamų duomenų priskyrimas basec nereikalauja raktinio žodžio as , tačiau norint priskirti " downcast" išvestinį raktažodį, jis nereikalingas as . Šis kodas kompiliuoja ir veikia be klaidų.

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

Raktažodis

Raktažodis is tikrina, ar objektas yra nurodytos klasės potipis. Reiškinys is pateikia true (teisinga ), jei objektas yra klasės potipis arba jei objektas yra to paties tipo kaip klasė. Kompiliatorius praneša apie klaidą, jei is raktažodžio reiškinys lygina du tipus, bet nė vienas tipas nėra kito potipis ir nėra to paties tipo. Kompiliatorius praneša apie panašią klaidą bet kuriame paprastojo priskyrimo sakinyje tarp dviejų tipų, kai nė vienas tipas nėra kito potipis ir jie nėra to paties tipo. Vykdymo metu kintamojo tipas, nurodantis esamą objektą, nėra svarbus raktažodžiui is . Dėl is raktažodžio sistema patikrina objektą, kuris nurodo kintamąjį, o ne paskelbtą kintamojo, kuris nurodo objektą, tipą.

Kodo pavyzdžiai, skirti raktažodžiui

Toliau pateiktuose kodų pavyzdžiuose parodytos sąlygos, valdančios, ar reiškinys pateikia is, ar klaidingą. Kodo pavyzdžiai priklauso nuo to, ar formos klasė ir užklausos klasė išplečia "TreeNode" klasę.

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

Kodo pavyzdys, kuris yra ir kaip raktažodžiai

Toliau pateiktame kodo pavyzdyje yra įprastas raktažodžio is naudojimas. Raktažodis as naudojamas po raktažodžio is , patvirtina, as kad raktinis žodis pavyksta. Šiame pavyzdyje ir raktažodžiai yra didžiosios raidės, isas kad jie būtų labiau matomi.

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.

Objektų klasė kaip specialus atvejis

Objekto klasė paveldimumo funkcijoje gali būti rodoma kaip specialus atvejis. Kompiliatorius apeis priskyrimų kintamiesiems, kurie paskelbti kaip objekto tipo, tipo tikrinimą. Kai kurios klasės paveldi iš objekto klasės, kai kurios klasės paveldi iš kitos klasės, o kai kurios klasės nepaveldi iš jokios klasės. Nors dialogo klasė nepaveldi iš jokios klasės, užduoties ir skambučių sakiniai toliau pateiktame kodo pavyzdyje veikia. Tačiau jei priskyrimas yra bank4 = dlog3;, jis nepavyks kompiliavimo metu, nes banko ir dialogo lango klasės neturi paveldėjimo ryšio. Kompiliatorius atlieka tik vieną nedidelį priskyrimų tikrinimą kintamajam, kuris laikomas objekto klase. Kompiliatorius patvirtina, kad elementas, kuriam priskirtas objekto kintamasis, yra klasės egzempliorius. Kompiliatorius neleidžia objekto kintamajam priskirti lentelės buferio egzemplioriaus. Be to, kompiliatorius neleidžia int priskirti primityvių duomenų tipų, pvzstr., arba .

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

Visos lentelės paveldi tiesiogiai iš įprastos sistemos lentelės, nebent jos tiesiogiai paveldi iš kitos lentelės. Įprastos lentelės egzempliorių kurti negalima. Jos nėra esamoje fizinėje duomenų bazėje. Lentelė Common paveldi iš klasės xRecord , bet specialiu būdu, kuris netinka raktažodžiui is arba raktažodžiui as . as Kai raktažodis naudojamas netinkamam lentelių testavimui atlikti, tikslinis kintamasis nurodo nenaudojamą ne null objektą. Bet koks bandymas panaikinti tikslinį kintamąjį sukels klaidą, kuri sustabdys programą.

Yra ir kaip raktiniai žodžiai ir išplėstiniai duomenų tipai

Kiekvienas išplėstinių duomenų tipas turi ypatybę Extends . Šios ypatybės valdiklių paveldimumo stilius skiriasi nuo paveldimumo stiliaus, is kuriam skirtas šis ir as raktažodžiai.

Relational operators

Šioje lentelėje išvardyti sąryšiniai operatoriai, kuriuos galima naudoti X++. Dauguma operatorių yra dvejetainiai ir užima du operandus. Tačiau operatorius ne (!) yra neįskaitęs ir užima tik vieną operandą. Dvejetainių operatorių sintaksė: reiškinys1relationalOperatorišraiška2 Neaiškaus operatoriaus sintaksė: relationalOperatorišraiška1

Operator	Description
like	Like relational operator returns true if expression1 is like expression2.
==	Lygybės sąryšinis operatorius grąžina true, jei abi išraiškos yra lygios.
>=	Daugiau arba lygu sąryšinio operatoriaus grąžina true , jei reiškinys1 yra didesnis už arba lygus išraiškai2.
<=	Mažiau nei arba lygu sąryšinį operatorių grąžina true , jei reiškinys1 yra mažesnis už arba lygus išraiškai2.
>	Daugiau nei sąryšinis operatorius grąžina true , jei reiškinys1 yra didesnis už išraišką2.
<	Mažiau nei sąryšinis operatorius grąžina true , jei reiškinys1 yra mažesnis už išraišką2.
!=	Nelygu sąryšinis operatorius grąžina true, jei reiškinys1 skiriasi nuo (t. y. jei jis nėra lygus) išraiškos2.
&&	Ir sąryšinis operatorius grąžina true, jei ir reiškinys1, ir reiškinys2 yra teisingi.
||	Arba sąryšinis operatorius grąžina true, jei reiškinys1 arba reiškinys2 yra teisingas arba jei abu yra teisingi.
!	Reiškinį paneigia notarinis sąryšinis operatorius. Ji pateikia true (teisinga ), jei reiškinys yra klaidingas ir klaidingas , jei reiškinys yra teisingas.

Operatorius Like

Operatorius like gali naudoti * kaip pakaitos simbolį nuliui ar daugiau simbolių ir ? kaip vieno simbolio pakaitos simbolį. Maksimalus operando ilgis yra 1 000 simbolių. Operatorius like įvertinamas pagal esamą SQL, todėl rezultatas gali skirtis skirtinguose diegimais. Jei išraiškose, kurias lyginate, yra failo kelias, tarp kiekvieno elemento turite įtraukti keturis pasviruosius brūkšnius, kaip parodyta toliau pateiktame pavyzdyje.

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

Operatorius lygu (==)

Kai objektams palyginti naudojate lygybės (==) operatorių, objektų nuorodos lyginamos, o ne patys objektai. Toks veikimas gali sukelti problemų, jei palyginsite du objektus, iš kurių vienas yra serveryje, o kitas yra kliente. Tokiais atvejais objekto klasėje turėtumėte naudoti vienodą metodą. Galite perrašyti šį metodą, kad nurodytumėte, ką jis reiškia, kad du objektai būtų lygūs. Jei nepaisysite vienodo metodo, palyginimas bus identiškas palyginimui, kurį atlieka lygybės (==) operatorius.

Sąryšinių operatorių kodų pavyzdžiai

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

Operator precedence

Sudėtinio reiškinio įvertinimo tvarka gali būti svarbi. Pvz., (x + y / 100) pateikia kitokį rezultatą, atsižvelgiant į tai, ar pridėjimas, ar dalyba atliekamas pirmiausia. Galite naudoti skliaustus (()), kad tiksliai nurodytumėte kompiliatorius, kaip jis turėtų įvertinti reiškinį. Pavyzdžiui, galite nurodyti (x + y) / 100. Jei neaiškite kompiliatorius užsakymo, kuriuo norite atlikti operacijas, tvarka yra pagrįsta pirmumo tvarka, priskirta operatoriams. Pavyzdžiui, dalybos operatorius turi didesnį pirmumą nei pridėjimo operatorius. Todėl reiškinio x + y / 100kompiliatorius pirmiausia įvertina y / 100 . Kitaip tariant, x + y / 100 atitinka x + (y / 100). Kad kodą būtų lengviau skaityti ir tvarkyti, būkite aiškūs. Naudokite skliaustus, kad nurodytumėte, kuriuos operatorius pirmiausia reikia įvertinti. Šioje lentelėje išvardyti operatoriai pirmumo tvarka. Kuo didesnis operatorius lentelėje, tuo didesnis jo pirmumas. Operatoriai, kurių pirmumas didesnis, vertinami prieš operatorius, kurių pirmumas mažesnis. Atkreipkite dėmesį, kad X++ operatoriaus pirmumas skiriasi nuo kitų kalbų, pvz., C# ir "Java", operatoriaus pirmumo.

Operatorių grupės pagal pirmumo tvarką	Operators
Unary	- ~ !
Daugyba, poslinkis, bitų ir bitų, išskirtinis OR	* / % DIV << >> & ^
Priedas, imtinai arba bitais	+ - |
Relational, equality	< <= == != > >= like as is
Loginė (AND, OR)	&& ||
Conditional	? :

Tos pačios eilutės operatoriai turi vienodą pirmumą. Jei reiškinyje yra daugiau nei vienas iš šių operatorių, jis įvertinamas iš kairės į dešinę, nebent naudojami priskyrimo operatoriai. (Priskyrimo operatoriai vertinami iš dešinės į kairę.) Pavyzdžiui, && (loginė AND) ir || (loginė OR) turi tą patį pirmumą ir yra vertinami iš kairės į dešinę. Therefore:

• 0 && 0 || 1 lygu 1
• 1 || 0 && 0 lygu 0.