Ez a fejezet a JavaScript kifejezéseket és operátorokat írja le, például hozzárendelést, összehasonlítást, aritmetikai, bitenkénti, logikai, karakterlánc- és különféle speciális operátorokat.

Az operátorok és kifejezések teljes és részletes listája szintén elérhető ebben a kézikönyvben.

Üzemeltetők

A JavaScript a következő típusú operátorokkal rendelkezik. Ez az alfejezet leírja az egyes típusokat, és információkat tartalmaz az egymással szembeni elsőbbségükről.

A JavaScript támogatja a bináris és unáris operátorokat, valamint egy másik speciális háromtagú operátort, a feltételes operátort. Egy bináris művelet két operandust használ, egyet az operátor előtt, egyet pedig utána:

operandus1 operátor operandus2

Például: 3+4 vagy x*y .

Az unáris operátor viszont egy operandust használ, az operátor előtt vagy után:

operátor operandus operandus operátor

Például: x++ vagy ++x .

Hozzárendelési operátorok

A hozzárendelési művelet eredményeként a hozzárendelési operátortól balra lévő operandus ("=" jel) a jobb oldali operandusból vett értékre lesz állítva. Az alap hozzárendelési operátor az =, amely a jobb oldali operandus értékét rendeli a bal oldali operandushoz. Tehát az x = y kifejezés azt jelenti, hogy x-hez y értéke van hozzárendelve.

Vannak olyan összetett hozzárendelési operátorok is, amelyek a következő táblázatban leírt műveletek rövidítésére szolgálnak:

A hozzárendelési operátorok listája

Név	gyorsírás operátor	Jelentése
Feladat	x=y	x=y
Hozzárendelés kiegészítéssel	x += y	x = x + y
Hozzárendelés kivonással	x -= y	x = x - y
Hozzárendelés szorzással	x *= y	x=x*y
Hozzárendelés felosztással	x /= y	x=x/y
Modul feladat	x %= y	x = x % y
Bal műszakos feladat	x<<= y	x = x<< y
Jobb műszak beosztás	x >>= y	x = x >> y
Hozzárendelés előjel nélküli jobbra tolással	x >>>= y	x = x >>> y
Hozzárendelés bitenkénti AND-szal	x &= y	x=x&y
Hozzárendelés bitenkénti XOR-rel	x ^= y	x=x^y
Hozzárendelés bitenkénti VAGY	x |= y	x = x | y

Destrukturálás

A bonyolultabb hozzárendelésekhez a JavaScript rendelkezik egy strukturáló szintaxissal, amely egy olyan kifejezés, amely lehetővé teszi adatok tömbökből vagy objektumokból történő kinyerését olyan szintaxis használatával, amely tükrözi a tömbkonstruktorokat és az objektumliterálokat.

var foo = ["egy", "kettő", "három"]; // nincs destructuring var one = foo; vartwo = foo; var három = foo; // destrukturálással var = foo;

Összehasonlító operátorok

Használhatja a delete operátort implicit módon deklarált változók törlésére, de nem használhatja a var paraméterrel deklarált változók törlésére.

A delete operátor alkalmazása után az elem tulajdonsága undefined értékre változik. A delete operátor true értéket ad vissza, ha a művelet lehetséges; operátor false értéket ad vissza, ha a művelet nem hajtható végre.

X = 42; változhat = 43; myobj = new Number(); myobj.h = 4; // h tulajdonság létrehozása x törlés; // igazat ad vissza (az implicit módon deklarált változó törölhető) delete y; // false értéket ad vissza (a var-ral deklarált változót nem lehet törölni) delete Math.PI; // false értéket ad vissza (a beépített tulajdonságokat nem lehet törölni) delete myobj.h; // igazat ad vissza (az egyéni tulajdonságok törölhetők) delete myobj; // true értéket ad vissza (az implicit módon deklarált objektumot törölheti)

Tömbelemek eltávolítása

Egy tömbelem törlése nem befolyásolja a tömb hosszát. Például, ha eltávolítja a elemet, az a elem a marad, és az a meghatározatlan lesz.

Ha egy tömbelemet törlünk a delete operátorral, akkor az adott elem értéke törlődik a tömbből. A következő példában az elemfákat a delete operátorral töröljük. A trees elem azonban címezhető marad, és nem definiálva tér vissza.

