En variabel är en namngiven minnesplats där du både kan lagra viss information och hämta den från den.

Att deklarera (skapa) variabler görs med nyckelordet var.

// meddelande - variabelnamn var meddelande;

När du skapar en variabel kan du omedelbart tilldela den ett värde.

Att tilldela ett värde till en variabel görs med operatorn "=".

// skapa till exempel en variabel e-post och tilldela den strängen " [e-postskyddad]"var email = " [e-postskyddad]"; // ställ in e-postvariabeln till ett nytt värde email = " [e-postskyddad]";

För att få värdet på en variabel hänvisar du helt enkelt till den med namn.

// mata till exempel ut värdet på e-postvariabeln till webbläsarkonsolen: console.log(email);

För att deklarera mer än en variabel med ett enda var-nyckelord måste du använda ett kommatecken.

Var pris = 78,55, kvantitet = 10, meddelande;

JavaScript är ett dynamiskt eller svagt skrivet språk. Det betyder att när en variabel deklareras behöver den inte ange vilken datatyp den kan acceptera. Därför kan du först placera ett värde av en datatyp i en variabel och sedan en annan.

Var output = "framgång"; // variabeln har en strängdatatyp output = 28; // samma variabel, men redan av datatypen "antal" output = true; // samma variabel, men som redan lagrar ett booleskt värde

Värdet på en variabel kan ändras ett obegränsat antal gånger.

// åldersvariabeln skapas var age; // variabel ålder tilldelas värdet 67 ålder = 67; // variabel ålder är satt till "Pensioneringsålder" age = "Pensioneringsålder"; // variabel ålder är satt till 55 ålder = 55;

En god praxis när man utvecklar klientapplikationer är att endast använda en datatyp i en given variabel, dvs. Skriv inte värden av olika datatyper till en variabel. För att förstå vilken typ av data som bör förväntas i en variabel, när du skapar en variabel, rekommenderas att omedelbart initiera den med ett specifikt värde.

Variabelnamnet kan bestå av bokstäver, siffror och symbolerna $ och _. I det här fallet får det första tecknet i variabeln inte vara ett tal. Dessutom kan du inte använda reserverade ord som variabelnamn.

// skapa två variabler, den första variabeln heter phone, den andra är message; var telefon, meddelande;

Stora versaler för bokstäverna i variabelnamnet har betydelse. Det vill säga att till exempel den variabla telefonen och Telefonen är två olika variabler.

Om strikt läge inte används kan du skapa en variabel med startvärdet utan nyckelordet var.

Pris = 250,00; // skapade en variabel och initierade den med talet 250,00 procent = "20%"; // skapade en variabel och initierade den med strängen "20%"

Men att skapa variabler på detta sätt rekommenderas inte.

Datatyper

I JavaScript kan datatyper delas in i primitiva och objekt.

Variabler som innehåller primitiva datatyper lagrar sitt värde explicit.

Det finns 5 primitiva datatyper i JavaScript:

• siffra;
• sträng;
• boolesk typ (boolesk);
• null;
• odefinierad.

Om en variabel tilldelas värdet av en annan som innehåller en primitiv datatyp, kommer den att få sin egen kopia av det värdet.

Var x = 77, y = x; x = 55; y; // 77

Variabler som innehåller ett objekt lagrar faktiskt inte själva objektet, utan en referens till det.

Om en variabel tilldelas värdet av en annan som innehåller ett objekt (en länk till det), kommer den också att få en länk till det. Som ett resultat av denna operation kommer dessa två variabler att innehålla en referens till samma objekt.

// exempel 1 (med datatypen "objekt") var coord1 = (x: 77, y: 100), coord2 = coord1; coordl.x = 55; // ställ in egenskapen x för objektet till ett nytt värde coord2.x; // 55, eftersom coord1 och coord2 innehåller en referens till samma objekt // exempel 2 (med en matrisdatatyp) var coord1 = , coord2 = coord1; koordinat1 = 55; // ställ in elementet med index 0 till ett nytt värde coord2; // 55, eftersom coord1 och coord2 innehåller en referens till samma objekt // exempel 3 (med datatypen "date") var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // öka datumet med 7 dagar date1; // 01/07/2018, eftersom datum1 och datum2 innehåller en referens till samma objekt

siffra

Den numeriska datatypen i JavaScript är generisk. Det används för att representera både heltal och bråk.

Var int = 5; // heltal var float = 5,98; // ett bråktal

Formatet för att representera siffror i JavaScript är i enlighet med IEEE 754-2008-standarden.

Heltal i JavaScript kan anges inte bara i decimalsystem talsystem, men också i oktalt (0) eller hexadecimalt talsystem (0x) med prefix som anges inom parentes:

Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184

Det är möjligt att skriva siffror i exponentiell form:

Var num = 2e3; // exponentiell notation av talet 2*10^3 (2000) num = 2e-3; // exponentiell notation av talet 2*10^-3 (0,002) num = 3,2e3; // 3200 num = 1,5e-2; // 0,015

Förutom siffror innehåller den numeriska datatypen även speciella numeriska värden:

• Infinity (positiv oändlighet);
• -Infinity (negativ oändlighet);
• NaN (Inte ett nummer).

Specialvärdet Infinity innebär ett mycket stort positivt tal, d.v.s. ett tal som inte kan representeras i JavaScript eftersom det är för stort.

Särskilda betydelser -Infinity betyder tvärtom ett mycket stort negativt tal, d.v.s. ett tal som inte kan representeras av JavaScript eftersom det också är för stort.

Ett exempel på uttryck som kommer att returnera speciella numeriska värden som ett resultat av deras beräkning:

5/0; // Infinity -5/0; // -Infinity Math.pow(10 399); // Infinity (10 till 399) Math.pow(10 399); // -Infinity (-10 upp till 399)

NaN-värdet returneras som ett resultat av att utföra matematiska operationer som JavaScript inte kan beräkna.

5 - "Hej"; // NaN (subtrahera en rad från talet 5) 1000 / "20px"; // NaN (tal dividerat med sträng) sant * "1rem"; // NaN (booleskt värde sant multiplicerat med sträng)

Det som är väldigt intressant är att värdet av NaN i JavaScript inte är lika med något inklusive sig själv.

NaN == NaN; // falskt NaN === NaN; //falsk

Boolesk datatyp

Boolean är en primitiv datatyp som bara har två värden: sant och falskt.

Var a = sant; var b = falskt;

Sträng

String är en datatyp som används i JavaScript för att representera text.

En JavaScript-sträng kan bestå av 0 eller Mer tecken.

JavaScript använder alltid Unicode som strängformat.

Att skapa en sträng (sträng bokstavlig) görs genom att omge text i singel eller dubbla citattecken.

"JavaScript"; "ECMAScript";

I JavaScript är det ingen skillnad mellan enkla och dubbla citattecken.

