Js karakterlánc konverzió. Adattípusok konvertálása JavaScriptben. Értékek konvertálása logikai értékekké

Jó napot mindenkinek. Alexey Gulynin kapcsolatban áll. Az utolsó cikkben megismerkedett a Javascript adattípusaival. Ebben a cikkben arról szeretnék beszélni típuskonverzió Javascriptben. A típuskonverziókat a Javascriptben, sőt bármely programozási nyelvben nagyon gyakran hajtják végre. Először a típuskonverzióról akartam beszélni, amikor olyan változókat vagy egyéb feltételeket hasonlítunk össze, amelyek igaz vagy hamis eredményt eredményeznek. Különböző típusú változók összehasonlításakor háttérkonverziókat hajtanak végre. A lényeg itt az, hogy az ilyen háttértranszformációk során a változóban tárolt érték nem változik. a változó a művelet végrehajtásához szükséges adattípusra konvertálódik (a változó ideiglenes értéke jön létre). Mondok egy példát:

A karakterlánc típusú és a numerikus típusú változókat hasonlítjuk össze. Összehasonlításkor ezeknek a változóknak az értékei ugyanarra az adattípusra redukálódnak. Az összehasonlítás ezután egy logikai értéket ad vissza, és a konvertált ideiglenes értékeket eltávolítja. Minden transzformáció a kontextustól függ – a műveleteket végrehajtó operátoroktól. minta kód:

Var a = 5; var b = "15"; Ha egy< b) alert("a < b"); else alert("a >b");

Ebben az esetben a b változó számmá alakul (a String típusú háttér konverziója Szám típusúra megtörtént, és a Szám = 15 típusú b változó ideiglenes értékét kapjuk meg, amely után törlésre kerül az összehasonlító műveletet végrehajtjuk), és az eredmény az lesz, hogy a .

Az alábbi táblázat bemutatja, hogyan konvertálódik az egyik adattípus egy másikra:

Érték tipusa	Kontextus, amelyben az értéket használják
Érték tipusa	Húr	Számszerű	Logikus	Tárgy
Meghatározatlan érték	'határozatlan'	NaN	hamis	Hiba
nulla	'nulla'	0	hamis	Hiba
Üres sor	Üres sor	0	hamis	String objektum
Nem üres karakterlánc	Nem üres karakterlánc	Numerikus karakterlánc érték vagy NaN	igaz	String objektum
0	’0′	0	hamis	Szám objektum
NaN	"NaN"	NaN	hamis	Szám objektum
végtelenség	'Végtelenség'	végtelenség	igaz	Szám objektum
-Végtelenség	'-Végtelenség'	-Végtelenség	igaz	Szám objektum
Bármilyen más szám	Egy szám karakterlánc-ábrázolása	Maga a szám	igaz	Szám objektum
igaz	'igaz'	1	igaz	Logikai objektum
hamis	'hamis'	0	hamis	Logikai objektum
Tárgy, funkció	toString()	valueOf(), toString() vagy NaN	igaz	Tárgy, funkció

Adattípus-konverziók

Bármilyen adattípusból beszerezhet logikai adattípust. Ez a negációs operátor vagy a dupla negáció használatával történik. Példa:

Var a = 20; var b = !a; //hamis visszatér var c = !!a; //vissza igaz

Karakterláncot bármilyen objektumból be lehet szerezni. Példa:

Var a = 20; var b = a.toString(); //return "20" var c = a + ""; //return "20" typeof b; //return string typeof c; //return string

Szám lekérése karakterláncból. Példa:

Var a = "20"; var b = a * 1; //return 20 var c = + a; //return 20 typeof b; //return number typeof c; //visszaadási szám

Most pedig a megszerzett ismeretek alapján elemezzük a logikai „ÉS” (&&) ill logikai "VAGY" (||):

Logikai "ÉS" (&&):

Az operátor helyes végrehajtásához szükséges, hogy az összes operandus értéke igazra konvertálható legyen. Ha az összes operandus értéke igazra konvertálható, akkor az utoljára összehasonlított operandus eredeti értéke kerül visszaadásra. Ha legalább egy operandus értékét false értékre konvertáljuk, akkor az adott operandus eredeti értéke kerül visszaadásra. Példa:

