JavaScript atslēgvārdi jeb keywords – kopsavilkums

JavaScript ir dinamiskā programmēšanas valoda, un tajā ir daudzi atslēgvārdi, kas tiek izmantoti dažādos veidos. Daži no biežāk sastopamajiem atslēgvārdiem ir:

“var”, “let”, “const”, “function”, “if”, “else”, “for”, “while”, “do”, “switch”, “case”, “break”, “continue”, “return”, “try”, “catch”, “finally”, “throw”, “await”, “async” un “this”.

Katrs no šiem atslēgvārdiem ir unikāls un tiek izmantots dažādos gadījumos, lai veiktu dažādas darbības un kontrolētu programmas darbību. Piemēram,

• “var” tiek izmantots, lai deklarētu mainīgos,
• “function” tiek izmantots, lai definētu funkcijas, un
• “if” un “else” tiek izmantoti, lai veiktu dažādas nosacījumu pārbaudes un izpildītu atbilstošos blokus kodā.

Atslēgvārdi ir svarīga daļa no JavaScript un ir jāizprot, lai efektīvi izmantotu valodu.

VAR:
JavaScript atslēgvārds “var” tiek izmantots, lai deklarētu mainīgo. Tā ļauj izveidot mainīgo, kuram var piešķirt vērtību un kuru var izmantot programmā. Piemēram:

var x = 5;
var y = 10;

console.log(x + y); // konsolē tiek izvadīta mainīgo summa 15

Svarīgi atcerēties, ka atslēgvārds “var” ir ierobežots mainīgajā diapazonā un neļauj mainīgajiem “izlekt” no tā. Tāpēc ieteicams izmantot atslēgvārdus “let” un “const” (ja ir pieejams), jo tie nodrošina plašāku kontroli pār mainīgajiem.

#var

LET

JavaScript atslēgvārds let ir lietojams, lai definētu mainīgos. Tas ir līdzīgs atslēgvārdam var, bet ar vairākām izmaiņām, piemēram, let deklarētais mainīgais ir pieejams tikai tajā blokā, kur tas ir deklarēts, nevis visā funkcijā vai skriptā kā ar var. Tā kā let mainīgie ir bloka līmenī, tās var izmantot ciklos un citās lietās, kur nepieciešama mainīgo pieejamība tikai noteiktā blokā.

Viens piemērs, kā izmantot JavaScript atslēgvārdu let, ir cikla gadījumā:

for (let i = 0; i < 10; i++) {
// Šajā blokā mainīgais "i" ir pieejams un ir i=0
console.log(i);
}
// Šeit mainīgais "i" vairs nav pieejams

Šajā gadījumā mainīgais i ir pieejams tikai cikla blokā un nevar tikt piekļūts no citām daļām skriptā. Ja būtu izmantots atslēgvārds var šajā gadījumā, mainīgais i būtu pieejams arī pēc cikla beigām.

#let

CONST

JavaScript atslēgvārds ‘const’ ir vēl viens veids, kā definēt mainīgo. Tā ir līdzīga atslēgvārdam ‘let’, taču tā atšķiras ar to, ka konstantei ir jābūt aizvērtai un tai nevar piešķirt jaunu vērtību vēlāk programmas izpildes laikā. Tātad, ja Jums ir nepieciešams mainīgais, kuram jābūt fiksētai vērtībai visu laiku, tad izmantojiet ‘const’ atslēgvārdu.

“const” ir JavaScript konstantes deklarēšanas komanda, kas ļauj jums uzstādīt mainīgu, kurš nevar tikt mainīts vēlāk programmas darbības laikā. Tātad, ja jūs deklarējat mainīgo ar “const”, jūs nevarēsiet mainīt to vērtību vēlāk programmā.

Šeit ir piemērs par to, kā izmantot “const” lai deklarētu skaitļa konstantes vērtību:

const pie = 3.14;

Šajā piemērā mēs deklarējam skaitli “pie” ar vērtību 3.14, un tā vērtība nevarēs tikt mainīta vēlāk programmas darbības laikā. Tā vietā, ja mēs vēlētos mainīt šo vērtību, mums būtu jāizmanto “let” vai “var” komandas.