Var fák = new Array("vörösfa", "öböl", "cédrus", "tölgy", "juhar"); fák törlése; if (3 a fákban) ( // feltétel sikertelen )

Ha azt szeretné, hogy egy elem a tömbben maradjon, de az értéke definiálatlan legyen, akkor használja az undefined kulcsszót a delete operátor helyett. A következő példában a trees elem undefined értékre van állítva, de az elem a tömbben marad:

Var fák = new Array("vörösfa", "öböl", "cédrus", "tölgy", "juhar"); fák = undefined; if (3 a fákban) ( // ez a kódblokk végrehajtása folyamatban van )

operátor típusa

Használja a kezelőt példány, amikor meg kell erősítenie egy objektum típusát futás közben. Például kivételek elkapásakor különböző kivételkezelési programozási ugrásokat hozhat létre a kezelt kivétel típusától függően.

Például a következő kód az instanceof operátort használja annak tesztelésére, hogy a nap dátum objektum-e. Mivel a theDay valóban egy Date objektum, a program végrehajtja az if utasításban található kódot.

Var theDay = new Date(1995, 12, 17); if (a dátum dátuma) ( // futtatható kód)

Üzemeltetői elsőbbség

Prioritás Az operátorok meghatározzák a végrehajtásuk sorrendjét egy kifejezés kiértékelésekor. Zárójelekkel befolyásolhatja az operátor elsőbbségét.

Az alábbi táblázat a kezelői elsőbbséget írja le a legmagasabbtól a legalacsonyabbig.

3.7. táblázat Kezelői prioritás

Üzemeltető típusa	Üzemeltetők
tárgytulajdonság	.
hívás, objektum példányosítás	() új
tagadás, növelés	! ~ - +++ -- typeof void delete
szorzás, osztás	* / %
összeadás, kivonás	+ -
biteltolás	<< >> >>>
összehasonlítás, bejegyzés	< <= >>= példány
egyenlőség	== != === !==
bit-és	&
bit-kizárólagos-vagy	^
bit-vagy	|
logikai-és	&&
logikai-ill	||
feltételes (háromtagú) operátor	?:
feladat	= += -= *= /= %= <<= >>= >>>= &= ^= |=
vessző	,

Több részletes változat ez a hivatkozásokat tartalmazó táblázat és További információ minden operátor esetében a JavaScript hivatkozásban található.

Kifejezések

Kifejezés bármely érvényes kódblokk, amely értéket ad vissza.

Fogalmilag kétféle kifejezés létezik: azok, amelyek értéket rendelnek egy változóhoz, és azok, amelyek kiértékelnek egy értéket anélkül, hogy hozzárendelnék.

Az x = 7 kifejezés egy példa az első típusú kifejezésre. Ez a kifejezés használ operátor= az x változóhoz a 7 értéket hozzárendelni . Maga a kifejezés is 7.

A 3 + 4 kód egy példa a második típusú kifejezésre. Ez a kifejezés azt használja operátor"+" a 3-as és 4-es szám hozzáadásához anélkül, hogy a kapott 7-es eredményt egy változóhoz rendelné.

A JavaScript minden kifejezése a következő kategóriákba tartozik:

Alapvető kifejezések

Alapvető kulcsszavakatés alapvető kifejezések JavaScriptben.

ezt az operátort

Használja ezt a kulcsszót az aktuális objektumra való hivatkozáshoz. Ez általában arra a hívható objektumra mutat, amelyhez ez a metódus tartozik. Használja ezt így:

This["propertyName"] this.propertyName

Tegyük fel, hogy a validate függvény valamely objektum érték tulajdonságát ellenőrzi; az objektum meg van adva, valamint a tulajdonság értékének felső és alsó határa:

Függvény validate(obj, lowval, hival)( if ((obj.value< lowval) || (obj.value >hival)) alert("Érvénytelen érték!"); )

Meghívhatja az érvényesítési függvényt az onChange eseménykezelőben minden űrlapelemhez, ezzel az űrlapelemre mutatva, ahogy az a következő példában látható:

Írjon be egy számot 18 és 99 között:

Csoportosítás operátor

A "zárójelek" () csoportosító operátor szabályozza a kifejezés kiértékelésének prioritását. Például újradefiniálhatja a sorrendet - "szorzás és osztás, majd összeadás és kivonás", így például az összeadás a szorzás előtt történik:

Vara = 1; var b = 2; var c = 3; // normál sorrend a + b * c // 7 // a szokásos módon fut, tehát a + (b * c) // 7 // most fordítsa meg a sorrendet // összeadás a szorzással (a + b) * c // 9 // ami ekvivalens a * c + b * c // 9

Egyszerűsített szintaxis tömbök és generátorok létrehozásához

Az egyszerűsített szintaxis egy kísérleti JavaScript-szolgáltatás, amely hozzáadható az ECMAScript jövőbeli verzióihoz. A szintaxisnak 2 verziója létezik:

Egyszerűsített szintaxis a tömbökhöz. ((x of y) y) Egyszerűsített szintaxis generátorokhoz.

Az egyszerűsített szintaxisok számos programozási nyelvben léteznek, és lehetővé teszik egy új tömb gyors felépítését egy meglévő tömb alapján. Például:

) i*i ]; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; ; // [ "a", "b", "c" ]

Balkezes kifejezések

A bal oldali értékekhez a jobb oldali értékek tartoznak.

új

Az új operátor segítségével egy felhasználó által meghatározott típusú objektumot vagy a beépített objektumok egyikét példányosíthatja. Használja az új operátort a következőképpen:

Var objectName = new objectType();

szuper

A kulcsszó a szülőobjektum függvényeinek meghívására szolgál. Ez olyan osztályoknál is hasznos, amelyek például a szülő konstruktorát hívják meg.

Szuper(); // meghívja a szülő konstruktorát. super.functionOnParent();

Kiterjesztés operátor

A spread operátor lehetővé teszi, hogy egy kifejezés több argumentummal (függvényhívásoknál) vagy több elemmel (tömböknél) bővüljön.

Példa: Ma, ha van egy tömbje, és újat szeretne létrehozni az első meglévő részével, akkor a literális tömb szintaxisa már nem elegendő, és kötelező (változat nélküli) kódot kell írnia a push , splice , splice kombinációjával. concat stb. De ezzel az operátorral a kód rövidebb lesz:

Var parts = ["váll", "térd"]; var lyrics = ["fej", ...részek, "és", "lábujjak"];

Az operátor hasonlóan működik a függvényhívásokkal:

f(x, y, z) függvény ( ) var args = ; f(...args);

Kifejezések JavaScriptben kombinációk operandusokés operátorok.

Tevékenységek kifejezésekben a prioritás értékének megfelelően szekvenciálisan hajtódnak végre (minél magasabb a prioritás érték, annál magasabb). A visszaadott eredmény nem mindig azonos típusú a feldolgozott adatok típusával. Például az összehasonlítási műveletekben részt vevő operandusok különféle típusok, de a visszaadott eredmény mindig logikai érték lesz.

Rizs. 1. A kifejezés szerkezete JavaScriptben

operandusok a JavaScript szkript által feldolgozott adat. Az operandusok lehetnek egyszerű típusok adatok és összetett, valamint egyéb kifejezések.

Üzemeltetők a nyelv szimbólumai, amelyek különféle műveleteket hajtanak végre az adatokon. Az operátorok írásjelekkel vagy kulcsszavakkal írhatók.

Az operandusok számától függően a következő típusú operátorokat különböztetjük meg:
egységes- egy operandus vesz részt a műveletben;
bináris— két operandus vesz részt a műveletben;
hármas— három operandust kombinál.

A kifejezés legegyszerűbb formája az szó szerinti— valami, ami önmagában kiértékeli, például a 100-as szám, a "Hellow world" karakterlánc. A változó lehet kifejezés is, mivel a hozzárendelt értékre értékeli ki.

Kifejezések és operátorok a JavaScriptben

1. Aritmetikai operátorok

Aritmetikai operátorok teljesítésére tervezték matematikai műveletek, numerikus operandusokkal (vagy numerikus értékeket tároló változókkal) működnek, és ennek eredményeként numerikus értéket adnak vissza.

Ha az egyik operandus egy karakterlánc, a JavaScript értelmező megpróbálja numerikus típussá alakítani, majd végrehajtja a megfelelő műveletet. Ha a típuskonverzió sikertelen, az eredmény NaN (nem szám) lesz.

1. táblázat Aritmetikai operátorok

Kezelő/Üzemeltető	Leírás	Prioritás
+ Kiegészítés	Numerikus operandusokat ad hozzá. Ha az egyik operandus egy karakterlánc, akkor a kifejezés eredménye egy karakterlánc.	12
- Kivonás	Kivonja a második operandust az elsőből.	12
- Egyedi mínusz	Pozitív számot negatív számmá alakít, és fordítva.	14
* Szorzás	Két operandust megszoroz.	13
/ Osztály	Az első operandust elosztja a másodikkal. Az osztás eredménye lehet egész vagy lebegőpontos szám.	13
% Modulo (a részleg fennmaradó része)	Kiszámítja az első operandus egész számmal való osztásának maradékát a másodikkal. Egész számokra és lebegőpontos számokra egyaránt vonatkozik.	13

var x = 5, y = 8, z; z = x + y // 13-at ad vissza z = x - y; // -3 értéket ad vissza z = - y; // -8 z = x * y értéket ad vissza; // 40-et ad vissza z = x / y; // 0,625-öt ad vissza z = y % x; // visszatérés 3

2. Hozzárendelési operátorok

Hozzárendelési operátorok változókhoz való értékek hozzárendelésére szolgálnak. A kombinált operátorok lehetővé teszik a kezdeti és az azt követő érték tárolását egy változóban.

var a = 5; // az 5-ös számérték hozzárendelése a változóhoz var b = "hellow"; // a hellow karakterlánc tárolása a b változóban var m = n = z = 10; // az m, n, z változókhoz hozzárendeljük a 10 x += 10 számértéket; // egyenértékű x = x + 10; x = 10; // egyenértékű x = x - 10; x *= 10; // ekvivalens: x = x * 10; x /= 10; // egyenértékű x = x / 10; x%=10; // egyenértékű x = x % 10;

3. Növelési és csökkentési operátorok

Tevékenységek növekedés és csökkentés unárisak, és eggyel növelik és csökkentik az operandus értékét. Az operandus lehet változó, tömbelem, objektumtulajdonság. Leggyakrabban az ilyen műveleteket a számláló hurokban történő növelésére használják.

var x = y = m = n = 5, z, s, k, l; z = ++x*2; /* a számítások eredményeként a z = 12, x = 6 értéket adja vissza, azaz. az x értéket először 1-gyel növeljük, majd végrehajtjuk a szorzási műveletet */ s = y++ * 2; /* a számítások eredményeként az s = 10, y = 6 értéket adja vissza, azaz. először a szorzási műveletet hajtjuk végre, majd az 1-gyel növelt értéket az y */ k = --m * 2 változóban tároljuk; // a k = 8, m = 4 értéket adja vissza l = n-- * 2; // l = 10, n = 4 értéket ad vissza

4. Összehasonlító operátorok

Összehasonlító operátorok operandusok egyeztetésére szolgálnak, a kifejezés eredménye két érték egyike lehet - igaz vagy hamis . Az operandusok nem csak számok, hanem karakterláncok, logikai értékek és objektumok is lehetnek. Az összehasonlítást azonban csak számokon és karakterláncokon lehet végrehajtani, ezért azokat az operandusokat konvertálja, amelyek nem számok vagy karakterláncok.

Ha mindkét operandus nem konvertálható sikeresen számokká vagy karakterláncokká, az operátorok mindig false értéket adnak vissza.

Ha mindkét operandus karakterlánc/szám, vagy karakterláncokká/számokká konvertálható, akkor ezeket karakterláncként/számként hasonlítja össze.

Ha az egyik operandus egy karakterlánc/karakterláncsá alakít, a másik pedig egy szám/számmá alakítja, akkor az operátor megkísérli a karakterláncot számmá alakítani, és numerikus összehasonlítást végez. Ha a karakterlánc nem szám, akkor a rendszer NaN-re konvertálja, és az összehasonlítás hamis értékre változik.

Leggyakrabban az összehasonlító műveleteket a programok fiókjainak szervezésekor használják.

4. táblázat Összehasonlító operátorok

Kezelő/Üzemeltető	Leírás	Prioritás
== Egyenlőség	Két értéket tesztel az egyezéshez, lehetővé téve a típuskonverziót. Igaz értéket ad vissza, ha az operandusok azonosak, és hamis értéket, ha különböznek.	9
!= Egyenlőtlenség	Igaz értéket ad vissza, ha az operandusok nem egyenlőek	9
=== Identitás	Két operandust tesztel "identitás" szempontjából szigorú egyezési definíció segítségével. Igaz értéket ad vissza, ha az operandusok típuskonverzió nélkül egyenlőek.	9
!== Nem azonos	Személyazonosság-ellenőrzést végez. Igaz értéket ad vissza, ha az operandusok típuskonverzió nélkül nem egyenlőek.	9
> Többet	Igaz értéket ad vissza, ha az első operandus nagyobb, mint a második, ellenkező esetben false értéket ad vissza.	10
>= Nagyobb vagy egyenlő	Igaz értéket ad vissza, ha az első operandus nem kisebb, mint a második, ellenkező esetben false értéket ad vissza.	10
	Igaz értéket ad vissza, ha az első operandus kisebb, mint a második, ellenkező esetben false értéket ad vissza.	10
	Igaz értéket ad vissza, ha az első operandus nem nagyobb, mint a második, ellenkező esetben false értéket ad vissza.	10

5 == "5"; // igaz 5-öt ad vissza != -5.0; // igaz 5 értéket ad vissza === "5"; // false false === false; // igaz 1-et ad vissza !== igaz; // igaz 1-et ad vissza != igaz; // hamis értéket ad vissza, mivel az igaz 1 3 > -3 értékre lesz konvertálva; // igaz 3-at ad vissza >= "4"; // false értéket ad vissza

5. Logikai operátorok

Logikai operátorok lehetővé teszi a logikai értékeket visszaadó feltételek kombinálását. Leggyakrabban if utasításban használatos.

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); // igazat ad vissza, ha x 0 és 10 között van !false; // igazat ad vissza

