Js kintamųjų deklaracija. Kintamieji, apimtis ir kintamųjų pakėlimas JavaScript

Kintamieji yra pagrindinė daugelio programavimo kalbų sudedamoji dalis; jie yra viena iš svarbiausių sąvokų naujiems programuotojams. „JavaScript“ yra daug skirtingų kintamųjų savybių, taip pat kelios taisyklės, kurių reikia laikytis suteikdami jiems pavadinimus. „JavaScript“ turi tris raktinius žodžius, naudojamus kintamajam deklaruoti – var, let ir const – ir kiekvienas iš jų turi įtakos tai, kaip kintamasis bus interpretuojamas kode.

Ši pamoka supažindins su kintamaisiais, išmokys juos deklaruoti ir pavadinti, taip pat paaiškins skirtumą tarp var, let ir const. Be to, sužinosite, kas yra kintamasis pakėlimas ir kaip apimtis veikia kintamojo elgesį.

Kintamasis yra pavadinta atminties dalis, naudojama skirtingoms reikšmėms saugoti. Informacijos dalis, kurią galima nurodyti kelis kartus, gali būti saugoma kintamajame, kad būtų galima vėliau naudoti ar modifikuoti. „JavaScript“ kintamajame esanti reikšmė gali būti bet kokio tipo duomenų, įskaitant skaičių, eilutę arba objektą.

Prieš ECMAScript 2015 (ES6) kalbos specifikaciją, kuria pagrįsta „JavaScript“. šiuo metu, buvo tik vienas būdas deklaruoti kintamąjį – naudojant raktinį žodį var. Štai kodėl dauguma senų kodų ir vadovų naudoja tik var kintamiesiems deklaruoti. Pažvelkime į skirtumus tarp var, let ir const.

Var raktinis žodis leidžia parodyti paties kintamojo sampratą. Toliau pateiktame pavyzdyje deklaruojame kintamąjį ir priskiriame jam reikšmę.

// Priskirkite eilutės reikšmę 8host vartotojo vardo identifikatoriui
var vartotojo vardas = "8host_blog";

Ši išraiška susideda iš kelių dalių:

• Kintamojo deklaravimas naudojant var raktažodį;
• Kintamojo pavadinimas (arba identifikatorius), vartotojo vardas;
• Priskyrimo operatorius, pavaizduotas sintaksės =;
• Priskirta reikšmė yra „8host_blog“.

Dabar savo kode galite naudoti vartotojo vardo kintamąjį. „JavaScript“ atsimins, kad vartotojo vardas reiškia reikšmę 8host_blog.

// Patikrinkite, ar kintamasis yra lygus vertei
if (naudotojo vardas === "8host_blog") (
console.log(true);
}
tiesa

Kaip minėta anksčiau, kintamieji gali būti išreikšti bet kuriuo JavaScript duomenų tipu. Šiame pavyzdyje kintamieji išreiškiami kaip eilutė, skaičius, objektas, loginis ir nulis.

// Įvairių kintamųjų priskyrimas
var name = "Morty";
var spartans = 300;
var karalystės = [ "žinduoliai", "paukščiai", "žuvys" ];
var eilėraštis = (rožės: "raudona", žibuoklės: "mėlyna" );
var sėkmės = tiesa;
var nieko = null;

Naudodami console.log galite peržiūrėti bet kurio kintamojo reikšmę:

// Siųsti spartans kintamąjį į konsolę
console.log(spartans);
300

Kintamieji atmintyje saugo duomenis, kuriuos vėliau galima naudoti arba pakeisti. Kintamieji taip pat gali būti priskirti iš naujo ir jiems suteikiama nauja reikšmė. Toliau pateiktame paprastame pavyzdyje parodyta, kaip slaptažodis gali būti saugomas ir atnaujinamas kintamajame.

// Priskirkite reikšmę slaptažodžio kintamajam
var slaptažodis = "hunter2";
// Pakartotinai priskirkite kintamojo reikšmę nauja reikšme
slaptažodis = "medžiotojas3";
console.log(slaptažodis);
"medžiotojas3"

IN tikra programa Slaptažodis greičiausiai bus saugiai saugomas duomenų bazėje. Tačiau šis paprastas pavyzdys iliustruoja situaciją, kai galbūt norėsite atnaujinti kintamojo reikšmę. Slaptažodžio kintamojo reikšmė buvo hunter2, tačiau jam buvo suteikta nauja reikšmė hunter3, o JavaScript dabar naudos naują reikšmę.