Var a = 15; var b = "abc"; var c = 0; var eredmény; resultat = a && b && c; //return 0 resultat = c && b && a; //return 0 resultat = 7 && a; //vissza 15 resultat = 7 && b; //return "abc"

Logikai "VAGY" (||):

Hadd magyarázzam el egy kicsit az operátorokról és operandusokról. Elemezzük az resultat = a && b && c kifejezést. Itt az operátorok "=" és "&&" , azaz. ezek akciók. Operandusok: resultat, a, b, c. Erre kerül sor.

Nem mindegy, hogy milyen típusú változót használunk a kifejezésben. Ha a kifejezés matematikai, akkor minden változója automatikusan numerikusként értelmeződik. Ha karakterláncokat dolgozunk fel, akkor a kifejezés minden „résztvevőjét” karakterláncként kezeli. A karakterláncból számmá konvertálás kihívása azonban a JavaScriptben sokkal szélesebb összefüggésben létezik.

JavaScript-módszerek karakterláncok számokká konvertálására

A karakterláncok számokká konvertálására szolgáló módszerek arzenálja nem nagy, de minden egyszerű esetben elegendő. Itt a JavaScript (különösen a kezdőknek) az egyszerűtől a bonyolultig vezető út gyakorlati példákon keresztül.

A példa négy különböző karakterláncot ír le. A kimenet első blokkjában a typeof függvény karakterláncként határozza meg az egyes változók típusát. Ezután minden karakterlánc nagyon egyszerűen számmá alakul. A második kimeneti blokkban a változók konverzió utáni változásai láthatók, típusuk szám lett. A JavaScript parseFloat konverziós példája különösen szemléletes: „12e+3” volt, és „12000” lett.

A karakterlánc számmá alakításakor bekövetkező változások jelentősek lehetnek! De csak az első karakterek számítanak: numerikusnak kell lenniük. Ha nincsenek számjegyek, az eredmény NaN lesz.

Egy karakterlánc fordított átalakítása, amelyből szám lesz, nem mindig ugyanaz a karakterlánc. Ez a pont használható a numerikus információk bevitelének helyességének ellenőrzésére.

Általános átalakítási módszerek

Vannak egész számok és vannak törtszámok, a JavaScript a karakterláncot számmá alakítja a következőképpen:

parseInt;
parseFloat.

Az általános esetet a karakterlánc egyszerű matematikai kifejezésben való felhasználásával valósítjuk meg.

Elég egy „+” jelet tenni a karaktersorozat elé, és ha számot tartalmaz, akkor a kifejezés eredménye egy szám lesz. A változó értéke változhat, de a típus mindig változik: a typeof számot fog mutatni, nem karakterláncot. Fontos megérteni, hogy egy konvertált változó használata egy karakterlánc-kifejezésben teljesen más eredményt eredményezhet.

A JavaScript kezdőknek ebben az összefüggésben rendkívül egyszerű. A pasrseInt metódussal nehezebb megérteni az egész számok konverziójának működését, mivel az automatikusan működik a decimális számrendszerben, de képes értelmezni a karakterláncot oktálisként vagy hexadecimálisként. Ez a körülmény azonban nem mindig függ a második paramétertől, amely a számrendszert jelzi.

A JavaScript mindig számmá alakítja a karakterláncot, de ha a karakterláncban nincs egyetlen digitális karakter sem a sor elején, akkor az eredmény NaN lesz.

Meg kell érteni a számrendszereket, a hexadecimális (a szám "0x"-el kezdődik) és az oktális számok (a szám "0"-val kezdődik) írását.

A JavaScript parseFloat módszer árnyalatainak megértéséhez elegendő, ha van egy elképzelése arról, hogy mi a valós szám matematikai jelölése.

Átalakítás válogatás céljából

A JavaScript egy böngésző nyelv, ezért fontosabb, mint más nyelvek a latin ábécé és a számok alapkészletén kívüli karakterek esetében. A válogatás népszerű művelet. De nem mindig van értelme rendezés céljából adatokat küldeni a szerverre, egyszerűbb és praktikusabb helyben, a böngészőben elvégezni a munkát.