Men i vissa fall är det vettigt att använda enkla citattecken snarare än dubbla citattecken och vice versa.

Till exempel, när en sträng innehåller dubbla citattecken är det bekvämare att omsluta den med enkla citattecken. Detta kommer att eliminera behovet av att undvika dubbla citattecken i den.

""ECMAScript""; // utan att escape (med enstaka citattecken) "\"ECMAScript\""; // med att fly

En sträng i JavaScript kan innehålla specialtecken. Till exempel, \n (radmatning), \t (tab), \r (vagnretur), etc.

"Detta är en mening.\nOch detta är också en mening, men den börjar från en ny rad.";

Med strängar kan du utföra operationen addition (union) eller, med andra ord, sammanlänkning. Operatorn "+" används för detta. Innebörden av denna operation är att lägga till den andra raden i slutet av den första.

"Jag älskar " + "JavaScript"; // Jag älskar JavaScript

Värdet är "odefinierat"

undefined är en speciell primitiv datatyp som har ett enda värde lika med undefined .

Denna datatyp har en deklarerad variabel som ännu inte har tilldelats något värde.

Var num; // odefinierat

Värdet undefined kommer också att returneras vid åtkomst till en icke-existerande egenskap hos ett objekt.

Var obj = (); // tomt objekt obj.prop; // odefinierat

"noll" värde

null är en speciell primitiv datatyp som har ett enda värde lika med null.

null är bara ett specialvärde som har betydelsen "ingenting" eller "okänt värde", d.v.s. det betyder uppenbarligen ingenting.

Objekt

Ett objekt är en datastruktur som består av namn-värdepar.

Att skapa ett objekt med hjälp av objekts bokstavlig notation görs på följande sätt:

( namn_1: värde_1, namn_2: värde_2, namn_3: värde_3, ... )

Som du kan se separeras namnet från värdet med ett kolon, och paren separeras från varandra med kommatecken.

Dessutom, om värdet på paret är en funktion, kallas det en metod för detta objekt. Alla andra par, dvs. par där en funktion inte används som ett värde kallas objektegenskaper.

Ett objekt är med andra ord en datastruktur som består av egenskaper och metoder.

Var person = ( namn: "Vitaly", ålder: 27, getAge: function () ( returnera "Age: " + this.age; ) )

Tillgång till egenskaperna för ett objekt görs genom en punkt eller genom att använda parentes.

// visa värdet på egenskapen age i webbläsarkonsolen // 1:a metoden (via en punkt) console.log(person.age); // Metod 2 (med parenteser) console.log(person["ålder"]); // anropar getAge-metoden; värdet det returnerar kommer att matas ut till konsolen console.log(person.getAge());

typ av operatör

Operatorn typeof används för att få information om datatypen för ett uttryck som en sträng.

Syntaxen för typen av operator (alternativ utan parentes):

Typ av uttryck

Typ av operatorsyntax (med parenteser):

Typ av (uttryck)

Var namn, ålder = 37, e-post = " [e-postskyddad]", isLicense = true, interest: null, lastExperience: ( period: "juni 2011 - juni 2018", plats: "ISACA, Moskva", position: "Webbdesigner" ), getExperience: function() ( return lastExperience.period + " ("+ lastExperience.position + " - " + lastExperience.place + ")"; ); typ av namn; // "odefinierad" typ av ålder; // "nummer" typ av ärLicens; // "boolesk" typ av intresse; / / "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) är en bugg som har funnits i språket sedan den första implementeringen; den har inte varit fixat för att bibehålla kompatibilitet och detta måste beaktas när man skriver skript; null är en primitiv datatyp, det är inte ett objekt */ /* (2) - det är mycket bekvämt att typen av operator separerar funktioner separat; men en funktion i JavaScipt är också objekt; detta kan enkelt verifieras genom att utföra följande konstruktion: */ typeof getExperience.__proto__.__proto__ // "object" (funktionsprototypen är ett objekt)

Konstanter

Med lanseringen av ECMAScript 6 blev det möjligt att skapa konstanter. Detta görs med hjälp av nyckelordet const.

Const COLOR_RED = "#ff0000";

En konstant är en variabel vars värde är skyddat från förändring. De där. När du försöker ändra värdet kommer ett fel att visas.

Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Tilldelning till konstant variabel.

Om till exempel en konstant innehåller ett objekt, kan det inte ändras, eller snarare en referens till det. Men egenskaperna för detta objekt kan ändras.

Const COLORS = ( röd: "#ff0000", grön: "#00ff00", blå: "#00ff00" ) FÄRG = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Tilldelning till konstant variabel. COLORS.green = "#4caf50";

Datatyper hjälper till att skapa en klassificering av data i programmeringsspråk. Till exempel är ett nummer och en teckensträng olika typer av data som JavaScript kommer att behandla olika.

Detta är viktigt eftersom varje datatyp kan anta specifika värden och utföra specifika åtgärder. För att kunna utföra operationer på variabler i JavaScript är det viktigt att förstå datatypen för varje given variabel.

Denna handledning introducerar dig till JavaScript-datatyper.

Obs: Informationen i den här guiden är inte uttömmande, men den ger dig en översikt över de grundläggande JavaScript-alternativen.

Dynamiskt skrivande

JavaScript är ett dynamiskt språk. Detta innebär att datatypskontroll görs vid körning, inte vid kompilering.

I dynamiska språk kan variabler med samma namn användas för att lagra olika typer data.

Till exempel kan variabeln t, definierad av nyckelordet var, lagra olika typer av data; den kan också initieras men lämnas odefinierad:

var t = 16; //t är ett tal
var t = "Teresa"; // t är en sträng
var t = sant; // t är en boolesk
var t; //t är odefinierat

Alla t-variabler innehåller olika JavaScript-datatyper. I JavaScript behöver du inte explicit ange datatypen för en variabel innan du använder den.

Tal

JavaScript har en enda numerisk datatyp, som inte skiljer mellan heltal och flyttal. Därför kan siffror i JavaScript skrivas med eller utan decimaler:

var num1 = 93;
var num2 = 93,00;

I exemplet ovan innehåller båda variablerna siffror, oavsett om det finns ett kommatecken i det eller inte.

Vetenskaplig notation i JavaScript låter dig förkorta mycket stora eller små tal:

var num3 = 987e8; // 98700000000
var num4 = 987e-8; // 0,00000987

I JavaScript anses siffror vara exakta till 15 siffror. Detta betyder att efter att ha nått den 16:e siffran kommer siffrorna att avrundas:

var num5 = 9999999999999999; // kvarstår som 9999999999999999
var num6 = 99999999999999999; // avrundat uppåt till 10000000000000000

Dessutom har siffror i JavaScript tre symboliska betydelser:

Oändlighet - numeriskt värde, vilket är ett positivt tal som närmar sig oändligheten.