„JavaScript“ kintamųjų pavadinimai vadinami identifikatoriais. Vadove rasite keletą identifikatorių pavadinimo taisyklių. Štai jie trumpai:

• Kintamųjų pavadinimus gali sudaryti tik raidės, skaičiai (0–9), dolerio ženklas ($) ir pabraukimas (_).
• Kintamųjų pavadinimuose negali būti tarpų simbolių.
• Kintamojo pavadinimas neturi prasidėti skaičiumi.
• Yra keletas rezervuotų raktinių žodžių, kurių negalima naudoti kaip kintamųjų.
• Kintamųjų pavadinimuose skiriamos didžiosios ir mažosios raidės.

„JavaScript“ taip pat turi konvenciją naudoti kupranugarių didžiąsias ir mažąsias raides funkcijų ir kintamųjų pavadinimuose, deklaruojamuose su var arba let. Tokiu atveju pirmasis žodis rašomas mažosiomis raidėmis, o kiekvienas paskesnis žodis prasideda didžiąja raide (žodžiai rašomi be tarpų tarp jų). Dauguma kintamųjų, kurie nėra konstantos, laikysis šios nuostatos, išskyrus keletą išimčių. Kintamųjų pavadinimai, kurie yra konstantos (deklaruojami su const raktiniu žodžiu), paprastai įrašomi didžiosiomis raidėmis.

Atrodo, kad taisyklių yra gana daug, bet taip atrodo tik iš pirmo žvilgsnio. Dažnai dirbdami su „JavaScript“ greitai juos prisiminsite.

„JavaScript“ naudoja tris skirtingus raktinius žodžius kintamiesiems deklaruoti, o tai suteikia papildomo sudėtingumo. Šie raktiniai žodžiai skiriasi kintama apimtimi, kėlimu ir perskirstymu.

Jums gali kilti klausimas, kuriuos iš trijų raktinių žodžių turėtumėte naudoti savo programose. Įprasta naudoti const kuo dažniau ir įleisti kilpas bei perskirstyti. Paprastai var yra naudojamas sename kode.

„JavaScript“ apimtis reiškia dabartinį kodo kontekstą, kuris nustato, ar kintamieji yra pasiekiami. Teritorija gali būti vietinė arba pasaulinė:

• Globalūs kintamieji yra tie, kurie deklaruojami už bloko ribų.
• Vietiniai kintamieji yra tie, kurie deklaruojami bloko viduje.

Toliau pateiktame pavyzdyje sukursime visuotinį kintamąjį.

var būtybė = "vilkas";

Jūs žinote, kad kintamuosius galima priskirti iš naujo. Vietinėje srityje galite sukurti naujus kintamuosius tuo pačiu pavadinimu kaip ir išorinės apimties kintamieji nekeisdami ar nepaisydami pradinės reikšmės.

Toliau pateiktame pavyzdyje sukuriama visuotinė kintamųjų rūšis. Funkcijos viduje yra vietinis kintamasis tuo pačiu pavadinimu. Kai juos nusiųsite į konsolę, pamatysite, kad kintamojo reikšmė skiriasi priklausomai nuo apimties, tačiau pradinė reikšmė nesikeičia.

// Inicijuoti visuotinį kintamąjį
var rūšis = "žmogus";
funkcija transform() (
// Inicijuoti vietinį, funkcijų apimties kintamąjį
var rūšis = "vilkolakis";
console.log(rūšis);
}
// Užregistruokite globalius ir vietinius kintamuosius
console.log(rūšis);
transformuoti ();
console.log(rūšis);
žmogaus
vilkolakis
žmogaus

Šiame pavyzdyje vietinis kintamasis turi funkcijos lygio apimtį. Kintamieji, deklaruoti naudojant raktinį žodį var, visada yra toje srityje (ty jie atpažįsta funkcijas kaip turinčias atskirą sritį). Taigi vietinis kintamasis nėra pasiekiamas pasaulinėje srityje.

Tačiau nauji raktiniai žodžiai let ir const yra taikomi bloko lygiu. Tai reiškia, kad nauja vietinė sritis sukuriama iš bet kurio bloko, įskaitant funkcinius blokus, if sakinius ir kilpoms ir kol.

Norėdami parodyti skirtumą tarp funkcijos lygio ir bloko lygio kintamųjų, sukurkite naują kintamąjį if bloke naudodami let.

var pilnatis = tiesa;
// Inicijuoti visuotinį kintamąjį
tegul rūšis = "žmogus";
jei (pilnatis) (
// Inicijuoti bloko apimties kintamąjį
tegul rūšis = "vilkolakis";

}