Galu galā, izmantojot “const” komandu, mēs varam nodrošināt, ka mūsu kodā nav mainīgu, kuru vērtības tiek mainītas nejauši vai nepamatoti, kas var radīt neskaidrības un potenciālus kļūdas mūsu programmā.

Tāpat kā ar skaitļiem, arī ar vārdiem varat izmantot “const” lai deklarētu konstantes vērtību. Šeit ir piemērs par to, kā izmantot “const” lai deklarētu vārda konstantes vērtību:

const welcomeMessage = "Sveicināts!";

Šajā piemērā mēs deklarējam vārdu “welcomeMessage” ar vērtību “Sveicināts!”, un tā vērtība nevarēs tikt mainīta vēlāk programmas darbības laikā. Tā vietā, ja mēs vēlētos mainīt šo vērtību, mums būtu jāizmanto “let” vai “var” komandas.

Galu galā, izmantojot “const” komandu, mēs varam nodrošināt, ka mūsu kodā nav mainīgu, kuru vērtības tiek mainītas nejauši vai nepamatoti, kas var radīt neskaidrības un potenciālus kļūdas mūsu programmā.

JavaScript ‘const’ piemērs ar masīva vērtību varētu izskatīties šādi:

const array = [1, 2, 3, 4, 5];

Tā kā ‘const’ ir konstantes mainīgais, masīvs ‘array’ nevarēs mainīt savu vērtību vēlāk skripta izpildes laikā. Ja mēģināsit mainīt masīva vērtību, JavaScript radīs kļūdu.

array = [6, 7, 8, 9, 10]; // JavaScript radīs kļūdu

Tomēr, ja vēlaties mainīt masīva saturu (piemēram, pievienot vērtības vai izdzēst esošās vērtības), to varat darīt, izmantojot masīva metodes, piemēram, ‘push’, ‘pop’, ‘shift’ un ‘unshift’.

array.push(6); // masīvs tagad ir [1, 2, 3, 4, 5, 6]
array.pop(); // masīvs tagad ir [1, 2, 3, 4, 5]
array.shift(); // masīvs tagad ir [2, 3, 4, 5]
array.unshift(1); // masīvs tagad ir [1, 2, 3, 4, 5]

Lai gan ‘const’ masīvs nevar mainīt savu vērtību, tā saturu var mainīt.

#const

FUNCTION

Šeit ir vienkāršs JavaScript funkcijas piemērs:

function greet(name) {
return "Hello, " + name + "!";
}

console.log(greet("John")); // "Hello, John!"

Šajā piemērā mēs izveidojām funkciju ar nosaukumu greet, kas pieņem vienu argumentu – name. Funkcija atgriež teikumu “Hello, [name]!”, kur [name] ir mainīgais name.

Lai izmantotu šo funkciju, mēs to izsaucam, izmantojot tās nosaukumu un pievienojot argumentu, piemēram greet("John"). Kad funkcija tiek izsaukta, tā atgriež rezultātu, kuru varētu izmantot turpmākajā kodā vai izvadīt uz konsoles, izmantojot console.log(), kā mēs to darījām piemērā.

#function

IF un ELSE

"if" un "else" ir pārbaudes un izvēles konstrukcijas, kas ļauj programmētājam izpildīt atšķirīgus darbības atkarībā no noteiktiem nosacījumiem. Piemēram:
if (nosacījums) {
// Izpildām šo kodu, ja nosacījums ir patiess
} else {
// Izpildām šo kodu, ja nosacījums nav patiess
}

Vienkāršākais veids, kā izmantot “if” un “else” ir ar vienkāršu pārbaudi, lai noskaidrotu, vai mainīgais “x” ir lielāks par 5. Šajā gadījumā “if” bloks tiks izpildīts, ja “x” ir lielāks par 5, un “else” bloks tiks izpildīts, ja “x” ir mazāks vai vienāds ar 5:

var x = 7;

if (x > 5) {
console.log("x ir lielāks par 5!");
} else {
console.log("x ir mazāks vai vienāds ar 5!");
}

Rezultāts konsolē būs “x ir lielāks par 5!”.

#if #else