6. Bitenkénti operátorok

Bitenkénti operátorok az operandusokat nullák és egyesek 32 bites sorozataként operálja, és a művelet eredményét jelző, decimális jelöléssel írt számértéket ad vissza. Az operandusok egész számok, törtrész operandus el van vetve. A bitenkénti műveletek használhatók például adatok titkosításakor, zászlókkal való munkavégzéskor és hozzáférési jogok elhatárolásakor.

6. táblázat Bitenkénti operátorok

Kezelő/Üzemeltető	Leírás	Prioritás
& Bitenkénti ÉS	Ha mindkét bit 1, akkor a kapott bit 1 lesz. Ellenkező esetben az eredmény 0.	8
| Bitenkénti VAGY	Ha az egyik operandus a pozícióban 1-et tartalmaz, akkor az eredmény ezen a helyen is 1-et tartalmaz, ellenkező esetben az adott pozícióban lévő eredmény 0 lesz.	6
^ XOR	Ha egy, és csak egy érték bármely pozícióban 1-et tartalmaz, akkor az eredmény ezen a helyen 1-et fog tartalmazni, ellenkező esetben az adott pozícióban az eredmény 0 lesz.	7
~ Tagadás	A rendszer bitenkénti negációs műveletet hajt végre bináris reprezentáció kifejezési értékek. Bármely pozíció, amely 1-et tartalmaz az eredeti kifejezésben, 0-ra cserélődik. Az eredeti kifejezésben 0-t tartalmazó bármely pozíció 0 lesz. A pozitív számok 0 , a negatív számok -1 , tehát ~ n == -(n+1) .	14
	Az operátor az első operandus bitjeit balra tolja a bitpozíciók számával a második állapította meg operandus. A nullák a jobb oldali pozíciók kitöltésére szolgálnak. Ugyanolyan típusú eredményt ad vissza, mint a bal oldali operandus.	11
>> Biteltolás jobbra	Az operátor az első operandus bitjeit jobbra tolja a második operandus által beállított bitpozíciók számával. A tartományon kívüli számjegyek eltávolításra kerülnek. A legjelentősebb bitet (32.) változatlanul hagyjuk, hogy az eredmény előjele megmaradjon. Ha az első operandus pozitív, akkor az eredmény magas bitjei nullákkal töltődnek fel; ha az első operandus negatív, akkor az eredmény magas bitjei eggyel vannak kitöltve. Egy érték jobbra eltolása egy pozícióval megegyezik a 2-vel való osztással (a maradék elvetésével), a jobbra két pozícióval való eltolás pedig a 4-gyel való osztással, és így tovább.	11
>>> Bitenkénti jobbra eltolás előjel nélkül	Az operátor az első operandus bitjeit jobbra tolja a második operandus által beállított bitpozíciók számával. Az első operandus előjelétől függetlenül nullákat adunk a bal oldalra. A tartományon kívüli számjegyek eltávolításra kerülnek.	11

