Javascript adattípusok: alapfogalmak, validálás, átalakítás

Ha egy programozó olyan nyelvekkel dolgozott, mint a C# vagy a Java, akkor tudja, hogy egy változó deklarálásához be kell állítani a statisztikai adattípust, amelyet a megadott változóban a kezdetektől fogva tárolnak. Ha a megadott változó értékét más típusra kell változtatni, a rendszer hibát ad ki. Ellentétben velük, a JavaScript dinamikus adattípussal rendelkezik, és nincs szükség annak meghatározására, hogy melyik típust tárolja ez a változó, mivel a kontextus végrehajtása során a JS megpróbálja megoldani a problémát a megadott értékeknek megfelelően.

Az adatok alapjai a JavaScript-ben

A JS adatok két csoportra oszthatók: primitív és objektumok. Az elsők között szerepel egy szöveges karakterlánc (String), logikai adatok-igaz vagy hamis (logikai) és számok (szám). Két másik speciális primitív típus létezik: Null És Undefined. Bemutatják az összekapcsolt Rendezetlen JavaScript adattípusokat, amelyeknek neve és tulajdonságai vannak.

Az objektumot speciálisan a programozó hozza létre, köztük van néhány speciális is: globális, prototípus, tömbök, függvények, osztály, előre definiált JS osztályok, RegExp osztály a reguláris kifejezések kezelésére és minták keresésére a szövegben, hibaosztály tárolni hibával kapcsolatos információk. Az első programozási nyelvek nem objektumokat használtak, hanem csak változókat.

A változók olyan számítógépes memóriaterület, amelyhez a fejlesztők főleg numerikus értékkel, karaktertípussal vagy karakterlánccal rendelnek tartalmat-alfanumerikus érték, amely csak számokkal kevert szövegből áll. Egy JavaScript adattípus példájaként definiálhatja az "a" változót, amely 32-et tartalmaz, és így írhatja:

a = 32.

Ezután megváltoztathatja az "a" értékét:

a = 78.

Vagy tegye az "a" - T egyenértékűvé egy másik "b" változó értékével, például:

a = b,

A változók elemi objektumok: szám, szimbólum, igaz vagy HAMIS érték, míg, hogyan tárgyak komplexek, amelyek nagy mennyiségű információval hozhatók létre. De mindkét forma ugyanazt a memóriaterületet foglalja el, amely többé-kevésbé nagy lehet.

Primitív típusok

Az objektumoktól eltérően a primitív JavaScript adattípusok nem referenciálisak, vagyis amikor egy másik változóból rendelnek értéket.

A JS - ben vannak ilyen primitív típusok:

• logikai;
• numerikus;
• kisbetűs;
• nulla;
• meghatározatlan.

Logikai képviseli az egyik: "igaz" vagy "hamis".

• var boo1 = igaz;
• var boo2 = hamis;

A JS-ben csak egy típusú szám van, tizedesvesszővel vagy anélkül írható. A szám is előfordul, hogy:

• +Infinity;
• -Infinity;
• NaN (nem szám).

var Szám1 = 32;

var num2 = + végtelen;

A sorok a szöveg mentésére szolgálnak. Dupla vagy egyetlen idézőjelben kell lenniük. A JS-ben a húrok változhatatlanok.

var str1 = `Szia, én vagyok`;

var str2 = "Szia, én vagyok";

Az érték nélküli változó nincs meghatározva.

var teszt Var;

konzol.log (testVar); / / meghatározatlan

Logikai - van adattípus, amely két dolog egyikét adja vissza: true / false. A JavaScript logikai adattípus neve matematikus George Boole, így mindig nagybetűvel. Meg tudja mutatni a működés elve az ilyen típusú egy példa:

1. Nyissa meg a JS konzolt, majd írja be az alábbi utasításokat az "Enter" megnyomásával minden művelet után az eredmény megtekintéséhez.
2. Ügyeljen arra, hogy minden operátor után egysoros megjegyzést használnak annak magyarázatára, hogy mit jelent.
3. 1<10 / / 1 kevesebb, mint 10?
4. 100> 2000 / / 100 több mint 2000?
5. 2 = = = 2 / / 2 pontosan egyenlő 2-vel?
6. hamis = = = hamis //

A logikai függvény egy változó logikai értékét adja vissza. Használható egy feltétel és kifejezés logikai eredményének keresésére is, ez lehetővé teszi a JavaScript számára a funkcionális adattípus használatát.