FOR
‘For’ cikls ir viena no biežāk izmantotajām konstrukcijām JavaScript, kas ļauj atkārtot noteiktas darbības noteiktu skaitu reižu. Šeit ir piemērs par to, kā izmantot ‘for’ ciklu JavaScript:

for (var i = 0; i < 10; i++) {
console.log(i);
}

Šajā kodā mēs definējam mainīgo ‘i’, kas sākas ar vērtību 0 un pēc tam tiek palielināta par vienu katru reizi, kad tiek atkārtots cikls. Cikls tiek atkārtojams tik ilgi, kamēr ‘i’ ir mazāks par 10. Kā rezultātā, šis kods izdrukās skaitļus no 0 līdz 9 konsoles logā.

#for

WHILE

‘While’ ir cikla konstrukcija, kas atkārtoti izpilda kodu, kamēr noteikts nosacījums ir patiess. Šeit ir piemērs, kā izmantot ‘while’ ciklu JavaScript:

// Iestatam sākuma vērtību mainīgajam 'x'
var x = 0;

// Izpildām ciklu, kamēr 'x' ir mazāks par 5
while (x < 5) {
// Palielinām 'x' vērtību par 1
x = x + 1;

// Izvadām tekstu konsolē
console.log("Cikls ir izpildīts " + x + " reizes");
}

Izpildot šo kodu, tas atkārtoti izpildīs ciklu un palielinās ‘x’ vērtība par 1 katru reizi, kamēr tā ir mazāka par 5. Pēc tam tas izvadīs tekstu konsolē, norādot, cik reizes cikls ir izpildīts.

#while

DO

Viena no darbībām, kuras JavaScript var veikt, ir cikla izpildīšana, izmantojot ‘do’ komandu. Piemērs:

do {
// izpildām kādu darbību
} while (noteikums);

Šajā piemērā darbība tiks izpildīta, kamēr noteikums ir patiess. Tātad, šis cikls izpildīsies vismaz vienu reizi, pat ja noteikums ir nepatiesi sākotnēji.

Lai izmantotu ‘do’ komandu savā JavaScript kodā, jums ir jāiekļauj tā cikla ietvaros, un jānorāda noteikums, kamēr kurš tiks izpildīts cikls. Piemēram:

var skaitlis = 0;

do {
skaitlis ++;
console.log(skaitlis);
} while (skaitlis < 5);

Šajā piemērā cikls tiks izpildīts, kamēr mainīgais ‘skaitlis’ ir mazāks par pieci. Tātad, šis kods izvadīs skaitļus no 1 līdz 5 konsolē.

#do

SWITCH

Šajā gadījumā var kalpot kā laba kontroles un izpildes programma, pēc būtības tā pārbauda kādu mainīgo vērtību un tad attiecīgi no uzdotā uzdevuma veic, vai neveic tālāk kādu darbību, bet par katru notikumu paziņo konsoles logā, ja šāda darbība piešķirta.

// Definējam mainīgo ar vērtību, kurai vēlamies piešķirt atbilstošu komandu
var darbība = "izvadīt";

// Izmantojam switch, lai pārbaudītu mainīgā vērtību un izpildītu atbilstošo komandu
switch (darbība) {
case "izvadīt":
// Ja mainīgā vērtība ir "izvadīt", izpildīsim komandu, lai izvadītu tekstu
console.log("Teksts tiek izvadīts!");
break;
case "izmainīt":
// Ja mainīgā vērtība ir "izmainīt", izpildīsim komandu, lai mainītu teksta vērtību
console.log("Teksta vērtība ir nomainīta!");
break;
default:
// Ja mainīgā vērtība nav nevienu no iepriekš noteiktajām vērtībām, izpildīsim komandu, lai izvadītu kļūdas paziņojumu
console.log("Kļūda: nezināma darbība!");
}

JavaScript switch komanda ir programmēšanas konstrukcija, ko var izmantot lai veiktu daudzveidīgu darbību atkarībā no dota konkrēta vērtības. Tā ir līdzīga izvēlnes komandai if, taču tā ļauj darboties ar vairākām iespējamām vērtībām un ir ērtāka lietošanā, ja ir nepieciešams salīdzināt daudzas dažādas vērtības.