A probléma megoldása érdekében a karakterlánc karaktereit numerikus kódjukká alakíthatja, vagy rendezett számsorozatot rendelhet betűkhez és számokhoz. A karakterláncra alkalmazott charCodeAt() metódus 98 számértéket rendel az iB változóhoz, azaz a "b" betű kódjához. Tekintettel arra, hogy az "a" betű kódértéke 97, a latin ábécé összes betűjének számát megkaphatja növekvő sorrendben kis- és nagybetűs készletben. Hasonlóan az orosz ábécé betűire is.

A számok szerinti rendezés saját verziója lehetővé teszi a szükséges karakterkészletek létrehozását. Például „átrendezheti” a cirill és a latin ábécét, vagy keverheti őket, hogy csak a helyesírásban eltérő betűket hagyja meg, vagy tabulátor- és szóköz karaktereket adhat a készletekhez.

Egyedi karakterláncszám kialakítása

Ha az "a" betű kódja 97, akkor a betű és a 97-es szám különbsége adja a betű egyedi számát az ábécében. Egy karakterlánc egyes karaktereihez tartozó egyedi számok összegzésével nehéz meghatározni az adott karakterlánc egyedi számát.

Ha súlyt rendel egy karakterlánc minden betűpozíciójához, például pozíció:

0 súly 1;
1 súly 10;
2 súly 100;

majd a karakterlánc minden egyes karakterének egyedi számát megszorozva annak a pozíciónak a súlyával, amelyben megtalálható, és az összes számot összeadva egyedi számot kaphat, és egy az egyben megfeleltetéseként használhatja az eredetihez húr.

A karakterlánc számmá alakítása reverzibilis, vagyis a számból mindig megkaphatja az eredeti karakterláncot. Az ilyen átalakítás előnyös, mert bármilyen művelet biztonságosan elvégezhető egy számmal a kódolás, a cirill és a webhely oldalának egyéb helyi jellemzői, az alkalmazási terület és a látogató országa összefüggésében.

„Növekvő” webhelyoldalválasztók

Gyakran felmerül a feladat olyan szelektorok létrehozása a weboldalakon, amelyek értékeit nem lehet előre megadni, de idővel kiegészítik. A legelső alkalmazásban egy üres választó áll rendelkezésre az első látogató számára, aki információkat adhat meg.

Az információs sztring minden új bevitele a választóba (bármely látogató által) számmá alakul, amely az eredetivel együtt tárolásra kerül a szerverre. Amikor új munkamenet kezdődik vagy új látogató érkezik, a választó már nem üres. Az oldal betöltésekor egy nem üres választóval érkezik a böngészőhöz.

Minden új választóérték esetében csak egyszer kerül elküldésre a szervernek tárolásra, és csak egyszer van hozzárendelve egyedi numerikus kód.

A probléma megoldásához a JavaScript string to number metódus nem használható. A szokásos parseInt és parseFloat metódusokat más célokra tervezték, de kitalálhat egy algoritmust, amellyel egyértelműen számmá konvertálhat egy karakterláncot, és nem feltétlenül invertálhatóvá. Elég, ha a konverziós algoritmus nem ismétlődik meg egy karakterlánc különböző karakterkészletein.

Forgalomoptimalizálás és elemzés

Az oldal létrehozásakor a fejlesztő jelentős mennyiségű információt használ fel. Ha lehetővé teszi a látogató számára, hogy információkat adjon meg, az jó módja annak, hogy csökkentse a webhely rangsorolását annak gyenge működése miatt, és frusztrálja a látogatót.

Ha a látogató bizonyos információblokkokra vonatkozó műveleteihez JavaScript függvény formájában eseménykezelőt rendelünk, lehetőség nyílik egy olyan szűrő megfogalmazására, amellyel a látogató pontosan kitűzhet egy célt, megtalálhatja a szükséges információkat, és megkaphatja a kívánt megoldást. .

A karakterlánc információ transzformációja itt tetszőlegesen nagy lehet a karakterlánc részben és nagyon kicsi a számrészben. Más szavakkal, a fejlesztő a JavaScript karakterláncot számmá alakítja saját algoritmusa segítségével. A látogató érthető információkat manipulál, és a minimális adatmennyiséget - egy számot - elküldi a szervernek.