Megváltoztathatatlan karakterek

A szimbólumok egy új primitív típus a JS-ben. A funkció használatával jönnek létre:

const mySymbol = szimbólum (`mySymbol`).

Minden alkalommal, amikor a programozó felhívja ezt a funkciót, egy új és egyedi szimbólum jön létre. Ezeket fel lehet használni, mint állandók, hogy képviselje fogalmak, mint a színek. A szimbólumokat elsősorban tulajdonkulcsként használják, és soha nem ütköznek más kulcsszimbólumokkal vagy karakterláncokkal. Például egy objektumot iteratívvá tehet, amelyet egy "for-of" cikluson és más nyelvi mechanizmusokon keresztül használ, a "Symbol" - ban tárolt szimbólum használatával.iterator " mint kulcs.

Az a sorban a szimbólumot használják módszerkulcsként. Ez az egyedi jelölő teszi az objektumot ismételhetővé, és lehetővé teszi a" for-of " hurok használatát. Nem lehet karaktereket karakterláncokba önteni, mert a JavaScript adattípusok kényszerítése vagy implicit átalakítása van. A kényszerítés megtiltása megakadályozza bizonyos hibákat, de megnehezíti a szimbólumokkal való munkát is.

Egy új típusú primitív tokenek, amelyek egyedi azonosítóként szolgálnak. A programozó szimbólumokat hoz létre a "Symbol ()" gyári funkcióval, amely kissé hasonlít a "String" - hez-a karakterláncok visszatérése, amikor a függvény meghívja őket:

const symbol1 = szimbólum();

A Symbol() rendelkezik egy opcionális string paraméterrel, amely lehetővé teszi az újonnan létrehozott szimbólum leírását. Ezt a leírást akkor használjuk, ha egy karaktert karakterláncgá alakítunk a "toString()" vagy a "String()"segítségével.

Aritmetikai operátorok

A JS, mint minden programozási nyelv, rendelkezik a matematikai műveletek beépített képességével, mint egy számológép. Olyan számokon vagy változókon hajtják végre őket, amelyek számként vannak ábrázolva.

Az összeadás operátor, amelyet pluszjel ( + ) képvisel, két értéket ad hozzá, és visszaadja az összeget.

var x = 2 + 2; / / x értéke 4

A kivonási operátor, amelyet mínuszjel ( - ) képvisel, kivonja a két értéket, és visszaadja a különbséget.

var x = 10 - 7; / / x értéke 3

A csillaggal ( * ) jelölt szorzás operátor két értéket szoroz, majd visszaadja a terméket.

var x = 4 * 5; / / x értéke 20

Az Osztás operátor, amelyet perjel ( / ) képvisel, elválasztja a két értéket, és visszaadja a hányadost.

var x = 20 / 2; / / x értéke 10

Kevésbé ismert a modulus operátor, amely az osztás után a maradékot adja vissza, amelyet százalékjel (%)képvisel.

var x = 10% 3; / / értéke 1

Ez azt jelenti, hogy a" 3 "háromszor lép be a" 10 "- be, az" 1 " marad.

A növekmény olyan műveletet hajt végre, amelyben a számot eggyel növelik a növekmény operátor által képviselt kettős pluszjel (++).

var x = 10; x++; / / x értéke 11

Ez a kinevezés után történik. Azt is megírhatja, hogy mi történik a találkozó előtt. Összehasonlításképpen:

++x;

var x = 10;

var y = x++;

// y Az 10, x az 11;

valamint:

var x = 10;

var y = ++x;

/ y az 11, x az 11.

Decrement - a szám eggyel csökken a decrement operátor használatával, amelyet kettős mínuszjel (--)képvisel.

var x = 10; x--;

// x értéke 9

Mint fent, ez is írható: -- x;

A JS operátorok fajtái:

• Feladatkezelő;
• aritmetikai növekmény és csökkenés operátorok;
• esélyegyenlőségi szereplők;
• relációs operátorok;
• logikai operátorok.

Igaz vagy hamis függvények

Az összehasonlító operátorok értékelik két érték egyenlőségét vagy különbségét, és "true" vagy "false"értéket adnak vissza. Általában logikai utasításokban használják őket. Két egyenlő jel ( = = ) egyenlő js-ben. A kezdő programozók könnyen összekeverhetik az egy -, kettős-és háromszoros egyenlőségjeleket, ne feledje, hogy egy egyenlőségjel egy értéket alkalmaz egy változóra, és soha nem értékeli az egyenlőséget.