Šeit ir piemērs tam, kā var izmantot switch komandu JavaScript:

switch (x) {
case 1:
// darīt kaut ko, ja x ir 1
break;
case 2:
// darīt kaut ko, ja x ir 2
break;
default:
// darīt kaut ko, ja x nav ne 1 ne 2
}

Kā jūs varat redzēt, switch komandā ir definēta mainīgā x, un tad ir dažādas “cases” (gadījumi), kas nosaka, ko darīt atkarībā no x vērtības. default case ir izmantots gadījumam, ja x vērtība neatbilst nevienam no citām cases.

#switch

CASE (switch sastāvdaļa)

case ir daļa no switch konstrukcijas. Switch ir kāds kods, kas salīdzina vienu vērtību ar daudzām citiem un izpilda atbilstošo kodu atkarībā no tā, kāda ir vērtība. Case ir daļa no switch, kurā ir definēta vērtība, ar kuru tiek salīdzināta sākotnējā vērtība, un kods, kas tiks izpildīts, ja sākotnējā vērtība atbilst definētajai vērtībai. Piemēram:

switch (x) {
case 1:
// Ja x ir 1, izpildiet šo kodu
break;
case 2:
// Ja x ir 2, izpildiet šo kodu
break;
default:
// Ja x nav neviens no iepriekš minētajiem, izpildiet šo kodu
}

Tā kā switch konstrukcija salīdzina vērtības, tā ir efektīvs veids, kā apstrādāt daudzas dažādas vērtības, un case ir tās daļa, kurā ir definētas šīs vērtības un kods, kas jāizpilda, ja tiek atrasta atbilstība.

#case

BREAK (switch sastāvdaļa)

JavaScript atslēgvārds break ir lietots ciklos, lai pārtrauktu tā izpildi. Kad break ir izpildīts, cikls pārtrauc darbību un pāriet pie sekojošās instrukcijas pēc cikla.

Piemērs:

for (let i = 0; i < 10; i++) {
if (i === 5) {
break;
}
console.log(i);
}

Šajā piemērā cikls for izpildīsies 10 reizes, un katru reizi konsolē tiks izdrukāts skaitlis no 0 līdz 4. Kad i ir vienāds ar 5, break instrukcija tiks izpildīta un cikls pārtrauks darbību. Tādējādi, konsolē netiks izdrukāts skaitlis 5.

#break

CONTINUE

JavaScript atslēgvārds ‘continue’ tiek izmantots cikla izpildes laikā, lai pārtrauktu pašreizējās iterācijas izpildi un sāktu nākamo iterāciju. Piemēram:

for (var i = 0; i < 10; i++) {
// ja i ir vienāds ar pieciem, pārtrauciet pašreizējo iterāciju un sāciet nākamo
if (i === 5) {
continue;
}
// dariet ko citu ar i
}

Tātad, ja mainīgais i ir vienāds ar pieciem, šis kods pārtrauks pašreizējo iterāciju un sāks nākamo iterāciju, neizpildot iekšējo bloku, kurā ir norādīts “dariet ko citu ar i”.

#continue

RETURN

JavaScript atslēgvārds ‘return’ tiek izmantots lai atgrieztu vērtību no funkcijas. Kad funkcija atgriež vērtību, tā vairs neizpilda pārējo kodu un tūlīt pārtrauc savu darbību. Piemēram, ja vēlaties atgriezt vērtību ‘5’ no funkcijas, varat izmantot sekojošu kodu:

function getFive() {
return 5;
}

Kad šo funkciju izsauc, tā atgriezīs vērtību ‘5’:

var result = getFive();
console.log(result); // izvadīs 5

Ja vēlaties, lai funkcija atgriež vairākas vērtības, varat izmantot objektu vai masīvu. Piemēram, šāds kods atgriež vērtības ‘x’ un ‘y’:

function getCoordinates() {
return {
x: 5,
y: 10
};
}

var coordinates = getCoordinates();
console.log(coordinates.x); // izvadīs 5
console.log(coordinates.y); // izvadīs 10

