Mainīgais ir nosaukta atmiņas vieta, kurā varat gan saglabāt noteiktu informāciju, gan izgūt to no tās.

Mainīgo deklarēšana (izveidošana) tiek veikta, izmantojot atslēgvārdu var.

// ziņojums - mainīgā nosaukums var ziņojums;

Kad veidojat mainīgo, varat nekavējoties piešķirt tam vērtību.

Vērtības piešķiršana mainīgajam tiek veikta, izmantojot operatoru “=”.

// piemēram, izveidojiet mainīgu e-pasta adresi un piešķiriet tai virkni " [aizsargāts ar e-pastu]"var email =" [aizsargāts ar e-pastu]"; // iestatiet e-pasta mainīgajam jaunu vērtību email = " [aizsargāts ar e-pastu]";

Lai iegūtu mainīgā lieluma vērtību, vienkārši atsaucieties uz to pēc nosaukuma.

// piemēram, izvadiet e-pasta mainīgā vērtību pārlūkprogrammas konsolei: console.log(email);

Lai deklarētu vairāk nekā vienu mainīgo, izmantojot vienu var atslēgvārdu, ir jāizmanto komats.

Var cena = 78,55, daudzums = 10, ziņojums;

JavaScript ir dinamiski vai vāji ievadīta valoda. Tas nozīmē, ka, deklarējot mainīgo, tam nav jānorāda datu tips, ko tas var pieņemt. Tāpēc vispirms varat ievietot viena datu tipa vērtību mainīgajā un pēc tam cita veida vērtību.

Var izvade = "veiksme"; // mainīgajam ir virknes datu tipa izvade = 28; // tas pats mainīgais, bet jau datu tipa “number” output = true; // tas pats mainīgais, bet jau saglabā Būla vērtību

Mainīgā lieluma vērtību var mainīt neierobežotu skaitu reižu.

// tiek izveidots vecuma mainīgais var age; // mainīgajam vecumam tiek piešķirta vērtība 67 vecums = 67; // mainīgais vecums ir iestatīts uz "Pensijas vecums" age = "Pensijas vecums"; // mainīgais vecums ir iestatīts uz 55 vecums = 55;

Laba prakse, izstrādājot klienta lietojumprogrammas, ir izmantot tikai vienu datu tipu dotajā mainīgajā, t.i. Nerakstiet mainīgajā lielumā dažādu datu tipu vērtības. Lai saprastu, kāda veida dati ir sagaidāmi mainīgajā, veidojot mainīgo, ieteicams to nekavējoties inicializēt ar konkrētu vērtību.

Mainīgā nosaukums var sastāvēt no burtiem, cipariem un simboliem $ un _. Šajā gadījumā mainīgā pirmā rakstzīme nedrīkst būt skaitlis. Turklāt jūs nevarat izmantot rezervētos vārdus kā mainīgo nosaukumus.

// veidojot divus mainīgos, pirmais mainīgais ir nosaukts phone, otrais ir message; var telefons, ziņa;

Burtu reģistram mainīgā nosaukumā ir nozīme. Tas ir, piemēram, mainīgais tālrunis un Tālrunis ir divi dažādi mainīgie.

Ja stingrais režīms netiek izmantots, varat izveidot mainīgo ar sākotnējo vērtību bez atslēgvārda var.

Cena = 250,00; // izveidoja mainīgo un inicializēja to ar skaitli 250,00 procenti = "20%"; // izveidoja mainīgo un inicializēja to ar virkni “20%”

Taču šādā veidā izveidot mainīgos nav ieteicams.

Datu veidi

JavaScript datu tipus var iedalīt primitīvajos un objektos.

Mainīgie, kas satur primitīvus datu tipus, skaidri saglabā to vērtību.

JavaScript ir 5 primitīvi datu veidi:

• numurs;
• aukla;
• Būla tips (būla veids);
• nulles;
• nenoteikts.

Ja vienam mainīgajam tiek piešķirta cita vērtība, kas satur primitīvu datu tipu, tas saņems savu šīs vērtības kopiju.

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

Mainīgie, kas satur objektu, faktiski nesaglabā pašu objektu, bet gan atsauci uz to.

Ja vienam mainīgajam tiek piešķirta cita vērtība, kas satur objektu (saite uz to), tad tas arī saņems saiti uz to. Šīs darbības rezultātā šie divi mainīgie saturēs atsauci uz vienu un to pašu objektu.

// 1. piemērs (ar datu tipu "object") var coord1 = (x: 77, y: 100), coord2 = coord1; koordina1.x = 55; // objekta x rekvizīta iestatīšana uz jaunu vērtību coord2.x; // 55, jo coord1 un coord2 satur atsauci uz vienu un to pašu objektu // 2. piemērs (ar masīva datu tipu) var coord1 = , coord2 = coord1; koordina1 = 55; // iestatiet elementam ar indeksu 0 uz jaunu vērtību coord2; // 55, jo coord1 un coord2 satur atsauci uz vienu un to pašu objektu // 3. piemērs (ar datu tipu "datums") var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // palielināt datumu par 7 dienām date1; // 01/07/2018, jo date1 un date2 satur atsauci uz vienu un to pašu objektu

Numurs

JavaScript skaitliskais datu tips ir vispārīgs. To izmanto, lai attēlotu gan veselus skaitļus, gan daļskaitļus.

Var int = 5; // vesels skaitlis var float = 5,98; // daļskaitlis

Formāts skaitļu attēlošanai JavaScript ir saskaņā ar IEEE 754-2008 standartu.

Veselus skaitļus JavaScript var norādīt ne tikai decimālā sistēma skaitļu sistēmā, bet arī oktālā (0) vai heksadecimālā skaitļu sistēmā (0x), izmantojot iekavās norādītos prefiksus:

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

Ir iespējams rakstīt skaitļus eksponenciālā formā:

Var skaitlis = 2e3; // skaitļa eksponenciāls apzīmējums 2*10^3 (2000) num = 2e-3; // skaitļa eksponenciālais apzīmējums 2*10^-3 (0,002) num = 3,2e3; // 3200 num = 1,5e-2; // 0,015

Papildus cipariem ciparu datu tips satur arī īpašas skaitliskas vērtības:

• Bezgalība (pozitīvā bezgalība);
• -Bezgalība (negatīvā bezgalība);
• NaN (nav skaitlis).

Īpašā vērtība Infinity nozīmē ļoti lielu pozitīvu skaitli, t.i. skaitlis, ko nevar attēlot JavaScript, jo tas ir pārāk liels.

Īpašas nozīmes -Bezgalība nozīmē, gluži pretēji, ļoti lielu negatīvu skaitli, t.i. skaitlis, ko nevar attēlot ar JavaScript, jo arī tas ir pārāk liels.

Piemērs izteiksmēm, kuras to aprēķina rezultātā atgriezīs īpašas skaitliskās vērtības:

5/0; // Bezgalība -5/0; // -Infinity Math.pow(10,399); // Bezgalība (10 līdz 399 pakāpēm) Math.pow(10,399); // -Bezgalība (-10 līdz pakāpei no 399)

NaN vērtība tiek atgriezta matemātisku darbību rezultātā, kuras JavaScript nevar aprēķināt.

5 - "Sveiks"; // NaN (atņemiet rindu no skaitļa 5) 1000 / "20px"; // NaN (skaitlis dalīts ar virkni) true * "1rem"; // NaN (būla vērtība true, reizināta ar virkni)

Ļoti interesanti ir tas, ka NaN vērtība JavaScript nav vienāda ar neko, ieskaitot sevi.

NaN == NaN; // viltus NaN === NaN; //nepatiess

Būla datu tips

Būla ir primitīvs datu tips, kuram ir tikai divas vērtības: patiesa un nepatiesa.

Var a = patiess; var b = false;

Stīga

Virkne ir datu tips, kas tiek izmantots JavaScript, lai attēlotu tekstu.

JavaScript virkne var sastāvēt no 0 vai vairāk rakstzīmes.

JavaScript kā virknes formātu vienmēr izmanto Unicode.

Virknes (string literal) izveidošana tiek veikta, iekļaujot tekstu vienā vai dubultpēdiņas.

"JavaScript"; "ECMAScript";

Programmā JavaScript nav atšķirības starp vienpēdiņām un dubultpēdiņām.

