Var, Let un Const - kāda ir atšķirība?

ES2015 (ES6) parādījās daudz jaunu spīdīgu funkciju. Un tagad, kopš ir 2020. gads, tiek pieņemts, ka daudzi JavaScript izstrādātāji ir iepazinušies un ir sākuši izmantot šīs funkcijas.

Lai gan šis pieņēmums varētu būt daļēji patiess, tomēr ir iespējams, ka dažas no šīm funkcijām dažām devēm paliek noslēpums.

Viena no funkcijām, kas tika piegādāta kopā ar ES6, ir pievienošana letun const, ko var izmantot mainīgo deklarēšanai. Jautājums ir, ar ko viņi atšķiras no labajiem oliem, varkurus mēs esam izmantojuši? Ja jums tas joprojām nav skaidrs, tad šis raksts ir domāts jums.

Šajā rakstā mēs apspriestu var, letun const  attiecībā uz to apjomu, lietošanu un celšanas ar. Lasot, ņemiet vērā atšķirības starp tām, uz kurām es norādīšu.

Var

Pirms ES6 parādīšanās varvaldīja deklarācijas. Tomēr ir jautājumi, kas saistīti ar mainīgajiem, kas deklarēti ar var. Tāpēc bija nepieciešami jauni mainīgo deklarēšanas veidi. Pirmkārt, sapratīsim varvairāk, pirms mēs apspriedīsim šos jautājumus.

Var. Darbības joma

Darbības joma būtībā nozīmē, kur šie mainīgie ir pieejami lietošanai. vardeklarācijas ir globāli piemērotas vai darbojas / lokāli.

Darbības joma ir globāla, ja varmainīgais tiek deklarēts ārpus funkcijas. Tas nozīmē, ka jebkurš mainīgais, kas ir deklarēts ar varārpus funkcijas bloka, ir pieejams lietošanai visā logā.

varir funkcijas darbības joma, kad tā ir deklarēta funkcijas ietvaros. Tas nozīmē, ka tas ir pieejams un tam var piekļūt tikai šīs funkcijas ietvaros.

Lai saprastu tālāk, aplūkojiet zemāk redzamo piemēru.

 var greeter = "hey hi"; function newFunction() { var hello = "hello"; } 

Lūk, tā greeterir globāli piemērojama, jo tā pastāv ārpus funkcijas, kamēr hellofunkcija ir piemērota. Tāpēc mēs nevaram piekļūt mainīgajam helloārpus funkcijas. Tātad, ja mēs to darām:

 var tester = "hey hi"; function newFunction() { var hello = "hello"; } console.log(hello); // error: hello is not defined 

Mēs saņemsim kļūdu, kas ir saistīta ar to, ka helloneesam pieejams ārpus funkcijas.

var mainīgos var atkārtoti deklarēt un atjaunināt

Tas nozīmē, ka mēs to varam darīt vienā darbības jomā un nedabūsim kļūdu.

 var greeter = "hey hi"; var greeter = "say Hello instead"; 

un tas arī

 var greeter = "hey hi"; greeter = "say Hello instead"; 

Var. Pacelšana

Pacelšana ir JavaScript mehānisms, kurā mainīgie un funkciju deklarācijas pirms koda izpildes tiek pārvietotas uz to darbības sfēras augšdaļu. Tas nozīmē, ka, ja mēs to darām:

 console.log (greeter); var greeter = "say hello" 

to interpretē šādi:

 var greeter; console.log(greeter); // greeter is undefined greeter = "say hello" 

Tātad varmainīgie tiek pacelti līdz to darbības jomai un tiek inicializēti ar vērtību undefined.

Problēma ar var

Ar to saistās vājums   var. Es izmantošu tālāk sniegto piemēru, lai izskaidrotu:

 var greeter = "hey hi"; var times = 4; if (times > 3) { var greeter = "say Hello instead"; } console.log(greeter) // "say Hello instead" 

Tātad, tā kā times > 3atgriežas taisnība, greetertiek definēts atkārtoti "say Hello instead". Lai gan tā nav problēma, ja jūs apzināti vēlaties greetertikt definēts no jauna, tā kļūst par problēmu, ja nesaprotat, ka mainīgais greeterjau ir definēts iepriekš.

Ja esat izmantojis greetercitas koda daļas, jūs varētu būt pārsteigts par iegūto rezultātu. Tas, iespējams, izraisīs daudz kļūdu jūsu kodā. Tāpēc letun constir nepieciešami.