Ja funkcijai nav nepieciešams atgriezt vērtību, varat izmantot atslēgvārdu ‘return’ bez nekādas vērtības. Piemēram, šāds kods neizvadīs neko:

function doNothing() {
return;
}

var result = doNothing();
console.log(result); // neizvadīs neko

#return

TRY ; CATCH ; FINALY ; THROW

JavaScript atslēgvārda ‘try’ tiek izmantota, lai izpildītu noteiktu kodu un pārbaudītu, vai tas rada kādas kļūdas. Ja kods izpildās bez kļūdām, ‘try’ bloks tiks pārtraukts un kods turpinās izpildīties pēc ‘try’ bloka. Ja kods rada kādu kļūdu, tā vietā tiks izpildīts ‘catch’ bloks, kurā varat apstrādāt šo kļūdu.

Try un catch ir lietotas kombinācijā, lai izpildītu kodu un pārbaudītu, vai tas rada kādas kļūdas. Ja tā ir, tad catch bloķē kļūdu un ļauj programmētājam veikt pasākumus, lai tiktu galā ar to.

Try bloks ir lietots, lai izpildītu kodu, kas varētu radīt kļūdu. Ja try blokā ir radusies kļūda, tad programma pārslēgsies uz catch bloku, kas izpilda kodu, lai tiktu galā ar kļūdu. Piemēram:

try {
// izpildāmais kods
} catch (error) {
// koda bloks, kas izpildīsies, ja radusies kļūda
}

Tā kā try un catch bloki ir daļa no JavaScript izpildes mehānismiem, tie ir ļoti noderīgi, lai nodrošinātu, ka jūsu JavaScript kods darbojas pareizi, pat ja ir radušās kļūdas.

JavaScript ‘try’ un ‘catch’ ir divas daļas no koda, kas tiek izmantotas, lai apstrādātu un apkopotu kļūdas un izņēmumus. Lietošanas piemērs ir šāds:

try {
// Mēģiniet izpildīt šo kodu
var x = someUndefinedVariable; // šī mainīgā vērtība nav definēta
var y = x + 10;
} catch (error) {
// Ja kods try blokā rada kļūdu, tas tiek apstrādāts šeit
console.log('Kļūda:', error); // Izvadiet kļūdas paziņojumu konsolē
}

Tā kā someUndefinedVariable nav definēta, izpildot kodu try blokā, tiks radīta kļūda. Tā tiks apstrādāta catch blokā, izvadot kļūdas paziņojumu konsolē. Šādā veidā programmētājs var kontrolēt un apstrādāt izņēmumus, lai programma varētu turpināt darboties pēc kļūdas.

#try #catch #finaly #throw

FINALY

Finaly ir JavaScript kārta, kas tiek izpildīta, kad ir pabeigta try-catch bloka izpilde, neatkarīgi no tā, vai tika atrasts kāds kļūdas exceptions vai ne. Tā ir laba vieta, kur izpildīt clean-up kodu, piemēram, atvērt failus vai atslēgt resursus, ko izmanto try blokā.

Šeit ir piemērs par to, kā var izmantot finaly kārtu:

try {
// Izpildiet potenciāli kļūdainu kodu šeit
} catch (err) {
// Apstrādājiet izņēmumu šeit
} finally {
// Izpildiet šo kodu neatkarīgi no tā, vai tika atrasts kāds exceptions vai ne
}

Lai gan var būt noderīgi, finaly kārtu ne vienmēr ir nepieciešams izmantot. Tā ir atkarīga no konkrētās situācijas un nepieciešamības pēc clean-up koda.

#finaly

THROW

JavaScript ‘throw’ ir komanda, kas ļauj izveidot izņēmuma situāciju jūsu programmā. Kad komanda ‘throw’ tiek izpildīta, tā rada izņēmuma objektu, kas tiek pārraidīts līdz tuvākajai ‘catch’ blokam, kur var tikt apstrādāts.

Piemēram:

try {
throw new Error("There was an error!");
} catch(error) {
console.log(error);
}

Šajā piemērā komanda ‘throw’ izveido jaunu kļūdas objektu ar tekstu “There was an error!”, kas tiek pārraidīts līdz tuvākajam ‘catch’ blokam, kur tas tiek izdrukāts konsolē.