Infinity är ett numeriskt värde som representerar ett negativt tal som närmar sig oändligheten.

NaN – Not-a-Number, ett specialtillstånd för ett flyttal.

Infinity och -Infinity returneras när man räknar ett nummer utöver det högsta möjliga antalet som är tillgängligt i JavaScript. De visas också när man räknar odefinierade värden, som att dividera med noll:

var num7 = 5 / 0; //Oändlighet
var num8 = -5 / 0; // -Oändlighet

Tekniskt sett returneras Infinity om antalet är större än 1,797693134862315E+308, vilket är den övre gränsen i JavaScript.

Likaså kommer -Infinity att visas när siffran går över den nedre gränsen, -1,797693134862316E+308.

Infinity-numret kan också användas i loopar:

medan (num9 != Infinity) (
// Koden här kommer att köras genom num9 = Infinity
}

För odefinierade tal skrivs NaN ut. Om du försöker utföra en matematisk operation på ett tal och ett icke-numeriskt värde får du NaN. Till exempel:

var x = 20 / "Shark"; // x kommer att vara NaN

Eftersom 20 inte kan delas med Shark-strängen kommer värdet på x att vara NaN.

Men om strängen kan utvärderas som ett numeriskt värde, kommer JavaScript att utvärdera det matematiska uttrycket:

var y = 20 / "5"; //y kommer att vara 4

Eftersom JavaScript kan behandla 5 som ett numeriskt värde, kommer 5 att fungera med den matematiska divisionsoperatorn.

Om en variabel i ett uttryck är satt till NaN blir resultatet NaN, även om den andra operanden är ett tal.

var a = NaN;
var b = 37;
var c = a + b; // c kommer att vara NaN

Så i JavaScript finns det bara en numerisk datatyp. I JavaScript finns det inget behov av att dela upp tal i heltal och flyttal eftersom JavaScript är ett dynamiskt språk.

Strängar

En sträng är en sekvens av ett eller flera tecken (bokstäver, siffror och andra symboler). Strängar representerar textdata.

I JavaScript kommer strängar i både enkla och dubbla citattecken. För att skapa en sträng måste du omge en sekvens av tecken inom citattecken:

var singleQuotes = "Detta är en sträng inom enstaka citattecken.";
var doubleQuotes = "Detta är en sträng inom dubbla citattecken.";

Du kan använda enkla eller dubbla citattecken, men du måste använda en typ av citattecken konsekvent inom samma kod.

Program "Hej världen!" visar hur strängar används i datorprogrammering. I huvudsak i i detta exempel en sträng är en sekvens av tecken som utgör frasen "Hello, World!" i alert().

function helloFunction() (
alert("Hej världen!");
}

Klicka här

Genom att köra koden och klicka på knappen Klicka på mig kommer du att se ett popup-fönster med texten:

Liksom andra datatyper kan strängar lagras i variabler.

var hw = "Hej världen!";

Du kan sedan visa strängen genom att anropa variabeln:

...

var hw = "Hej världen!";
function helloFunction() (
alert(hw);
}

...
Hej världen!

Strängar gör att information kan skickas till användaren och tillbaka till programmet.

Boolesk datatyp

En boolesk (eller boolesk) datatyp består av två värden – sant och falskt.

Denna typ används för att representera sanningsvärden associerade med logik och algoritmer inom datavetenskap.

Obs: Denna datatyp är uppkallad efter matematikern George Boole.

Många operationer i matematik ger resultat som kan utvärderas som sanna eller falska:

Mer än:

• 500 > 100 sant
• 1 > 5 falskt

Mindre än:

• 200 < 400 true
• 4 < 2 false

• 5 = 5 sant
• 500 = 400 falskt

Precis som andra typer kan den booleska datatypen lagras i variabler.

var myBool = 5 > 8; // falskt

Eftersom 5 inte är större än 8 kommer myBool att vara falskt.

När du kodar i JavaScript kommer du att bli bekant med hur boolesk data fungerar och hur olika sanningsutvärderande funktioner och operationer kan förändra flödet i ett program.

Matriser

En matris kan innehålla flera värden inom en enda variabel. Det betyder att du kan lagra en lista med värden inuti en array och iterera genom dem.

Varje värde inom arrayen kallas ett element. Du kan komma åt elementen i en array med hjälp av ett index.

Matriser definieras av hakparenteser.

Strängarrayen ser ut så här:

var fish = ["haj", "bläckfisk", "clownfisk", "ål"];

Genom att anropa fiskvariabeln får du resultatet:

["haj", "bläckfisk", "clownfisk", "ål"]

Arrayer är en mycket flexibel datatyp eftersom de är föränderliga: du kan lägga till, ta bort och ändra värdena på element.

Föremål

Ett objekt i JavaScript består av nyckel:värdepar.

Objektsyntaxen består av nyckel:värdepar. Ett objekt separeras av hängslen på båda sidor (()).

Par i objektet separeras med mellanslag:

var sammy = (förnamn:"Wally", efternamn:"Shark", färg:"blå", plats:"ocean");

Ett objekt kan också skrivas på flera rader (detta gäller särskilt för stora objekt).

var wally = (
förnamn: "Wally",
efternamn: "Shark",
färgen blå",
plats: "Ocean"
};

Arbeta med flera datatyper

Varje program du skapar kommer sannolikt att innehålla flera datatyper, men operationer utförs vanligtvis på en enda datatyp. matematik tillämpas på siffror och skivning tillämpas på strängar.

Genom att använda operatorer som fungerar med alla typer av data (till exempel kan operatorn + lägga till siffror eller utföra strängsammansättning) kan du få oväntade resultat.

Om du skapar en variabel för sammanlänkning kommer JavaScript att tolka varje element som en sträng.

var o = "Ocean" + 5 + 3;

Genom att anropa variabel o får du följande resultat:

Men om strängen innehåller siffror först och sedan en sträng, kommer operatorn + att utföra addition och sedan sammanlänkning:

var p = 5 + 3 + "Ocean";
8 Havet

Eftersom resultaten är oförutsägbara är det bekvämare att utföra operationer och metoder i en enda datatyp. JavaScript returnerar dock inga fel vid blandning av datatyper, vilket vissa andra programmeringsspråk gör.

Slutsats

Du är nu bekant med JavaScript-datatyper. Var och en av de typer som listas här är viktiga när du skriver JavaScript-program.

Taggar: En variabel är en identifierare som har tilldelats ett värde. En variabel kan nås i ett program, och arbetar därmed med det värde som tilldelats den.

En JavaScript-variabel i sig innehåller inte information om vilken typ av värden som kommer att lagras i den. Det betyder att genom att skriva till exempel en sträng till en variabel kan du senare skriva ett tal till den. En sådan operation kommer inte att orsaka ett fel i programmet. Det är därför JavaScript ibland kallas ett "otypat" språk.