Tai ne pilnatis. Lubinas šiuo metu yra žmogus.

Šiame pavyzdyje kintamoji rūšis turi vieną pasaulinę reikšmę (žmogus) ir vieną vietinę reikšmę (vilkolakis). Tačiau jei naudosite var, rezultatas bus kitoks.

// Naudokite var kintamajam inicijuoti
var rūšis = "žmogus";
jei (pilnatis) (
// Bandymas sukurti naują kintamąjį bloke
var rūšis = "vilkolakis";
console.log(`Tai pilnatis. Lubinai šiuo metu yra $(rūšis).`);
}
console.log(`Tai ne pilnatis. Lubinai šiuo metu yra $(rūšis).`);
Tai pilnatis. Lubinas šiuo metu yra vilkolakis.
Tai ne pilnatis. Lubinas šiuo metu yra vilkolakis.

Dėl to ir pasaulinis kintamasis, ir bloko lygio kintamasis sukuria tą pačią reikšmę – vilkolakis. Taip yra todėl, kad užuot sukūręs naują vietinį kintamąjį, var iš naujo priskiria tą patį kintamąjį toje pačioje srityje. var nesupranta, kad jei turėtų būti kitos, naujos apimties dalis. Paprastai rekomenduojama kintamuosius deklaruoti bloko lygiu, nes tai sumažina netyčinio kintamųjų verčių nepaisymo riziką.

Daugumoje iki šiol pateiktų pavyzdžių buvo naudojamas raktinis žodis var kintamajam deklaruoti ir kintamajam inicijuoti reikšme. Kai paskelbiama ir inicijuojama, reikšmę galima pasiekti arba ją iš naujo priskirti.

Jei bandysite naudoti kintamąjį prieš jo paskelbimą ir inicijavimą, rezultatas bus neapibrėžtas.

console.log(x);
// Kintamojo priskyrimas
var x = 100;
neapibrėžtas

Tačiau jei praleisite raktinį žodį var, kintamasis nebus deklaruojamas, o tik inicijuotas. Tai grąžins ReferenceError ir sustabdys scenarijaus vykdymą.

// Bandykite naudoti kintamąjį prieš jį deklaruodami
console.log(x);
// Kintamojo priskyrimas be var
x = 100;
ReferenceError: x neapibrėžtas

Taip yra dėl pakėlimo, „JavaScript“ elgsenos, į kurią perkeliamos kintamųjų ir funkcijų deklaracijos viršutinė dalis jų plotai. Kadangi iškeliama tik tikroji deklaracija, o ne inicijavimas, pirmasis pavyzdys pateikia neapibrėžtą.

Norėdami geriau parodyti šią koncepciją, parašėme šį kodą ir paaiškinome, kaip „JavaScript“ jį nuskaito:

// Mūsų parašytas kodas
console.log(x);
var x = 100;
// Kaip JavaScript jį interpretavo
var x;
console.log(x);
x = 100;

Prieš vykdydamas scenarijų, JavaScript išsaugo x atmintyje kaip kintamąjį. Kadangi kintamasis buvo iškviestas prieš jį apibrėžiant, rezultatas grąžinamas neapibrėžtas, o ne 100. Tačiau tai nesukelia ReferenceError ir nesustabdo scenarijaus. Nors raktinis žodis var iš tikrųjų nepakeitė varo vietos, jis parodo, kaip veikia kėlimas. Toks elgesys gali sukelti problemų, nes programuotojas, parašęs šį kodą, greičiausiai tikisi, kad x išvestis bus teisinga, o ne neapibrėžta.

Pakėlimas taip pat gali sukelti nenuspėjamų rezultatų, kaip parodyta šiame pavyzdyje:

var x = 100;
funkcija liftas() (
// Sąlyga, kuri neturėtų turėti įtakos kodo rezultatui
jei (klaidinga) (
var x = 200;
}
console.log(x);
}
keltuvas ();
neapibrėžtas

Šiame pavyzdyje visuotinis kintamasis x yra 100. Atsižvelgiant į if teiginį, x gali pasikeisti į 200, bet kadangi sąlyga buvo klaidinga, ji neturėtų turėti įtakos x reikšmei. Vietoj to x buvo padidintas prieš paleidžiant liftą () ir reikšmė tapo neapibrėžta.

Šis nenuspėjamas elgesys gali sukelti programos klaidų. Kadangi let ir const yra apibrėžti bloko lygiu, jie nebus pakelti taip, kaip toliau pateiktame pavyzdyje.