Bet dažos gadījumos ir lietderīgi izmantot vienas pēdiņas, nevis dubultpēdiņas un otrādi.

Piemēram, ja virknē ir dubultpēdiņas, ērtāk to ievietot vienpēdiņās. Tas novērsīs nepieciešamību izvairīties no dubultpēdiņām.

""ECMAScript""; // bez atspēriena (izmantojot vienas pēdiņas) "\"ECMAScript\""; // ar aizbēgšanu

JavaScript virknē var būt speciālās rakstzīmes. Piemēram, \n (rindas plūsma), \t (cilne), \r (ratu atgriešana) utt.

"Šis ir teikums.\nUn šis arī ir teikums, bet tas sāksies no jaunas rindas.";

Ar virknēm var veikt saskaitīšanas (savienības) vai, citiem vārdiem sakot, savienošanas darbību. Šim nolūkam tiek izmantots operators "+". Šīs darbības nozīme ir otrās rindas pievienošana pirmās rindas beigām.

"Es mīlu" + "JavaScript"; // Man patīk JavaScript

Vērtība ir "nenodefinēta"

undefined ir īpašs primitīvs datu tips, kam ir viena vērtība, kas vienāda ar undefined .

Šim datu tipam ir deklarēts mainīgais, kuram vēl nav piešķirta vērtība.

Var num; // nenoteikts

Vērtība undefined tiks atgriezta arī, piekļūstot neesošam objekta rekvizītam.

Var obj = (); // tukšs objekts obj.prop; // nenoteikts

"nulle" vērtība

null ir īpašs primitīvs datu tips, kam ir viena vērtība, kas vienāda ar nulli.

null ir tikai īpaša vērtība, kurai ir nozīme "nekas" vai "nezināma vērtība", t.i. tas nepārprotami neko nenozīmē.

Objekts

Objekts ir datu struktūra, kas sastāv no nosaukuma un vērtības pāriem.

Objekta izveide, izmantojot objekta burtisko apzīmējumu, tiek veikta šādi:

(nosaukums_1: vērtība_1, nosaukums_2: vērtība_2, nosaukums_3: vērtība_3, ... )

Kā redzat, nosaukums tiek atdalīts no vērtības, izmantojot kolu, un pāri tiek atdalīti viens no otra, izmantojot komatu.

Turklāt, ja pāra vērtība ir funkcija, tad to sauc par šī objekta metodi. Visi pārējie pāri, t.i. pārus, kuros funkcija netiek izmantota kā vērtība, sauc par objekta īpašībām.

Citiem vārdiem sakot, objekts ir datu struktūra, kas sastāv no īpašībām un metodēm.

Var persona = ( vārds: "Vitālijs", vecums: 27, getAge: funkcija () ( atgriež "Vecums: " + this.age; ) )

Piekļuve objekta īpašībām tiek veikta, izmantojot punktu vai iekavu apzīmējumu.

// parāda vecuma rekvizīta vērtību pārlūkprogrammas konsolē // 1. metode (caur punktu) console.log(person.age); // 2. metode (izmantojot iekavas) console.log(person["vecums"]); // izsaukt metodi getAge; vērtība, ko tā atgriež, tiks izvadīta konsolē console.log(person.getAge());

operatora veids

Operatoru typeof izmanto, lai iegūtu informāciju par izteiksmes kā virknes datu tipu.

Operatora veida sintakse (opcija bez iekavām):

Izteiksmes veids

Operatora sintakses veids (izmantojot iekavas):

(izteiksmes) veids

Var nosaukums, vecums = 37, e-pasts = " [aizsargāts ar e-pastu]", isLicense = true, interese: null, pēdējāPieredze: ( periods: "2011. gada jūnijs - 2018. gada jūnijs", vieta: "ISACA, Maskava", pozīcija: "Web dizainers" ), iegūtPieredze: funkcija() ( atgriezties pēdējāPieredze.period + " ("+ pēdējāPieredze.pozīcija + " - " + pēdējāPieredze.vieta + ")"; ); nosaukuma veids; // "nedefinēts" vecuma veids; // Licences veids "numurs"; // interešu veids "būla"; / / "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) ir kļūda, kas ir bijusi valodā kopš tās pirmās ieviešanas; tā nav bijusi fiksēts, lai saglabātu savietojamību un tas ir jāņem vērā rakstot skriptus; null ir primitīvs datu tips, tas nav objekts */ /* (2) - ļoti ērti, ka operatora tips funkcijas atdala atsevišķi; bet JavaScipt funkcija arī ir objekts; to var viegli pārbaudīt, izpildot šādu konstrukciju: */ typeof getExperience.__proto__.__proto__ // "objekts" (funkcijas prototips ir objekts)

Konstantes

Līdz ar ECMAScript 6 izlaišanu kļuva iespējams izveidot konstantes. Tas tiek darīts, izmantojot atslēgvārdu const.

Const COLOR_RED = "#ff0000";

Konstante ir mainīgais, kura vērtība ir aizsargāta no izmaiņām. Tie. Mēģinot mainīt vērtību, tiks parādīta kļūda.

Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Nenoķertā tipa kļūda: Piešķiršana nemainīgam mainīgajam.

Ja, piemēram, konstante satur objektu, tad to nevar mainīt vai drīzāk atsauce uz to. Bet šī objekta īpašības var mainīt.

Const COLORS = ( sarkans: "#ff0000", zaļš: "#00ff00", zils: "#00ff00" ) KRĀSAS = ["#ff0000","#00ff00","#00ff00"]; // Nenoķertā tipa kļūda: Piešķiršana nemainīgam mainīgajam. KRĀSAS.zaļš = "#4caf50";

Datu tipi palīdz izveidot datu klasifikāciju programmēšanas valodās. Piemēram, cipars un rakstzīmju virkne ir dažādi datu veidi, kurus JavaScript apstrādās atšķirīgi.

Tas ir svarīgi, jo katrs datu tips var iegūt noteiktas vērtības un veikt noteiktas darbības. Lai varētu veikt darbības ar mainīgajiem JavaScript, ir svarīgi saprast katra konkrētā mainīgā datu tipu.

Šī apmācība iepazīstinās jūs ar JavaScript datu veidiem.

Piezīme. Šajā rokasgrāmatā sniegtā informācija nav pilnīga, taču tā sniegs pārskatu par JavaScript pamata opcijām.

Dinamiskā rakstīšana

JavaScript ir dinamiska valoda. Tas nozīmē, ka datu tipa pārbaude tiek veikta izpildes laikā, nevis kompilēšanas laikā.

Dinamiskajās valodās glabāšanai var izmantot viena nosaukuma mainīgos dažādi veidi datus.

Piemēram, mainīgais t, ko definē ar atslēgvārdu var, var uzglabāt dažāda veida datus; to var arī inicializēt, bet atstāt nedefinētu:

var t = 16; // t ir skaitlis
var t = "Terēza"; // t ir virkne
var t = patiess; // t ir Būla vērtība
var t; // t ir nenoteikts

Visi t mainīgie satur dažādus JavaScript datu tipus. Programmā JavaScript jums nav skaidri jānorāda mainīgā datu veids, pirms to izmantojat.

Skaitļi

JavaScript ir viens ciparu datu tips, nenošķirot veselus skaitļus un peldošā komata skaitļus. Tāpēc skaitļus JavaScript var rakstīt ar vai bez zīmēm aiz komata:

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

Iepriekš minētajā piemērā abos mainīgajos ir skaitļi neatkarīgi no tā, vai tajos ir vai nav komats.

Zinātniskais apzīmējums JavaScript ļauj saīsināt ļoti lielus vai mazus skaitļus:

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

Programmā JavaScript skaitļi tiek uzskatīti par precīziem līdz 15 cipariem. Tas nozīmē, ka pēc 16. cipara sasniegšanas skaitļi tiks noapaļoti:

var num5 = 999999999999999; // paliek kā 999999999999999
var num6 = 9999999999999999; // noapaļots līdz 10000000000000000

Turklāt JavaScript skaitļiem ir trīs simboliskas nozīmes:

Bezgalība - skaitliskā vērtība, kas ir pozitīvs skaitlis, kas tuvojas bezgalībai.

