En variabel er en navngitt minneplassering der du både kan lagre noe informasjon og hente den fra den.

Deklarering (oppretting) av variabler gjøres ved å bruke nøkkelordet var.

// melding - variabelnavn var melding;

Når du oppretter en variabel, kan du umiddelbart tilordne en verdi til den.

Tilordning av en verdi til en variabel gjøres ved å bruke "="-operatoren.

// for eksempel, lag en variabel e-post og tilordne den strengen " [e-postbeskyttet]"var email = " [e-postbeskyttet]"; // sett e-postvariabelen til en ny verdi e-post = " [e-postbeskyttet]";

For å få verdien av en variabel, referer ganske enkelt til den ved navn.

// kan du for eksempel skrive ut verdien til e-postvariabelen til nettleserkonsollen: console.log(email);

For å deklarere mer enn én variabel ved å bruke et enkelt var-nøkkelord, må du bruke komma.

Var pris = 78,55, mengde = 10, melding;

JavaScript er et dynamisk eller svakt skrevet språk. Dette betyr at når en variabel er deklarert, trenger den ikke spesifisere datatypen den kan akseptere. Derfor kan du først plassere en verdi av én datatype i en variabel, og deretter en annen.

Var output = "suksess"; // variabelen har en streng datatype output = 28; // samme variabel, men allerede av "nummer" datatypen output = true; // samme variabel, men lagrer allerede en boolsk verdi

Verdien av en variabel kan endres et ubegrenset antall ganger.

// aldersvariabelen opprettes var alder; // variabel alder tildeles verdien 67 alder = 67; // variabel alder er satt til "Pensjonsalder" alder = "Pensjonsalder"; // variabel alder er satt til 55 alder = 55;

En god praksis ved utvikling av klientapplikasjoner er å bruke kun én datatype i en gitt variabel, dvs. Ikke skriv verdier av forskjellige datatyper til en variabel. For å forstå hvilken type data som bør forventes i en variabel, når du oppretter en variabel, anbefales det å initialisere den umiddelbart med en bestemt verdi.

Variabelnavnet kan være sammensatt av bokstaver, tall og symbolene $ og _. I dette tilfellet må det første tegnet i variabelen ikke være et tall. I tillegg kan du ikke bruke reserverte ord som variabelnavn.

// lage to variabler, den første variabelen heter telefon, den andre er meassage; var telefon, melding;

Størrelsen på bokstavene i variabelnavnet er viktig. Det vil si at for eksempel variabel telefon og telefon er to forskjellige variabler.

Hvis streng modus ikke brukes, kan du opprette en variabel med startverdien uten nøkkelordet var.

Pris = 250,00; // opprettet en variabel og initialiserte den med tallet 250,00 prosent = "20%"; // opprettet en variabel og initialiserte den med strengen "20%"

Men å lage variabler på denne måten anbefales ikke.

Datatyper

I JavaScript kan datatyper deles inn i primitiv og objekt.

Variabler som inneholder primitive datatyper lagrer verdien eksplisitt.

Det er 5 primitive datatyper i JavaScript:

• Antall;
• streng;
• boolsk type (boolsk);
• null;
• udefinert.

Hvis en variabel blir tildelt verdien til en annen som inneholder en primitiv datatype, vil den motta sin egen kopi av den verdien.

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

Variabler som inneholder et objekt lagrer faktisk ikke selve objektet, men en referanse til det.

Hvis en variabel tildeles verdien til en annen som inneholder et objekt (en lenke til det), vil den også motta en lenke til det. Som et resultat av denne operasjonen vil disse to variablene inneholde en referanse til det samme objektet.

// eksempel 1 (med datatypen "objekt") var coord1 = (x: 77, y: 100), coord2 = coord1; coord1.x = 55; // sett x-egenskapen til objektet til en ny verdi coord2.x; // 55, fordi coord1 og coord2 inneholder en referanse til det samme objektet // eksempel 2 (med en matrisedatatype) var coord1 = , coord2 = coord1; coord1 = 55; // sett elementet med indeks 0 til en ny verdi coord2; // 55, fordi coord1 og coord2 inneholder en referanse til det samme objektet // eksempel 3 (med datatypen "date") var date1 = new Date(2018,00,01), date2 = date1; dato2 = dato2.settDato(dato2.getDato()+7); // øke datoen med 7 dager dato1; // 01/07/2018, fordi dato1 og dato2 inneholder en referanse til samme objekt

Antall

Den numeriske datatypen i JavaScript er generisk. Det brukes til å representere både heltall og brøker.

Var int = 5; // heltall var float = 5,98; // et brøktall

Formatet for å representere tall i JavaScript er i samsvar med IEEE 754-2008-standarden.

Heltall i JavaScript kan spesifiseres ikke bare i desimalsystem tallsystem, men også i oktalt (0) eller heksadesimalt tallsystem (0x) ved bruk av prefikser angitt i parentes:

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

Det er mulig å skrive tall i eksponentiell form:

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

I tillegg til tall, inneholder den numeriske datatypen også spesielle numeriske verdier:

• Uendelig (positiv uendelighet);
• -Uendelig (negativ uendelighet);
• NaN (ikke et tall).

Spesialverdien Infinity betyr et veldig stort positivt tall, dvs. et tall som ikke kan representeres i JavaScript fordi det er for stort.

Spesielle betydninger -Uendelig betyr tvert imot et veldig stort negativt tall, dvs. et tall som ikke kan representeres av JavaScript fordi det også er for stort.

Et eksempel på uttrykk som vil returnere spesielle numeriske verdier som et resultat av deres beregning:

5/0; // Infinity -5/0; // -Infinity Math.pow(10 399); // Infinity (10 i potensen 399) Math.pow(10 399); // -Uendelig (-10 i potensen 399)

NaN-verdien returneres som et resultat av å utføre matematiske operasjoner som JavaScript ikke kan beregne.

5 - "Hei"; // NaN (trekk fra en linje fra tallet 5) 1000 / "20px"; // NaN (tall delt på streng) true * "1rem"; // NaN (boolsk verdi sann multiplisert med streng)

Det som er veldig interessant er at verdien av NaN i JavaScript ikke er lik noe som inkluderer seg selv.

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

Boolsk datatype

Boolsk er en primitiv datatype som bare har to verdier: sann og usann.

Var a = sant; var b = usann;

String

String er en datatype som brukes i JavaScript for å representere tekst.

En JavaScript-streng kan bestå av 0 eller mer tegn.

JavaScript bruker alltid Unicode som strengformat.

Å lage en streng (streng literal) gjøres ved å omslutte tekst i enkelt eller doble anførselstegn.

"JavaScript"; "ECMAScript";

I JavaScript er det ingen forskjell mellom enkle og doble anførselstegn.

Men i noen tilfeller er det fornuftig å bruke enkle anførselstegn i stedet for doble anførselstegn og omvendt.

For eksempel, når en streng inneholder doble anførselstegn, er det mer praktisk å sette den i enkle anførselstegn. Dette vil eliminere behovet for å unnslippe doble anførselstegn i den.