Ļaujiet

lettagad dod priekšroku mainīgo deklarēšanai. Tas nav pārsteigums, jo tas notiek kā vardeklarāciju uzlabošana . Tas arī atrisina problēmu, varkuru mēs tikko aplūkojām. Apsvērsim, kāpēc tas tā ir.

ļaujiet bloķēt darbības jomu

Bloks ir koda gabals, ko ierobežo {}. Bloks dzīvo cirtainās breketēs. Viss, kas atrodas cirtainajās breketēs, ir bloks.

Tātad mainīgais, kas deklarēts blokā ar, let  ir pieejams lietošanai tikai šajā blokā. Ļaujiet man to paskaidrot ar piemēru:

 let greeting = "say Hi"; let times = 4; if (times > 3) { let hello = "say Hello instead"; console.log(hello);// "say Hello instead" } console.log(hello) // hello is not defined 

Mēs redzam, ka, izmantojot helloārpus tā bloka (cirtainās lencītes, kur tas tika definēts), tiek parādīta kļūda. Tas ir tāpēc, ka letmainīgie tiek bloķēti.

let var atjaunināt, bet nav atkārtoti deklarēts.

Tāpat kā varmainīgo mainīgo letvar atjaunināt tā darbības jomā. Atšķirībā no tā var, letmainīgo nevar atkārtoti deklarēt tā darbības jomā. Lai gan tas darbosies:

 let greeting = "say Hi"; greeting = "say Hello instead"; 

tas atgriezīs kļūdu:

 let greeting = "say Hi"; let greeting = "say Hello instead"; // error: Identifier 'greeting' has already been declared 

Tomēr, ja viens un tas pats mainīgais ir definēts dažādās jomās, kļūdas nebūs:

 let greeting = "say Hi"; if (true) { let greeting = "say Hello instead"; console.log(greeting); // "say Hello instead" } console.log(greeting); // "say Hi" 

Kāpēc nav kļūdu? Tas ir tāpēc, ka abus gadījumus uzskata par atšķirīgiem mainīgajiem, jo ​​tiem ir atšķirīga darbības joma.

This fact makes let a better choice than var. When using let, you don't have to bother if you have used a name for a variable before as a variable exists only within its scope.

Also, since a variable cannot be declared more than once within a scope, then the problem discussed earlier that occurs with var does not happen.

Hoisting of let

Just like  var, let declarations are hoisted to the top. Unlike var which is initialized as undefined, the let keyword is not initialized. So if you try to use a let variable before declaration, you'll get a Reference Error.

Const

Variables declared with the const maintain constant values. const declarations share some similarities with let declarations.

const declarations are block scoped

Like let declarations, const declarations can only be accessed within the block they were declared.

const cannot be updated or re-declared

This means that the value of a variable declared with const remains the same within its scope. It cannot be updated or re-declared. So if we declare a variable with const, we can neither do this:

 const greeting = "say Hi"; greeting = "say Hello instead";// error: Assignment to constant variable. 

nor this:

 const greeting = "say Hi"; const greeting = "say Hello instead";// error: Identifier 'greeting' has already been declared 

Every const declaration, therefore, must be initialized at the time of declaration.

This behavior is somehow different when it comes to objects declared with const. While a const object cannot be updated, the properties of this objects can be updated. Therefore, if we declare a const object as this:

 const greeting = { message: "say Hi", times: 4 } 

while we cannot do this:

 const greeting = { words: "Hello", number: "five" } // error: Assignment to constant variable. 

we can do this:

 greeting.message = "say Hello instead"; 

This will update the value of greeting.message without returning errors.

Hoisting of const

Just like let, const declarations are hoisted to the top but are not initialized.

So just in case you missed the differences, here they are:

  • var declarations are globally scoped or function scoped while let and const are block scoped.
  • var variables can be updated and re-declared within its scope; let variables can be updated but not re-declared; const variables can neither be updated nor re-declared.
  • They are all hoisted to the top of their scope. But while var variables are initialized with undefined, let and const variables are not initialized.
  • Kamēr varun letto var deklarēt bez inicializācijas, consttas ir jāinicializē deklarēšanas laikā.

Vai jums ir kādi jautājumi vai papildinājumi? Lūdzu, ļauj man zināt.

Paldies par lasīšanu :)