#throw

AWAIT

JavaScript await ir operācijas vārds, kas tiek izmantots JavaScript funkcijās ar lietotāja definētu asinhronu (async) funkcijām. Await ļauj JavaScript darboties sinhroni, t.i., ļauj programmai gaidīt, kamēr beidzas asinhrona operācija, pirms turpināt darbību. Tādējādi await ļauj programmai rīkoties secīgi un saglabāt datu integritāti.

JavaScript await ir operācijas, kas dod iespēju programmētājam uzturēt līdzsvaru starp asinkrono un sinhrono programmēšanu. Tā kā JavaScript ir asinhrona programmēšanas valoda, await operācija ļauj programmētājam “pagaidīt” līdz kādai asinhronai operācijai ir pabeigta, pirms turpināt darbību. Piemēram:

async function doSomething() {
// "Pagaidīsim" līdz getData() funkcija ir pabeigta
let data = await getData();

// Kad getData() funkcija ir pabeigta, varam izmantot saņemtos datus
// un turpināt darbības
console.log(data);
}

Šajā piemērā await operācija tiek lietota, lai “pagaidītu” līdz getData() funkcija ir pabeigta un saņemti dati, kas var tikt izmantoti turpmākajā koda daļā.

#await

ASYNC

JawaScript ir programmēšanas valoda, kas ir izveidota uz JavaScript bāzes. Async ir kāds no JawaScript sintakses elementiem, kas ļauj lietotājam izveidot asinhronus kodu. Asinhroni kods ir tāds kods, kas var turpināt darboties un atrisināt citas uzdevumus, pat ja kāds no tā elementiem joprojām tiek izpildīts. Tas nozīmē, ka async ļauj JawaScript kodam darboties nevienlaicīgi, kas var palīdzēt uzlabot programmas efektivitāti un ātrdarbību.

‘async’ ir funkcija, ko var izmantot, lai radītu asinhronus (nebloķējošus) JavaScript kodu. Vienkāršs piemērs varētu būt šāds:

async function example() {
// Uzstādām promisus, lai gaidītu, kamēr tas ir pabeigts
const promise = new Promise((resolve, reject) => {
setTimeout(() => resolve("async piemērs pabeigts!"), 1000);
});

// Atgriežam promisi un gaidām, lai tas ir pabeigts
const result = await promise;

// Izvadam rezultātu
console.log(result);
}

Kodu var izsaukt, izmantojot example() funkciju. Tā kā tā ir asinhrona, tā nebloķēs citu koda daļu, bet gaidīs, līdz promiss ir pabeigts.

#async

THIS

JavaScript this ir specifiska sintakse, kas atsaucas uz objektu, kas saistīts ar tā pašreizējo kontekstu. Tajā pašā laikā this var atsaukties uz dažādiem objektiem atkarībā no tā, kur un kā tiek izmantota this sintakse. Piemēram, ja this tiek izmantota kāda objekta metodē, tā var atsaukties uz pašu objektu, bet, ja tā tiek izmantota funkcijā, kas ir definēta kāda objekta metode, this var atsaukties uz objektu, kamā šī metode pieder. Tāpat this var atsaukties arī uz globālo objektu vai būt tukša atkarībā no tā, kā tas tiek izmantots.

JavaScript this atslēgvārds attiecas uz objektu, kuram tas pieder. Tas ir ļoti spēcīgs un svarīgs JavaScript jēdziens, un to bieži izmanto notikumu apstrādē, atzvanīšanas funkcijās un objektorientētā programmēšanā.

Šeit ir piemērs, kā to var izmantot JavaScript:

const person = {
firstName: 'Juris',
lastName: 'Bērzs',
fullName: function() {
return `${this.firstName} ${this.lastName}`;
}
}

console.log(person.fullName()); // Output: “Juris Bērzs”

Šajā piemērā tas attiecas uz personas objektu, un tas tiek izmantots, lai piekļūtu personas objekta rekvizītiem FirstName un LastName. Kad tiek izsaukta metode fullName, tā atgriež personas pilnu vārdu, savienojot rekvizītus FirstName un LastName, izmantojot šo atslēgvārdu.

#this