// Ez a legegyszerűbb kifejezés. Ezeket - a logika nyelvén - atomi kifejezésnek hívjuk, mivel egyelemű, ezekből épülnek fel az összetett kifejezések.

0

// A zárójelezések is működnek ebben az esetben, és könnyebb olvashatóságot biztosít

(0)

// Példák matematikai kifejezésekre.

// Operátorok:

// + mint összeadás

// - mint kivonás

// * mint szorzás

// / mint osztás

// % mint maradékos osztás, ami a maradékot fogja visszaadni (pl 7%3 értéke 1)

(2+3)                       // Eredmény: 5

((2*7)+3)                   // Eredmény: 17

((((1+3)/2)*4)-6)           // Eredmény: 2

((2*10) % 7)                 // Eredmény: 6

// További kifejezésekre példa

(true)                      // Eredmény: true

(5.0 + 2.3)                 // Eredmény: 7.3 Float típusú érték.

new a = 3                   // 'a' változó létrehozva 3-as kezdeti értékkel (a==3)

new b = a + 7               // 'b' változó létrehozva ( a + 7 )-as kezdeti értékkel (b==10)

a = a - 1;                  // 'a' értékét csökkentjük eggyel (a==2)

new c = b * a / 2           // 'c' változó létrehozva ( b * a / 2 ) értékkel (c==10)

a++          // visszaadja (a)-t, majd növeli egyel.

++a          // növeli (a)t, és utána adja vissza

// Lényegében:

/*

változó++ › posztfixes alak, csak a kifejezés kiértékelése után növeli az értékét, ehhez létrehoz egy átmeneti változót.

++változó › prefixes alak, nincs átmeneti változó, azonnal növeli az értékét, általában ezt használjuk.

*/

 

// Hasonló módon működik a -- operátor is

a--

--a

//mint említettem, az a++ operátor létrehoz egy átmeneti változót, mivel hasonlóan működik, mint az alábbi kód.

a = a + 1

// Az ++a ezzel ellentétben direktben növeli az értékét, nem szükséges létrehoznia ideiglenes változót.

 

a = a OP y

a OP= x

a += 1       // Növeli 'a'-t 1-el

a -= b       // 'a' értékét csökenti 'b' vel

a *= 0       // 'a'-t szorozza 0-val

a /= 2       // 'a'-t ossza 2-vel

 

(1 && 0)                    // Ez false, mivel 0 false vissza (lsd feljebb)

(1 && 2)                    // Mindkét kifejezés true így true lesz a && eredménye

(true && false)             // false

(false && false)            // false

(true && true)              // true

(1 || 0)                    // true, mivel az első kifejezés (1) true 

(1 || 2)                    // true

(true || false)             // true

(false || false)            // false

(true || true)              // true

// Például a 11 és 8 bitenkénti és eredménye 8, mivel:

// 11 (1011) és 8 (1000)

(11 & 8) //Eredménye 8 (1000)

// 4 (00100) és 16 (10000)

(16 & 4) eredménye 0

// 9 (1001) és 3 (0011)

(9 | 3) eredménye: 11

// Példák:

// 2 (00010) elcsúsztatva 3 - mal:

(2 << 3) eredménye: 16 (10000)

// Másik irányba való shiftelés:

// 16 (10000) 3-mal:

(16 >> 3) eredménye: 2 (00010)

(!true)  // Eredménye: false

(!false) // Eredménye: true

!9 // Eredménye: 6  (9 (1001) => 6 (0110)

// Számok esetében szokás a ~ (bitenkénti komplemens) operátort használni:

(~(9))  // Eredménye: 6

 condition ? exp1 : exp2