Az összes látogató számkészletének dinamikája a pontosan ismert információk kontextusában lehetővé teszi, hogy egy másik JavaScript funkció (nem egy kezelő), amely az AJAX-mechanizmuson keresztül hívja meg a szerver válaszát, hogy minden látogatónak gyorsan, egyidejűleg, valós időben biztosítsa a szükséges információkat. . Így működik a rendszer.

Ez a JavaScript-karakterlánc számmá konvertálása nagyon népszerű az online játékok, az interaktív konferenciák, az azonnali üzenetküldés stb. fejlesztésében.

Transzformációk instrumentális alkalmazása

A JavaScript és a CSS a numerikus információk feldolgozásával összefüggésben lehetővé teszi az oldal megjelenítésének vezérlését a szerver közreműködése nélkül. A CSS-szabályok részkarakterláncokként épülnek fel, rekurzív módon. A paraméter általában egy szám, amelyet több betű követ (például "px", "pt", "em", ...). A paraméter egy részkarakterlánc a szabályban, a szabály pedig egy részkarakterlánc az osztály vagy azonosító stílusban.

JavaScript recursion.Substring.Substring... megkeresi a kívánt számot, karakterláncból számmá alakítja, módosítja és visszaírja a kívánt helyre. A szabály automatikusan megváltozik. Egyszerű és kényelmes, nincs szükség szerverre.

A JavaScript 2 beépített funkcióval rendelkezik a karakterláncok számokká alakításához: parseFloat() és parseInt() .

A parseFloat() argumentumként egy karakterláncot vesz fel, amelyet numerikus típussá kell alakítani, és egy lebegőpontos számot ad vissza. A számnak a sor elején kell megjelennie. Ha a szám utáni sorban más karakterek is vannak, akkor azok le lesznek vágva. A szám tört részét ponttal elválasztva kell írni (a vesszőt nem tekintjük elválasztónak). Ha a parseFloat() nem tudja konvertálni a karakterláncot, akkor NaN-t ad vissza.

A függvény képes feldolgozni „az n számot 10-zel szorozva az x hatványra”, amit a programozásban általában E betűvel írnak, például: 0,5E6 vagy 0,5E+6. A mérték negatív is lehet: 0,5E-6, ami 0,5*10^-6 vagy 0,5/1000000.

ParseFloat(""3.78kg"") // 3.78 parseFloat(""kg33"") // NaN parseFloat("0004.111"") // 4.111 parseFloat(""0x66"") // 0 parseFloat("". 5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0,0003 parseFloat(""-3E-4"") // -0,0003

A parseInt(string[, radix]) függvény egy karakterláncot vesz első argumentumként, elemzi, és egy egész számot ad vissza (integer típus). A függvény megpróbálja elemezni azt a számrendszert, amelyben a forráskarakterláncban szereplő szám szerepel (például decimális, oktális vagy hexadecimális – de nem csak ezek). A számrendszert explicit módon is megadhatja úgy, hogy a második paramétergyökként adja át. A radix paraméter tetszőleges számot vehet fel 2-től 36-ig (10-nél nagyobb rendszerekben az angol ábécé betűit használják A-tól Z-ig).

A függvény nem kezel olyan számokat, mint az 1.5e6, mint például a parseFloat() .

Kérjük, olvassa el az alábbi példákat, nehogy belebotljon a parseInt() függvény működésében rejlő buktatókba.

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045",10) // 45 parseInt( ""70",8) // 56 (a 70 az oktálisban 56 decimálisban) parseInt(""070"") // 56 (FONTOS! nulla esetén a függvény oktális számként értelmezi a karakterláncot ) parseInt(" "88",8) // NaN (nincs 8-as számjegy az oktális rendszerben) parseInt(""a1"") // NaN (FONTOS!!! Az alapértelmezett függvény nem kezeli a számot hexadecimális, ha nincs hozzáadva a kezdő sorokhoz 0x) parseInt(""a1",16) // 161 (itt a számrendszer kifejezetten meg van adva) parseInt(""0xa1"") // 161 (helyes hexadecimális számformátum , nem kell megadni a második paramétert) parseInt( ""099"") // 0 (FONTOS!!! A szám oktálisként kezelendő, de érvénytelen karaktereket tartalmaz) parseInt(""0.5e6"") / / 0 (FONTOS!!! nem úgy működik, mint a parseFloat) parseInt("" ZZ",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF",16) / / -255