var x = 8;

var y = 8;

x = = y; / / igaz

Ez egy szabad típusú egyenlőség, amely "true" értéket ad vissza, még akkor is, ha egy karakterláncot használnak szám helyett.

var x = 8;

var y = "8";

x = = y; / / igaz

Három egyenlőségjel ( = = = ) szigorú egyenlőséget jelent a JS-ben.

var x = 8;

var y = 8;

x = = = y; / / igaz

Ez az egyenlőség meghatározásának gyakrabban használt és pontosabb formája, mint a szokásos "egyenlő(==)" függvény, mivel a visszatérés megköveteli, hogy a típus és az érték azonos legyen.

var x = 8;

var y = "8";

x = = = Y; / / hamis

Felkiáltójel, amelyet egyenlőségjel követ (!= ), azt jelenti, hogy nem egyenlő JS-ben. Ez a "= = " pont ellentéte, és csak az érték kerül ellenőrzésre, nem a típus.

var x = 50;

var y = 50;

x != y; / / hamis

Felkiáltójel, amelyet két egyenlő jel követ (!= = ) szigorúan nem egyenlő. Ez pontosan ellentétes a ( = = = ) értékkel, és ellenőrzi mind az értéket, mind a típust. Egy másik ismerős karakter, kevesebb, mint (<), ellenőrzi, hogy a bal oldali érték kisebb-e, mint a jobb oldali érték. Kisebb vagy egyenlő (<= )- ugyanaz, mint fent, de az értéke is "igaz". Nagyobb, mint (>) ellenőrzi, hogy a bal oldali érték nagyobb-e, mint a jobb oldali érték. Érték nagyobb vagy egyenlő (>= ), ugyanaz, mint fent, de ez is igaz lesz.

Dinamikus típusellenőrzés

A JavaScript adattípusai és változói a fő programozási nyelv. A JS-ben sok végrehajtási hiba típushiba. Például, amikor megpróbálják szorozni a "számot" "karakterlánccal", hibát kapnak a visszaadott érték "nem száma" formájában. Néha, amikor függvényeket hív, és az "undefined nem függvény" hibát kapja, ez akkor történik, amikor megpróbál hozzáférni egy olyan tulajdonsághoz, amely nincs meghatározva. Mivel a JS nem találja a tulajdonságot, az alapértelmezett értéket adja vissza a biztonsági mentéshez: undefined. Egy másik gyakori, a típushoz kapcsolódó hiba akkor fordul elő, amikor egy tulajdonságot null vagy nem definiált értékből próbál megváltoztatni vagy elérni. Itt nincsenek olyan konstruktorok, mint az Undefined vagy a Null.

A JS típusú rendszer segít elkerülni ezeket a gyakori hibákat. Definíció szerint ez egy értelmezett és dinamikus nyelv, és megköveteli, hogy a típusrendszer működjön a kódfuttatás során. A nyelv az értéktípusok csendes átalakításával is megpróbál segíteni. A típus vagy a kényszerítés megváltoztatása az oka annak, hogy sok fejlesztő szigorú használatra vált (===) az értékek egyenlőségének ellenőrzésére.

A dinamikus JavaScript adattípus-ellenőrzés a TypeRight könyvtáron keresztül történik. Egyéb jellemzők mellett megközelítést alkalmaz a következő álosztályok megvalósítására, amelyek egyetlen célja az operátor példányának jobb oldala:

• PrimitiveUndefined.
• PrimitiveNull.
• Primitivboolean.
• PrimitiveNumber.
• PrimitiveString.
• Primitívszimbólum.

A TypeRight jelenleg nem nyújt osztályt hogy ellenőrizze függetlenül attól, hogy egy érték objektum-e, de könnyen hozzáadható.

Változó konténerek

A JS változói olyan tárolók, amelyek újrafelhasználható adatokat tartalmaznak. Az ES2015 előtt a JavaScript változókat kizárólag a var kulcsszó használatával deklarálták:

• var x;
• var y;
• var z;

Ma a változókat típusok szerint állítják be: var, let és const. A maga módján egyediek, és a kódfejlesztés hatékonyságának növelését szolgálják, azonban , ajánlott használni: let-amikor csak lehetséges, és const-amikor egy változó értéke állandó marad. A változók használata az adatok tárolására a nyelv alapja, amely három részből áll.