""ECMAScript""; // uten å unnslippe (med enkle anførselstegn) "\"ECMAScript\""; // med rømming

En streng i JavaScript kan inneholde spesialtegn. For eksempel, \n (linjeskift), \t (tab), \r (vognretur) osv.

"Dette er en setning.\nOg dette er også en setning, men den starter fra en ny linje.";

Med strenger kan du utføre operasjonen addisjon (union) eller, med andre ord, sammenkobling. Operatoren "+" brukes til dette. Meningen med denne operasjonen er å legge den andre linjen til slutten av den første.

"Jeg elsker " + "JavaScript"; // Jeg elsker JavaScript

Verdien er "udefinert"

undefined er en spesiell primitiv datatype som har en enkelt verdi lik undefined .

Denne datatypen har en deklarert variabel som ennå ikke har blitt tildelt en verdi.

Var num; //udefinert

Verdien undefined vil også bli returnert når du får tilgang til en ikke-eksisterende egenskap til et objekt.

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

"null" verdi

null er en spesiell primitiv datatype som har en enkelt verdi lik null .

null er bare en spesiell verdi som har betydningen "ingenting" eller "ukjent verdi", dvs. det betyr tydeligvis ingenting.

Gjenstand

Et objekt er en datastruktur som består av navn-verdi-par.

Å lage et objekt ved å bruke objekt-literal notasjon gjøres som følger:

( navn_1: verdi_1, navn_2: verdi_2, navn_3: verdi_3, ... )

Som du kan se, skilles navnet fra verdien ved hjelp av et kolon, og parene skilles fra hverandre med komma.

Videre, hvis verdien av paret er en funksjon, kalles det en metode for dette objektet. Alle andre par, dvs. par der en funksjon ikke brukes som verdi kalles objektegenskaper.

Et objekt er med andre ord en datastruktur som består av egenskaper og metoder.

Var person = ( navn: "Vitaly", alder: 27, getAlder: funksjon () ( returner "Alder: " + denne.alder; ) )

Tilgang til egenskapene til et objekt gjøres gjennom et punktum eller ved å bruke parentesnotasjon.

// vis verdien av age-egenskapen i nettleserkonsollen // 1. vei (via en prikk) console.log(person.age); // Metode 2 (ved hjelp av parenteser) console.log(person["alder"]); // kall getAge-metoden; verdien den returnerer vil bli sendt til konsollen console.log(person.getAge());

type operatør

Typeoperatoren brukes til å få informasjon om datatypen til et uttrykk som en streng.

Syntaksen til typen operator (alternativ uten parentes):

Type uttrykk

Type operatørsyntaks (ved hjelp av parenteser):

Type (uttrykk)

Var navn, alder = 37, e-post = " [e-postbeskyttet]", isLicense = true, interest: null, lastExperience: (periode: "juni 2011 - juni 2018", sted: "ISACA, Moskva", stilling: "Webdesigner" ), getExperience: function() ( return lastExperience.period + " ("+ lastExperience.position + " - " + lastExperience.place + ")"; ); type navn; // "udefinert" type alder; // "nummer" type er Lisens; // "boolsk" type interesse; / / "objekt" (1) type lastExperience; // "objekt" type getExperience; // "function" (2) /* (1) er en feil som har vært tilstede i språket siden den første implementeringen; den har ikke vært løst for å opprettholde kompatibilitet, og dette må tas i betraktning når du skriver skript; null er en primitiv datatype, det er ikke et objekt */ /* (2) - det er veldig praktisk at operatørtypen skiller funksjoner separat; men en funksjon i JavaScipt er også objekt; dette kan enkelt verifiseres ved å utføre følgende konstruksjon: */ typeof getExperience.__proto__.__proto__ // "objekt" (funksjonsprototypen er et objekt)

Konstanter

Med utgivelsen av ECMAScript 6 ble det mulig å lage konstanter. Dette gjøres ved å bruke søkeordet const.

Const COLOR_RED = "#ff0000";

En konstant er en variabel hvis verdi er beskyttet mot endring. De. Når du prøver å endre verdien, vises en feil.

Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Tilordning til konstant variabel.

Hvis for eksempel en konstant inneholder et objekt, kan det ikke endres, eller snarere en referanse til det. Men egenskapene til dette objektet kan endres.

Const COLORS = ( rød: "#ff0000", grønn: "#00ff00", blå: "#00ff00" ) FARGER = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Tilordning til konstant variabel. COLORS.green = "#4caf50";

Datatyper bidrar til å bygge en klassifisering av data i programmeringsspråk. For eksempel er et tall og en tegnstreng forskjellige typer data som JavaScript vil behandle forskjellig.

Dette er viktig fordi hver datatype kan ta på seg spesifikke verdier og utføre spesifikke handlinger. For å kunne utføre operasjoner på variabler i JavaScript, er det viktig å forstå datatypen til hver gitt variabel.

Denne opplæringen vil introdusere deg til JavaScript-datatyper.

Merk: Informasjonen i denne veiledningen er ikke uttømmende, men den vil gi deg en oversikt over de grunnleggende JavaScript-alternativene.

Dynamisk skriving

JavaScript er et dynamisk språk. Dette betyr at datatypekontroll utføres på kjøretid, ikke på kompileringstidspunkt.

I dynamiske språk kan variabler med samme navn brukes til å lagre forskjellige typer data.

For eksempel kan variabelen t, definert av nøkkelordet var, lagre forskjellige typer data; den kan også initialiseres, men la den være udefinert:

var t = 16; // t er et tall
var t = "Teresa"; // t er en streng
var t = sant; // t er en boolsk
var t; // t er udefinert

Alle t-variabler inneholder forskjellige JavaScript-datatyper. I JavaScript trenger du ikke eksplisitt spesifisere datatypen til en variabel før du bruker den.

Tall

JavaScript har en enkelt numerisk datatype, som ikke skiller mellom heltall og flyttall. Derfor kan tall i JavaScript skrives med eller uten desimaler:

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

I eksemplet ovenfor inneholder begge variablene tall, enten det er komma i den eller ikke.

Vitenskapelig notasjon i JavaScript lar deg forkorte svært store eller små tall:

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

I JavaScript anses tall som nøyaktige til 15 sifre. Dette betyr at etter å ha nådd det 16. sifferet vil tallene bli avrundet:

var num5 = 9999999999999999; // forblir som 9999999999999999
var num6 = 99999999999999999; // avrundet opp til 10000000000000000

Tall i JavaScript har også tre symbolske betydninger:

Evighet - numerisk verdi, som er et positivt tall som nærmer seg uendelig.

Uendelig er en numerisk verdi som representerer et negativt tall som nærmer seg uendelig.

NaN – Not-a-Number, en spesiell tilstand av et flyttall.

Infinity og -Infinity returneres når man teller et tall utover det maksimalt mulige antallet tilgjengelig i JavaScript. De vises også når du teller udefinerte verdier, for eksempel å dele på null:

var num7 = 5 / 0; //Evighet
var num8 = -5 / 0; // -Evighet

Teknisk sett returneres Infinity hvis tallet er større enn 1,797693134862315E+308, som er den øvre grensen i JavaScript.

På samme måte vil -Infinity vises når tallet går utover den nedre grensen, -1.797693134862316E+308.

Infinity-nummeret kan også brukes i løkker:

while (tall9 != Infinity) (
// Koden her vil utføres gjennom num9 = Infinity
}

For udefinerte tall skrives NaN ut. Hvis du prøver å utføre en matematisk operasjon på et tall og en ikke-numerisk verdi, får du NaN. For eksempel:

var x = 20 / "Shark"; // x vil være NaN

Siden 20 ikke kan deles med Shark-strengen, vil verdien av x være NaN.

Men hvis strengen kan evalueres som en numerisk verdi, vil JavaScript evaluere det matematiske uttrykket:

var y = 20 / "5"; // du blir 4

Siden JavaScript kan behandle 5 som en numerisk verdi, vil 5 fungere med den matematiske divisjonsoperatoren.

Hvis én variabel i et uttrykk er satt til NaN, vil resultatet være NaN, selv om den andre operanden er et tall.

var a = NaN;
var b = 37;
var c = a + b; // c vil være NaN

Så i JavaScript er det bare én numerisk datatype. I JavaScript er det ikke nødvendig å skille tall i heltall og flytende tall fordi JavaScript er et dynamisk språk.

Strenger

En streng er en sekvens av ett eller flere tegn (bokstaver, tall og andre symboler). Strenger representerer tekstdata.

I JavaScript kommer strenger i både enkle og doble anførselstegn. For å lage en streng, må du omslutte en sekvens av tegn i anførselstegn:

var singleQuotes = "Dette er en streng i enkle anførselstegn.";
var doubleQuotes = "Dette er en streng i doble anførselstegn.";

Du kan bruke enkle eller doble anførselstegn, men du må bruke én type anførselstegn konsekvent innenfor samme kode.

Program "Hei, verden!" demonstrerer hvordan strenger brukes i dataprogrammering. I hovedsak i i dette eksemplet en streng er en sekvens av tegn som utgjør uttrykket "Hello, World!" i varsling ().

funksjon helloFunction() (
alert("Hei, verden!");
}

Klikk på meg

Ved å kjøre koden og klikke på Klikk meg-knappen, vil du se et popup-vindu med teksten:

Som andre datatyper kan strenger lagres i variabler.

var hw = "Hei, verden!";

Du kan deretter vise strengen ved å kalle variabelen:

...

var hw = "Hei, verden!";
funksjon helloFunction() (
varsling(hw);
}

...
Hei Verden!

Strenger lar informasjon sendes til brukeren og tilbake til programmet.

Boolsk datatype

En boolsk (eller boolsk) datatype består av to verdier – sann og usann.

Denne typen brukes til å representere sannhetsverdier assosiert med logikk og algoritmer i informatikk.

Merk: Denne datatypen er oppkalt etter matematikeren George Boole.

Mange operasjoner i matematikk gir resultater som kan vurderes som sanne eller usanne:

Mer enn:

• 500 > 100 sanne
• 1 > 5 falsk

Mindre enn:

• 200 < 400 true
• 4 < 2 false

• 5 = 5 sant
• 500 = 400 falsk

Som andre typer kan den boolske datatypen lagres i variabler.

var myBool = 5 > 8; // falsk

Siden 5 ikke er større enn 8, vil myBool være falsk.

Når du koder i JavaScript, vil du bli kjent med hvordan boolske data fungerer og hvordan ulike sannhetsevaluerende funksjoner og operasjoner kan endre flyten til et program.

Matriser

En matrise kan inneholde flere verdier innenfor en enkelt variabel. Dette betyr at du kan lagre en liste over verdier inne i en matrise og iterere gjennom dem.

Hver verdi i matrisen kalles et element. Du kan få tilgang til elementene i en matrise ved hjelp av en indeks.

Matriser er definert av firkantede parenteser.

Strengearrayen ser slik ut:

var fish = ["hai", "blekksprut", "klovnefisk", "ål"];

Ved å kalle fiskvariabelen får du resultatet:

["hai", "blekksprut", "klovnefisk", "ål"]

Matriser er en veldig fleksibel datatype fordi de kan endres: du kan legge til, fjerne og endre verdiene til elementer.

Objekter

Et objekt i JavaScript består av nøkkel:verdi-par.

Objektsyntaks består av nøkkel:verdi-par. Et objekt er atskilt med krøllete klammeparenteser på begge sider (()).

Par i objektet er atskilt med mellomrom:

var sammy = (fornavn:"Wally", etternavn:"Shark", farge:"blå", plassering:"hav");

Et objekt kan også skrives på flere linjer (dette gjelder spesielt for store objekter).

var wally = (
fornavn: "Wally",
etternavn: "Shark",
farge: "blå",
sted: "Ocean"
};

Arbeide med flere datatyper

Hvert program du oppretter vil sannsynligvis inneholde flere datatyper, men operasjoner utføres vanligvis på en enkelt datatype. matematikk brukes på tall, og slicing brukes på strenger.

Ved å bruke operatorer som fungerer med alle typer data (for eksempel kan +-operatoren legge til tall eller utføre strengsammenkobling), kan du få uventede resultater.

Hvis du oppretter en variabel for sammenkobling, vil JavaScript tolke hvert element som en streng.

var o = "Ocean" + 5 + 3;

Ved å kalle variabel o får du følgende resultat:

Imidlertid, hvis strengen inneholder tall først og deretter en streng, vil +-operatoren utføre addisjon og deretter sammenkobling:

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

Fordi resultatene er uforutsigbare, er det mer praktisk å utføre operasjoner og metoder i en enkelt datatype. JavaScript returnerer imidlertid ikke feil ved blanding av datatyper, slik noen andre programmeringsspråk gjør.

Konklusjon

Du er nå kjent med JavaScript-datatyper. Hver av typene som er oppført her er viktige når du skriver JavaScript-programmer.

Tags: En variabel er en identifikator som har blitt tildelt en verdi. En variabel kan nås i et program, og fungerer dermed med verdien som er tildelt den.

En JavaScript-variabel i seg selv inneholder ikke informasjon om hvilken type verdier som vil bli lagret i den. Dette betyr at ved å skrive for eksempel en streng til en variabel, kan du senere skrive et tall til den. En slik operasjon vil ikke forårsake en feil i programmet. Dette er grunnen til at JavaScript noen ganger kalles et "untyped" språk.

Før en variabel kan brukes, må den deklareres med nøkkelordet var or let. Hvis vi snakker om en konstant, brukes nøkkelordet const. Du kan deklarere en variabel og tilordne den en verdi uten å bruke disse nøkkelordene, men det anbefales ikke å gjøre det.

▍Nøkkelord var Før ES2015-standarden var bruken av søkeordet var den eneste måten variable erklæringer.