Ha szövegmezőből értelmezi a felhasználói bevitelt, mindig használja a parseInt() függvényt egy második radix paraméterrel együtt, hogy megvédje a kódot a váratlan eredményektől.

| |

A JavaScript típusokra osztja az adatokat, ami segít az adatok csoportosításában és annak meghatározásában, hogy milyen értékeket lehet hozzárendelni és milyen műveleteket lehet végrehajtani.

Bár a JavaScript sok értéket automatikusan konvertál a típusöntés miatt, a legjobb az adattípusok manuális konvertálása a várt eredmények elérése érdekében.

Ez az oktatóanyag megtanítja Önnek, hogyan konvertálhat primitív JavaScript-adattípusokat, beleértve a számokat, karakterláncokat és logikai értékeket.

Implicit konverzió

A JavaScript programozási nyelv nagyon jó a váratlan értékek kezelésére. A JavaScript nem utasítja el a váratlan értékeket, hanem megkísérli a konvertálást. Ezt az implicit konverziót típuskényszernek is nevezik.

Egyes módszerek automatikusan konvertálják az értékeket a használatukra. Az alert() metódus egy karakterláncot vesz paraméterként, és automatikusan átalakítja a többi típust karakterláncokká. Tehát numerikus értéket adhat át ennek a módszernek:

Ha ezt a karakterláncot futtatja, a böngésző egy 8.5 értékű felugró ablakot ad vissza, amely már sztringgé lesz konvertálva.

Ha számsorokat és matematikai operátorokat használ, azt tapasztalhatja, hogy a JavaScript képes kezelni az értékeket azáltal, hogy a karakterláncokat implicit módon számokká alakítja:

// Kivonás
"15" - "10";
5
// Modul
"15" % "10";
5

De nem minden operátor dolgozik kiszámíthatóan. Ez különösen igaz a + operátorra: elvégzi a számok összeadását és a karakterláncok összefűzését.

// Ha karakterláncokkal dolgozik, a + összefűzést hajt végre
"2" + "3";
"23"

Mivel a + operátornak számos felhasználási módja van, ebben a példában a 2 és 3 értékeket karakterláncként kezeli, még akkor is, ha numerikus karakterláncokként vannak kifejezve. Ezért összevonja a „2” és „3” karakterláncokat, és 23-at kap, ahelyett, hogy hozzáadna 2-t és 3-at, és 5-öt kapna.

Az ilyen kétértelműség a kódban fordul elő, és néha váratlan eredményeket okoz, ezért jobb, ha lehetőség szerint kifejezetten konvertálja az adattípusokat. Ez segít a kód karbantartásában és a hibakezelésben.

Értékek konvertálása karakterláncokká

Egy érték karakterláncsá alakításához hívja meg a String() vagy n.toString() metódust.

Próbálja meg konvertálni a true logikai értéket stringgé a String() segítségével.

Ez visszaadja a "true" karakterláncot.

Megpróbálhat egy számot is átadni a függvénynek:

Egy string literált ad vissza:

Most próbálja meg használni a String()-et egy változóval. Rendeljen numerikus értéket az odyssey változóhoz, és használja a typeof operátort a típus ellenőrzéséhez.

hadd Odüsszea = 2001;
console.log(odyssey típusa);
szám

Jelenleg az odyssey változóhoz 2001 numerikus érték tartozik. Az operátor típusa megerősíti, hogy az érték szám.

Most rendelje hozzá az odyssey változót a megfelelőjéhez a String() függvényen belül, majd használja a typeof parancsot annak biztosítására, hogy a változó értékét sikeresen konvertálja számból karakterláncsá.

odüsszea = String(odüsszeia); // "2001"
console.log(odyssey típusa);
húr

Amint látja, az odyssey változó most tartalmaz egy karakterláncot.