var x = 9, y = 5, z = 2, s = -5, eredmény; // 9 ekvivalens 1001-nek, 5 0101 eredmény = x & y; // 1-et ad vissza (0001-nek megfelelő) eredmény = x | y; // 13-at ad vissza (1101-nek egyenértékű) eredmény = x ^ y; // 12-t ad vissza (1100-nak egyenértékű) eredmény = ~ y; // -6-ot ad vissza (ez 1100-nak felel meg) eredmény = x<< y; // вернет 288 (эквивалентно 100100000) result = x >>z; // 2-t ad vissza (10-nek megfelelő) eredmény = s >>> z; // 1073741822-t ad vissza (egyenértékű: 11111111111111111111111111110)

7. String operátorok

Számos operátor létezik, amely speciális módon kezeli a karakterláncokat.

"1" + "10"; // a következőt adja vissza: "110" "1" + 10; // „110” 2 + 5 + „színes ceruzák” értéket ad vissza; // „7 színes ceruza” „Színes ceruzák” + 2 + 5; // „Színes ceruzák 25” „1” > „10”; // hamis "10"-et ad vissza<= 10; // вернет true "СССР" == "ссср"; // вернет false x = "micro"; x+= "soft"; // вернет "microsoft"

8. Speciális operátorok

8. táblázat: Speciális operátorok

Kezelő/Üzemeltető	Leírás	Prioritás
. Hozzáférés egy ingatlanhoz	Hozzáfér egy objektum egy tulajdonságához.	15
, Többszörös számítás	Egy sorba írt több független kifejezést értékel.	1
Tömb indexelés	Hozzáfér tömbelemekhez vagy objektumtulajdonságokhoz.	15
() Funkcióhívás, csoportosítás	Csoportosítja a műveleteket vagy meghív egy függvényt.	15
typeof Adattípus definíció	Unáris operátor, az operandus adattípusát adja vissza.	14
instanceof Ellenőrizze az objektumtípust	Az operátor ellenőrzi, hogy egy objektum egy adott osztály példánya-e. A bal oldali operandusnak objektumnak kell lennie, a jobb oldalinak pedig az objektumosztály nevét. Az eredmény igaz, ha a bal oldalon megadott objektum a jobb oldalon megadott osztály példánya, egyébként hamis.	10
Az ingatlan létezésének ellenőrzése részben	A bal oldali operandusnak karakterláncnak, a jobb oldali operandusnak pedig tömbnek vagy objektumnak kell lennie. Ha a bal oldali érték egy objektum tulajdonsága, az eredmény igaz lesz.	10
új objektum létrehozása	Az operátor létrehoz egy új objektumot definiálatlan tulajdonságokkal, majd meghívja a konstruktor függvényt, hogy inicializálja (paraméterek átadása). Tömb létrehozására is használható.	1
töröl	Az operátor lehetővé teszi egy tulajdonság eltávolítását egy objektumból vagy egy elemet egy tömbből. Igazat ad vissza, ha a törlés sikeres volt, hamis értéket egyébként. Egy tömbelem eltávolításakor a hossza nem változik.	14
void Visszatérési érték nélküli kifejezés meghatározása	Unáris operátor, elveti az operandus értékét, és alulfinomult értéket ad vissza.	14
?: Feltételes kifejezés művelet	A háromtagú operátor lehetővé teszi az egyszerű elágazás megszervezését. A kifejezésben három operandus vesz részt, az elsőnek logikai értéknek kell lennie, vagy arra kell konvertálni, a másodiknak és a harmadiknak pedig tetszőleges értéknek kell lennie. Ha az első operandus igaz , akkor a feltételes kifejezés a második operandus értékét veszi fel; ha hamis - akkor a harmadik.	3

document.write("hello világ"); // megjeleníti a karakterláncot hello world i = 0, j = 1; // értékek tárolása a változókban function1(10, 5); // függvényhívás függvény1 10-es és 5-ös paraméterekkel var year = ; // tömböt hoz létre typeof (a:1) elemekkel; // az "object"-t adja vissza var d = new Date(); // új objektum létrehozása a Date() konstruktor használatával d példány of Date; // visszaadja a true var mycar = (gyártó: "Honda", modell: "Accord", év: 2005); "make" in mycar; // true értéket ad vissza var obj = new Object(); // üres objektumot hoz létre var food = ["tej", "kenyér", "hús", "olívaolaj", "sajt"]; törölje az ételt; // eltávolítja a negyedik elemet a tömb élelmiszerből x > 10 ? x*2:x/2; // x * 2 értéket ad vissza, ha x > 10, ellenkező esetben x / 2

9. Megjegyzések JavaScriptben

Egysoros megjegyzés: a megjegyzés szövege elé kerüljön // karakter.

Először is, röviden a JavaScript kifejezéseiről.

JavaScript kifejezések

A JavaScript utasításokat és kifejezéseket tartalmaz.

Az utasítások nem adnak vissza értékeket.

Kifejezések mindig visszaad néhány értéket. Amikor az értelmező lát egy kifejezést, kiértékeli annak értékét, és lecseréli a kifejezést az értékére.

A kifejezések egyszerűek vagy összetettek. Az egyszerű kifejezések nem tartalmaznak más kifejezéseket.

Az egyszerű kifejezések a következők:

1. Azonosítók: someVar (változónév);
2. Literálok: "karakterlánc" vagy 675 (szám vagy numerikus literál);
3. Néhány ehhez hasonló kulcsszó ;

Amikor az elemző találkozik egy azonosítóval, először ki kell számítania az értékét, azaz például le kell cserélnie egy változó nevét annak értékére.

A literál értéke ugyanaz lesz, mint a szkript kódjában.

Operátorok és összetett JavaScript-kifejezések

Az operátorokat arra használják, hogy több egyszerű kifejezést egyetlen összetett kifejezéssé kombináljanak.

Az üzemeltetők a következők:

• Unáris (egy operandus).
• Bináris (két operandus).
• hármas operátor? JavaScriptben (három operandus, csak egy hármas operátor van).

Az operandus egy egyszerű kifejezés, amelyre operátort alkalmazunk.

Például a "+" aritmetikai összeadás operátor bináris operátor. Összegezi a bal és jobb operandust, és visszaadja az összeget.

vardigit = 4 + 7;

A hozzárendelés egyébként a "="" hozzárendelési operátor használatával történik. Ez az operátor kiértékeli a jobb oldali operandus értékét, és hozzárendeli a bal oldali operandushoz.

A JavaScriptnek van egy unáris pluszja, csak egy operandusa van. Unary plus nem aritmetikai operátor, az operandust számmá alakítja.

