რა განსხვავებაა var, let და const-ს შორის?

var ფუნქციონალურ მასშტაბს ფლობს, მაშინ როდესაც let და const ბლოკის მასშტაბს. var შეიძლება განმეორებით გამოაცხადოს და გადანაწილდეს, let შეიძლება გადანაწილდეს, მაგრამ არა განმეორებით გამოაცხადოს იგივე მასშტაბში, const კი არც გამოაცხადოს და არც გადანაწილდეს. var-ით გამოცხადებული ცვლადები განიცდიან ჰოისტინგს (hoisting) undefined-ით, ხოლო let და const-იც განიცდიან ჰოისტინგს, მაგრამ რჩებიან "დასახიჩრებული ზონაში" (temporal dead zone) ინიციალიზაციისამდე.

// `var` ფუნქციონალურ მასშტაბს ფლობს
function exampleVar() {
  if (true) {
    var x = 10;
    console.log(x); // 10
  }
  console.log(x); // 10 (აქ ჩანს x)
}

// `let` და `const` ბლოკის მასშტაბს ფლობენ
function exampleLetConst() {
  if (true) {
    let y = 20;
    const z = 30;
    console.log(y); // 20
    console.log(z); // 30
  }
  // console.log(y); // შეცდომა ReferenceError: y არ არის განსაზღვრული
  // console.log(z); // შეცდომა ReferenceError: z არ არის განსაზღვრული
}

// `var` შეიძლება განმეორებით გამოაცხადოს და გადანაწილდეს
var a = 1;
var a = 2; // განმეორებითი გამოცხადება
a = 3; // გადანაწილება
console.log(a); // 3

// `let` შეიძლება გადანაწილდეს, მაგრამ არა განმეორებით იგივე მასშტაბში
let b = 4;
// let b = 5; // სინტაქსური შეცდომა SyntaxError: 'b' უკვე გამოაცხადებულია
b = 6; // გადანაწილება
console.log(b); // 6

// `const` არ შეიძლება გადანაწილდეს და არც განმეორებით გამოაცხადოს
const c = 7;
// const c = 8; // სინტაქსური შეცდომა SyntaxError: 'c' უკვე გამოაცხადებულია
// c = 9; // ტიპის შეცდომა TypeError: გადაცემის შეცდომა კონსტანტულ ცვლადზე
console.log(c); // 7 (პრიმიტიული ტიპებისთვის)

// ჰოისტინგი (hoisting)
console.log(hoistedVar); // undefined (var ჰოისტინგი და ინიციალიზაცია `undefined`-ით)
var hoistedVar = "მე ვარ var";

// console.log(hoistedLet); // შეცდომა ReferenceError: შეუძლებელია მისვლა 'hoistedLet'-ზე ინიციალიზაციის წინ
// let hoistedLet = "მე ვარ let"; // დროებითი მკვდარი ზონა

ძირითადი განსხვავებები სია:

თვისება	var	let	const
მასშტაბი	ფუნქციონალური	ბლოკური	ბლოკური
განმეორებითი გამოცხადება	დიახ	არა (სწორად იგივე მასშტაბში)	არა
გადანაწილება	დიახ	დიახ	არა (პრიმიტიული ტიპებისთვის)
ჰოისტინგი	დიახ (თან undefined)	დიახ (დროებითი მკვდარი ზონა)	დიახ (დროებითი მკვდარი ზონა)
საწყისი მუტაცია	საჭირო არ არის ინიციალიზაცია	საჭირო არ არის ინიციალიზაცია	ინიციალიზაცია საჭიროა

მნიშვნელოვანია აღინიშნოს, რომ const-ით გამოცხადებული ობიექტებისა და მასივების შემთხვევაში, თავად ცვლადი არ შეიძლება იყოს გადანაწილებული სხვა ობიექტზე/მასივზე, მაგრამ ობიექტის ან მასივის შიგთავსი შეიძლება შეიცვალოს:

const myObject = { key: 'value' };
// myObject = { newKey: 'newValue' }; // შეცდომა TypeError: გადაცემის შეცდომა კონსტანტულ ცვლადზე
myObject.key = 'newValue'; // შესაძლებელია
console.log(myObject); // { key: 'newValue' }

const myArray = [1, 2];
// myArray = [3, 4]; // შეცდომა TypeError: გადაცემის შეცდომა კონსტანტულ ცვლადზე
myArray.push(3); // შესაძლებელია
console.log(myArray); // [ 1, 2, 3 ]