Az n.toString() függvény hasonló módon működik. Cserélje le az n-t egy változóra.

hadd ütések = 400;
fúj.toString();

A blows változó tartalmazza a karakterláncot.

Változó helyett zárójelben értéket is tehet:

(1776).toString(); // az "1776" értéket adja vissza
(false).toString(); // "false"-t ad vissza
(100 + 200).toString(); // „300”-at ad vissza

A String() és az n.toString() kifejezetten karakterláncokká alakítja át a logikai és numerikus értékeket.

Értékek számokká konvertálása

A Number() metódus egy értéket számmá alakíthat. Gyakran van szükség számokból álló karakterláncok konvertálására, de néha logikai értékeket is kell konvertálni.

Például adja át a következő karakterláncot a Number() metódusnak:

A karakterlánc számmá alakul, és többé nem lesz idézőjel.

Hozzárendelhet egy karakterláncot egy változóhoz, majd konvertálhatja azt.

legyen dalmaták = "101";
szám (dalmaták);
101

A "101" karakterláncot 101-re alakították át.

A szóközökből vagy üres karakterláncokból álló karakterláncok 0-ra lesznek konvertálva.

Szám(" "); // 0-t ad vissza
Szám(""); // 0-t ad vissza

Ne feledje, hogy a nem számokból álló karakterláncok NaN-re konvertálódnak, ami azt jelenti, hogy nem szám. Ez vonatkozik a szóközzel elválasztott számokra is.

Szám("tizenkettő"); // NaN-t ad vissza
Szám("20 000"); // NaN-t ad vissza
Szám("2 3"); // NaN-t ad vissza
Szám("11-11-11"); // NaN-t ad vissza

A logikai adatokban a false értéke 0, az igaz pedig 1.

Értékek konvertálása logikai értékekké

A számok vagy karakterláncok logikai értékké alakításához a Boolean() metódust használjuk. Például segít meghatározni, hogy a felhasználó beír-e adatokat egy szövegmezőbe vagy sem.

Minden üresnek értelmezett érték, például a 0 szám, az üres karakterlánc, az undefined, a NaN vagy a null, hamisra konvertálódik.

Boolean(0); // hamis értéket ad vissza
Boolean(""); // hamis értéket ad vissza
Boolean (undefined); // hamis értéket ad vissza
logikai (NaN); // hamis értéket ad vissza
Boolean(null); // hamis értéket ad vissza

A többi érték, beleértve a szóközökből álló karakterlánc-literálokat is, igaz értékre konvertálódik.

Boolean (2000); // igazat ad vissza
Boolean(" "); // igazat ad vissza
Boolean("mániákus"); // igazat ad vissza

Vegye figyelembe, hogy a "0" karakterlánc igazra konvertálódik, mert nem üres érték:

Boolean("0"); // igazat ad vissza

A számok és karakterláncok logikai értékké való konvertálása lehetővé teszi az adatok binárisan történő kiértékelését, és felhasználható a programok áramlásának szabályozására.

Következtetés

Most már tudja, hogyan alakítja át a JavaScript adattípusokat. A típusöntés gyakran az adatok implicit átalakítását okozza, ami váratlan értékeket eredményezhet. Javasoljuk, hogy kifejezetten konvertálja az adattípusokat, hogy biztosítsa a programok megfelelő működését.

A JavaScript számos beépített adattípust biztosít. Ezeken kívül ez a cikk a jQuery virtuális típusaival foglalkozik, például szelektorokkal, kiterjesztett pszeudotípusokkal, például eseményekkel és mindenféle funkcióval.

A legjobb, ha az alábbi példák többségét kipróbálja. Ez egyszerűen megtehető, ha egyszerűen átmásolja ezeket a példákat a Firebug konzolra, egy Firefox böngészőbővítményre.

Amikor a példák logikai kontextusban hajtanak végre műveleteket (például összehasonlításokat), fontos tudni, hogy az egyes adattípusok hogyan viselkednek az adott kontextusban:

Var x = "" if (x) console.log("x alapértelmezés szerint igaz") else console.log("x alapértelmezés szerint hamis")

Ebben az esetben "x egyenlő hamis" lesz kinyomtatva.