Var myVar = "7"; document.write(typeof(myVar) + "
"); // Kiírja a karakterláncot myVar = +sajatVar; document.write(typeof(myVar) + "
"); // Szám nyomtatása a dokumentumban

A myVar eleinte a "7" karakterláncot tartalmazta, amely a karakterlánc típusának (karakterlánc) literálja, nem pedig numerikus (szám). Az unáris plusz operátor segítségével a karakterlánc literált numerikussá alakítottuk.

Aritmetikai műveletek

Az aritmetikai műveletek jól ismert matematikai műveletek.

Talán a % (maradvány) operátor pontosításra szorul. A 9 osztható 5-tel 4 maradékával, és ezt a maradékot adja vissza ez az operátor. Modulo felvételének is nevezik. Egész számok használatakor ennek az operátornak az eredménye is egész szám lesz. Ha lebegőpontos számokkal dolgozunk, az eredmény egy lebegőpontos szám lesz.

5.5 % 2.2 = 1.1

Az aritmetikai műveletek során emlékezni kell arra, hogy ha helytelenül hajtják végre, eredményekhez vezethetnek:

• NaN (Not a Number) – nem szám.
• Végtelen – végtelen.

Íme, mit eredményez a nullával való osztás:

Var myVar = 0/0; document.write("Változó értéke: " + myVar + ", típusa: " + typeof(myVar) + "
");

Összehasonlító műveletek

Az összehasonlító operátorokat a kifejezések egyeztetésére használják. A feltételes operátorral rendelkező kifejezés logikai értéket ad vissza – igaz vagy hamis (igaz / hamis).

Összehasonlító műveletek sztringekkel is elvégezhetők, erről egy másik leckében lesz szó. A helyes eredmény egyetlen feltétele az azonos típusú adatok egyezése. Ellenkező esetben a JavaScript megpróbálja az adatokat egyik típusból a másikba konvertálni, és ez nem mindig lehetséges. A hibák elkerülése érdekében csak az azonos típusú adatokat hasonlítsa össze.

Hozzárendelési műveletek

A hozzárendelési operátor legkézenfekvőbb példája az egyszerű hozzárendelés (=). Ez az operátor (=) értéket rendel egy változóhoz.

De számos olyan hozzárendelési művelet létezik, amelyek rövidítettek.

Boole-műveletek

A logikai műveleteket gyakran használják az if else konstrukcióval a JS-ben. Munkájukat ennek a tervnek a példáin mutatják be. De először a logikai operátorok listája.

Most egyszerű példák:

If (igaz és igaz) document.write("Működik!
"); if (igaz || hamis) document.write("Működik!
"); if (!false) document.write("Működik!
");

Nézzük meg ezeket a példákat:

A logikai ÉS operátor (&&) igaz értéket ad vissza, ha mindkét operandus igaz.

A logikai VAGY operátor (||) igazat ad vissza, ha legalább egy operandus igaz.

A logikai NOT operátor (!) vesz egy operandust, és megfordítja az igaz/hamis értéket.

Unáris operátorok

Az unáris operátorok egy operandussal rendelkező operátorok. Íme néhány ilyen operátor:

• ++ - növelés 1-gyel (növekmény). Lehet elő- és utótag is, erről lentebb olvashat bővebben.
• -- - 1-gyel csökkenteni (csökkenteni). Lehet elő- és utótag is, erről lentebb olvashat bővebben.
• + - unáris plusz.
• - - egységes mínusz.

egységes mínusz

Az unáris mínusz megfordítja a kifejezés előjelét. Például, amikor egy programban -100-at ír, akkor egyszerűen egy unáris mínuszt alkalmaz a 100-as numerikus literálra.

Pontosan meg kell értenie az unáris mínusz működését - az operandus értékét az ellenkező előjellel adja vissza. Íme egy példa az unáris mínusz helyes használatára:

Var myVar = -100; document.write(-myVar + " - az unáris mínusz működött, de a változó is = " + myVar + ".
"); myVar = -sajatVar; document.write("Most változó = " + myVar + ".
");

Itt van egy értelmetlen példa a kettős unáris mínuszra. Szerintem hasznos lesz oktatási célokra:

Var myVar = -100; document.write(--myVar + " egy növekmény, nem pedig egy dupla unáris mínusz.
"); document.write("Most változó = " + myVar + ".
"); document.write(-(-sajatVar) + ", amely az unáris mínusz kettős használata.
");

egységes plusz

Az unáris plusz nem végez matematikai műveleteket. Literált numerikus típusba önt.

Var myVar = "78687"; document.write(typeof(myVar) + ".
"); myVar = +sajátVar; document.write(typeof(myVar) + ".
");

növekedés és csökkentés

A programozás során gyakran szükséges egy változó értékét eggyel növelni vagy csökkenteni. Ehhez unáris operátorok vannak:

• ++ - növelés 1-gyel (növekmény).
• -- - 1-gyel csökkenteni (csökkenteni).

Az unáris plusztól és mínusztól eltérően a növekmény és a csökkentés megváltoztatja a változó értékét híváskor.

Var myVar = 10; document.write(++myVar + ".
"); document.write(myVar + ".
");

A csökkentés (-- ) hasonlóan működik.

Most nézzük meg ezen operátorok elő- és utótag-használatát.

• ++myVar - előtag növelése 1-gyel.
• myVar++ - postfix növelés 1-gyel.

A különbség a következő:

• Ezen operátorok prefix használata először kiértékeli az unáris operátor értékét, majd az eredményt használja a kifejezésben.
• A Postfix használata először kiértékeli a kifejezést, majd végrehajtja az unáris operátort (++ vagy -- ).

Egy egyszerű példa segít megérteni ezt:

Var myVar = 10; document.write((++myVar + 5) + ".

"); var myVar = 10; document.write((sajatVar++ + 5) + ".
"); document.write("Változó = " + myVar + ".
");

Növekedés és csökkentés csak változókkal használható, numerikus literálokra nem alkalmazható. Egyszerűen fogalmazva, a ++7 kód hibát adott a szkriptben.

Egyéb operátorok

A JavaScriptnek más operátorai is vannak:

• Ternáris (három operandussal) operátor

Dokumentum tartalomjegyzék

A JavaScript egy kompakt operátorkészletet támogat, amellyel interaktív weboldalak hozhatók létre. Ez a fejezet áttekintést nyújt ezekről az operátorokról.

Ez a fejezet a következő szakaszokat tartalmazza rövid áttekintés minden operátor:

• Blokkoperátorok: { }

• Feltételes nyilatkozatok: ha másés kapcsoló

• Hurok operátorok: for, while, do...míg, címkézz, törj és folytasd (címkeönmagában nem hurokutasítás, de gyakran használják az említett kijelentésekkel)

• Tárgymanipulációs operátorok: beés val vel

• Hozzászólások

• Kivételkezelési nyilatkozatok: próbáld... elkapniés dobás

Bármely kifejezés egyben operátor is. Lásd a 3. fejezetet a "Kifejezések és műveletek" fejezetben a műveletek teljes részleteiért.

Használja a pontosvesszőt (;) az utasítások elválasztásához a JavaScript-kódban.

Lásd: Core JavaScript. Könyvtár. részleteket az operátorokról ebből a fejezetből.

1. Kimutatás blokk

Egy utasításblokk az utasítások csoportosítására szolgál. A blokkot göndör kapcsos zárójelek határolják:

( állítás1 állítás2 . állítás )

2. Feltételes állítások

A feltételes utasítás olyan parancsok halmaza, amelyek akkor futnak le, ha a megadott feltétel: igaz. A JavaScript két feltételes utasítást támogat: ha másés kapcsoló.

2.1. ha...egyéb kijelentés

Ez az utasítás bizonyos utasítások végrehajtására szolgál logikai feltétel esetén igaz; opcionális blokkot használjon más más utasítások végrehajtására, ha a feltétel hamis. Az if utasítás így néz ki:

if (feltétel ) ( utasítások1 ) [ else ( utasítások2 ) ]

A feltétel bármely JavaScript-kifejezés lehet, amely kiértékelődik igaz vagy hamis. A végrehajtandó utasítások bármilyen JavaScript utasítások lehetnek, beleértve a beágyazott utasításokat is. ha. Ha az utasítások után egynél több utasítást kell végrehajtania ha vagy más, ezeket a végrehajtható utasításokat kapcsos zárójelek közé kell tennie ().

Ne használjon egyszerű hozzárendeléseket egy feltételes utasításban. Például NE használja ezt a kódot:

Ha hozzárendelést kell használnia egy feltételes utasításban, tegyen extra zárójeleket a hozzárendelési utasítás köré. Például, ha((x = y)).

Ne keverje össze a primitívet Boolean-értékek igazés hamisértékekkel igazés hamis tárgy Boolean. Minden olyan objektum, amelynek értéke nem meghatározatlan, nulla, nulla, **NaN** vagy az üres karakterlánc, beleértve az objektumot Boolean jelentéssel hamis, -ben van kiszámítva igaz amikor átadjuk a feltételes operátornak. Például:

varb = new Boolean(false) ; ha (b) // ez a feltétel igazra értékelődik

Példa.

Ebben a példában a függvény checkData visszatér igaz ha a karakterek száma benne Szöveg-objektum egyenlő hárommal; ellenkező esetben figyelmeztetést nyomtat és visszatér hamis.

függvény checkData () ( if (dokumentum . form1 . threeChar . value . long == 3 ) ( true return ) else ( alert (" Írjon be pontosan három karaktert." + document . form1 . threeChar . value + " érvénytelen. " ) vissza hamis ))

2.2. switch utasítás

Operátor kapcsoló lehetővé teszi a program számára, hogy kiértékelje a kifejezést, és megpróbálja egyeztetni a kifejezés értékét az esetcímkében található értékkel. Ha talál egyezést, a program végrehajtja a kapcsolódó utasítást. Operátor kapcsolóígy néz ki:

switch (kifejezés )( case label : utasítás ; break ; case label : utasítás ; break ; ... default : utasítás; )

A program először megkeresi címke, amely megfelel az értéknek kifejezés majd végrehajtja a kapcsolódó utasítást. Ha egyezik címke nem található, a program egy választható lehetőséget keres alapértelmezett nyilatkozat/ operátor az alapértelmezett, és ha megtalálják, végrehajtja a társított operátort. Ha egy alapértelmezett nyilatkozat nem található, a program az utasítás végét követően is végrehajtja az utasítást kapcsoló.

Opcionális kezelő szünet, amely a címkéhez kapcsolódik ügy címke, garantálja, hogy a program megszakítja az utasítás végrehajtását kapcsoló, amint a talált egyezés utasítása végrehajtásra kerül, és folytassa a végrehajtást az utasítást követő utasítástól kapcsoló. Ha egy szünet hiányzik, a program folytatja az utasításon belüli következő utasítás végrehajtását kapcsoló.

Példa.

Itt ha expr kiértékeli a Bananas -t, a program megfelelteti a Bananas kis- és nagybetűket, és végrehajtja a kapcsolódó utasítást. Ha törést talál, a program leáll kapcsolóés az utasításblokk után végrehajtja az utasítást kapcsoló. Ha egy szünet hiányzik, kezelő be ügy A cseresznye is elkészül.

kapcsoló (kifejezés ) ( "Narancsok" eset : dokumentum . írás (" A narancs 0,59 dollár fontonként.
" ) ; break ; case " Apples " : document . write (" Az alma fontja 0,32 dollár.
" ) ; break ; case "Banán" : dokumentum . write (" A banán fontonként 0,48 dollár.
" ) ; break ; case " Cseresznye " : dokumentum . írás ( " A cseresznye fontja 3,00 dollár.
" ) ; break ; default : document . write (" Sajnáljuk, kifogytunk a " + i + " -ból .
" ) ; ) document.write(" Van még valami, amit szeretnél?
" ) ;

3. Loop utasítások

Ciklus/ hurok ez olyan utasítások halmaza, amelyek többször végrehajtásra kerülnek, amíg egy meghatározott feltétel nem teljesül. A JavaScript támogatja a ciklikus utasításokat számára, csinálni, miközbenés míg, szintén címke (címkeönmagában nem hurokutasítás, de gyakran használják az említett kijelentésekkel). Alternatív megoldásként használhatja az operátorokat szünetés folytatni belső ciklusú utasítások.

Egy újabb hurokállítás be, szintén ciklusban hajtja végre utasításait, de objektumok műveletére használják. Lásd: Objektummanipulációs operátorok.

3.1. nyilatkozathoz

Ciklus számára ismétlődik a megadott értékig hamis. JavaScript ciklus számára ciklusokhoz hasonlóan számára Java és C. Operátor számáraígy néz ki:

for ([ kezdeti kifejezés ] ; [ feltétel ] ; [ incrementExpression ]) ( utasítások )

Amikor a ciklus számára végrehajtva a következő történik:

1. Kifejezés inicializálása kezdeti kifejezés, ha van, végrehajtódik. Ez a kifejezés általában egy vagy több hurokszámlálót inicializál, és a szintaxis bármilyen bonyolultságú kifejezést lehetővé tesz. Ez a kifejezés változókat is deklarálhat.

2. A feltétel kifejezés kiértékelésre kerül. Ha az érték állapot - igaz, az utasítások/hurokutasítások végrehajtásra kerülnek. Ha az érték feltétel - hamis, ciklus számára leáll. Ha a kifejezés állapot teljesen hiányzik, feltételezhető állapot - igaz.

3. Elvégezve nyilatkozatok.

4. Frissítse a kifejezést incrementExpression, ha van, végrehajtódik, és a vezérlés visszatér a 2. lépéshez.

Példa.

Ez a funkció tartalmazza az operátort számára, amely megszámolja a kiválasztott opciók számát egy görgethető listában (objektum Válassza ki, amely lehetővé teszi több elem kiválasztását). Operátor számára változót deklarál énés inicializálja nullára. Ellenőrzi, ha kevesebb én objektum opciók száma Válassza ki, végrehajtja az utasítást haés változó növekmény én eggyel a ciklus minden iterációja után.

Válasszon ki néhány zenetípust, majd kattintson az alábbi gombra:
R&B Dzsessz Blues új kor klasszikus Opera

"alert("A kiválasztott opciók száma: " + howMany(document.selectForm.musicTypes))">

3.2. do...míg nyilatkozat

Operátor csinálni, miközben addig ismétlődik, amíg a megadott kifejezés meg nem lesz hamis. Operátor csinálni, miközbenígy néz ki:

do ( állítás ) while ( feltétel )

nyilatkozat egyszer végrehajtásra kerül a feltétel ellenőrzése előtt. Ha egy állapot - igaz, az utasítás újra végrehajtásra kerül. Minden futás végén állapot ellenőrizve. Ha egy feltétel - hamis, a végrehajtás leáll, és az irányítás átkerül a kezelőhöz, miután csinálni, miközben.

Példa.

Ebben a példában a hurok csináld legalább egyszer ismétlődik, és addig ismétlődik én Kevésbé 5 .

do ( i += 1 ; dokumentum . írás (i ) ; ) while (i< 5 ) ;

3.3. míg nyilatkozat

Operátor míg utasításait végrehajtja, amíg a megadott feltétel fennáll igaz. Operátor mígígy néz ki:

while ( feltétel ) ( állítások )

Ha egy állapot válik hamis, a cikluson belüli utasítások végrehajtása leáll, és a vezérlés átkerül a ciklust követő utasításba.

A feltétel/állapot ellenőrzése a cikluson belüli utasítások végrehajtása előtt történik. Ha egy állapot visszatér igaz, az utasítások végrehajtásra kerülnek és állapotújra ellenőrizve. Ha az állapot visszatér hamis, a hurok végrehajtása megszakad, és a vezérlés átkerül az operátort követő operátorhoz míg.

1. példa

Ezt a ciklust míg ig ismétlődik n Kevésbé 3 :

n = 0 x = 0 míg (n< 3 ) { n ++; x += n ; }

Minden iterációval a ciklus növekszik nés adja hozzá ezt az értéket a változóhoz x. Következésképpen, xés n vegyük a következő értékeket:

• Az első menet után: n=1 és x=1

• A második passz után: n=2 és x=3

• A harmadik passz után: n=3 és x=6

A ciklus három iterációja után állapot n< 3 már nem igaz, ezért a ciklus megszakad.

2. példa: Végtelen hurok.

Győződjön meg arról, hogy a hurokállapot egy napon azzá válik hamis; különben a ciklus soha nem szakad meg. Következő ciklus nyilatkozatai míg határozatlan ideig végrehajtódnak, mivel a feltétel soha nem válik be hamis:

while (true ) ( alert (" Hello, world " ) )

3.4. címke nyilatkozat

Operátor címke egy azonosító, amelyre a programban bárhonnan hivatkozni lehet. Például használhatja címke hogy azonosítsa a hurkot, majd használja az utasításokat szünet vagy folytatni a hurok megszakításához vagy a végrehajtás folytatásához.

Operátori szintaxis címkeígy néz ki:

címke : nyilatkozat

Jelentése címke bármilyen érvényes JavaScript azonosító lehet, amely nem lefoglalt szó. által azonosított nyilatkozat címke, bármely operátor lehet.

Példa.

Ebben a példában címke markLoop ciklust azonosít míg.

markLoop : while (theMark == true ) doSomething () ; )

3.5. szünet kijelentés

Használja a kezelőt szünet megtörni a hurkot kapcsoló vagy kezelő címkével címke.

• Ha használ szünet nélkül címke, azonnal megtöri a legközelebbi tartalmazó míg, csinálni, miközben, számára vagy kapcsolóés átadja az irányítást a következő kezelőnek.

• Ha használ szünet Val vel címke, leállítja a megadott címkézett utasítást.

Operátori szintaxis szünet ez:

egy . szünet 2. feltörni a címkét

Az első opció megszakítja a legközelebbi tartalmazó hurkot, vagy kapcsoló; a második opció megszakítja a címkével rendelkező megadott utasítást.

Példa.

Ez addig ismétlődik a tömb elemei között, amíg meg nem találja az elem indexét az értékkel az érték:

for (i = 0 ; i< a . length ; i ++ ) { if (a [ i ] = theValue ) break ; }

3.6. nyilatkozat folytatása

Operátor folytatni utasítások újraindítására szolgál míg, csinálni, miközben, számáraés címke.

• Ha használ folytatni nélkül címke, megszakítja a legközelebbi hurok aktuális iterációját közben, do-közben vagy számáraés a következő iterációval folytatja ennek a ciklusnak a végrehajtását. Ellentétben az operátorral szünet, folytatás nem szakítja meg teljesen a hurkot. Egy ciklusban míg odamegy állapot. A for ciklusban bekapcsolva növekmény-kifejezés.

• Ha használja, folytassa a címke, az ezzel azonosított ciklusutasításra vonatkozik címke.

Operátori szintaxis folytatni ez:

egy . folytatás 2. folytatás címke

1. példa

Ez egy példa a hurokra míg operátorral folytatni, amely akkor kerül végrehajtásra, ha az érték én egyenlő 3 . Ily módon n megkapja az 1, 3, 7 és 12 értékeket.

i = 0 n = 0 miközben én< 5 ) { i ++; if (i == 3 ) continue ; n += i ; }

2. példa

Az üzemeltető mint checkiandj, a következőként megjelölt utasítást tartalmazza checkj. Ha észlelik folytatni, a program megszakítja az aktuális iterációt checkjés elindítja a következő iterációt. Valahányszor folytatásra kerül sor, checkjújra elkezdi az iterációt, amíg állapota vissza nem tér hamis. Ha visszaküldik hamis, akkor az utasítás többi része végrehajtásra kerül checkiandjés checkiandj addig ismétlődik, amíg a feltétele false értékre nem tér vissza. Ha visszatér hamis, a program az utána következő utasítástól folytatja a végrehajtást checkiandj.

Ha a folytatás megvan címke számára checkiandj, a program az utasítás elejétől folytatja a végrehajtást checkiandj.

checkiandj : while (i< 4 ) { document . write (i + "
" ) ; i += 1 ; checkj : while (j > 4 ) ( dokumentum . írás (j + "
" ) ; j -= 1 ; ha ((j % 2 ) == 0 ) folytassa az ellenőrzést j ; dokumentum . write (j + " páratlan.
" ) ; ) document.write(" i = " + i + "
" ) ;document.write(" j = " + j + "
" ) ; }

4. Objektummanipulációs operátorok

A JavaScript operátorokat használ beés val vel tárgyakat manipulálni.

4.1. mert... nyilatkozatban

Operátor be iterálja a megadott változót az objektum összes tulajdonságán. A JavaScript minden elért tulajdonságnál végrehajtja a megadott utasításokat. Operátor beígy néz ki:

For (változó az objektumban) (

Példa.

Ez a függvény egy objektumot és az objektum nevét veszi argumentumként. Ezután az objektum összes tulajdonságán áthalad, és egy karakterláncot ad vissza – a tulajdonságnevek és értékük listáját.

függvény dump_props (obj , obj_name ) ( var result = "" ; for (var i in obj ) ( result += obj_name + " . " + i + " = " + obj [ i ] + "
" ) eredmény += "

---

" ; eredmény visszaadása ;)

Tárgyhoz autó tulajdonságokkal készítsenekés modellígy lesz az eredmény:

autó. gyártmány = Ford autó . modell = Mustang

4.2. nyilatkozattal

Operátor val vel beállítja az alapértelmezett objektumot egy utasításblokk-készlethez. A JavaScript megvizsgálja az utasításblokkon belüli minősítetlen neveket, és meghatározza, hogy a nevek az objektum alapértelmezett tulajdonságai-e. Ha a minősítetlen név tulajdonság, akkor ez a tulajdonság kerül felhasználásra az utasításban; egyébként helyi vagy globális változót használunk.

A with nyilatkozat így néz ki:

(objektum )( utasításokkal)

Példa.

Itt az operátor val vel megadja, hogy az objektum Math az alapértelmezett objektum. A with utasítás utáni állítások egy tulajdonságra vonatkoznak PIés módszerek kötözősalátaés bűn objektum specifikáció nélkül. A JavaScript egy objektumot vesz fel Math mint tárgy ezekhez a hívásokhoz.

var a , x , y ;; var r = 10 és (Math) (a = PI * r * r ; x = r * cos (PI ) ; y = r * sin (PI / 2); )

jegyzet:

A with utasítás használata jelentősen lelassíthatja a program végrehajtását.

5. Megjegyzések

A megjegyzések általában elmagyarázzák, mit csinál a kód. A tolmács figyelmen kívül hagyja a megjegyzéseket. A JavaScript támogatja a Java és C++ stílusú megjegyzéseket:

• Egysoros megjegyzés dupla perjellel a sor elején (//).

• Többsoros megjegyzés: /* az elején és */ a végén.

Példa.

Íme egy példa két megjegyzésre:

// Ez egysoros megjegyzés. /* És ez többsoros. Bármilyen hosszúságú lehet, és bármit berakhatsz ide. */

6. Kivételkezelési nyilatkozatok

Kivételt dobhatsz az állítással dobásés operátorokkal dolgozza fel próbáld... elkapni.

Operátor próbáld... elkapni Java kivételek kezelésére is használják. Lásd: „Java-kivételek kezelése JavaScript-ben” és „Java-kivételek kezelése Java-ban”.

6.1. dobja kijelentés

Operátor dobás kivételt szoktak dobni. Ha kivételt dob, akkor megad egy kifejezést, amely a kivétel értékét tartalmazza:

dobja kifejezést

A következő kód több kivételt is tartalmaz.

dobja "Error2"; // karakterlánc értékű kivételt dob dobás 42 ; // 42-es értékű kivételt dob dobja igaz ; // igaz értékű kivételt dob

Kivétel dobásakor megadhat egy objektumot. Ezután elérheti a blokkban lévő objektum tulajdonságait fogás. A következő példa egy objektumot hoz létre myUserException típus UserExceptionés használja a nyilatkozatban dobás.

// Létrejön egy UserException típusú objektum function UserException ( üzenet ) ( this . message = üzenet ; this . name = " UserException " ; ) // Létrejön és meghívódik az objektum egy példánya myUserException = new UserException ("Túl magas érték"); throw myUserException ;

6.2. próbálja meg... elkapni a nyilatkozatot

Operátor próbáld... elkapni megjelöl egy utasításblokkot, megpróbálja végrehajtani azokat, és kivétel esetén egy vagy több választ ad meg. Kivétel esetén az operátor próbáld... elkapni elkapja őt.

Operátor próbáld... elkapni blokkból áll próbálja meg, amely egy vagy több utasítást és nulla vagy több blokkot tartalmaz fogás, amely olyan utasításokat tartalmaz, amelyek meghatározzák a műveleteket, amikor kivétel kerül a blokkba próbálja meg. Vagyis ha blokkot akarsz végrehajtani próbálja megés nem hajtódik végre, átadja a vezérlést a blokknak fogás. Ha bármilyen blokk utasítás próbálja meg(vagy egy blokkból meghívott függvény operátora próbálja meg) kivételt dob, az irányítás azonnal átkerül a blokkra fogás. Ha nem dobtak kivételt, a blokkot fogásátugrott. Blokk végül blokkvégrehajtás után hajtják végre próbálja megés fogás, de az utasításblokkot követő utasítás végrehajtása előtt próbáld... elkapni.

A következő példa az operátort használja próbáld... elkapni. Egy függvényt hívunk meg, amely lekérdezi a hónap nevét a tömbből a függvénynek átadott érték alapján. Ha az érték nem egyezik a hónap számával (1-12 ), a rendszer kivételt dob ​​az értékkel együtt "Érvénytelen hónapszám"és blokk utasítások fogásállítsa be a változót hónapNév jelentése ismeretlen.

függvény getMonthName (mo ) ( mo = mo - 1 ; // A hónap számát a tömbindex adja meg (1=január, 12=dec) var months = new Array ( " Jan " , " Feb " , " Mar " , " Apr " , " May " , " Jun " , " Jul " , " Aug " , " Sep " , " Oct " , " Nov " , "december"); if (months [ mo ] != null ) ( return months [ mo ] ) else ( dobja " InvalidMonthNo " ) ) try ( // próbálja meg végrehajtani ezeket az utasításokat: monthName = getMonthName(myMonth) // függvény kivételt dobhat) catch (e ) ( monthName = " unknown " logMyErrors (e ) // a kivételt dobó objektum átadásra kerül a kivételkezelőnek}

dobás; ezzel az azonosítóval információt kaphat a kidobott kivételről. A JavaScript blokk beírásakor hozza létre ezt az azonosítót fogás; Az azonosító csak a blokk végrehajtása során létezik fogás; blokk befejezése után fogás Az azonosító már nem elérhető.

Például a következő kód kivételt dob. Kivétel esetén a vezérlés átkerül a blokkra fogás.

try(dobja a "myException" kifejezést // kivételt dob) fogás (e ) ( // operátorok kezelik a kivételeket logMyErrors (e ) // kivételt ad át a hibakezelőnek}

Több fogási blokk

Egyedülálló kezelő próbálja meg több feltételes blokkot is tartalmazhat fogás, amelyek mindegyike egy adott típusú kivételt kezel. Ebben az esetben a megfelelő feltételes blokk bemenete fogás csak akkor kerül végrehajtásra, ha az ehhez a blokkhoz megadott kivételt dobják. Opcionálisan külön blokkot is beépíthet fogás utolsó blokkként minden meg nem határozott kivételre fogás az operátorban.

Például, következő funkció három másik (máshol deklarált) függvényt hív meg, amelyek tesztelik az argumentumait. Ha a tesztfüggvény azt állapítja meg, hogy a tesztelt összetevő érvénytelen, 0-t ad vissza, így a hívó a megadott kivételt dobja.

függvény getCustInfo (név , id , email ) ( var n , i , e ; if (! validate_name (name )) throw " InvalidNameException " else n = név ; if (! validate_id (id )) throw " InvalidIdException " else i = id ; if (! validate_email (email )) throw " InvalidEmailException " else e = email ; cust = (n + " " + i + " " + e ) ; return (cust ) ; )

Feltételes blokkok fogás szabályozza a megfelelő kivételkezelő meghívását.
" ) { // meghívja az érvénytelen ids kezelőt bad_id_handler (e ) ) catch (e if e == " InvalidEmailException " ) ( // felhívja a rossz e-mail kezelőt bad_email_handler (e ) ) catch (e )( // ismeretlen kivétel naplózva logError (e ) )

végül blokkolja

Az utolsó blokk olyan utasításokat tartalmaz, amelyek a blokkok végrehajtása után kerülnek végrehajtásra próbálja megés fogás, de a nyilatkozatot követő állítások végrehajtása előtt próbáld... elkapni. Blokk végül függetlenül attól, hogy történt-e kivétel. Kivétel esetén blokkolja az utasításokat végül akkor is végrehajtódik, ha nincs blokk fogás nem kezelte a kivételt.

Használhatja a blokkot végül a szkript helyes befejezése érdekében, amikor kivétel történik; például előfordulhat, hogy fel kell szabadítania egy szkripthez társított erőforrást. A következő példában egy fájl nyílik meg, és az operátorok dolgoznak vele (a kiszolgálóoldali JavaScript lehetővé teszi a fájlok elérését). Ha kivételt dobnak, amikor fájl megnyitása, Blokk végül bezárja a fájlt, mielőtt a szkript meghiúsulna.

openMyFile(); próbáld meg ( writeMyFile (theData ) ) végül ( closeMyFile () // az erőforrás mindig zárva van}

Nesting try...catch nyilatkozatok

Egy vagy több állítást egymásba ágyazhat próbáld... elkapni egymásba. Ha a belső kezelő próbáld... elkapni nincs blokkja fogás, a blokk egyezést keres fogás operátort tartalmazó próbáld... elkapni.