Innan en variabel kan användas måste den deklareras med nyckelordet var or let. Om vi ​​pratar om en konstant används nyckelordet const. Du kan deklarera en variabel och tilldela den ett värde utan att använda dessa nyckelord, men det rekommenderas inte att göra det.

▍Nyckelord var Före ES2015-standarden var användningen av nyckelordet var det enda sättet rörliga deklarationer.

Var a = 0
Om du utelämnar var i den här konstruktionen kommer värdet att tilldelas en odeklarerad variabel. Resultatet av denna operation beror på i vilket läge programmet körs.

Så om det så kallade strikta läget är aktiverat kommer detta att orsaka ett fel. Om strikt läge inte är aktiverat kommer variabeln att deklareras implicit och tilldelas det globala objektet. Detta innebär i synnerhet att en variabel som deklareras implicit i en funktion på detta sätt kommer att förbli tillgänglig efter att funktionen har slutförts. Vanligtvis förväntas det att variabler som deklareras i funktioner inte "går utöver" deras räckvidd. Det ser ut så här:

Funktion notVar() ( bNotVar = 1 //bättre att inte göra detta) notVar() console.log(bNotVar)
1 kommer att visas i konsolen, ingen förväntar sig vanligtvis ett sådant beteende från ett program, uttrycket bNotVar = 1 ser inte ut som ett försök att deklarera och initiera en variabel, utan som ett försök att komma åt en variabel som ligger i ett omfång utanför funktion (detta är ganska normalt). Som ett resultat är implicita variabeldeklarationer förvirrande för dem som läser koden och kan leda till oväntat programbeteende. Senare kommer vi att prata om både funktioner och omfattningar, men försök tills vidare att alltid använda specialiserade nyckelord när meningen med ett uttryck är att deklarera en variabel. Om funktionskroppen i det här exemplet skrivs om till var bNotVar = 1, kommer ett felmeddelande att visas om du försöker köra ovanstående kodfragment (du kan se det i webbläsarkonsolen).

Till exempel kan det se ut så här: Uncaught ReferenceError: bNotVar är inte definierad . Dess innebörd kokar ner till det faktum att programmet inte kan fungera med en obefintlig variabel. Det är mycket bättre att se ett sådant felmeddelande när du först startar ett program än att skriva obegriplig kod som kan bete sig oväntat.

Om, när en variabel deklareras, den inte initieras eller tilldelas något värde, kommer den automatiskt att tilldelas värdet odefinierat.

Var a //typeof a === "odefinierad"
Variabler som deklareras med nyckelordet var kan deklareras igen många gånger och tilldela dem nya värden (men detta kan vara förvirrande för den som läser koden).

Var a = 1 var a = 2
Du kan deklarera flera variabler i ett uttryck:

Var a = 1, b = 2
Omfattningen av en variabel är det område av programmet där denna variabel är tillgänglig (synlig).

En variabel initierad med nyckelordet var utanför en funktion tilldelas ett globalt objekt. Den har global räckvidd och är tillgänglig från var som helst i programmet. Om en variabel deklareras med nyckelordet var inuti en funktion, är den endast synlig inom den funktionen, eftersom den är en lokal variabel för den.

Om en funktion som använder var deklarerar en variabel vars namn är detsamma som en variabel i det globala omfånget, kommer den att "åsidosätta" den globala variabeln. Det vill säga, när man kommer åt en sådan variabel inuti en funktion kommer dess lokala version att användas.

Det är viktigt att förstå att block (kodområden inneslutna i hängslen) inte skapar nya omfång. Nytt område synlighet skapas när funktionen anropas. Nyckelordet var har vad som kallas functional scope snarare än block scope.

Om en variabel deklareras i funktionskoden är den synlig för hela funktionskoden. Även om en variabel deklareras med var i slutet av funktionskoden, kan den nås i början av koden, eftersom JavaScript har en variabel hissmekanism. Denna mekanism "lyfter" variabla deklarationer, men inte deras initialiseringsoperationer. Detta kan vara en källa till förvirring, så gör det till en vana att deklarera variabler i början av din funktion.

▍Nyckelordet let Nyckelordet let introducerades i ES2015 och kan på ett förenklat sätt kallas "block"-versionen av var . Variabler som deklareras med nyckelordet let är omfångade till blocket, satsen eller uttrycket där det deklareras och till kapslade block.

Om själva ordet "låt" inte verkar så tydligt kan du tänka dig att använda ordet "låt" istället. Sedan kan uttrycket låt färg = "röd" översättas till engelska enligt följande: "låt färgen vara röd", och till ryska enligt följande: "låt färgen vara röd".

Genom att använda nyckelordet let kan du undvika oklarheterna som följer med nyckelordet var (du kommer till exempel inte att kunna deklarera samma variabel två gånger med let ). Att använda let utanför en funktion, till exempel när man initierar loopar, skapar inte globala variabler.

Till exempel kommer den här koden att generera ett fel:

För (låt i = 0; i< 5; i++) { console.log(i) } console.log(i)
Om, när slingan initieras, räknaren i deklareras med nyckelordet var, kommer i att vara tillgänglig utanför slingan efter att den har slutfört sitt arbete.

Nuförtiden, när man utvecklar JS-program baserade på moderna standarder, är det fullt möjligt att helt överge var och bara använda nyckelorden let och const.

▍Nyckelordet const Värdena för variabler som deklareras med nyckelorden var eller let kan skrivas över. Om const används istället för dessa nyckelord, kan en konstant som deklareras och initieras med dess hjälp inte tilldelas ett nytt värde.

Const a = "test"
I det här exemplet kan konstanten a inte tilldelas ett nytt värde. Men det bör noteras att om a inte är ett primitivt värde som ett tal, utan ett objekt, skyddar inte användningen av nyckelordet const detta objekt från ändringar.

När de säger att ett objekt är lagrat i en variabel, menar de egentligen att variabeln lagrar en referens till objektet. Denna länk kan inte ändras, men själva objektet som länken leder till kan ändras.

Nyckelordet const gör inte objekt oföränderliga. Det skyddar helt enkelt referenser till dem skrivna i motsvarande konstanter från förändringar. Så här ser det ut:

Const obj = () console.log(obj.a) obj.a = 1 //works console.log(obj.a) //obj = 5 //orsakar ett fel
Under initieringen skrivs ett nytt tomt objekt till obj-konstanten. Ett försök att komma åt dess egenskap a, som inte finns, orsakar inget fel. Konsolen blir odefinierad. Efter det lägger vi till en ny egenskap till objektet och försöker komma åt den igen. Denna gång är värdet på den här egenskapen 1 i konsolen. Om du avkommenterar den sista raden i exemplet kommer ett försök att köra den här koden att resultera i ett fel.

Nyckelordet const är mycket likt let , i synnerhet har det blockomfattning.

Under moderna förhållanden är det helt acceptabelt att använda nyckelordet const för att deklarera alla enheter vars värden inte är planerade att ändras, och endast använda i speciella fall. Varför? Hela poängen är att det är bäst att sträva efter att använda enklast möjliga konstruktioner som finns för att inte komplicera programmet och undvika fel.

JavaScript-datatyper kallas ibland ett "otypat" språk, men så är inte fallet. Det är sant att du kan skriva värden av olika typer i variabler, men det finns fortfarande datatyper i JavaScript. I synnerhet talar vi om primitiva och objektdatatyper.

För att bestämma datatypen för ett värde kan du använda typen av operator. Den returnerar en sträng som anger typen av operanden.

▍Primitiva datatyper Här är en lista över primitiva JavaScript-datatyper:

• siffra
• sträng
• booleskt (booleskt värde)
• null (särskilt värde null)
• odefinierat (speciellt värde odefinierat)
• symbol (symbol, används i speciella fall, introducerad i ES6)

Här anges namnen på datatyperna eftersom de returneras av typen av operatör.

Låt oss prata om de vanligaste datatyperna från den här listan.

Nummertypsvärdena för typnummer i JavaScript representeras som 64-bitars flyttal med dubbel precision.

I koden representeras numeriska bokstaver som heltal och bråk i decimaltalssystemet. Du kan använda andra metoder för att skriva siffror. Till exempel, om det finns ett prefix 0x i början av en numerisk literal, uppfattas det som ett tal skrivet med hexadecimal notation. Tal kan också skrivas i exponentiell notation (bokstaven e finns i sådana siffror).

Här är exempel på hur man skriver heltal:

10 5354576767321 0xCC // hexadecimalt nummer
Här är bråken.

3.14 .1234 5.2e4 //5.2 * 10^4
Numeriska bokstaver (detta beteende är också typiskt för vissa andra primitiva typer), när du försöker komma åt dem som objekt, omvandlas automatiskt, under operationens varaktighet, till motsvarande objekt, som kallas "objektomslag". I det här fallet talar vi om Nummerobjektets omslag.

Här är till exempel hur ett försök att komma åt variabeln a, som innehåller en numerisk bokstavlig, ser ut som ett objekt i Google Chrome-konsolen.

Nummerobjektomslagstips

Om du till exempel använder metoden toString() för ett objekt av typen Number, kommer det att returnera en strängrepresentation av numret. Motsvarande kommando ser ut så här, som kan köras i webbläsarkonsolen (och i vanlig kod) så här:

A.toString()
Notera de dubbla parenteserna efter metodnamnet. Om du inte tillhandahåller dem kommer systemet inte att generera ett fel, men istället för den förväntade utdata kommer du att se något i konsolen som inte alls liknar strängrepresentationen av siffran 5.

Det globala Number-objektet kan användas som en konstruktor och skapar nya siffror med dess hjälp (dock används det nästan aldrig i den här formen), det kan också användas som en oberoende enhet utan att skapa dess instanser (det vill säga vissa siffror) representeras med dess hjälp). Till exempel innehåller dess Number.MAX_VALUE-egenskap det maximala numeriska värdet som kan representeras i JavaScript.