Bezgalība ir skaitliska vērtība, kas apzīmē negatīvu skaitli, kas tuvojas bezgalībai.

NaN — Not-a-Number, īpašs peldošā komata skaitļa stāvoklis.

Infinity un -Infinity tiek atgrieztas, ja tiek skaitīts skaitlis, kas pārsniedz maksimālo iespējamo JavaScript programmā pieejamo skaitu. Tie parādās arī, skaitot nedefinētas vērtības, piemēram, dalot ar nulli:

var num7 = 5/0; // Bezgalība
var num8 = -5 / 0; // -Bezgalība

Tehniski Infinity tiek atgriezta, ja skaitlis ir lielāks par 1,797693134862315E+308, kas ir JavaScript augšējā robeža.

Tāpat tiks parādīta opcija -Infinity, kad skaitlis pārsniedz apakšējo robežu, -1,797693134862316E+308.

Bezgalības skaitli var izmantot arī cilpās:

while (num9 != Bezgalība) (
// Kods šeit tiks izpildīts līdz num9 = Infinity
}

Nedefinētiem skaitļiem tiek drukāts NaN. Ja mēģināsit veikt matemātisko darbību ar skaitli un vērtību, kas nav skaitliska, jūs iegūsit NaN. Piemēram:

var x = 20 / "haizivs"; // x būs NaN

Tā kā 20 nevar dalīt ar Shark virkni, x vērtība būs NaN.

Tomēr, ja virkni var novērtēt kā skaitlisku vērtību, JavaScript novērtēs matemātisko izteiksmi:

var y = 20 / "5"; // y būs 4

Tā kā JavaScript var uzskatīt 5 kā skaitlisku vērtību, 5 darbosies ar matemātiskās dalīšanas operatoru.

Ja izteiksmē viens mainīgais ir iestatīts uz NaN, rezultāts būs NaN, pat ja otrais operands ir skaitlis.

var a = NaN;
var b = 37;
var c = a + b; // c būs NaN

Tātad JavaScript ir tikai viens skaitlisks datu tips. Programmā JavaScript nav nepieciešams skaitļus sadalīt veselos skaitļos un peldošā komata skaitļos, jo JavaScript ir dinamiska valoda.

Stīgas

Virkne ir vienas vai vairāku rakstzīmju (burtu, ciparu un citu simbolu) secība. Virknes apzīmē teksta datus.

Programmā JavaScript virknes ir gan vienpēdiņās, gan dubultpēdiņās. Lai izveidotu virkni, pēdiņās jāiekļauj rakstzīmju secība:

var singleQuotes = "Šī ir virkne atsevišķās pēdiņās.";
var doubleQuotes = "Šī ir virkne dubultpēdiņās.";

Varat izmantot vienpēdiņas vai dubultpēdiņas, taču vienā un tajā pašā kodā konsekventi jāizmanto viena veida pēdiņas.

Raidījums "Sveika, pasaule!" parāda, kā virknes tiek izmantotas datorprogrammēšanā. Būtībā iekšā šajā piemērā virkne ir rakstzīmju virkne, kas veido frāzi "Sveika, pasaule!" brīdinājumā ().

funkcija helloFunction() (
brīdinājums ("Sveika, pasaule!");
}

Noklikšķiniet uz manis

Palaižot kodu un noklikšķinot uz pogas Noklikšķiniet uz manis, jūs redzēsit uznirstošo logu ar tekstu:

Tāpat kā citus datu tipus, virknes var saglabāt mainīgajos.

var hw = "Sveika, pasaule!";

Pēc tam virkni var parādīt, izsaucot mainīgo:

...

var hw = "Sveika, pasaule!";
funkcija helloFunction() (
brīdinājums(hw);
}

...
Sveika pasaule!

Virknes ļauj nosūtīt informāciju lietotājam un atpakaļ uz programmu.

Būla datu tips

Būla (vai Būla) datu tips sastāv no divām vērtībām – patiesa un nepatiesa.

Šo veidu izmanto, lai attēlotu patiesības vērtības, kas saistītas ar loģiku un algoritmiem datorzinātnēs.

Piezīme. Šis datu tips ir nosaukts matemātiķa Džordža Būla vārdā.

Daudzas matemātikas darbības rada rezultātus, kurus var novērtēt kā patiesus vai nepatiesus:

Vairāk par:

• 500 > 100 taisnība
• 1 > 5 nepatiesi

Mazāk nekā:

• 200 < 400 true
• 4 < 2 false

• 5 = 5 taisnība
• 500 = 400 nepatiesi

Tāpat kā citus veidus, Būla datu tipu var saglabāt mainīgajos lielumos.

var myBool = 5 > 8; // viltus

Tā kā 5 nav lielāks par 8, myBool būs nepatiess.

Kodējot JavaScript, jūs iepazīsities ar Būla datu darbību un to, kā dažādas patiesības novērtēšanas funkcijas un darbības var mainīt programmas plūsmu.

Masīvi

Masīvs var saturēt vairākas vērtības vienā mainīgajā. Tas nozīmē, ka masīvā varat saglabāt vērtību sarakstu un tos atkārtot.

Katru vērtību masīvā sauc par elementu. Masīva elementiem var piekļūt, izmantojot indeksu.

Masīvus nosaka kvadrātiekavās.

Virkņu masīvs izskatās šādi:

var zivis = ["haizivs", "sēpija", "klaunzivs", "zutis"];

Izsaucot zivju mainīgo, jūs iegūsit rezultātu:

["haizivs", "sēpija", "klaunzivs", "zutis"]

Masīvi ir ļoti elastīgs datu tips, jo tie ir mainīgi: jūs varat pievienot, noņemt un mainīt elementu vērtības.

Objekti

JavaScript objekts sastāv no atslēgas:vērtības pāriem.

Objekta sintakse sastāv no atslēgas:vērtības pāriem. Objekts ir atdalīts ar cirtainiem lencēm abās pusēs (()).

Pāri objektā ir atdalīti ar atstarpēm:

var sammy = (firstName:"Wally", LastName:"Haizivs", krāsa:"zils", atrašanās vieta:"okeāns");

Objektu var rakstīt arī vairākās rindās (tas īpaši attiecas uz lieliem objektiem).

var Wally = (
vārds: "Wally",
uzvārds: "Haizivs",
krāsa: "zila",
vieta: "Okeāns"
};

Darbs ar vairākiem datu tipiem

Katrā izveidotajā programmā, iespējams, būs vairāki datu tipi, taču darbības parasti tiek veiktas ar vienu datu tipu. skaitļiem tiek lietota matemātika, bet virknēm tiek piemērota šķēlēšana.

Izmantojot operatorus, kas strādā ar visa veida datiem (piemēram, operators + var pievienot skaitļus vai veikt virkņu savienošanu), varat iegūt negaidītus rezultātus.

Ja izveidojat mainīgo savienošanai, JavaScript interpretēs katru elementu kā virkni.

var o = "Okeāns" + 5 + 3;

Izsaucot mainīgo o, jūs iegūsit šādu rezultātu:

Tomēr, ja virknē vispirms ir skaitļi un pēc tam virkne, operators + veiks saskaitīšanu un pēc tam savienošanu:

var p = 5 + 3 + "Okeāns";
8 Okeāns

Tā kā rezultāti ir neparedzami, operācijas un metodes ir ērtāk veikt vienā datu tipā. Tomēr JavaScript neatgriež kļūdas, sajaucot datu tipus, kā to dara dažas citas programmēšanas valodas.

Secinājums

Tagad esat iepazinies ar JavaScript datu veidiem. Katrs no šeit uzskaitītajiem veidiem ir svarīgs, rakstot JavaScript programmas.

Tagi: mainīgais ir identifikators, kam ir piešķirta vērtība. Mainīgajam var piekļūt programmā, tādējādi strādājot ar tam piešķirto vērtību.

JavaScript mainīgais pats par sevi nesatur informāciju par vērtību veidu, kas tajā tiks saglabāts. Tas nozīmē, ka, rakstot, piemēram, virkni mainīgajam, vēlāk tam var ierakstīt skaitli. Šāda darbība neizraisīs programmā kļūdu. Šī iemesla dēļ JavaScript dažreiz tiek saukta par "nedrukātu" valodu.