// Inicijuoti x visuotinėje srityje
tegul x = tiesa;
funkcija liftas() (
// Inicijuoti x funkcijos srityje
jei (3 === 4) (
tegul x = klaidinga;
}
console.log(x);
}
keltuvas ();
tiesa

Pasikartojančios kintamųjų deklaracijos, kurios galimos naudojant var, sukels klaidą su let ir const.

// Bandymas perrašyti kintamąjį, deklaruotą su var
var x = 1;
var x = 2;
console.log(x);
2
// Bandymas perrašyti kintamąjį, deklaruotą su let
tegul y = 1;
tegul y = 2;
console.log(y);

Nepagauta sintaksės klaida: identifikatorius „y“ jau buvo deklaruotas
Taigi, kintamieji, deklaruoti su var, gali turėti įtakos pakėlimas. Pakėlimas yra „JavaScript“ mechanizmas, kurio atmintyje saugomos kintamųjų deklaracijos. Dėl to kode gali būti neapibrėžtų kintamųjų. Raktiniai žodžiai let ir const išsprendžia šią problemą sukeldami klaidą, jei bandote naudoti kintamąjį prieš jį deklaruodami arba deklaruoti kintamąjį daugiau nei vieną kartą.

Daugelis programavimo kalbų naudoja konstantas, kurios yra reikšmės, kurių negalima pakeisti. Tai reiškia, kad konstantai priskirtų verčių negalima priskirti iš naujo.

Pagal bendrą susitarimą const identifikatoriai rašomi didžiosiomis raidėmis. Tai išskiria juos iš kitų kintamųjų.

Toliau pateiktame pavyzdyje kintamasis SPECIES inicijuojamas kaip konstanta, naudojant raktinį žodį const. Bandant iš naujo priskirti kintamąjį, atsiras klaida.

// Priskirkite reikšmę const
const RŪŠYS = "žmogus";
// Bandymas iš naujo priskirti vertę
RŪŠIS = "vilkolakis";
console.log(SECIES);
Nepagautas tipo klaida: priskyrimas pastoviam kintamajam.

Kadangi const reikšmių negalima priskirti iš naujo, jos turi būti deklaruojamos ir inicijuojamos tuo pačiu metu, kitaip įvyks klaida.

// Deklaruoti, bet neinicijuoti const
const TODO;
console.log(TODO);
Nepagauta sintaksės klaida: Const deklaracijoje trūksta iniciatoriaus

Reikšmės, kurių negalima pakeisti programuojant, vadinamos nekintančiomis, o vertės, kurias galima keisti, vadinamos kintančiomis (akivaizdu). Konstantos reikšmių negalima priskirti iš naujo, tačiau jos yra kintamos, nes gali būti pakeistos su const deklaruotų objektų savybės.

// Sukurkite CAR objektą su dviem savybėmis
const CAR = (
spalva: "mėlyna",
kaina: 15000
}
// Keisti CAR ypatybę
AUTOMOBILIS.kaina = 20000;
console.log(CAR);
( spalva: "mėlyna", kaina: 20000 )

Konstantos leidžia pranešti kitiems programuotojams, dirbantiems su projektu, ir sau pačiam, kad duotas kintamasis neturėtų būti priskirtas iš naujo. Norėdami deklaruoti kintamąjį, kurį galima priskirti iš naujo, turėtumėte naudoti let.

Šiame vadove sužinojote, kas yra kintamasis, susipažinote su kintamųjų įvardijimo taisyklėmis ir išmokote iš naujo priskirti jų reikšmes. Taip pat sužinojote apie kintamą aprėptį ir pakėlimą, raktinio žodžio var apribojimus ir kaip „let and const“ pašalinti šias problemas.

Var teiginys deklaruoja kintamąjį, pasirinktinai inicijuodamas jį į reikšmę.

Šio interaktyvaus pavyzdžio šaltinis yra saugomas „GitHub“ saugykloje. Jei norite prisidėti prie interaktyvių pavyzdžių projekto, klonuokite https://github.com/mdn/interactive-examples ir atsiųskite mums užklausą.

neapibrėžtas

. Aprašymas var deklaracijos, kad ir kur jos būtų, yra apdorojamos prieš vykdant bet kokį kodą. Tai vadinama kėlimu ir toliau aptariama. Kintamojo, deklaruoto su var, apimtis yra jo srovė

Nedeklaruojamam kintamajam priskiriant reikšmę, jis netiesiogiai sukuriamas kaip visuotinis kintamasis (ji tampa visuotinio objekto savybe), kai vykdomas priskyrimas. Skirtumai tarp deklaruotų ir nedeklaruotų kintamųjų yra šie:

1. Deklaruojami kintamieji yra apriboti vykdymo kontekste, kuriame jie deklaruojami. Nedeklaruoti kintamieji visada yra globalūs.

Funkcija x() ( y = 1; // Griežtuoju režimu pateikia nuorodos klaidą. var z = 2; ) x(); console.log(y); // 1 konsolė.log(z); // Išmeta ReferenceError: z neapibrėžtas už x ribų.

2. Deklaruoti kintamieji sukuriami prieš vykdant bet kokį kodą. Nedeklaruoti kintamieji neegzistuoja, kol nevykdomas jiems priskiriamas kodas.

Console.log(a); // "neapibrėžta" arba "" priklausomai nuo naršyklės console.log("vis dar vyksta..."); // vis dar vyksta... var a = 1; console.log(a); // 1 console.log("vis dar vyksta..."); // vis dar vyksta...

3. Deklaruoti kintamieji yra nekonfigūruojama jų vykdymo konteksto (funkcinio arba visuotinio) savybė. Nedeklaruotus kintamuosius galima konfigūruoti (pvz., juos galima ištrinti).

Var a = 1; b = 2; ištrinti tai.a; // Griežtuoju režimu išmeta Type Error. Kitaip tyliai nepavyksta. ištrinti tai.b; console.log(a, b); // Išmeta ReferenceError. // Ypatybė „b“ buvo ištrinta ir nebėra.

Dėl šių trijų skirtumų labai tikėtina, kad kintamųjų nepaskelbimas sukels netikėtų rezultatų. Todėl rekomenduojama visada deklaruoti kintamuosius, neatsižvelgiant į tai, ar jie yra funkcijos ar visuotinės apimties.

var kėlimas

Kadangi kintamųjų deklaracijos (ir deklaracijos apskritai) apdorojamos prieš bet kokio kodo vykdymą, kintamojo deklaravimas bet kurioje kode yra tolygu jo deklaravimui viršuje. Tai taip pat reiškia, kad kintamasis gali būti naudojamas prieš jį paskelbiant. Toks elgesys vadinamas „pakėlimu“, nes atrodo, kad kintamojo deklaracija perkeliama į funkcijos arba visuotinio kodo viršų.

Bla = 2; var bla; // ...netiesiogiai suprantamas kaip: var bla; bla = 2;

Dėl šios priežasties rekomenduojama visada deklaruoti kintamuosius jų apimties viršuje (visuotinio kodo viršuje ir funkcijos kodo viršuje), kad būtų aišku, kurie kintamieji yra priskirti funkcijai (lokaliai), o kurie sprendžiami pagal apimtį. grandine.

Funkcija do_something() ( console.log(bar); // undefined var bar = 111; console.log(bar); // 111 ) // ...netiesiogiai suprantama kaip: function do_something() ( var bar; console .log(bar); // undefined bar = 111.log(bar);

Atkreipkite dėmesį į tvarką:

Var x = y, y = "A"; console.log(x + y); //neapibrėžtaA

Čia x ir y deklaruojami prieš bet kokio kodo vykdymą, tačiau priskyrimai įvyksta vėliau. Tuo metu, kai „x = y“ yra įvertinamas, y egzistuoja, todėl ReferenceError nėra išmestas ir jo reikšmė neapibrėžta. Taigi, x priskiriama neapibrėžta reikšmė. Tada y priskiriama reikšmė "A" . Consequently, after the first line, x === undefined && y === "A" , hence the result.!}

Tas pats pavyzdys, kaip ir aukščiau, bet su griežtu režimu:

„naudokite griežtą“; var x = 0; function f() ( var x = y = 1; // Griežtuoju režimu išmeta nuorodos klaidą. ) f(); console.log(x, y);

Kintamieji, kurie atrodo kaip numanomi globalūs, gali būti nuorodos į išorinės funkcijos apimties kintamuosius:

Var x = 0; // Deklaruoja x failo apimtyje, tada priskiria jam reikšmę 0. console.log(typeof z); // "neapibrėžta", nes z dar neegzistuoja funkcijos a() ( var y = 2; // Deklaruoja y funkcijos a srityje, tada priskiria jai reikšmę 2. console.log(x, y); // 0 2 funkcija b() ( x = 3; // 3 priskiria esamam failui, kurio apimtis x. y = 4; // 4 priskiria esamam išoriniam y. z = 5; // Sukuria naują visuotinį kintamąjį z ir priskiria jai reikšmę 5. // (Meta ReferenceError griežtu režimu.) b() Sukuria z kaip globalinį kintamąjį.log(x, y, z) taip pat iškviečia b console.log(x, z) // 3 5 console.log(y type);

Šiame puslapyje esanti suderinamumo lentelė sukurta iš struktūrinių duomenų. Jei norite prisidėti prie duomenų, apsilankykite https://github.com/mdn/browser-compat-data ir atsiųskite mums užklausą.

Atnaujinkite GitHub suderinamumo duomenis

Dirbdami Javascript galime įvesti skaitinius, eilutes ir loginės reikšmės, tačiau jie veikia, jei programoje yra reikiamos informacijos. Tam buvo sukurti kintamieji, kurie leidžia saugoti įvairaus tipo informaciją ir vaizduoti ją kaip savotišką konteinerį, prie kurio galime bet kada prieiti ir gauti joje esančią informaciją.

Kintamasis kuriamas dviem etapais: deklaruojant kintamąjį ir suteikiant jam pavadinimą.

Pirmiausia turime deklaruoti kintamąjį, ty jį deklaruoti, tai daroma naudojant raktinį žodį var. Toliau rašome instrukciją, tai yra kintamojo pavadinimas, jo pavadinimas yra kaip jį pasieksime, pavyzdžiui, parašysiu dwstv.

Žinoma, kaip pavadinti kintamuosius, priklauso nuo jūsų, tačiau norint, kad „Javascript“ veiktų, reikia laikytis kelių taisyklių:

• pirmoji taisyklė, nenaudokite rezervuotų žodžių. Kai kurie JavaScript kalbos žodžiai yra naudojami pačioje sistemoje, pavyzdžiui, žodis var, kuriuo deklaruojame kintamąjį. Be to, kai kurie žodžiai, pvz., įspėjimas , dokumentas , langas , yra laikomi specialiomis tinklalapio savybėmis. Jei bandysite juos naudoti kaip kintamuosius, gausite klaidos pranešimą. Čia galite pamatyti rezervuotų žodžių sąrašą.
• antroji taisyklė, kintamojo pavadinimas turi prasidėti raide, $ arba _ simboliu. Tai reiškia, kad kintamasis negali prasidėti skaičiumi ar skyrybos ženklu: pavadinimas 1dwstv ir &dwstv neveiks, bet pavadinimai $dwstv ir _dwstv veiks.
• trečioji taisyklė, kintamojo pavadinime gali būti raidžių, skaičių, simbolių $ ir _, o pavadinime negali būti tarpų ar kitų simbolių specialūs ženklai: dws&tv ir dws tv yra neteisingi pavadinimai, tačiau šis formatas yra įmanomas, dws_tv ir dwstv1 arba dws_tv_1 .
• ketvirta taisyklė, kintamųjų pavadinimuose skiriamos didžiosios ir mažosios raidės. „JavaScript“ interpretatorius skirtingai traktuoja mažąsias ir didžiąsias raides, tai yra, DWSTV kintamasis skiriasi nuo kintamojo dwstv, taip pat nuo kintamųjų DwStv ir Dwstv.
• penktoji taisyklė, nerekomenduojama naudoti kitų simbolių, išskyrus lotyniškus kintamuosius, nors jie veiks, negarantuojami ir jų nesupras kolegos iš kitų šalių.

Tai yra penkios pagrindinės taisyklės, kurių rekomenduoju laikytis, be jų norėčiau pasakyti, kad kintamiesiems skirkite aiškius ir išraiškingus pavadinimus. Pavadinkite kintamuosius pagal juose saugomų duomenų tipą, tai padės geriau suprasti, kas parašyta, o pažiūrėjus į tokius kintamuosius bus aišku, apie ką mes kalbame.

Vardindami kintamuosius stenkitės, kad juos būtų lengva skaityti. Jei naudojate kelis žodžius, tarp jų pridėkite apatinį brūkšnį arba kiekvieną žodį po pirmojo pradėkite didžiąja raide. Pavyzdžiui, dwsTv arba dws_tv.

Pamokos pradžioje pažiūrėjome, iš ko susideda kintamasis, dabar, kai žinome, kaip jį sukurti, savo nuožiūra jame galime saugoti bet kokio tipo duomenis.

Norėdami įdėti duomenis į kintamąjį, naudokite ypatingas personažas, lygybės ženklas (=) vadinamas priskyrimo operatoriumi, nes jis naudojamas kintamojo reikšmei priskirti.

Pavyzdžiui, į dwstv kintamąjį įdėkime skaitmeninę reikšmę, abonentų skaičius yra 8500, deklaruokite kintamąjį var dwstv;

o antroje eilutėje įdedame reikšmę dwstv = 8500;

Var dwstv; dwstv = 7200;

Taigi su pirmąja eilute sukūrėme kintamąjį, o su antrąja įrašėme į jį reikšmę. Taip pat galime sukurti kintamąjį ir išsaugoti jame reikšmes naudodami vieną teiginį, pavyzdžiui:

Var dwstv = 7200;

Kintamajame galime saugoti bet kokio tipo duomenis, kuriuos aptarėme ankstesnėse pamokose, tai gali būti skaitinės, eilutės ir loginės reikšmės:

Var dwstv = 7200;var lessons = 'JavaScript'; var youtubeKanal = 'DwsTV'; var abonentai = '7700'; var turinys = tiesa;

Var lessons = 'JavaScript', youtubeKanal = 'DwsTV', prenumeratoriai = '7700', turinys = tiesa;

Išsaugoję reikšmes kintamuosiuose, galime pasiekti šiuos duomenis. Norėdami tai padaryti, tiesiog naudokite paties kintamojo pavadinimą.

Pavyzdžiui, jei norime atidaryti įspėjimo dialogo langą ir parodyti kanalo kintamajame saugomą reikšmę, galime tiesiog įrašyti kintamojo pavadinimą įspėjimo funkcijoje.

Alert(kanalas);

Atkreipkite dėmesį, kad kabučių aplink kintamuosius nededame – jos skirtos tik eilutėms, todėl nerašome alert('kanal'), nes tai suteiktų žodžius kanal, o ne kintamajame saugomą reikšmę.

Dabar manau, kad suprantate, kodėl eilutės turi būti įdėtos į kabutes: JavaScript interpretatorius žodžius be kabučių traktuoja kaip specialius objektus (pavyzdžiui, komanda alert()) arba kaip kintamųjų pavadinimus.

Taip pat yra momentas, kai mes paskelbėme kintamąjį raktiniu žodžiu var ir norime jį pakeisti kintamoji vertė, nebūtina jo dar kartą deklaruoti rašant žodį var , užtenka iškviesti kintamojo pavadinimą ir suteikti jam naują reikšmę.

Prenumeratoriai = '10 000';

Šios pamokos pabaigoje noriu pasakyti, kad mokydamasis bet kokios kalbos, neišmoksi programuoti. Neabejotinai sužinosite ką nors naujo, tačiau greičiausiai jūsų smegenys šios informacijos neprisimins, nes jūs su ja nedirbate. Neįmanoma išmokti kalbos be praktikos, todėl iš šios pamokos gauni nedidelę užduotį, kad pateikta informacija tilptų į tavo mintis ir galėtum su ja dirbti.

Praktinė užduotis:

Sukurkite tris kintamuosius, vienam priskirkite skaitinę reikšmę, antrajam – eilutės reikšmę, o trečiam – loginę reikšmę. Deklaruokite visus kintamuosius naudodami vieną raktinį žodį var ir parodykite juos puslapyje. Tada iš naujo apibrėžkite kintamąjį su skaitinė reikšmė ir parodykite gautą rezultatą naudodami alert() funkciją.

Kito vaizdo įrašo pradžioje apžvelgsime šią užduotį, pasidalinkite savo rezultatais komentaruose, rašykite, jei kas turi klausimų. Jei pamoka patiko ir norite paremti projektą, tiesiog pasidalykite ja socialiniuose tinkluose.

Kitoje pamokoje išsamiai apžvelgsime, kaip dirbti su duomenų tipais ir kintamaisiais, susipažinsime su matematinėmis operacijomis ir jų vykdymo tvarka, taip pat analizuosime eilučių ir skaitinių reikšmių derinimo metodus.

Pamoką parengė Denisas Gorelovas.

Programuotojas nori sukurti visuotinį kintamąjį filmą ir kitą kintamąjį, kuris turi tą patį pavadinimą, bet veikia tik su showBadFilm() funkcija. Kokį pranešimą išves įspėjimas iš funkcijos showGoodFilm()? Koks pranešimas bus rodomas, jei ši funkcija bus iškviesta dar kartą, bet iškvietus funkciją showBadFilm()?

Geras ar blogas filmas?

var film = "Raudonasis viburnum";

funkcija showGoodFilm() ( alert(film + " - geras filmas!"); ) function showBadFilm() ( filmas = "Rugsėjo 11 d."; alert(filmas + " - blogas filmas!"); ) showGoodFilm(); // kas bus rodoma perspėjime?

• showBadFilm(); // kas bus rodoma perspėjime?

  rodytiGeras filmas(); // kas bus rodoma perspėjime?

  Sprendimas:

  var film = "Raudonasis viburnum";

  Atkreipkite dėmesį, kad funkcija showBadFilm() neturi raktinio žodžio var prieš filmo kintamąjį. Todėl „JavaScript“ daro prielaidą, kad norite nepaisyti visuotinio kintamojo reikšmės, o ne sukurti vietinį kintamąjį tuo pačiu pavadinimu. Todėl dar kartą paskambinus showGoodFilm() bus išspausdinta: "Rugsėjo 11-oji yra geras filmas!"

Duomenų tipo tikrinimas

Kokio primityvaus tipo duomenų yra šie kintamieji? Pabandykite atsakyti nepaleidę scenarijaus.

• Tikrinamas duomenų tipas var film = "Red Viburnum";
• var 07_agent = "Agentas";
• var num = 10;

var u = tiesa;

var x;

įspėjimas (filmo tipas); //???

įspėjimas (07_agento tipas); //???

įspėjimas (numerio tipas); //???

įspėjimas (u tipas); //???

įspėjimas (x tipas); //???

Identifikatoriai gali būti trumpi pavadinimai (pvz., x ir y) arba labiau apibūdinantys pavadinimai (amžius, suma, bendras tūris).

Bendrosios taisyklės kintamųjų (unikalių identifikatorių) pavadinimai yra šie:

• Varduose gali būti raidžių, skaičių, apatinių brūkšnių ir dolerio ženklų.
• Vardai turi prasidėti raide
• Vardai taip pat gali prasidėti $ ir _ (bet šioje pamokoje to nenaudosime)
• Varduose skiriamos didžiosios ir mažosios raidės (y ir y yra skirtingi kintamieji)
• Rezervuoti žodžiai (pvz., „JavaScript“ raktiniai žodžiai) negali būti naudojami kaip pavadinimai

„JavaScript“ identifikatoriuose skiriamos didžiosios ir mažosios raidės.

„JavaScript“ lygybės ženklas (=) yra „priskyrimo“, o ne „lygu“ operatorius.

Tai skiriasi nuo algebros. Algebroje nėra prasmės:

Tačiau „JavaScript“ tai prasminga: ji priskiria x + 5 reikšmę x.

(Jis apskaičiuoja x + 5 reikšmę, o rezultatą pateikia x. x reikšmė padidinama 5)

„JavaScript“ operatorius „lygu“ yra parašytas kaip ==.

„JavaScript“ kintamuosiuose gali būti tokių skaičių kaip 100 ir tekstinės reikšmės kaip „John Doe“.

Programuojant teksto reikšmės vadinamos teksto eilutėmis.

„JavaScript“ gali veikti įvairių tipų duomenis, bet kol kas tik galvoju apie skaičius ir eilutes.

Eilutės rašomos dvigubai arba pavienės citatos. Skaičiai rašomi be kabučių.

Jei aplink skaičių rašysite kabutes, jis bus traktuojamas kaip teksto eilutė.

Kintamojo sukūrimas „JavaScript“ vadinamas kintamojo „deklaravimu“.

Jūs skelbiate „JavaScript“ kintamasis su var raktiniu žodžiu:

Paskelbtas kintamasis neturi reikšmės. (Techniškai reikšmė neapibrėžta)

Norėdami kintamajam priskirti reikšmę, naudokite lygybės ženklą:

carName = "Volvo";

Taip pat galite priskirti reikšmę kintamajam jį deklaruodami:

var carName = "Volvo";

Toliau pateiktame pavyzdyje sukuriame kintamąjį pavadinimu carName ir priskiriame jam reikšmę „Volvo“.

Tada mes „išvedame“ ​​reikšmę HTML elemento viduje naudodami id="demo" :

var carName = "Volvo";
document.getElementById("demo").innerHTML = carName;

Viename sakinyje galite deklaruoti daug kintamųjų.

Pradėkite teiginį vardais var ir atskirkite kintamuosius kableliais:

Deklaraciją gali sudaryti kelios eilutės:

IN kompiuterines programas, kintamieji dažnai deklaruojami be reikšmės. Vertė gali būti kažkas, ką reikia apskaičiuoti, arba kažkas, kas bus pateikta vėliau kaip vartotojo įvestis.

Kintamasis, deklaruotas be reikšmės, turės neapibrėžtą reikšmę.

Įvykdžius šį teiginį, kintamojo carName reikšmė bus neapibrėžta.