Typsträng Värden för typsträng är sekvenser av tecken. Sådana värden specificeras som strängliteraler omslutna av enkla eller dubbla citattecken.

"En sträng" "En annan sträng"
Strängvärden kan delas upp i flera delar med omvänt snedstreck.

"A\sträng"
Linjen kan innehålla så kallade escape-sekvenser, som tolkas när raden matas ut till konsolen. Till exempel betyder sekvensen \n ett nyradstecken. Omvänt snedstreck kan också användas för att lägga till citattecken till strängar som omges av samma citattecken. Om du undviker citattecknet med \ gör att systemet inte behandlar det som ett specialtecken.

"Jag är en utvecklare"
Strängar kan sammanfogas med operatorn +.

"A" + "sträng"

Mallliterals I ES2015 dök det upp så kallade mallliterals, eller mallsträngar. De är strängar inneslutna i bakre citat (`) och har några intressanta egenskaper.

`ett snöre`
Till exempel kan du ersätta vissa värden som är resultatet av att utvärdera JavaScript-uttryck till mallbokstavar.

`en sträng med $(något)` `en sträng med $(någonting+någontingEtt)` `en sträng med $(obj.something())`
Att använda bakåtriktade citat gör det lättare att skriva bokstavliga strängar på flera rader:

`en sträng med $(något)`

Den booleska typen JavaScript har ett par reserverade ord som används när man arbetar med booleska värden: sant och falskt. Jämförelseoperatorer, som == , === ,< , >, returnera sant eller falskt.

Booleska uttryck används i satser som if och while för att hjälpa till att kontrollera flödet av ett program.

Det bör noteras att där värdet true eller false förväntas, kan du använda andra värden som automatiskt utvärderas av språket som sant (sanning) eller falskt (falskt).

Specifikt är följande falska värden:

0 -0 NaN undefined null "" //tom sträng
De återstående värdena är sanna.

Nulltypen JavaScript har ett speciellt värde, null , som indikerar frånvaron av ett värde. Liknande värden används på andra språk Typ undefined Värdet undefined som skrivits till en viss variabel indikerar att denna variabel inte är initialiserad och att det inte finns något värde för den.

Detta värde returneras automatiskt från funktioner vars resultat inte uttryckligen returneras med nyckelordet return. Om en funktion tar en parameter som inte anges när den anropas, är den också inställd på undefined .

För att kontrollera ett värde för undefined kan du använda följande konstruktion.

Variabeltyp === "odefinierad"

▍Objekt Alla icke-primitiva värden är av objekttyp. Vi pratar om funktioner, arrayer, vad vi kallar "objekt" och många andra entiteter. Alla dessa datatyper är baserade på objekttypen och även om de skiljer sig från varandra på många sätt har de också mycket gemensamt.Uttryck Uttryck är kodbitar som kan bearbetas och få ett visst värde utifrån de beräkningar som utförs . Det finns flera kategorier av uttryck i JavaScript Aritmetiska uttryck Denna kategori innehåller uttryck som utvärderas till tal.

1/2 i++ i -= 2 i * 2

Stränguttryck Resultatet av att utvärdera sådana uttryck är strängar.

"En " + "sträng" "A " += "sträng"

Primära uttryck Bokstaver, konstanter och referenser till identifierare faller inom denna kategori.

2 0.02 "något" sant falskt detta //exekveringskontext, referens till det aktuella objektet odefinierat i //där i är en variabel eller konstant
Detta inkluderar även vissa JavaScript-sökord och konstruktioner.

Funktionsklassfunktion* //avkastningsgenerator //kommando för att pausa/återuppta generatorns avkastning* //delegering till en annan iterator eller generator asynkronfunktion* //asynkront funktionellt uttryck avvaktar //organisation av väntan på exekvering av en asynkron funktion /mönster /i // vanligt uttryck() //gruppering

Initialiseringsuttryck för arrayer och objekt //array literal () //objekt literal (a: 1, b: 2) (a: (b: 1)) Logiska uttryck Användning av logiska uttryck logiska operatorer, resultatet av deras beräkning är logiska värden.

A && b a || b!a

Egenskapsåtkomstuttryck Dessa uttryck låter dig komma åt egenskaper och metoder för objekt.

Object.property //anropar en egenskap (eller metod) för ett objektobjekt objekt["property"]

Objektskapande uttryck new object() new a(1) new MyRectangle("namn", 2, (a: 4)) Funktionsdeklarationsuttryck function() () function(a, b) ( return a * b ) (a, b) => a * b a => a * 2 () => ( return 2 ) Anropsuttryck Sådana uttryck används för att anropa funktioner eller metoder för objekt.

A.x(2) window.resize()

Arbeta med objekt Vi har redan stött på objekt ovan, pratar om objekts bokstavliga ord, anropar deras metoder och får tillgång till deras egenskaper. Här kommer vi att prata om objekt mer i detalj, i synnerhet kommer vi att titta på mekanismen för prototypiskt arv och användningen av klassnyckelordet.▍Prototypiskt arv JavaScript sticker ut bland moderna programmeringsspråk genom att det stöder prototypiskt arv . De flesta objektorienterade språk använder en klassbaserad arvsmodell.

Varje JavaScript-objekt har en speciell egenskap (__proto__) som pekar på ett annat objekt som är dess prototyp. Ett objekt ärver prototypens egenskaper och metoder.

Låt oss säga att vi har ett objekt skapat med hjälp av ett objekt bokstavligt.

Const bil = ()
Eller så skapade vi ett objekt med hjälp av objektkonstruktorn.

Const bil = nytt objekt()
I något av dessa fall kommer prototypen för bilobjektet att vara Object.prototype .

Om du skapar en array som också är ett objekt, kommer dess prototyp att vara Array.prototype-objektet.

Const list = //eller så const list = new Array()
Du kan kontrollera detta enligt följande.

Car.__proto__ == Object.prototype //true car.__proto__ == new Object().__proto__ //true list.__proto__ == Object.prototype //false list.__proto__ == Array.prototype //true list.__proto__ == new Array().__proto__ //true
Här använde vi egenskapen __proto__; den behöver inte vara tillgänglig för utvecklaren, men den kan vanligtvis nås. Det bör noteras att mer på ett tillförlitligt sätt för att få prototypen för ett objekt är att använda metoden getPrototypeOf() global Objekt.

Object.getPrototypeOf(new Object())
Alla egenskaper och metoder för en prototyp är tillgängliga för objektet som har den prototypen. Här är till exempel hur deras lista ser ut för en array.

Array-tips

Basprototypen för alla objekt är Object.prototype.

Array.prototype.__proto__ == Objekt.prototyp
Object.prototype har ingen prototyp.

Det vi såg ovan är ett exempel på en prototypkedja.

När du försöker komma åt en egenskap eller metod för ett objekt, om objektet i sig inte har en sådan egenskap eller metod, utförs deras sökning i dess prototyp, sedan i prototypens prototyp, och så vidare tills den önskade egenskapen hittas, eller tills kedjan av prototyper inte tar slut.

Förutom att skapa objekt med den nya operatorn och använda objekt- eller arrayliterals, kan du skapa en instans av ett objekt med metoden Object.create() . Det första argumentet som skickas till denna metod är ett objekt som kommer att vara prototypen för objektet som det skapar.

Const car = Object.create(Object.prototype)
Du kan kontrollera om ett objekt är en del av prototypkedjan för ett annat objekt med metoden isPrototypeOf() .

Const list = Array.prototype.isPrototypeOf(list)

Konstruktorfunktioner Ovan skapade vi nya objekt med hjälp av de konstruktorfunktioner som redan finns tillgängliga i språket (nyckelordet new används när man anropar dem). Du kan skapa sådana funktioner själv. Låt oss titta på ett exempel.

Funktion Person(namn) ( this.name = name ) Person.prototype.hello = function() ( console.log(this.name) ) let person = new Person("Flavio") person.hello() console.log( Person.prototype.isPrototypeOf(person))
Här skapar vi en konstruktorfunktion. När den anropas skapas den nytt objekt, vilket indikeras av knappen ordet detta i konstruktörens kropp. Vi lägger till en name-egenskap till detta objekt och skriver till det vad som skickades till konstruktorn. Detta objekt returneras automatiskt från konstruktorn. Med hjälp av konstruktorfunktionen kan du skapa många objekt vars namnegenskaper kommer att innehålla det som skickades till konstruktorn när de skapades.

Efter att ha skapat konstruktorn lägger vi till en funktion till dess prototyp som kommer att skriva ut till konsolen värdet av namnegenskapen för objektet som skapats med den här funktionen. Alla objekt som skapas med denna konstruktor kommer att ha samma prototyp och använder därför samma hello()-funktion. Detta kan enkelt kontrolleras genom att skapa ett annat objekt av typen Person och jämföra dess hello()-funktion med funktionen för objektet som redan finns i exemplet (i detta fall skrivs funktionsnamnet utan parentes).

▍Klasser I ES6-standarden introducerade JavaScript konceptet med en "klass".

Tidigare kunde JavaScript endast använda den ovan beskrivna prototypiska arvsmekanismen. Denna mekanism såg ovanlig ut för programmerare som kom till JS från andra språk. Därför dök klasser upp i språket, som i huvudsak är "syntaktisk socker" för prototypens arvsmekanism. Det vill säga skapade objekt traditionellt sätt, och objekt skapade med klasser har prototyper.

Klassdeklaration Så här ser en klassdeklaration ut.

Klassperson ( constructor(name) ( this.name = name ) hello() ( returnera "Hej, jag är " + this.name + "." ) )
En klass har en identifierare som kan användas för att skapa nya objekt med den nya ClassIdentifier()-konstruktionen.

När ett nytt objekt skapas anropas konstruktormetoden och parametrar skickas till det.

Du kan deklarera metoder i en klass. I vårt fall är hello() en metod som kan anropas av alla objekt som skapas baserat på klassen. Så här ser det ut att skapa ett nytt objekt med klassen Person.

Const flavio = new Person("Flavio") flavio.hello()

Klassbaserade arvsklasser kan utöka andra klasser. Objekt skapade från sådana klasser kommer att ärva både metoderna för den ursprungliga klassen och metoderna som specificeras i den utökade klassen.

Om en klass som utökar en annan klass (en underklass till den klassen) har en metod vars namn är detsamma som den överordnade klassen, har den företräde framför den ursprungliga.

Klass Programmerare utökar Person ( hello() ( return super.hello() + " Jag är en programmerare." ) ) const flavio = new Programmer("Flavio") flavio.hello()
Att anropa hello()-metoden i exemplet ovan kommer att returnera strängen Hej, jag är Flavio. Jag är programmerare.

Klasser tillhandahåller inte förekomsten av variabler (egenskaper); egenskaperna för objekt skapade med klasser måste konfigureras i konstruktorn.

Inom en klass kan du komma åt föräldraklassen med hjälp av supernyckelordet.

Statiska metoder Metoder som beskrivs i en klass kan anropas genom att komma åt objekt skapade från klassen, men inte genom att komma åt själva klassen. Statiska metoder kan anropas genom att gå direkt till klassen Privata metoder JavaScript har ingen inbyggd mekanism som låter dig deklarera privata metoder. Denna begränsning kan övervinnas, till exempel genom att använda closures Getters och setters Du kan definiera metoder i en klass genom att prefixet dem med get eller set nyckelord. Detta gör att du kan skapa så kallade getters och setters - funktioner som används för att kontrollera åtkomsten till egenskaperna för objekt som skapats utifrån klassen. Gettern anropas när du försöker läsa värdet på en pseudo-egenskap, och settern anropas när du försöker skriva ett nytt värde till den.

Klass Person ( constructor(name) ( this.userName = name ) set name(value) (​this.userName = value ) get name() (retur this.userName ) )

Sammanfattning I detta material pratade vi om variabler, datatyper, uttryck och att arbeta med objekt i JavaScript. Ämnet för vårt nästa material kommer att vara funktioner.

Kära läsare! Om du har skrivit i JS länge, snälla berätta för oss vad du tycker om utseendet på klassens nyckelord i språket.

I den här handledningen kommer vi att introducera ett mycket viktigt koncept - JavaScript-datatyper. Vi rekommenderar att du är mycket uppmärksam på detta koncept - om du inte förstår det från början, kommer du ofta att behöva hantera konstigt beteende hos programmet du skapade.

Dynamiskt skrivande

Pågående datorprogram manipulera olika värden, som var och en kan bearbetas i ett programmeringsspråk och tillhör en specifik datatyp.

I JavaScript kan datatyper delas in i två kategorier: enkla (även kallade primitiva) typer och sammansatta (även kallade referens eller objekt).

JavaScript är ett svagt skrivet eller dynamiskt programmeringsspråk som gör att datatyper kan definieras, analyseras och kompileras i farten under programkörning. Det betyder att du inte behöver definiera typen av variabel i förväg. Typen bestäms automatiskt under programkörning.
Sålunda, i olika delar av programmet, kan samma variabel anta värden av olika typer:

Datatyper

ECMAScript®-standarden definierar följande datatyper:

• Enkla (även kallade primitiva) typer:
  • Boolean - kan ta två möjliga värden, ibland kallade sant och falskt;
  • null – värdet null representerar en referens som pekar, vanligtvis avsiktligt, till ett icke-existerande eller felaktigt objekt eller adress;
  • undefined – betecknar en fördefinierad global variabel initierad med ett odefinierat värde;
  • numerisk (engelsk nummer) – numerisk datatyp i formatet ett 64-bitars flyttalstal med dubbel precision;
  • sträng (engelsk sträng) – är en sekvens av tecken som används för att representera text;
  • symbol (eng. Symbol) är en datatyp, vars instanser är unika och oföränderliga. (ny i ECMAScript 6).
• Ett objekt är en samling namngivna värden, vanligtvis kallade egenskaper hos ett objekt.

Skillnad mellan primitiva och sammansatta typer

Innan vi tittar på varje datatyp, låt oss först bli bekanta med typen av operatör. Operatortypen typ returnerar en sträng som beskriver datatypen för en variabel.
Låt oss visa hur det fungerar med följande exempel:

Exempelskriptet deklarerar variabler, initierar dem (tilldelar värden) och skriver sedan ut typen av varje variabel.

Skillnaden mellan primitiva och sammansatta datatyper uppstår när deras värden kopieras.

När en variabel tilldelas ett värde av en enkel typ, skrivs själva värdet (till exempel ett tal) till variabeln. När vi tilldelar en variabel av en enkel typ till en annan, kopierar den värdet. Som ett resultat kommer varje variabel att ha sitt eget värde och ändringar i en av variablerna kommer inte att påverka värdet på den andra variabeln på något sätt:

När vi tilldelar ett värde av en sammansatt (referens) typ till en variabel, skrivs en referens till värdet (en referens till ett objekt) till variabeln. När vi tilldelar en variabel (vars värde innehåller en referens till ett sammansatt värde) till en annan variabel, kopieras referensen till det sammansatta värdet. Som ett resultat hänvisar båda variablerna till samma sammansatta värde, och förändringar i värdet på en variabel kommer att påverka den andra variabeln:

Primitiva typer

Alla datatyper i JavaScript, förutom objekt, är oföränderliga eller oföränderliga. Det betyder att deras värden inte kan ändras, utan bara skrivas över med ett nytt, annorlunda värde. Till exempel kan strängar inte justeras tecken för tecken - de kan bara skrivas om helt. Värden av sådana typer kallas "primitiv".

De enklaste data som ett program kan arbeta med kallas bokstavliga. Bokstaver är siffror eller strängar som används för att representera värden i JavaScript. Informationen som tillhandahålls kan vara mycket varierande, och därför varierar betydelserna olika typer. De enklaste datatyperna i JavaScript kallas grundläggande datatyper: siffror, strängar och booleaner. Alla klassas som "primitiva".

Boolean (logisk) typ "boolean"

Logiska, eller booleska värden (efter namnet på deras uppfinnare - booleska), kan bara ha ett av två värden: sant (sant) eller falskt (falskt). Värderingar sanna eller falskt visas vanligtvis i jämförelse eller logiska operationer.

Följande program skapar en boolesk variabel och testar sedan dess värde med hjälp av en if/else-sats:

Vilket uttryck som helst kan användas som ett jämförande uttryck. Alla uttryck som returnerar 0, null, odefinierat eller den tomma strängen tolkas som false . Ett uttryck som anger något annat värde tolkas som sant.

Obs! När du skriver booleska värden omges de inte av citattecken: var myVar = true;
Samtidigt skapas en strängvariabel genom att deklarera var myVar = "true".

Nummerdatatyp

I JavaScript finns det ingen skillnad mellan ett heltal och ett flyttal – i huvudsak representerar JavaScript alla tal som ett flyttal.

JavaScript använder ett 64-bitarsformat som definieras av IEEE-754-standarden för att representera siffror. Det här formatet kan representera tal i intervallet ±1,7976931348623157 × 10308 till ±5 × 10 -324.

Ett nummer som finns direkt i programkoden kallas en numerisk bokstav. Förutom decimala heltalsliteraler känner JavaScript igen hexadecimala värden.
Hexadecimala tal kan inkludera valfri sekvens av siffror från 0 till 9 och bokstäver från a till f, som måste börja med teckensekvensen "0x".

Vara = 255; var b = 0xFF; // Nummer 255 i hexadecimal notation

Dessutom innehåller JavaScript speciella numeriska värden:

• NaN (inte ett tal eller beräkningsfel). Är resultatet av en felaktig matematisk operation på ogiltiga data, som strängar eller ett odefinierat värde.
• Oändlighet (positiv oändlighet). Används när ett positivt tal är för stort för att representeras i JavaScript.
• -Infinity (negativ oändlighet). Används när ett negativt tal är för stort för att representeras i JavaScript.
• ±0 (positiv och negativ 0). JavaScript skiljer mellan positiv och negativ nolla.

Strängdatatyp

En strängtyp är en oföränderlig, ordnad sekvens av 16-bitars värden, som vart och ett representerar ett Unicode-tecken (bokstäver, siffror, skiljetecken, specialtecken och mellanslag). Rader kan vara tomma eller bestå av ett eller flera tecken. Strängar skapas med dubbla (") eller enkla (") citattecken. En sträng avgränsad av ett par enkla citattecken kan använda dubbla citattecken, och omvänt kan enstaka citattecken användas inom en sträng som omges av ett par dubbla citattecken:

I JavaScript är det ingen skillnad mellan dubbla och enkla citattecken, men citattecken i början och slutet av en sträng ska inte vara olika. Till exempel skulle ett uttryck som detta orsaka ett syntaxfel:

var firstName = "Max"; //syntaxfel - olika citattecken

Obs: JavaScript har ingen speciell datatyp med ett tecken som char i C, C++ och Java. Ett enskilt tecken representeras av en sträng med enhetslängd.

Null-datatyp Null-typen innehåller ett enda specialvärde – null.

Nyckelordet null kan inte användas som ett funktions- eller variabelnamn. Värdet null är en referens till ett "tomt" objekt och har ett speciellt syfte - det används vanligtvis för att initiera en variabel som senare kommer att tilldelas ett värde.

Typen av operator för ett nollvärde returnerar strängen "objekt", vilket indikerar att nollvärdet är ett speciellt "tomt" objekt.

Odefinierad datatyp

En odefinierad typ bildar sin egen typ, som innehåller ett enda specialvärde - odefinierat. Detta är värdet på en variabel som deklareras med var-operatorn, men som inte initierats:

Värdet undefined returneras vid åtkomst till en variabel som aldrig har tilldelats ett värde, en icke-existerande objektegenskap eller ett matriselement.

Det bör noteras att en variabel med värdet odefinierad skiljer sig från en variabel som inte är definierad alls:

I det här exemplet visar metoden alert() värdet på åldersvariabeln, som är odefinierad. I det andra fallet skickas en odeklarerad bilvariabel till alert()-metoden, vilket leder till ett fel.

Följande exempel kan vara något förvirrande för nybörjare, eftersom... Operatortypen returnerar odefinierad för både en oinitierad och en odeklarerad variabel:

I exemplet ovan deklareras variabeln ålder, men ingenting skrivs till den, så dess värde är bara odefinierat . Bilvariabeln deklareras inte - i själva verket existerar den inte. Typeof returnerar dock strängen odefinierad i båda fallen. Detta är förstås vettigt, eftersom det är omöjligt att utföra några operationer med någon av dessa variabler, även om de tekniskt sett är helt olika.

Obs: Det rekommenderas att alltid initialisera en deklarerad variabel. I det här fallet kommer du att veta att typen av operator returnerar odefinierad eftersom variabeln inte deklarerades, inte för att den inte initierades.

Värdet undefined härleds från null , så i ECMA-262 behandlar == ekvivalensoperatorn dem som lika:

Även om null och odefinierad är relaterade, används de på olika sätt. Du bör inte uttryckligen tilldela värdet undefined till en variabel, men detta gäller inte null. Om det önskade objektet inte är tillgängligt ska null användas istället. Detta indikerar att null introducerades som en pekare till ett tomt objekt och understryker dess skillnad från undefined .

För att skilja mellan null och odefinierat i ett program kan du använda identitetsoperatorn === :

Datatyp Symbol

En symbol är ett nytt tillägg till JavaScript sedan ECMAScript version 6. En symbol är ett unikt, oföränderligt, primitivt värde som används för att skapa unika identifierare.

För att skapa en symbol måste du anropa symbolfunktionen:

var mySymbol = Symbol();

För att definiera en symbol kan du använda typen av operator; om värdet är en symbol kommer strängsymbolen att returneras:

Symbolfunktionen har en valfri parameter - en sträng som tjänar till att beskriva symbolen:

Egenskapens namn är en sträng, så objekt kan anses associera strängar med värden. Tillsammans bildar dessa informationsdelar nyckel-värdepar.

I JavaScript-objekt kan skapas med en av två syntaxer:

1. var obj = (); // använder object literal 2. var obj = new Object(); // använder en metod som kallas constructor

Att skapa ett objekt med hjälp av en objektliteral börjar med att definiera en vanlig variabel. Den högra sidan av detta uttalande skriver ett objekt bokstavligt - det här är en kommaseparerad lista med par omslutna av krulliga klammerparenteser (). "namn-värde", innesluten i lockiga hängslen. Egenskapens namn och värde separeras med ett kolon:

var cat = ( "ben": 4, "namn": "Murzik", "färg": "Röd" )

Det andra sättet att skapa objekt är att använda konstruktorn Object(). I det här fallet används det nya Object()-uttrycket först, och sedan definieras och initieras egenskaperna för det resulterande objektet:

När vi tilldelar en variabel (vars värde innehåller en referens till ett sammansatt värde) till en annan variabel, kopieras referensen till det sammansatta värdet. Som ett resultat hänvisar båda variablerna till samma sammansatta värde, och förändringar i värdet på en variabel kommer att påverka den andra variabeln.

Alla uttryck som returnerar 0, null, odefinierat eller den tomma strängen tolkas som false .

Strängar skapas med dubbla (") eller enkla (") citattecken. En sträng som avgränsas av ett par enkla citattecken kan använda dubbla citattecken, och vice versa, enkla citattecken kan användas i en sträng som omges av ett par dubbla citattecken.

Värdet null är en referens till ett "tomt" objekt och har ett speciellt syfte - det används vanligtvis för att initiera en variabel som senare kommer att tilldelas ett värde.

Värdet (odefinierat) är en variabel som deklareras med var-operatorn, men inte initierad.

I JavaScript kan objekt skapas på ett av två sätt:

• använder ett objekt bokstavligt
• använder en metod som kallas konstruktor

Ett objekt innehåller en oordnad samling egenskaper, som var och en innehåller ett namn och ett värde. Du kan lägga till nya namngivna värden till ett objekt när som helst eller ta bort befintliga.