Var a = 0
Hvis du utelater var i denne konstruksjonen, vil verdien bli tildelt en ikke-deklarert variabel. Resultatet av denne operasjonen avhenger av modusen programmet kjøres i.

Så hvis den såkalte strenge modusen er aktivert, vil dette forårsake en feil. Hvis streng modus ikke er aktivert, vil variabelen bli implisitt deklarert og tilordnet det globale objektet. Spesielt betyr dette at en variabel deklarert implisitt i en funksjon på denne måten vil forbli tilgjengelig etter at funksjonen er fullført. Vanligvis forventes det at variabler deklarert i funksjoner ikke "går utover" deres omfang. Det ser slik ut:

Funksjon notVar() ( bNotVar = 1 //bedre å ikke gjøre dette) notVar() console.log(bNotVar)
1 vil vises i konsollen, ingen forventer vanligvis slik oppførsel fra et program, uttrykket bNotVar = 1 ser ikke ut som et forsøk på å deklarere og initialisere en variabel, men som et forsøk på å få tilgang til en variabel som ligger i et omfang utenfor funksjon (dette er ganske normalt). Som et resultat er implisitte variabeldeklarasjoner forvirrende for de som leser koden og kan føre til uventet programoppførsel. Senere skal vi snakke om både funksjoner og omfang, men prøv foreløpig å alltid bruke spesialiserte nøkkelord når meningen med et uttrykk er å deklarere en variabel. Hvis funksjonsteksten i dette eksemplet skrives om til var bNotVar = 1, vil forsøk på å kjøre kodefragmentet ovenfor resultere i en feilmelding (du kan se den i nettleserkonsollen).

For eksempel kan det se slik ut: Uncatught ReferenceError: bNotVar er ikke definert . Betydningen koker ned til det faktum at programmet ikke kan fungere med en ikke-eksisterende variabel. Det er mye bedre å se en slik feilmelding når du først starter et program enn å skrive uforståelig kode som kan oppføre seg uventet.

Hvis, når en variabel deklareres, den ikke initialiseres eller tildeles noen verdi, vil den automatisk bli tildelt verdien udefinert.

Var a //typeof a === "udefinert"
Variabler deklarert med var-nøkkelordet kan deklareres igjen mange ganger, og tildele dem nye verdier (men dette kan være forvirrende for personen som leser koden).

Var a = 1 var a = 2
Du kan deklarere flere variabler i ett uttrykk:

Var a = 1, b = 2
Omfanget av en variabel er området i programmet der denne variabelen er tilgjengelig (synlig).

En variabel initialisert med nøkkelordet var utenfor en funksjon tilordnes et globalt objekt. Den har globalt omfang og er tilgjengelig fra hvor som helst i programmet. Hvis en variabel er deklarert ved å bruke nøkkelordet var inne i en funksjon, er den kun synlig innenfor denne funksjonen, og er en lokal variabel for den.

Hvis en funksjon som bruker var erklærer en variabel hvis navn er det samme som en variabel i det globale omfanget, vil den "overstyre" den globale variabelen. Det vil si at når du får tilgang til en slik variabel inne i en funksjon, vil dens lokale versjon bli brukt.

Det er viktig å forstå at blokker (kodeområder omsluttet av krøllete klammeparenteser) ikke skaper nye omfang. Nytt område synlighet opprettes når funksjonen kalles. Nøkkelordet var har det som kalles funksjonelt omfang i stedet for blokkomfang.

Hvis en variabel er deklarert i funksjonskoden, er den synlig for hele funksjonskoden. Selv om en variabel er deklarert ved å bruke var på slutten av funksjonskoden, kan den nås i begynnelsen av koden, siden JavaScript har en variabel heisemekanisme. Denne mekanismen "løfter" variabeldeklarasjoner, men ikke initialiseringsoperasjonene deres. Dette kan være en kilde til forvirring, så gjør det til en vane å deklarere variabler i begynnelsen av funksjonen din.

▍Let nøkkelordet let nøkkelordet ble introdusert i ES2015 og kan på en forenklet måte kalles "blokk"-versjonen av var . Variabler som er deklarert med let-nøkkelordet, er scoped til blokken, setningen eller uttrykket det er deklarert i, og til nestede blokker.

Hvis selve ordet "la" ikke virker veldig tydelig, kan du tenke deg å bruke ordet "la" i stedet. Deretter kan uttrykket la farge = "rød" oversettes til engelsk som følger: "la fargen være rød", og til russisk som følger: "la fargen være rød".

Ved å bruke let-nøkkelordet kan du unngå tvetydighetene som følger med var-nøkkelordet (du vil for eksempel ikke kunne erklære den samme variabelen to ganger ved å bruke let ). Å bruke la utenfor en funksjon, for eksempel når du initialiserer løkker, skaper ikke globale variabler.

For eksempel vil denne koden generere en feil:

For (la i = 0; i< 5; i++) { console.log(i) } console.log(i)
Hvis, når sløyfen er initialisert, telleren i er deklarert ved å bruke nøkkelordet var, vil i være tilgjengelig utenfor løkken etter at den har fullført arbeidet.

I disse dager, når man utvikler JS-programmer basert på moderne standarder, er det fullt mulig å forlate var og kun bruke søkeordene let og const.

▍Const-nøkkelordet Verdiene til variabler som er deklarert ved hjelp av var or let-nøkkelord kan overskrives. Hvis const brukes i stedet for disse nøkkelordene, kan ikke en konstant deklarert og initialisert med dens hjelp tildeles en ny verdi.

Const a = "test"
I dette eksemplet kan konstanten a ikke tildeles en ny verdi. Men det bør bemerkes at hvis a ikke er en primitiv verdi som et tall, men et objekt, beskytter ikke dette objektet mot endringer ved bruk av nøkkelordet const.

Når de sier at et objekt er lagret i en variabel, mener de egentlig at variabelen lagrer en referanse til objektet. Denne lenken kan ikke endres, men selve objektet som lenken fører til kan endres.

Nøkkelordet const gjør ikke objekter uforanderlige. Den beskytter ganske enkelt referanser til dem skrevet i de tilsvarende konstantene mot endringer. Slik ser det ut:

Const obj = () console.log(obj.a) obj.a = 1 //works console.log(obj.a) //obj = 5 //forårsaker en feil
Under initialisering skrives et nytt tomt objekt til obj-konstanten. Et forsøk på å få tilgang til egenskapen a, som ikke eksisterer, forårsaker ikke en feil. Konsollen blir udefinert. Etter det legger vi til en ny egenskap til objektet og prøver å få tilgang til den igjen. Denne gangen er verdien av denne egenskapen 1 i konsollen. Hvis du fjerner den siste linjen i eksemplet, vil forsøk på å kjøre denne koden resultere i en feil.

Nøkkelordet const er veldig likt let , spesielt har det blokkomfang.

Under moderne forhold er det helt akseptabelt å bruke nøkkelordet const for å erklære alle enheter hvis verdier ikke er planlagt å endres, og ty til å la bare i spesielle tilfeller. Hvorfor? Hele poenget er at det er best å strebe etter å bruke enklest mulige konstruksjoner som er tilgjengelige for ikke å komplisere programmet og unngå feil.

JavaScript-datatyper kalles noen ganger et "untyped" språk, men dette er ikke tilfelle. Det er sant at du kan skrive verdier av forskjellige typer inn i variabler, men det er fortsatt datatyper i JavaScript. Spesielt snakker vi om primitive og objektdatatyper.

For å bestemme datatypen til en verdi, kan du bruke typen operator. Den returnerer en streng som indikerer typen av operanden.

▍Primitive datatyper Her er en liste over primitive JavaScript-datatyper:

• Antall
• streng
• boolsk (boolsk verdi)
• null (spesiell verdi null)
• udefinert (spesiell verdi udefinert)
• symbol (symbol, brukt i spesielle tilfeller, introdusert i ES6)

Her er navnene på datatypene gitt ettersom de returneres av typen operatør.

La oss snakke om de mest brukte datatypene fra denne listen.

Nummertype Verdiene for typenummer i JavaScript er representert som 64-bits flyttall med dobbel presisjon.

I koden er numeriske bokstaver representert som heltall og brøker i desimaltallsystemet. Du kan bruke andre metoder for å skrive tall. For eksempel, hvis det er et prefiks 0x i begynnelsen av en numerisk bokstav, oppfattes det som et tall skrevet i heksadesimal notasjon. Tall kan også skrives med eksponentiell notasjon (bokstaven e finnes i slike tall).

Her er eksempler på å skrive heltall:

10 5354576767321 0xCC // heksadesimalt tall
Her er brøkene.

3.14 .1234 5.2e4 //5.2 * 10^4
Numeriske bokstaver (denne oppførselen er også typisk for noen andre primitive typer), når du prøver å få tilgang til dem som objekter, blir automatisk, under operasjonens varighet, konvertert til de tilsvarende objektene, som kalles "objektomslag". I dette tilfellet snakker vi om nummerobjektomslaget.

Her er for eksempel hvordan et forsøk på å få tilgang til variabelen a, som inneholder en numerisk bokstav, ser ut som et objekt i Google Chrome-konsollen.

Hint for nummerobjektomslag

Hvis du for eksempel bruker toString()-metoden til et objekt av typen Number, vil den returnere en strengrepresentasjon av tallet. Den tilsvarende kommandoen ser slik ut, som kan utføres i nettleserkonsollen (og i vanlig kode) slik:

A.toString()
Legg merke til de doble parentesene etter metodenavnet. Hvis du ikke leverer dem, vil ikke systemet generere en feil, men i stedet for forventet utgang, vil du se noe i konsollen som ikke i det hele tatt ligner på strengrepresentasjonen av tallet 5.

Det globale Number-objektet kan brukes som en konstruktør, og skaper nye tall ved hjelp av det (det brukes imidlertid nesten aldri i denne formen), det kan også brukes som en uavhengig enhet, uten å opprette forekomster (det vil si visse tall). representert med dens hjelp). For eksempel inneholder dens Number.MAX_VALUE-egenskap den maksimale numeriske verdien som kan representeres i JavaScript.