Lai varētu izmantot mainīgo, tas ir jādeklarē, izmantojot atslēgvārdu var vai let. Ja mēs runājam par konstanti, tiek izmantots atslēgvārds const. Varat deklarēt mainīgo un piešķirt tam vērtību, neizmantojot šos atslēgvārdus, taču tas nav ieteicams.

▍Atslēgvārds var Pirms ES2015 standarta atslēgvārda var lietojums bija vienīgais ceļš mainīgās deklarācijas.

Var a = 0
Ja šajā konstrukcijā izlaidīsit var, vērtība tiks piešķirta nedeklarētam mainīgajam. Šīs darbības rezultāts ir atkarīgs no režīma, kurā programma tiek izpildīta.

Tātad, ja ir iespējots tā sauktais stingrais režīms, tas radīs kļūdu. Ja stingrais režīms nav iespējots, mainīgais tiks netieši deklarēts un piešķirts globālajam objektam. Tas jo īpaši nozīmē, ka mainīgais, kas šādā veidā netieši deklarēts funkcijā, paliks pieejams pēc funkcijas pabeigšanas. Parasti ir sagaidāms, ka funkcijās deklarētie mainīgie “nepārsniedz” to darbības jomu. Tas izskatās šādi:

Funkcija notVar() ( bNotVar = 1 //labāk to nedarīt) notVar() console.log(bNotVar)
1 parādīsies konsolē, neviens parasti negaida no programmas šādu uzvedību, izteiksme bNotVar = 1 neizskatās pēc mēģinājuma deklarēt un inicializēt mainīgo, bet gan kā mēģinājums piekļūt mainīgajam, kas atrodas ārpus programmas. funkcija (tas ir diezgan normāli). Tā rezultātā netiešās mainīgo deklarācijas mulsina tos, kas lasa kodu, un var izraisīt neparedzētu programmas darbību. Vēlāk mēs runāsim gan par funkcijām, gan tvērumiem, bet pagaidām mēģiniet vienmēr izmantot specializētus atslēgvārdus, kad izteiksmes nozīme ir mainīgā deklarēšana. Ja šajā piemērā funkcijas pamatteksts ir pārrakstīts kā var bNotVar = 1, tad, mēģinot palaist iepriekš minēto koda fragmentu, tiks parādīts kļūdas ziņojums (to var redzēt pārlūkprogrammas konsolē).

Piemēram, tas varētu izskatīties šādi: Uncaught ReferenceError: bNotVar nav definēts . Tās nozīme ir tāda, ka programma nevar strādāt ar neesošu mainīgo. Daudz labāk ir redzēt šādu kļūdas ziņojumu, kad pirmo reizi startējat programmu, nekā rakstīt nesaprotamu kodu, kas var uzvesties negaidīti.

Ja, deklarējot mainīgo, tas netiek inicializēts vai tam nav piešķirta vērtība, tam automātiski tiks piešķirta vērtība nenoteikta.

Var a //typeof a === "nenodefinēts"
Mainīgos, kas deklarēti ar atslēgvārdu var, var atkārtoti deklarēt vairākas reizes, piešķirot tiem jaunas vērtības (taču tas var mulsināt personu, kas lasa kodu).

Var a = 1 var a = 2
Varat deklarēt vairākus mainīgos vienā izteiksmē:

Var a = 1, b = 2
Mainīgā lieluma apjoms ir programmas apgabals, kurā šis mainīgais ir pieejams (redzams).

Mainīgais, kas inicializēts ar atslēgvārdu var ārpus funkcijas, tiek piešķirts globālam objektam. Tam ir globāls mērogs, un tas ir pieejams no jebkuras programmas vietas. Ja mainīgais tiek deklarēts, izmantojot atslēgvārdu var funkcijā, tad tas ir redzams tikai šajā funkcijā, kas ir tās lokālais mainīgais.

Ja funkcija, kas izmanto var, deklarē mainīgo, kura nosaukums ir tāds pats kā mainīgajam globālajā tvērumā, tā “ignorēs” globālo mainīgo. Tas ir, piekļūstot šādam mainīgajam funkcijā, tiks izmantota tā vietējā versija.

Ir svarīgi saprast, ka bloki (koda apgabali, kas ietverti krokainajās iekavās) nerada jaunus tvērumus. Jauns rajons redzamība tiek izveidota, kad funkcija tiek izsaukta. Atslēgvārdam var ir tā sauktā funkcionālā joma, nevis bloka darbības joma.

Ja funkcijas kodā ir deklarēts mainīgais, tas ir redzams visam funkcijas kodam. Pat ja mainīgais ir deklarēts, izmantojot var funkcijas koda beigās, tam var piekļūt koda sākumā, jo JavaScript ir mainīga pacelšanas mehānisms. Šis mehānisms "paceļ" mainīgo deklarācijas, bet ne to inicializācijas darbības. Tas var radīt neskaidrības, tāpēc izveidojiet ieradumu deklarēt mainīgos savas funkcijas sākumā.

▍Atslēgvārds let Atslēgvārds let tika ieviests ES2015, un vienkāršotā veidā to var saukt par var “bloka” versiju. Mainīgie, kas deklarēti ar atslēgvārdu let, tiek attiecināti uz bloku, priekšrakstu vai izteiksmi, kurā tas ir deklarēts, un uz ligzdotiem blokiem.

Ja pats vārds “ļaujiet” nešķiet ļoti skaidrs, varat iedomāties tā vietā lietot vārdu “ļaujiet”. Tad izteicienu let color = "red" angļu valodā var tulkot šādi: "lai krāsa būtu sarkana" un krieviski šādi: "lai krāsa būtu sarkana".

Izmantojot atslēgvārdu let, varat izvairīties no neskaidrībām, kas rodas ar atslēgvārdu var (piemēram, nevarēsit divreiz deklarēt vienu un to pašu mainīgo, izmantojot let ). Lietojot let ārpus funkcijas, piemēram, inicializējot cilpas, netiek izveidoti globālie mainīgie.

Piemēram, šis kods radīs kļūdu:

For (lai i = 0; i< 5; i++) { console.log(i) } console.log(i)
Ja, inicializējot cilpu, skaitītājs i tiek deklarēts, izmantojot atslēgvārdu var, tad i būs pieejams ārpus cilpas pēc tam, kad tas būs pabeidzis darbu.

Mūsdienās, izstrādājot uz mūsdienu standartiem balstītas JS programmas, ir pilnīgi iespējams pilnībā atteikties no var un izmantot tikai atslēgvārdus let un const.

▍Const atslēgvārds To mainīgo vērtības, kas deklarētas, izmantojot atslēgvārdus var vai let, var pārrakstīt. Ja šo atslēgvārdu vietā izmanto const, tad ar tās palīdzību deklarētai un inicializētai konstantei nevar piešķirt jaunu vērtību.

Const a = "pārbaude"
Šajā piemērā konstantei a nevar piešķirt jaunu vērtību. Taču jāņem vērā, ka, ja a nav primitīva vērtība kā skaitlis, bet objekts, atslēgvārda const izmantošana nepasargā šo objektu no izmaiņām.

Kad viņi saka, ka objekts ir saglabāts mainīgajā, viņi patiesībā domā, ka mainīgais saglabā atsauci uz objektu. Šo saiti nevar mainīt, bet var mainīt pašu objektu, uz kuru saite ved.

Const atslēgvārds nepadara objektus nemainīgus. Tas vienkārši aizsargā atsauces uz tām, kas ierakstītas attiecīgajās konstantēs, no izmaiņām. Tas izskatās šādi:

Const obj = () console.log(obj.a) obj.a = 1 //darbojas console.log(obj.a) //obj = 5 //izraisa kļūdu
Inicializācijas laikā obj konstantei tiek ierakstīts jauns tukšs objekts. Mēģinājums piekļūt tās īpašumam a, kas neeksistē, neizraisa kļūdu. Konsole kļūst nenoteikta. Pēc tam objektam pievienojam jaunu rekvizītu un mēģinām tam piekļūt vēlreiz. Šoreiz šī īpašuma vērtība konsolē ir 1. Ja noņemat komentāru no piemēra pēdējās rindiņas, mēģinot izpildīt šo kodu, tiks parādīta kļūda.

Atslēgvārds const ir ļoti līdzīgs atslēgvārdam let , jo īpaši tam ir bloka darbības joma.

Mūsdienu apstākļos ir diezgan pieņemami izmantot atslēgvārdu const, lai deklarētu visas entītijas, kuru vērtības nav plānots mainīt, izmantojot atļaušanu tikai īpašos gadījumos. Kāpēc? Būtība ir tāda, ka vislabāk ir censties izmantot pēc iespējas vienkāršākas pieejamās konstrukcijas, lai nesarežģītu programmu un izvairītos no kļūdām.

JavaScript datu tipus dažreiz sauc par "nerakstīto" valodu, taču tas tā nav. Tā ir taisnība, ka mainīgajos var ierakstīt dažāda veida vērtības, taču JavaScript joprojām ir datu veidi. Jo īpaši mēs runājam par primitīviem un objektu datu veidiem.

Lai noteiktu vērtības datu tipu, varat izmantot operatora tipu. Tas atgriež virkni, kas norāda operanda veidu.

▍Primitīvie datu tipi Šeit ir JavaScript primitīvo datu tipu saraksts:

• numuru
• stīga
• Būla vērtība (būla vērtība)
• null (īpaša vērtība null)
• undefined (īpaša vērtība nav definēta)
• simbols (simbols, ko izmanto īpašos gadījumos, ieviests ES6)

Šeit tiek norādīti datu tipu nosaukumi, kā tos atgriež operatora veids.

Parunāsim par visbiežāk izmantotajiem datu veidiem no šī saraksta.

Ciparu tips Numura veida vērtības JavaScript tiek attēlotas kā 64 bitu dubultas precizitātes peldošā komata skaitļi.

Kodā ciparu literāļi tiek attēloti kā veseli skaitļi un daļas decimālo skaitļu sistēmā. Ciparu rakstīšanai varat izmantot citas metodes. Piemēram, ja skaitliskā literāļa sākumā ir prefikss 0x, tas tiek uztverts kā skaitlis, kas rakstīts ar heksadecimālo apzīmējumu. Ciparus var rakstīt arī eksponenciālā apzīmējumā (šādos skaitļos var atrast burtu e).

Šeit ir veselu skaitļu rakstīšanas piemēri:

10 5354576767321 0xCC // heksadecimālais skaitlis
Šeit ir frakcijas.

3.14 .1234 5.2e4 //5.2 * 10^4
Ciparu literāļi (šī uzvedība ir raksturīga arī dažiem citiem primitīvajiem tipiem), mēģinot tiem piekļūt kā objektiem, operācijas laikā tiek automātiski pārveidoti par attiecīgajiem objektiem, kurus sauc par “objektu aptinējiem”. Šajā gadījumā mēs runājam par numura objektu iesaiņojumu.

Lūk, piemēram, mēģinājums piekļūt mainīgajam a, kas satur ciparu literālu, izskatās kā objekts Google Chrome konsolē.

Ciparu objekta iesaiņojuma mājiens

Ja, piemēram, izmantojat metodi toString() objektam, kura tips ir Number, tas atgriezīs skaitļa virknes attēlojumu. Atbilstošā komanda izskatās šādi, ko var izpildīt pārlūkprogrammas konsolē (un parastajā kodā) šādi:

A.toString()
Ievērojiet dubultās iekavas aiz metodes nosaukuma. Ja jūs tos nepiegādāsit, sistēma neģenerēs kļūdu, bet gaidītās izvades vietā jūs redzēsiet konsolē kaut ko tādu, kas nepavisam nav līdzīgs skaitļa 5 virknes attēlojumam.

Globālo Skaitļa objektu var izmantot kā konstruktoru, ar tā palīdzību veidojot jaunus skaitļus (tomēr tas gandrīz nekad netiek lietots šādā formā), to var izmantot arī kā neatkarīgu entītiju, neveidojot savus gadījumus (tas ir, noteiktus skaitļus pārstāvēta ar tās palīdzību). Piemēram, tā rekvizīts Number.MAX_VALUE satur maksimālo skaitlisko vērtību, ko var attēlot JavaScript.

Tipa virkne Tipa virknes vērtības ir rakstzīmju secības. Šādas vērtības ir norādītas kā virknes literāļi, kas ievietoti vienpēdiņās vai dubultpēdiņās.

"A virkne" "Cita virkne"
Virknes vērtības var sadalīt vairākās daļās, izmantojot atpakaļvērstās slīpsvītras rakstzīmi.

"virkne"
Rindā var būt tā sauktās evakuācijas sekvences, kuras tiek interpretētas, kad līnija tiek izvadīta uz konsoli. Piemēram, secība \n nozīmē jaunas rindiņas rakstzīmi. Apgrieztās slīpsvītras rakstzīmi var izmantot arī, lai pievienotu pēdiņas virknēm, kas ietvertas tajās pašās pēdiņās. Atbrīvojot no pēdiņas rakstzīmes ar \, sistēma to neuzskata par īpašu rakstzīmi.

"Es esmu izstrādātājs"
Virknes var savienot, izmantojot operatoru +.

"A" + "virkne"

Veidņu literāļi ES2015 parādījās tā sauktie šablonu literāļi jeb šablonu virknes. Tās ir virknes, kas ietvertas pēdiņās (`), un tām ir dažas interesantas īpašības.

"stīga".
Piemēram, jūs varat aizstāt noteiktas vērtības, kas ir JavaScript izteiksmju novērtēšanas rezultāts, veidņu literāļos.

`virkne ar $(something)` `virkne ar $(something+somethingElse)` `virkne ar $(obj.something())`
Atpakaļpēdiņu izmantošana atvieglo virkņu literāļu rakstīšanu vairākās rindās:

"virkne ar $(kaut ko)".

Būla tipam JavaScript ir rezervētu vārdu pāris, ko izmanto, strādājot ar Būla vērtībām: patiess un nepatiess. Salīdzināšanas operatori, piemēram, == , === ,< , >, atgriezt patiesu vai nepatiesu .

Būla izteiksmes tiek izmantotas priekšrakstos, piemēram, ja un kamēr, lai palīdzētu kontrolēt programmas plūsmu.

Jāņem vērā, ka gadījumos, kad tiek gaidīta vērtība patiesa vai nepatiesa, varat izmantot citas vērtības, kuras valoda automātiski novērtē kā patiesu (patiesība) vai nepatiesu (falsy).

Precīzāk, šādas ir nepatiesas vērtības:

0 -0 NaN undefined null "" //tukša virkne
Atlikušās vērtības ir patiesas.

Nulles tipa JavaScript ir īpaša vērtība null , kas norāda uz vērtības neesamību. Līdzīgas vērtības tiek izmantotas arī citās valodās. Type undefined Vērtība undefined, kas rakstīta noteiktam mainīgajam, norāda, ka šis mainīgais nav inicializēts un tam nav vērtības.

Šī vērtība tiek automātiski atgriezta no funkcijām, kuru rezultāti netiek tieši atgriezti, izmantojot atgriešanas atslēgvārdu. Ja funkcija izmanto parametru, kas nav norādīts, kad tā tiek izsaukta, tā tiek iestatīta arī uz undefined .

Lai pārbaudītu undefined vērtību, varat izmantot šādu konstrukciju.

Mainīgā veids === "nenodefinēts"

▍Objekti Visas neprimitīvās vērtības ir objekta tipa. Mēs runājam par funkcijām, masīviem, ko mēs saucam par "objektiem" un daudzām citām entītijām. Visi šie datu tipi ir balstīti uz objekta tipu, un, lai gan tie daudzējādā ziņā atšķiras viens no otra, tiem ir arī daudz kopīga Izteiksmes Izteiksmes ir koda daļas, kuras var apstrādāt un iegūt noteiktu vērtību, pamatojoties uz veiktajiem aprēķiniem . JavaScript ir vairākas izteiksmju kategorijas Aritmētiskās izteiksmes Šajā kategorijā ietilpst izteiksmes, kas tiek novērtētas līdz skaitļiem.

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

Virknes izteiksmes Šādu izteiksmju novērtēšanas rezultāts ir virknes.

"A " + "virkne" "A " += "virkne"

Primārās izteiksmes Šajā kategorijā ietilpst burti, konstantes un atsauces uz identifikatoriem.

2 0.02 "kaut kas" patiess nepatiess šis //izpildes konteksts, atsauce uz pašreizējo objektu undefined i //kur i ir mainīgais vai konstante
Tas ietver arī dažus JavaScript atslēgvārdus un konstrukcijas.

Funkciju klases funkcija* //ieguves ģenerators //komanda apturēt/atsākt ģeneratora ienesīgumu* //deleģēšana citam iteratoram vai ģeneratora asinhronā funkcija* //asinhronā funkcionālā izteiksme gaida //asinhronās funkcijas izpildes gaidīšanas organizācija / modelis /i // regulāra izteiksme() //grupēšana

Masīvu un objektu inicializācijas izteiksmes //masīva literāls () //objektu literāls (a: 1, b: 2) (a: (b: 1)) Loģiskās izteiksmes Loģisko izteiksmju izmantošana loģiskie operatori, to aprēķina rezultāts ir loģiskās vērtības.

A && b a || ba

Rekvizītu piekļuves izteiksmes Šīs izteiksmes ļauj piekļūt objektu rekvizītiem un metodēm.

Object.property //objekta objekta rekvizīta (vai metodes) izsaukšana objekts["īpašums"]

Objekta izveides izteiksmes jauns objekts() jauns a(1) jauns MyRectangle("nosaukums", 2, (a: 4)) Funkciju deklarācijas izteiksmes function() () function(a, b) ( return a * b ) (a, b) => a * b a => a * 2 () => ( return 2 ) Izsaukšanas izteiksmes Šādas izteiksmes tiek izmantotas, lai izsauktu objektu funkcijas vai metodes.

A.x(2) window.resize()

Darbs ar objektiem Mēs jau esam saskārušies ar objektiem iepriekš, runājot par objektu literāļiem, izsaucot to metodes un piekļūstot to īpašībām. Šeit mēs runāsim par objektiem sīkāk, jo īpaši, apskatīsim prototipiskās mantošanas mehānismu un klases atslēgvārda izmantošanu.▍Prototipiskā mantošana JavaScript izceļas starp mūsdienu programmēšanas valodām ar to, ka atbalsta prototipu pārmantošanu . Lielākā daļa objektu orientēto valodu izmanto uz klasi balstītu mantojuma modeli.

Katram JavaScript objektam ir īpašs īpašums (__proto__), kas norāda uz citu objektu, kas ir tā prototips. Objekts pārmanto prototipa īpašības un metodes.

Pieņemsim, ka mums ir objekts, kas izveidots, izmantojot objekta literālu.

Const auto = ()
Vai arī mēs izveidojām objektu, izmantojot objektu konstruktoru.

Const auto = jauns objekts()
Jebkurā no šiem gadījumiem automašīnas objekta prototips būs Object.prototype .

Ja izveidojat masīvu, kas ir arī objekts, tā prototips būs objekts Array.prototype.

Const saraksts = //vai tā const saraksts = new Array()
To var pārbaudīt šādi.

Auto.__proto__ == Object.prototype //true car.__proto__ == new Object().__proto__ //true list.__proto__ == Object.prototype //false list.__proto__ == Masīvs.prototips //true list.__proto__ == jauns masīvs().__proto__ //true
Šeit mēs izmantojām rekvizītu __proto__; tam nav jābūt pieejamam izstrādātājam, taču parasti tam var piekļūt. Jāpiebilst, ka vairāk uzticamā veidā lai iegūtu objekta prototipu, ir jāizmanto globālā metode getPrototypeOf() Objekts.

Object.getPrototypeOf(new Object())
Visas prototipa īpašības un metodes ir pieejamas objektam, kuram ir šis prototips. Piemēram, šeit ir redzams, kā viņu saraksts izskatās masīvam.

Masīva mājiens

Visu objektu bāzes prototips ir Object.prototype.

Array.prototype.__proto__ == Object.prototype
Objektam Object.prototype nav prototipa.

Tas, ko mēs redzējām iepriekš, ir prototipa ķēdes piemērs.

Mēģinot piekļūt objekta rekvizītam vai metodei, ja pašam objektam šādas īpašības vai metodes nav, to meklēšana tiek veikta tā prototipā, pēc tam prototipa prototipā un tā tālāk, līdz tiek atrasta vēlamā īpašība, vai līdz prototipu ķēde nebeigsies.

Papildus objektu izveidei, izmantojot jauno operatoru un objektu vai masīvu literāļus, varat izveidot objekta gadījumu, izmantojot metodi Object.create(). Pirmais arguments, kas tiek nodots šai metodei, ir objekts, kas būs tā izveidotā objekta prototips.

Const auto = Object.create (Object.prototype)
Varat pārbaudīt, vai objekts ir daļa no cita objekta prototipu ķēdes, izmantojot metodi isPrototypeOf().

Const saraksts = Array.prototype.isPrototypeOf(saraksts)

Konstruktora funkcijas Iepriekš mēs izveidojām jaunus objektus, izmantojot valodā jau pieejamās konstruktora funkcijas (tos izsaucot tiek lietots atslēgvārds new). Šādas funkcijas varat izveidot pats. Apskatīsim piemēru.

Funkcija Persona(vārds) ( this.name = vārds ) Person.prototype.hello = funkcija() ( console.log(this.name) ) let person = new Person("Flavio") person.hello() console.log( Person.prototype.isPrototypeOf(person))
Šeit mēs izveidojam konstruktora funkciju. Kad tiek izsaukts, tas tiek izveidots jauns objekts, ko norāda atslēga vārds šis konstruktora korpusā. Mēs pievienojam šim objektam rekvizītu name un ierakstām tam to, kas tika nodots konstruktoram. Šis objekts tiek automātiski atgriezts no konstruktora. Izmantojot konstruktora funkciju, varat izveidot daudzus objektus, kuru nosaukuma rekvizīti saturēs to, kas tika nodots konstruktoram, kad tie tika izveidoti.

Pēc konstruktora izveidošanas tā prototipam pievienojam funkciju, kas uz konsole izdrukās ar šo funkciju izveidotā objekta name rekvizīta vērtību. Visiem objektiem, kas izveidoti, izmantojot šo konstruktoru, būs viens un tas pats prototips, un tāpēc tie izmantos to pašu hello() funkciju. To var viegli pārbaudīt, izveidojot citu Person tipa objektu un salīdzinot tā funkciju hello() ar piemērā jau esošā objekta funkciju (šajā gadījumā funkcijas nosaukums tiek rakstīts bez iekavām).

▍Klases ES6 standartā JavaScript ieviesa “klases” jēdzienu.

Iepriekš JavaScript varēja izmantot tikai iepriekš aprakstīto prototipa mantojuma mehānismu. Šis mehānisms izskatījās neparasts programmētājiem, kuri ieradās JS no citām valodām. Tāpēc valodā parādījās klases, kas būtībā ir “sintaktiskais cukurs” prototipa mantojuma mehānismam. Tas ir, izveidotie objekti tradicionālā veidā, un objektiem, kas izveidoti, izmantojot klases, ir prototipi.

Klases deklarācija Šādi izskatās klases deklarācija.

Klases Persona ( konstruktors(vārds) ( this.name = name ) hello() ( atgriež "Sveiks, es esmu " + this.name + "." ) )
Klasei ir identifikators, ko var izmantot, lai izveidotu jaunus objektus, izmantojot jauno ClassIdentifier() konstrukciju.

Kad tiek izveidots jauns objekts, tiek izsaukta konstruktora metode un tam tiek nodoti parametri.

Jūs varat deklarēt metodes klasē. Mūsu gadījumā hello () ir metode, kuru var izsaukt visi objekti, kas izveidoti, pamatojoties uz klasi. Šādi izskatās jauna objekta izveide, izmantojot Personas klasi.

Const flavio = jauna persona ("Flavio") flavio.hello()

Uz klasēm balstītas mantojuma klases var paplašināt citas klases. No šādām klasēm izveidotie objekti pārmantos gan sākotnējās klases metodes, gan paplašinātajā klasē norādītās metodes.

Ja klasei, kas paplašina citu klasi (šīs klases apakšklasi), ir metode, kuras nosaukums ir tāds pats kā vecākklasei, šī metode ir prioritāra pār sākotnējo.

Klases programmētājs paplašina Personu ( sveiks() ( return super.hello() + " Es esmu programmētājs." ) ) const flavio = new Programmer("Flavio") flavio.hello()
Iepriekš minētajā piemērā izsaucot metodi hello(), tiks atgriezta virkne Sveiki, es esmu Flavio. Es esmu programmētājs.

Klases neparedz mainīgo (īpašību) klātbūtni, objektu īpašības, kas izveidotas, izmantojot klases, ir jākonfigurē konstruktorā.

Klasē varat piekļūt vecākajai klasei, izmantojot super atslēgvārdu.

Statiskās metodes Klasē aprakstītās metodes var izsaukt, piekļūstot objektiem, kas izveidoti no klases, bet ne pašai klasei. Statiskās metodes var izsaukt, tieši piekļūstot klasei Privātās metodes JavaScript nav iebūvēta mehānisma, kas ļauj deklarēt privātās metodes. Šo ierobežojumu var pārvarēt, piemēram, izmantojot aizvērumus Getteri un iestatītāji Jūs varat definēt metodes klasē, pievienojot tām prefiksus ar get vai set atslēgvārdiem. Tas ļauj izveidot tā sauktos getters un setters - funkcijas, kas tiek izmantotas, lai kontrolētu piekļuvi to objektu īpašībām, kas izveidoti, pamatojoties uz klasi. Getter tiek izsaukts, kad mēģināt nolasīt pseidoīpašuma vērtību, un iestatītājs tiek izsaukts, kad mēģināt tam ierakstīt jaunu vērtību.

Klases persona (konstruktors(nosaukums) ( this.userName = name ) set name(value) (this.userName = value ) get name() (atgriezt šo.lietotājaVārds ))

Kopsavilkums Šajā materiālā mēs runājām par mainīgajiem, datu tipiem, izteiksmēm un darbu ar objektiem JavaScript. Mūsu nākamā materiāla tēma būs funkcijas.

Cienījamie lasītāji! Ja raksti JS jau ilgu laiku, lūdzu, pastāsti, kā jūties par klases atslēgvārda parādīšanos valodā.

Šajā apmācībā iepazīstināsim ar ļoti svarīgu jēdzienu – JavaScript datu tipiem. Mēs iesakām pievērst īpašu uzmanību šim jēdzienam - ja jūs to nesaprotat no paša sākuma, tad bieži nāksies saskarties ar dīvainu jūsu izveidotās programmas uzvedību.

Dinamiskā rakstīšana

Notiek datorprogrammas manipulēt ar dažādām vērtībām, no kurām katru var apstrādāt programmēšanas valodā un kas pieder noteiktam datu tipam.

Programmā JavaScript datu tipus var iedalīt divās kategorijās: vienkāršie (saukti arī par primitīviem) un saliktajiem (saukti arī par atsauci vai objektu).

JavaScript ir vāji drukāta vai dinamiska programmēšanas valoda, kas programmas izpildes laikā ļauj definēt, parsēt un apkopot datu tipus. Tas nozīmē, ka jums nav iepriekš jādefinē mainīgā veids. Tips tiks noteikts automātiski programmas izpildes laikā.
Tādējādi dažādās programmas daļās viens un tas pats mainīgais var iegūt dažāda veida vērtības:

Datu veidi

ECMAScript® standarts nosaka šādus datu tipus:

• Vienkārši (saukti arī par primitīviem) veidi:
  • Būla — var izmantot divas iespējamās vērtības, ko dažreiz sauc par patiesu un nepatiesu;
  • null – vērtība null ir atsauce, kas parasti tīši norāda uz neesošu vai nepareizu objektu vai adresi;
  • undefined – apzīmē iepriekš definētu globālo mainīgo, kas inicializēts ar nenoteiktu vērtību;
  • numeric (English Number) – ciparu datu tips 64 bitu dubultās precizitātes peldošā komata skaitļa formātā;
  • virkne (angļu valodā String) – ir rakstzīmju secība, ko izmanto teksta attēlošanai;
  • simbols (eng. Symbol) ir datu tips, kura gadījumi ir unikāli un nemainīgi. (jaunums ECMAScript 6).
• Objekts ir nosauktu vērtību kopums, ko parasti sauc par objekta īpašībām.

Atšķirība starp primitīvajiem un saliktajiem veidiem

Pirms aplūkojam katru datu tipu, vispirms iepazīsimies ar operatora veidu. Operators typeof atgriež virkni, kas apraksta mainīgā datu tipu.
Parādīsim, kā tas darbojas, izmantojot šādu piemēru:

Piemēra skripts deklarē mainīgos, inicializē tos (piešķir vērtības) un pēc tam izdrukā katra mainīgā veidu.

Atšķirība starp primitīvajiem un saliktajiem datu tipiem rodas, kad tiek kopētas to vērtības.

Ja mainīgajam tiek piešķirta vienkārša veida vērtība, mainīgajam tiek ierakstīta pati vērtība (piemēram, skaitlis). Kad mēs piešķiram citam vienkārša tipa mainīgo, tas kopē vērtību. Rezultātā katram mainīgajam būs sava vērtība, un izmaiņas vienā no mainīgajiem nekādā veidā neietekmēs otra mainīgā vērtību:

Kad mainīgajam piešķiram saliktā (atsauces) tipa vērtību, mainīgajam tiek ierakstīta atsauce uz vērtību (atsauce uz objektu). Kad mēs piešķiram vienu mainīgo (kura vērtība satur atsauci uz saliktu vērtību) citam mainīgajam, atsauce uz salikto vērtību tiek kopēta. Rezultātā abi mainīgie attiecas uz vienu un to pašu salikto vērtību, un viena mainīgā vērtības izmaiņas ietekmēs otru mainīgo:

Primitīvie tipi

Visi JavaScript datu tipi, izņemot objektus, ir nemainīgi vai nemainīgi. Tas nozīmē, ka to vērtības nevar mainīt, bet tikai pārrakstīt ar jaunu, atšķirīgu vērtību. Piemēram, virknes nevar pielāgot rakstzīmei pēc rakstzīmes - tās var tikai pilnībā pārrakstīt. Šādu veidu vērtības sauc par "primitīvām".

Vienkāršākos datus, ar kuriem programma var darboties, sauc par literāļiem. Literāļi ir skaitļi vai virknes, ko izmanto, lai attēlotu vērtības JavaScript. Sniegtā informācija var būt ļoti dažāda, un tāpēc to nozīme atšķiras dažādi veidi. Vienkāršākos JavaScript datu tipus sauc par pamata datu tipiem: cipariem, virknēm un Būla vērtībām. Visi no tiem ir klasificēti kā "primitīvi".

Būla (loģiskais) veids “būla”

Loģiskajām jeb Būla vērtībām (pēc to izgudrotāja vārda - Būla) var būt tikai viena no divām vērtībām: patiesa (patiesa) vai nepatiesa (nepatiesa). Vērtības patiesas vai false parasti parādās salīdzināšanā vai loģiskās operācijās.

Šī programma izveido Būla mainīgo un pēc tam pārbauda tā vērtību, izmantojot if/else priekšrakstu:

Jebkuru izteiksmi var izmantot kā salīdzinošu izteiksmi. Jebkura izteiksme, kas atgriež 0, nulli, nedefinētu vai tukšu virkni, tiek interpretēta kā nepatiesa . Izteiksme, kas norāda jebkuru citu vērtību, tiek interpretēta kā patiesa.

Piezīme. Rakstot Būla vērtības, tās netiek liktas pēdiņās: var myVar = true;
Tajā pašā laikā, deklarējot var myVar = "true", tiek izveidots virknes mainīgais.

Skaitļa datu tips

Programmā JavaScript nav atšķirības starp veselu skaitli un peldošā komata skaitli — būtībā JavaScript attēlo visus skaitļus kā peldošā komata vērtību.

JavaScript izmanto 64 bitu formātu, ko nosaka IEEE-754 standarts, lai attēlotu skaitļus. Šis formāts spēj attēlot skaitļus diapazonā no ±1,7976931348623157 × 10308 līdz ±5 × 10 -324.

Skaitli, kas atrodams tieši programmas kodā, sauc par ciparu literālu. Papildus decimālskaitļu literāļiem JavaScript atpazīst heksadecimālās vērtības.
Heksadecimālie skaitļi var ietvert jebkuru ciparu secību no 0 līdz 9 un burtus no a līdz f, kam jāsākas ar rakstzīmju secību "0x".

Var a = 255; var b = 0xFF; // Skaitlis 255 heksadecimālajā apzīmējumā

Turklāt JavaScript satur īpašas skaitliskas vērtības:

• NaN (nevis skaitlis vai aprēķina kļūda). Tas ir nepareizas matemātiskas darbības rezultāts ar nederīgiem datiem, piemēram, virknēm vai nenoteiktu vērtību.
• Bezgalība (pozitīvā bezgalība). Izmanto, ja pozitīvs skaitlis ir pārāk liels, lai to attēlotu JavaScript.
• -Bezgalība (negatīvā bezgalība). Izmanto, ja negatīvs skaitlis ir pārāk liels, lai to attēlotu JavaScript.
• ±0 (pozitīvs un negatīvs 0). JavaScript atšķir pozitīvo un negatīvo nulli.

Virknes datu tips

Virknes veids ir nemainīga, sakārtota 16 bitu vērtību secība, no kurām katra apzīmē unikoda rakstzīmi (burtus, ciparus, pieturzīmes, īpašās rakstzīmes un atstarpes). Rindas var būt tukšas vai sastāvēt no vienas vai vairākām rakstzīmēm. Virknes tiek izveidotas, izmantojot dubultās (") vai vienas (") pēdiņas. Virknē, kas atdalīta ar vienpēdiņu pāri, var izmantot dubultpēdiņas, un otrādi, vienpēdiņas var izmantot virknē, ko ietver dubultpēdiņu pāris.

Programmā JavaScript nav atšķirības starp dubultpēdiņām un vienpēdiņām, taču pēdiņām virknes sākumā un beigās nevajadzētu atšķirties. Piemēram, šāda izteiksme izraisītu sintakses kļūdu:

var firstName = "Max"; //sintakses kļūda - dažādas pēdiņas

Piezīme. JavaScript nav īpaša vienas rakstzīmes datu veida, piemēram, char C, C++ un Java. Viena rakstzīme tiek attēlota ar vienības garuma virkni.

Null datu tips Nulles tips satur vienu īpašu vērtību — null.

Nulles atslēgvārdu nevar izmantot kā funkcijas vai mainīgā nosaukumu. Vērtība null ir atsauce uz "tukšu" objektu, un tai ir īpašs mērķis — to parasti izmanto, lai inicializētu mainīgo, kam vēlāk tiks piešķirta vērtība.

Operators typeof nulles vērtībai atgriež virkni "objekts", norādot, ka nulles vērtība ir īpašs "tukšs" objekts.

Nedefinēts datu tips

Nedefinēts tips veido savu tipu, kas satur vienu īpašu vērtību - undefined. Šī ir mainīgā vērtība, kas deklarēta, izmantojot operatoru var, bet nav inicializēta:

Vērtība undefined tiek atgriezta, piekļūstot mainīgajam, kuram nekad nav piešķirta vērtība, neesošam objekta rekvizītam vai masīva elementam.

Jāņem vērā, ka mainīgais ar nenoteiktu vērtību atšķiras no mainīgā, kas vispār nav definēts:

Šajā piemērā alert() metode parāda vecuma mainīgā vērtību, kas nav definēta. Otrajā gadījumā nedeklarēts automašīnas mainīgais tiek nodots alert() metodei, kas izraisa kļūdu.

Šis piemērs var būt nedaudz mulsinošs iesācēju programmētājiem, jo... Operatora tips atgriež nedefinētu gan inicializētam, gan nedeklarētam mainīgajam:

Iepriekš minētajā piemērā mainīgais vecums ir deklarēts, bet tam nekas nav rakstīts, tāpēc tā vērtība ir tikai undefined . Automašīnas mainīgais nav deklarēts - patiesībā tas neeksistē. Tomēr typeof abos gadījumos atgriež virkni nenoteiktu. Tam, protams, ir zināma jēga, jo nav iespējams veikt nekādas darbības ar kādu no šiem mainīgajiem, lai gan tehniski tie ir pilnīgi atšķirīgi.

Piezīme. Ieteicams vienmēr inicializēt deklarēto mainīgo. Šajā gadījumā jūs zināt, ka operatora tips atgriež nedefinētu, jo mainīgais nav deklarēts, nevis tāpēc, ka tas nebija inicializēts.

Vērtība undefined ir atvasināta no nulles , tāpēc ECMA-262 == ekvivalences operators tos uzskata par vienādiem:

Lai gan null un undefined ir saistīti, tie tiek izmantoti atšķirīgi. Mainīgajam nevajadzētu tieši piešķirt vērtību undefined, taču tas neattiecas uz nulli. Ja nepieciešamais objekts nav pieejams, tā vietā jāizmanto null. Tas norāda, ka null tika ieviests kā rādītājs uz tukšu objektu, un uzsver tā atšķirību no undefined .

Lai programmā atšķirtu nulli no undefined, varat izmantot identitātes operatoru === :

Datu tips Simbols

Simbols ir jauns JavaScript papildinājums kopš ECMAScript 6. versijas. Simbols ir unikāla, nemainīga, primitīva vērtība, ko izmanto, lai izveidotu unikālus identifikatorus.

Lai izveidotu simbolu, jāizsauc funkcija Symbol:

var mySymbol = Simbols();

Lai definētu simbolu, varat izmantot operatora tipu; ja vērtība ir simbols, tiks atgriezts virknes simbols:

Funkcijai Simbols ir neobligāts parametrs — virkne, kas kalpo simbola aprakstīšanai:

Rekvizīta nosaukums ir virkne, tāpēc var uzskatīt, ka objekti virknes saista ar vērtībām. Kopā šīs informācijas daļas veido atslēgu un vērtību pārus.

IN JavaScript objekti var izveidot, izmantojot vienu no divām sintaksēm:

1. var obj = (); // izmantojot objektu literālu 2. var obj = new Object(); // izmantojot metodi, ko sauc par konstruktoru

Objekta izveide, izmantojot objekta literālu, sākas ar regulāra mainīgā definēšanu. Šī paziņojuma labajā pusē objekts tiek rakstīts burtiski — tas ir ar komatu atdalīts pāru saraksts, kas ietverts cirtainajās iekavās (). "nosaukums-vērtība", kas ietverts cirtainos lencēs. Īpašuma nosaukums un vērtība ir atdalīti ar kolu:

var cat = ( "kājas": 4, "nosaukums": "Murzik", "krāsa": "sarkans")

Otrs veids, kā izveidot objektus, ir Object() konstruktora izmantošana. Šajā gadījumā vispirms tiek izmantota jaunā Object() izteiksme, un pēc tam tiek definēti un inicializēti iegūtā objekta rekvizīti:

Kad mēs piešķiram vienu mainīgo (kura vērtība satur atsauci uz saliktu vērtību) citam mainīgajam, atsauce uz salikto vērtību tiek kopēta. Rezultātā abi mainīgie attiecas uz vienu un to pašu salikto vērtību, un viena mainīgā vērtības izmaiņas ietekmēs otru mainīgo.

Jebkura izteiksme, kas atgriež 0, nulli, nedefinētu vai tukšu virkni, tiek interpretēta kā nepatiesa .

Virknes tiek izveidotas, izmantojot dubultās (") vai vienas (") pēdiņas. Virknē, kas atdalīta ar vienpēdiņu pāri, var izmantot dubultpēdiņas, un otrādi, vienpēdiņas var izmantot virknē, ko ietver dubultpēdiņu pāris.

Vērtība null ir atsauce uz "tukšu" objektu, un tai ir īpašs mērķis — to parasti izmanto, lai inicializētu mainīgo, kam vēlāk tiks piešķirta vērtība.

Vērtība (nenodefinēta) ir mainīgais, kas deklarēts, izmantojot operatoru var, bet nav inicializēts.

Programmā JavaScript objektus var izveidot vienā no diviem veidiem:

• izmantojot objektu literālu
• izmantojot metodi, ko sauc par konstruktoru

Objekts satur nesakārtotu rekvizītu kopumu, no kuriem katrs satur nosaukumu un vērtību. Varat jebkurā laikā objektam pievienot jaunas nosauktās vērtības vai noņemt esošās.