A példák hosszának csökkentése érdekében a negációs operátort a logikai kontextus megjelenítésére használják:

X // igaz

jQuery adattípusok

Húrok
- Beépített metódusok karakterláncokhoz
- hossz tulajdonság
- Logikai kontextus
Számok
- Logikai kontextus
- Számok elemzése
- Számok karakterláncok
- NaN és Infinity
- Egész szám
- Úszó
Logikai típus
Objektumok
- Pontjelölés
- Tömb jelölése
- Ismétlés
- Logikai alapértelmezés
- Prototípus
Lehetőségek
Tömbök
- Ismétlés
- Logikai alapértelmezés
- Sor Jelölés
Funkciók
- Érvek
- Kontextusban, hívjon és jelentkezzen
- Láthatósági terület
- Lezárások
- Proxy minta
Visszahívási funkciók
Kiválasztók
Események
Elemek
jQuery típusú
XMLHttpRequest típus

Húrok

"Ez egy JavaScript karakterlánc!" – És ez is egy sor!

A JavaScript karakterlánca egy megváltoztathatatlan objektum, amely nulla, egy vagy több karaktert tartalmaz.

A karakterláncok típusa "string". A karakterlánc típusát így találhatja meg:

"valamilyen karakterlánc" típusa; // "húr"

Idézőjelek használata karakterláncokban

Egy karakterlánc definiálható szimpla vagy dupla idézőjelekkel. Szabadon használhat szimpla idézőjeleket egy dupla idézőjelbe zárt karakterláncon belül, és fordítva. Ha kettős idézőjeleket szeretne használni a dupla idézőjeles karakterláncokon belül, akkor azokat fordított perjellel kell megszakítani \ . Ez vonatkozik az egyszeres idézőjelekre is.

"Elszomorítasz." "Szent "forgató" Mózes! " itthon" "itthon"

Beépített metódusok karakterláncokhoz

A JavaScript számos beépített metódussal rendelkezik a karakterláncok manipulálására, amelyek eredménye lehet egy karakterlánc vagy például egy tömb:

"hello".charAt(0) // "h" - a karakter megszerzése a karakterlánc kívánt pozíciójában a "hello".toUpperCase() // "HELLO" - a karakterlánc átalakítása nagybetűssé "Hello".toLowerCase() / / "hello" - egy karakterlánc átalakítása kisbetűs "hello".replace(/e|o/g, "x") // "hxllx" - egy karakterlánc egy részének lecserélése egy részkarakterláncra az "1,2" reguláris kifejezésmintával ,3".split(", ") // ["1", "2", "3"] - egy karakterlánc felosztása tömbre egy adott részkarakterlánc által

hossz tulajdonság

A karakterláncoknak van egy hossz tulajdonsága, amely meghatározza a karakterlánc hosszát.

"Hello".length // 5 "".length // 0

Logikai kontextus

Az üres karakterlánc hamisra értékelődik:

!"" // igaz ! "hello" // false ! "igaz" // false !new Boolean(false) // false

Számok

12 3.543