Typestreng Verdier for typestreng er sekvenser av tegn. Slike verdier er spesifisert som streng bokstaver omsluttet av enkle eller doble anførselstegn.

"En streng" "En annen streng"
Strengverdier kan deles opp i flere deler ved å bruke omvendt skråstrek.

"En streng"
Linjen kan inneholde såkalte escape-sekvenser, som tolkes når linjen sendes ut til konsollen. For eksempel betyr sekvensen \n et linjeskifttegn. Omvendt skråstrek kan også brukes til å legge til anførselstegn til strenger som er omsluttet av de samme anførselstegnene. Å unnslippe sitattegnet med \ fører til at systemet ikke behandler det som et spesialtegn.

"Jeg er en utvikler"
Strenger kan settes sammen ved å bruke +-operatoren.

"A" + "streng"

Template literals I ES2015 dukket det opp såkalte template literals, eller malstrenger. De er strenger omsluttet av anførselstegn (`) og har noen interessante egenskaper.

`en streng`
Du kan for eksempel erstatte visse verdier som er et resultat av å evaluere JavaScript-uttrykk til bokstaver i maler.

`en streng med $(noe)` `en streng med $(something+somethingElse)` `en streng med $(obj.something())`
Å bruke bakanførselstegn gjør det lettere å skrive strenge bokstaver på flere linjer:

`en streng med $(noe)`

Den boolske typen JavaScript har et par reserverte ord som brukes når du arbeider med boolske verdier: sant og usant. Sammenligningsoperatorer, for eksempel == , === ,< , >, returner sant eller usant .

Boolske uttrykk brukes i utsagn som if og while for å kontrollere flyten til et program.

Det skal bemerkes at der verdien sann eller usann er forventet, kan du bruke andre verdier som automatisk blir evaluert av språket som sann (sannhet) eller usann (falsk).

Nærmere bestemt er følgende falske verdier:

0 -0 NaN undefined null "" //tom streng
De resterende verdiene er sanne.

Null Type JavaScript har en spesiell verdi, null , som indikerer fravær av en verdi. Lignende verdier brukes på andre språk Type undefined Verdien undefined skrevet til en bestemt variabel indikerer at denne variabelen ikke er initialisert og det er ingen verdi for den.

Denne verdien returneres automatisk fra funksjoner hvis resultater ikke eksplisitt returneres ved hjelp av nøkkelordet return. Hvis en funksjon tar en parameter som ikke er spesifisert når den kalles, settes den også til undefined .

For å sjekke en verdi for undefined , kan du bruke følgende konstruksjon.

Typevariabel === "udefinert"

▍Objekter Alle ikke-primitive verdier er av objekttype. Vi snakker om funksjoner, arrays, det vi kaller "objekter", og mange andre enheter. Alle disse datatypene er basert på objekttypen, og selv om de skiller seg fra hverandre på mange måter, har de også mye til felles Uttrykk Uttrykk er kodebiter som kan bearbeides og få en viss verdi basert på de beregningene som er utført. . Det finnes flere kategorier av uttrykk i JavaScript Aritmetiske uttrykk Denne kategorien inkluderer uttrykk som evalueres til tall.

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

Strenguttrykk Resultatet av å evaluere slike uttrykk er strenger.

"En " + "streng" "A " += "streng"

Primære uttrykk Bokstaver, konstanter og referanser til identifikatorer faller inn under denne kategorien.

2 0.02 "noe" sant usant denne //utførelseskonteksten, referanse til gjeldende objekt udefinert i //hvor i er en variabel eller konstant
Dette inkluderer også noen JavaScript-nøkkelord og konstruksjoner.

Funksjonsklassefunksjon* //yield generator //kommando for å pause/gjenoppta generatoren yield* //delegering til en annen iterator eller generator asynkronfunksjon* //asynkront funksjonelt uttrykk avventer //organisering av å vente på utførelse av en asynkron funksjon /pattern /Jeg // vanlig uttrykk() //gruppering

Initialiseringsuttrykk for matriser og objekter //array literal () //objekt literal (a: 1, b: 2) (a: (b: 1)) Logiske uttrykk Bruk av logiske uttrykk logiske operatorer, resultatet av deres beregning er logiske verdier.

A && b a || b!a

Eiendomstilgangsuttrykk Disse uttrykkene lar deg få tilgang til egenskaper og metoder for objekter.

Object.property //kaller en egenskap (eller metode) til et objektobjekt objekt["property"]

Uttrykk for opprettelse av objekter nytt objekt() nytt a(1) nytt MyRectangle("navn", 2, (a: 4)) Funksjonserklæringsuttrykk funksjon() () funksjon(a, b) ( return a * b ) (a, b) => a * b a => a * 2 () => ( return 2 ) Anropsuttrykk Slike uttrykk brukes til å kalle funksjoner eller metoder for objekter.

A.x(2) window.resize()

Arbeide med objekter Vi har allerede støtt på objekter ovenfor, som snakker om objekter, kaller metodene deres og får tilgang til egenskapene deres. Her skal vi snakke om objekter mer detaljert, spesielt vil vi se på mekanismen for prototypisk arv og bruken av klassenøkkelordet.▍Prototypisk arv JavaScript skiller seg ut blant moderne programmeringsspråk ved at det støtter prototypisk arv . De fleste objektorienterte språk bruker en klassebasert arvemodell.

Hvert JavaScript-objekt har en spesiell egenskap (__proto__) som peker til et annet objekt som er prototypen. Et objekt arver egenskapene og metodene til prototypen.

La oss si at vi har et objekt skapt ved hjelp av et objekt bokstavelig.

Const bil = ()
Eller vi opprettet et objekt ved hjelp av objektkonstruktøren.

Const bil = nytt objekt()
I alle disse tilfellene vil prototypen til bilobjektet være Object.prototype .

Hvis du oppretter en matrise som også er et objekt, vil prototypen være Array.prototype-objektet.

Const list = //eller så const list = new Array()
Du kan sjekke dette på følgende måte.

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
Her brukte vi egenskapen __proto__; den trenger ikke være tilgjengelig for utvikleren, men den kan vanligvis nås. Det skal bemerkes at mer på en pålitelig måte for å få prototypen til et objekt er å bruke getPrototypeOf()-metoden global Gjenstand.

Object.getPrototypeOf(new Object())
Alle egenskaper og metoder for en prototype er tilgjengelig for objektet som har den prototypen. Her er for eksempel hvordan listen deres ser ut for en matrise.

Array hint

Basisprototypen for alle objekter er Object.prototype.

Array.prototype.__proto__ == Objekt.prototype
Object.prototype har ikke en prototype.

Det vi så ovenfor er et eksempel på en prototypekjede.

Når du prøver å få tilgang til en egenskap eller metode for et objekt, hvis selve objektet ikke har en slik egenskap eller metode, utføres søket i prototypen, deretter i prototypens prototype, og så videre til den ønskede egenskapen er funnet, eller til kjeden av prototyper ikke vil ta slutt.

I tillegg til å lage objekter ved å bruke den nye operatoren og bruke objekt- eller matriseliterals, kan du opprette en forekomst av et objekt ved å bruke Object.create()-metoden. Det første argumentet som sendes til denne metoden er et objekt som vil være prototypen til objektet det oppretter.

Const car = Object.create(Object.prototype)
Du kan sjekke om et objekt er en del av prototypekjeden til et annet objekt ved å bruke isPrototypeOf()-metoden.

Const list = Array.prototype.isPrototypeOf(list)

Konstruktørfunksjoner Ovenfor har vi laget nye objekter ved å bruke konstruktørfunksjonene som allerede er tilgjengelige på språket (nøkkelordet new brukes når de kalles). Du kan lage slike funksjoner selv. La oss se på et eksempel.

Funksjon Person(navn) ( dette.navn = navn ) Person.prototype.hello = funksjon() ( console.log(dette.navn) ) la person = ny Person("Flavio") person.hello() console.log( Person.prototype.isPrototypeOf(person))
Her lager vi en konstruktørfunksjon. Når den kalles opp, blir den opprettet nytt objekt, som angis med tasten ordet dette i kroppen til konstruktøren. Vi legger til en navneegenskap til dette objektet og skriver til det hva som ble sendt til konstruktøren. Dette objektet returneres automatisk fra konstruktøren. Ved å bruke konstruktørfunksjonen kan du lage mange objekter hvis navneegenskaper vil inneholde det som ble sendt til konstruktøren da de ble opprettet.

Etter å ha opprettet konstruktøren, legger vi til en funksjon til prototypen som vil skrive ut verdien av navneegenskapen til objektet som er opprettet med denne funksjonen til konsollen. Alle objekter opprettet ved hjelp av denne konstruktøren vil ha samme prototype, og bruker derfor den samme hello()-funksjonen. Dette kan enkelt sjekkes ved å lage et annet objekt av typen Person og sammenligne dets hello()-funksjon med funksjonen til objektet som allerede eksisterer i eksemplet (i dette tilfellet skrives funksjonsnavnet uten parentes).

▍Klasser I ES6-standarden introduserte JavaScript konseptet med en "klasse".

Tidligere kunne JavaScript bare bruke den prototypiske arvemekanismen beskrevet ovenfor. Denne mekanismen så uvanlig ut for programmerere som kom til JS fra andre språk. Derfor dukket det opp klasser i språket, som i hovedsak er "syntaktisk sukker" for prototypens arvemekanisme. Det vil si gjenstander skapt tradisjonell måte, og objekter opprettet ved hjelp av klasser har prototyper.

Klasseerklæring Slik ser en klasseerklæring ut.

Klasseperson ( constructor(name) ( this.name = name ) hello() ( return "Hei, jeg er " + this.name + "." ) )
En klasse har en identifikator som kan brukes til å lage nye objekter ved å bruke den nye ClassIdentifier()-konstruksjonen.

Når et nytt objekt er opprettet, kalles konstruktørmetoden og parametere sendes til det.

Du kan deklarere metoder i en klasse. I vårt tilfelle er hello() en metode som kan kalles opp av alle objekter som er opprettet basert på klassen. Slik ser det ut å lage et nytt objekt ved hjelp av Person-klassen.

Const flavio = ny person("Flavio") flavio.hello()

Klassebaserte arveklasser kan utvide andre klasser. Objekter opprettet fra slike klasser vil arve både metodene til den opprinnelige klassen og metodene spesifisert i den utvidede klassen.

Hvis en klasse som utvider en annen klasse (en underklasse av den klassen) har en metode hvis navn er det samme som navnet til den overordnede klassen, har denne metoden forrang over den opprinnelige.

Klasseprogrammerer utvider Person ( hello() ( return super.hello() + "Jeg er en programmerer." ) ) const flavio = new Programmer("Flavio") flavio.hello()
Å kalle hello()-metoden i eksemplet ovenfor vil returnere strengen Hallo, jeg er Flavio. Jeg er en programmerer.

Klasser sørger ikke for tilstedeværelsen av variabler (egenskaper); egenskapene til objekter opprettet ved bruk av klasser må konfigureres i konstruktøren.

Innenfor en klasse kan du få tilgang til overordnet klasse ved å bruke supernøkkelordet.

Statiske metoder Metoder beskrevet i en klasse kan kalles ved å få tilgang til objekter opprettet fra klassen, men ikke ved å få tilgang til selve klassen. Statiske metoder kan kalles ved å gå direkte til klassen Private metoder JavaScript har ikke en innebygd mekanisme som lar deg deklarere private metoder. Denne begrensningen kan overvinnes for eksempel ved å bruke closures Gettere og settere Du kan definere metoder i en klasse ved å sette dem foran med søkeordene get eller set. Dette lar deg lage såkalte getters og settere - funksjoner som brukes til å kontrollere tilgangen til egenskapene til objekter som er opprettet basert på klassen. Getteren kalles når du prøver å lese verdien til en pseudo-egenskap, og setteren kalles når du prøver å skrive en ny verdi til den.

Klasse Person ( constructor(name) ( this.userName = name ) set name (value) ( ​​this.userName = value ) get name() ( return this.userName ) )

Oppsummering I dette materialet har vi snakket om variabler, datatyper, uttrykk og arbeid med objekter i JavaScript. Temaet for vårt neste materiale vil være funksjoner.

Kjære lesere! Hvis du har skrevet i JS lenge, vennligst fortell oss hva du synes om utseendet til klassens nøkkelord på språket.

I denne opplæringen vil vi introdusere et veldig viktig konsept - JavaScript-datatyper. Vi anbefaler at du følger nøye med på dette konseptet - hvis du ikke forstår det helt fra begynnelsen, vil du ofte måtte forholde deg til merkelig oppførsel til programmet du opprettet.

Dynamisk skriving

I prosess dataprogrammer manipulere forskjellige verdier, som hver kan behandles i et programmeringsspråk og tilhører en bestemt datatype.

I JavaScript kan datatyper deles inn i to kategorier: enkle (også kalt primitive) typer og sammensatte (også kalt referanse eller objekt).

JavaScript er et svakt skrevet eller dynamisk programmeringsspråk som lar datatyper defineres, analyseres og kompileres på farten under programkjøring. Dette betyr at du ikke trenger å definere type variabel på forhånd. Typen vil bli bestemt automatisk under programkjøring.
Således, i forskjellige deler av programmet, kan den samme variabelen ta på seg verdier av forskjellige typer:

Datatyper

ECMAScript®-standarden definerer følgende datatyper:

• Enkle (også kalt primitive) typer:
  • Boolean - kan ta to mulige verdier, noen ganger kalt sant og usant;
  • null – verdien null representerer en referanse som peker, vanligvis med vilje, til et ikke-eksisterende eller feil objekt eller adresse;
  • undefined – angir en forhåndsdefinert global variabel initialisert med en udefinert verdi;
  • numerisk (engelsk tall) – numerisk datatype i formatet til et 64-bits flyttall med dobbel presisjon;
  • streng (engelsk streng) – er en sekvens av tegn som brukes til å representere tekst;
  • symbol (eng. Symbol) er en datatype, hvis forekomster er unike og uforanderlige. (ny i ECMAScript 6).
• Et objekt er en samling navngitte verdier, vanligvis kalt egenskaper til et objekt.

Forskjellen mellom primitive og sammensatte typer

Før vi ser på hver datatype, la oss først bli kjent med typen operatør. Typeoperatoren returnerer en streng som beskriver datatypen til en variabel.
La oss demonstrere hvordan det fungerer ved å bruke følgende eksempel:

Eksempelskriptet erklærer variabler, initialiserer dem (tildeler verdier), og skriver deretter ut typen til hver variabel.

Forskjellen mellom primitive og sammensatte datatyper oppstår når verdiene deres kopieres.

Når en variabel tildeles en verdi av en enkel type, skrives selve verdien (for eksempel et tall) til variabelen. Når vi tilordner en variabel av en enkel type til en annen, kopierer den verdien. Som et resultat vil hver variabel ha sin egen verdi og endringer i en av variablene vil ikke påvirke verdien til den andre variabelen på noen måte:

Når vi tilordner en verdi av en sammensatt (referanse) type til en variabel, skrives en referanse til verdien (en referanse til et objekt) til variabelen. Når vi tilordner en variabel (hvis verdi inneholder en referanse til en sammensatt verdi) til en annen variabel, kopieres referansen til den sammensatte verdien. Som et resultat refererer begge variablene til den samme sammensatte verdien, og endringer i verdien til en variabel vil påvirke den andre variabelen:

Primitive typer

Alle datatyper i JavaScript, unntatt objekter, er uforanderlige eller uforanderlige. Dette betyr at verdiene deres ikke kan endres, men bare overskrives med en ny, annen verdi. For eksempel kan strenger ikke justeres tegn for tegn - de kan bare skrives helt om. Verdier av slike typer kalles "primitive".

De enkleste dataene som et program kan operere med kalles bokstaver. Bokstaver er tall eller strenger som brukes til å representere verdier i JavaScript. Informasjonen som gis kan være svært mangfoldig, og derfor varierer betydningen forskjellige typer. De enkleste datatypene i JavaScript kalles grunnleggende datatyper: tall, strenger og booleaner. Alle er klassifisert som "primitive".

Boolsk (logisk) type "boolean"

Logiske, eller boolske verdier (etter navnet på oppfinneren deres - boolske), kan bare ha én av to verdier: sann (sann) eller usann (falsk). Verdier er sanne eller falsk vises vanligvis i sammenligning eller logiske operasjoner.

Følgende program lager en boolsk variabel og tester deretter verdien ved hjelp av en if/else-setning:

Ethvert uttrykk kan brukes som et komparativt uttrykk. Ethvert uttrykk som returnerer 0, null, udefinert eller den tomme strengen tolkes som usann. Et uttrykk som spesifiserer en annen verdi tolkes som sant.

Merk: Når du skriver boolske verdier, er de ikke omgitt av anførselstegn: var myVar = true;
Samtidig opprettes en strengvariabel ved å erklære var myVar = "true".

Nummerdatatype

I JavaScript er det ingen forskjell mellom et heltall og et flyttall – i hovedsak representerer JavaScript alle tall som en flyttallverdi.

JavaScript bruker et 64-bits format definert av IEEE-754-standarden for å representere tall. Dette formatet er i stand til å representere tall i området ±1,7976931348623157 × 10308 til ±5 × 10 -324.

Et tall som finnes direkte i programkoden kalles en numerisk bokstav. I tillegg til desimale heltallsliteraler gjenkjenner JavaScript heksadesimale verdier.
Heksadesimale tall kan inkludere en hvilken som helst rekkefølge av tall fra 0 til 9 og bokstaver fra a til f, som må begynne med tegnsekvensen "0x".

Var a = 255; var b = 0xFF; // Tall 255 i heksadesimal notasjon

I tillegg inneholder JavaScript spesielle numeriske verdier:

• NaN (ikke et tall eller regnefeil). Er resultatet av en feil matematisk operasjon på ugyldige data, for eksempel strenger eller en udefinert verdi.
• Uendelig (positiv uendelighet). Brukes når et positivt tall er for stort til å bli representert i JavaScript.
• -Uendelig (negativ uendelighet). Brukes når et negativt tall er for stort til å bli representert i JavaScript.
• ±0 (positiv og negativ 0). JavaScript skiller mellom positiv og negativ null.

Datatype streng

En strengtype er en uforanderlig, ordnet sekvens av 16-bits verdier, som hver representerer et Unicode-tegn (bokstaver, tall, tegnsetting, spesialtegn og mellomrom). Linjer kan være tomme eller bestå av ett eller flere tegn. Strenger lages ved hjelp av doble (") eller enkle (") anførselstegn. En streng avgrenset av et par enkle anførselstegn kan bruke doble anførselstegn, og omvendt kan enkle anførselstegn brukes innenfor en streng omsluttet av et par doble anførselstegn:

I JavaScript er det ingen forskjell mellom doble og enkle anførselstegn, men anførselstegnene på begynnelsen og slutten av en streng skal ikke være forskjellige. For eksempel vil et uttrykk som dette forårsake en syntaksfeil:

var fornavn = "Maks"; //syntaksfeil - forskjellige anførselstegn

Merk: JavaScript har ikke en spesiell enkelttegnsdatatype som tegn i C, C++ og Java. Et enkelt tegn er representert av en streng med lengdeenhet.

Null-datatype Null-typen inneholder en enkelt spesiell verdi – null.

Null-nøkkelordet kan ikke brukes som et funksjons- eller variabelnavn. Verdien null er en referanse til et "tomt" objekt og har en spesiell hensikt - den brukes vanligvis til å initialisere en variabel som senere vil bli tildelt en verdi.

Operatortypen for en nullverdi returnerer strengen "objekt", noe som indikerer at nullverdien er et spesielt "tomt" objekt.

Udefinert datatype

En udefinert type danner sin egen type, som inneholder en enkelt spesiell verdi - udefinert. Dette er verdien av en variabel deklarert ved hjelp av var-operatoren, men ikke initialisert:

Verdien undefined returneres når du får tilgang til en variabel som aldri har blitt tildelt en verdi, en ikke-eksisterende objektegenskap eller et matriseelement.

Det bør bemerkes at en variabel med verdien udefinert er forskjellig fra en variabel som ikke er definert i det hele tatt:

I dette eksemplet viser alert()-metoden verdien til aldersvariabelen, som er udefinert. I det andre tilfellet sendes en ikke-deklarert bilvariabel til alert()-metoden, noe som fører til en feil.

Følgende eksempel kan være noe forvirrende for nybegynnere, fordi... Operatortypen returnerer udefinert for både en ikke-initialisert og en ikke-deklarert variabel:

I eksemplet ovenfor er variabelen alder erklært, men ingenting er skrevet til den, så verdien er bare udefinert . Bilvariabelen er ikke deklarert - faktisk eksisterer den ikke. Typeof returnerer imidlertid strengen udefinert i begge tilfeller. Dette gir selvfølgelig en viss mening, fordi det er umulig å utføre noen operasjoner med noen av disse variablene, selv om de teknisk sett er helt forskjellige.

Merk: Det anbefales alltid å initialisere en deklarert variabel. I dette tilfellet vil du vite at typen operator returnerer udefinert fordi variabelen ikke ble deklarert, ikke fordi den ikke ble initialisert.

Verdien undefined er avledet fra null , så i ECMA-262 behandler == ekvivalensoperatoren dem som like:

Selv om null og undefined er relatert, brukes de annerledes. Du bør ikke eksplisitt tilordne verdien undefined til en variabel, men dette gjelder ikke null. I tilfelle det nødvendige objektet ikke er tilgjengelig, bør null brukes i stedet. Dette indikerer at null ble introdusert som en peker til et tomt objekt, og understreker forskjellen fra undefined .

For å skille mellom null og udefinert i et program, kan du bruke identitetsoperatøren === :

Datatype Symbol

Et symbol er et nytt tillegg til JavaScript siden ECMAScript versjon 6. Et symbol er en unik, uforanderlig, primitiv verdi som brukes til å lage unike identifikatorer.

For å lage et symbol må du kalle opp symbolfunksjonen:

var mittSymbol = Symbol();

For å definere et symbol, kan du bruke typen operator; hvis verdien er et symbol, vil strengsymbolet bli returnert:

Symbolfunksjonen har en valgfri parameter - en streng som tjener til å beskrive symbolet:

Egenskapsnavnet er en streng, så objekter kan anses å knytte strenger til verdier. Sammen danner disse informasjonsbitene nøkkelverdi-par.

I JavaScript-objekter kan opprettes ved hjelp av en av to syntakser:

1. var obj = (); // ved å bruke object literal 2. var obj = new Object(); // ved å bruke en metode kalt konstruktør

Å lage et objekt ved å bruke en objektliteral begynner med å definere en vanlig variabel. Høyre side av denne setningen skriver et objekt bokstavelig - dette er en kommadelt liste over par omsluttet av krøllete klammeparenteser (). "navn-verdi", innelukket i krøllete seler. Egenskapens navn og verdi er atskilt med et kolon:

var cat = ( "ben": 4, "navn": "Murzik", "farge": "Rød" )

Den andre måten å lage objekter på er å bruke Object()-konstruktøren. I dette tilfellet blir det nye Object()-uttrykket først brukt, og deretter blir egenskapene til det resulterende objektet definert og initialisert:

Når vi tilordner en variabel (hvis verdi inneholder en referanse til en sammensatt verdi) til en annen variabel, kopieres referansen til den sammensatte verdien. Som et resultat refererer begge variablene til den samme sammensatte verdien, og endringer i verdien av en variabel vil påvirke den andre variabelen.

Ethvert uttrykk som returnerer 0, null, udefinert eller den tomme strengen tolkes som usann.

Strenger lages ved hjelp av doble (") eller enkle (") anførselstegn. En streng avgrenset av et par enkle anførselstegn kan bruke doble anførselstegn, og omvendt kan enkle anførselstegn brukes i en streng omsluttet av et par doble anførselstegn.

Verdien null er en referanse til et "tomt" objekt og har en spesiell hensikt - den brukes vanligvis til å initialisere en variabel som senere vil bli tildelt en verdi.

Verdien (udefinert) er en variabel deklarert ved hjelp av var-operatoren, men ikke initialisert.

I JavaScript kan objekter opprettes på en av to måter:

• ved å bruke et bokstavelig objekt
• ved hjelp av en metode kalt konstruktør

Et objekt inneholder en uordnet samling av egenskaper, som hver inneholder et navn og en verdi. Du kan legge til nye navngitte verdier til et objekt når som helst eller fjerne eksisterende.