Változó deklaráció - itt a változó a megfelelő hatókörben van regisztrálva. Példák változó deklarációkra:

• var x;
• var cup;
• var car.

Az inicializálás egy változó deklarálásakor történik. Itt van hozzárendelve memória vagy hely a JavaScript motor segítségével. Emiatt, amint egy változót deklarálnak, az értéket még a hozzárendelés előtt is meghatározatlanná teszi.

A változó hozzárendelése a legfontosabb lépés a használat során. Itt a változóhoz olyan adatok vannak hozzárendelve, amelyek értékek a "="hozzárendelési operátor segítségével.

A JavaScript értékei a szokásos adattípusok egyikét veszik fel:

• string;
• szám;
• logikai;
• nulla;
• határozatlan.

A típusok hozzárendelésének szintaxisa fent csak olyan karakterláncokkal látható, amelyek egyszeres vagy dupla idézőjelekkel rendelkeznek. A logikai értékek lehetnek igazak vagy hamisak is. A változók JavaScript-ben történő elnevezésekor bizonyos szabályokat be kell tartani, nevezetesen:

1. A neveknek kisbetűvel kell kezdődniük.
2. A nevek nem tartalmazhatnak karaktereket, vagy nem kezdődhetnek karakterekkel.
3. A nevek nem kezdődhetnek számmal.
4. A nevek nagybetűk, kisbetűk és számjegyek kombinációját is tartalmazhatják.

A JS inicializálásának módjai

Egy változó inicializálódik, amikor a tartalmát vagy értékét először állítja be. Például ár = 22,55 - ez lehet egy változó inicializálásának módja. Egyszerre deklarálható és inicializálható. Például írhatja a változót "ár = 22,55", amellyel a változót egy sorban deklarálták és inicializálták. A JS nem igényel változótípus-deklarációt, sőt lehetővé teszi egy változó számára, hogy különböző típusú tartalmakat tároljon különböző időpontokban. Például használhatja "az ár = 22.55", egy későbbi helyen írja be az árat = "nagyon drága". Ez olyan dolog, ami más nyelveken hibához vezethet, de a JavaScript elfogadott.

A JS lehetővé teszi egy változó használatát anélkül, hogy deklarálná. Sok esetben programozási nyelvek , használat előtt deklarálni kell egy változót, de JS nem kötelezi. Amikor egy nyelv talál egy be nem jelentett változót, automatikusan létrehoz egy változót, és lehetővé teszi annak használatát.

A "var" kulcsszó helytelen használata hibához vezethet, amelynek következtében a JS nem működik, vagyis a weboldal helytelenül jelenik meg, a var csak egy változó deklarálására szolgál, másra nem használható. Miután egy változót deklaráltak,azt a var kulcsszó nélkül fogják használni. Ha a változó már deklarálva van, a JavaScript megpróbálja folytatni és megszerezni.

A munka bemutatása

Bemutathatja a kód munkáját a JavaScript adattípusok alapfogalmainak megszilárdításához, a program elolvassa az ábrán látható kódot, amelyet a html kiterjesztési fájlba mentett.

Az eredmény vizualizálása után gondoskodnak arról, hogy a weboldal normálisan jelenjen meg, vagyis a JavaScript normálisan fut, és a várt eredmény a következőket kell mutatnia:

1. A változó ár érvényes: undefined (accept).
2. A data1 változó érvényes: null (Elfogad).
3. Változó ár érvényes: 32.55 (Elfogad).
4. Dupla ár: 65.1 (elfogadom).
5. Az ár szorzásával kapott összeg a mennyiséggel: 325,5 (elfogadás).
6. Változó árak most: nagyon drága (elfogadás).
7. Dupla ár most: NaN (Elfogad).
8. Az árváltozót második alkalommal jelentették be, most érvényes: 99,55 (elfogadás).
9. Változó $ discount_applied: 0.55 (Elfogad).

A nyelv működésének megértése automatikusan jobb programozóvá teszi a fejlesztőt. De mivel a "gyakorlat javul", nem elég csak az elméletet megtanulni, fontos, hogy elkezdjük a gyakorlatban alkalmazni a JavaScript adatbázis alapjait és az adatok működését. A fenti információk elolvasása után egy kezdő programozónak nem lesz nehéz megválaszolnia azt a kérdést, hogy hány adattípus van a JavaScript nyelven.