A JavaScriptben szereplő számok az IEEE 754 szabvány szerint 64 bites dupla pontosságú formátumban vannak, és változtathatatlanok is. A számokkal való munkához minden operátor elérhető, ugyanúgy, mint a C nyelvben (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

A számok típusa "szám". A számok típusát így ellenőrizheti:

Typeof 12 // "szám" typeof 3.543 // "number"

Logikai kontextus

Ha a szám nulla, akkor egyenlő hamis:

0 // igaz !1 // hamis !-1 // hamis

Mivel a számok kettős pontosságú formátumban vannak implementálva, a következő példa kimenete nem hibás:

0.1 + 0.2 // 0.30000000000000004

Matematikai objektum

A JavaScript funkciókat biztosít a matematikai objektumban lévő számokkal való munkavégzéshez:

Math.PI // 3.141592653589793 Math.cos(Math.PI) // -1

Átalakítás számokká

A parseInt és parseFloat függvények a karakterláncokat számokká alakítják. Mindkét függvény implicit konverziót hajt végre, ha a számrendszer nincs megadva:

ParseInt("123") = 123 (implicit decimális konverzió) parseInt("010") = 8 (implicit oktális konverzió) parseInt("0xCAFE") = 51966 (implicit hexa konverzió) parseInt("010", 10) = 10 ( explicit decimális konverzió 10-es gyökkel) parseInt("11", 2) = 3 (explicit bináris konverzió) parseFloat("10.10") = 10.1

Számok átalakítása karakterláncokká

Ha a "+" művelettel számokat ad hozzá egy karakterlánchoz, az eredmény mindig egy karakterlánc lesz. Ha számításokat szeretne végrehajtani, mielőtt számot adna egy karakterlánchoz, feltétlenül tegye zárójelbe a számításokat:

"" + 1 + 2; // "12" "" + (1 + 2); // "3" "" + 0,0000001; // "1e-7" parseInt(0.0000001); // 1 (megjegyzés!)

Használhatja a JavaScript String osztályt is, amely az átadott értéket karakterláncsá alakítja:

Karakterlánc(1) + Karakterlánc(2); // "12" String(1 + 2); "3"

NaN és Infinity típusok

Az olyan értékek konvertálása, amelyek nem számok, NaN-t eredményez. Az isNaN függvény meghatározza, hogy a neki átadott érték egyenlő-e NaN-nel:

ParseInt("hello", 10) // NaN isNaN(parseInt("hello", 10)) // igaz

Nullával osztva a végtelent kapjuk:

1 / 0 // Végtelen

Mind a NaN, mind az Infinity értéke "szám" típusú:

Typeof NaN // "szám" typeof Infinity // "szám"

Felhívjuk figyelmét, hogy a NaN értékek összehasonlítása nem szabványos módon történik:

NaN == NaN // hamis (!)

Végtelen == Végtelen // igaz

Egész típusú

Az Integer egy egész szám típusa.

Úszó típus

A Float egy lebegőpontos számtípus.

Logikai típus

A JavaScript logikai típusa igaz vagy hamis lehet:

If (igaz) console.log("mindig!") if (false) console.log("soha!")

Például a logikai típus így néz ki a beállítások megadásakor a jQuery beépülő modulok csatlakoztatásakor:

$("...").somePlugin(( hideOnStartup: true, onlyOnce: false ));

Objektumok

A JavaScriptben minden objektum. Az objektum létrehozásának legegyszerűbb módja:

Var x = (); var y = ( név: "Pete", életkor: 15 );

Az objektumok típusa "object":

Typeof() // "objektum"

Az objektum tulajdonságai

Megváltoztathatja és lekérheti egy objektum tulajdonságait pontjelöléssel:

Y.name // "Pete" y.age // 15 x.name = y.name + " Pan" // "Pete Pan" x.age = y.age + 1 // 16

Az objektumot tömbként is használhatja:

Var műveletek = ( növekedés: "++", csökkentés: "--" ) var operation = "növelés"; műveletek // "++"; műveletek["multiply"] = "*"; // "*"

Iterációk tárgyakon

Az objektumok feletti iteráció nagyon egyszerű a for-in ciklus operátor használatával:

Var obj = ( név: "Pete", életkor: 15 ); for(kulcs az obj-ban) ( alert("kulcs "++", érték "+obj); )

A jQuery funkciót biztosít

objektumtulajdonságok vagy tömbelemek iterálásához:

JQuery.each(obj, function(kulcs, érték) (console.log("kulcs", kulcs, "érték", érték); ));

Logikai kontextus

Egy objektum, akár vannak tulajdonságai, akár nem, mindig igaz:

!() // hamis

Prototípusok

Minden objektum rendelkezik prototípus tulajdonsággal. Amikor az értelmező egy tulajdonságot keres egy objektumon, ellenőrzi annak prototípusát is. A jQuery-ben ezt a mechanizmust széles körben használják metódusok hozzáadására a jQuery objektumok példányaihoz.

Var form = $("#myform"); form.clearForm; // undefined form.fn.clearForm = function() ( return this.find(":input").each(function() ( this.value = ""; )).end(); ); A form.clearForm() // a jQuery objektumok összes példányára alkalmazható, mivel egy új metódust adtak a prototípushoz