ما الفرق بين استخدام "let" و "var" لإعلان متغير في JavaScript؟




scope ecmascript-6 (18)

let

كتلة النطاق

المتغيرات التي تم الإعلان عنها باستخدام الكلمة المفتاحية هي عبارة عن حجب للمجموعة ، مما يعني أنها متاحة فقط في الكتلة التي تم الإعلان عنها.

في المستوى العلوي (خارج الوظيفة)

في المستوى الأعلى ، فإن المتغيرات التي يتم الإعلان عنها باستخدام لا let بإنشاء خصائص على الكائن العام.

var globalVariable = 42;
let blockScopedVariable = 43;

console.log(globalVariable); // 42
console.log(blockScopedVariable); // 43

console.log(this.globalVariable); // 42
console.log(this.blockScopedVariable); // undefined

داخل وظيفة

داخل دالة (ولكن خارج كتلة) ، let نفس نطاق var .

(() => {
  var functionScopedVariable = 42;
  let blockScopedVariable = 43;

  console.log(functionScopedVariable); // 42
  console.log(blockScopedVariable); // 43
})();

console.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

داخل كتلة

لا يمكن الوصول إلى المتغيرات المُعلنة باستخدام let داخل كتلة خارج تلك الكتلة.

{
  var globalVariable = 42;
  let blockScopedVariable = 43;
  console.log(globalVariable); // 42
  console.log(blockScopedVariable); // 43
}

console.log(globalVariable); // 42
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

داخل حلقة

يمكن الإشارة إلى المتغيرات المُعلنة مع حلقات التكرار داخل الحلقة فقط.

for (var i = 0; i < 3; i++) {
  var j = i * 2;
}
console.log(i); // 3
console.log(j); // 4

for (let k = 0; k < 3; k++) {
  let l = k * 2;
}
console.log(typeof k); // undefined
console.log(typeof l); // undefined
// Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.

الحلقات مع الإغلاق

إذا كنت تستخدم let بدلاً من var في حلقة ، فستحصل على متغير جديد مع كل تكرار. وهذا يعني أنه يمكنك استخدام الإغلاق داخل الحلقة بأمان.

// Logs 3 thrice, not what we meant.
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

// Logs 0, 1 and 2, as expected.
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}

المنطقة الزمنية الميتة

وبسبب المنطقة الميتة المؤقتة ، لا يمكن الوصول إلى المتغيرات التي يتم استخدامها باستخدام let قبل أن يتم الإعلان عنها. محاولة القيام بذلك يرمي خطأ.

console.log(noTDZ); // undefined
var noTDZ = 43;
console.log(hasTDZ); // ReferenceError: hasTDZ is not defined
let hasTDZ = 42;

لا إعادة التصريح

لا يمكنك الإعلان عن نفس المتغير عدة مرات باستخدام let . لا يمكنك أيضًا الإعلان عن متغير باستخدام let باستخدام نفس المعرف كمتغير آخر تم التصريح به باستخدام var .

var a;
var a; // Works fine.

let b;
let b; // SyntaxError: Identifier 'b' has already been declared

var c;
let c; // SyntaxError: Identifier 'c' has already been declared

const

const يشبه إلى حدٍّ ما let لـ block-scoped ولديه TDZ. هناك ، مع ذلك ، شيئين مختلفين.

لا إعادة تخصيص

لا يمكن إعادة تعيين المتغير المُعلَن باستخدام const .

const a = 42;
a = 43; // TypeError: Assignment to constant variable.

لاحظ أنه لا يعني أن القيمة غير قابلة للتغيير. خصائصه لا يزال يمكن تغييرها.

const obj = {};
obj.a = 42;
console.log(obj.a); // 42

إذا كنت ترغب في الحصول على كائن غير قابل للتغيير ، يجب عليك استخدام Object.freeze() .

مطلوب المبدئ

يجب عليك دائمًا تحديد قيمة عند التصريح عن متغير باستخدام const .

const a; // SyntaxError: Missing initializer in const declaration

قدم ECMAScript 6 بيان let . سمعت أنه وصف بأنه متغير "محلي" ، لكنني لا أزال غير متأكد تمامًا من سلوكه بشكل مختلف عن الكلمة الرئيسية var .

ما هي الاختلافات؟ متى يجب let باستخدام var ؟


نطاق وظيفة نطاق VS:

والفرق الرئيسي بين varو letهو أن المتغيرات أعلن مع varو ظيفة راقب . في حين أن الوظائف المعلنة مع letهي خاصة بتطبيق كتلة . فمثلا:

function testVar () {
  if(true) {
    var foo = 'foo';
  }

  console.log(foo);
}

testVar();  
// logs 'foo'


function testLet () {
  if(true) {
    let bar = 'bar';
  }

  console.log(bar);
}

testLet(); 
// reference error
// bar is scoped to the block of the if statement 

المتغيرات مع var:

عندما testVarيتم استدعاء الوظيفة الأولى var، لا يزال يمكن الوصول إلى المتغير foo ، المُعلن عنه ، خارج ifالبيان. fooسيكون هذا المتغير متاحًا في كل مكان ضمن نطاق testVar الوظيفة .

المتغيرات مع let:

عندما testLetيتم استدعاء الوظيفة الثانية let، يمكن الوصول إلى شريط المتغير ، الذي تم التصريح به ، داخل ifالبيان فقط. لأن المتغيرات التي تم التصريح عنها letهي كتلة محددة (حيث يكون الكود هو الكود بين الأقواس المتعرجة على سبيل المثال if{}، for{}، function{}).

let المتغيرات لا ترفع:

وثمة فرق آخر بين varو letهو المتغيرات مع المعلن مع let عدم الحصول على رفع . مثال على ذلك هو أفضل طريقة لتوضيح هذا السلوك:

المتغيرات مع let عدم الحصول على رافعة:

console.log(letVar);

let letVar = 10;
// referenceError, the variable doesn't get hoisted

المتغيرات مع var ما يحصل رفعت:

console.log(varVar);

var varVar = 10;
// logs undefined, the variable gets hoisted

letلا تلتزم جلوبل بما windowيلي:

لا يتم إضافة متغير تم التصريح به letفي النطاق العالمي (وهو رمز غير موجود في إحدى الوظائف) كخاصية على windowالكائن العام. على سبيل المثال (هذا الرمز في النطاق العالمي):

var bar = 5;
let foo  = 10;

console.log(bar); // logs 5
console.log(foo); // logs 10

console.log(window.bar);  
// logs 5, variable added to window object

console.log(window.foo);
// logs undefined, variable not added to window object


متى يجب letاستخدام أكثر var؟

استخدام letأكثر varكلما استطعت لأنه راقب ببساطة أكثر تحديدا. هذا يقلل من تعارض التسمية المحتملة التي يمكن أن تحدث عند التعامل مع عدد كبير من المتغيرات. varيمكن استخدامها عندما تريد أن يكون المتغير الشامل صريحًا على windowالكائن (فكر دائمًا بعناية إذا كان ذلك ضروريًا حقًا).


إليك شرحًا حول let للكلمة الرئيسية ببعض الأمثلة.

اسمحوا يعمل يشبه إلى حد كبير فار. والفرق الرئيسي هو أن نطاق متغير var هو دالة الإحاطة بأكملها

يوضح هذا الجدول على موقع Wikipedia أي المستعرضات تدعم Javascript 1.7.

لاحظ أن مستعرضات Mozilla و Chrome فقط يدعمان ذلك. IE ، سفاري ، وربما الآخرين لا.


الاختلاف الرئيسي هو اختلاف النطاق ، بينما يمكن أن يكون متاحًا فقط داخل النطاق الذي تم الإعلان عنه ، مثل في حلقة for ، يمكن الوصول إلى var خارج الحلقة على سبيل المثال. من الوثائق في MDN (أمثلة أيضًا من MDN):

يسمح لك بتعريف المتغيرات التي تكون محدودة في النطاق إلى الكتلة أو العبارة أو التعبير الذي يتم استخدامه. هذا على عكس الكلمة الرئيسية var ، التي تحدد متغيرًا عالميًا ، أو محليًا إلى وظيفة بأكملها بغض النظر عن نطاق المنع.

المتغيرات المعلنة عن طريق السماح لنطاق لها الكتلة التي يتم تعريفها ، وكذلك في أي كتل فرعية الواردة. بهذه الطريقة ، دع العمل يشبه إلى حد كبير var . والفرق الرئيسي هو أن نطاق متغير var هو دالة الإحاطة بأكملها:

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}`

في المستوى الأعلى من البرامج والوظائف ، دعونا ، على خلاف var ، لا يقوم بإنشاء خاصية على الكائن العام. فمثلا:

var x = 'global';
let y = 'global';
console.log(this.x); // "global"
console.log(this.y); // undefined

عند استخدامها داخل كتلة ، اترك حدود نطاق المتغير لهذه الكتلة. لاحظ الفرق بين var الذي يكون نطاقه داخل الدالة حيث يتم الإعلان عنه.

var a = 1;
var b = 2;

if (a === 1) {
  var a = 11; // the scope is global
  let b = 22; // the scope is inside the if-block

  console.log(a);  // 11
  console.log(b);  // 22
} 

console.log(a); // 11
console.log(b); // 2

لا تنس أيضًا ميزة ECMA6 ، لذا فهي غير مدعومة بالكامل حتى الآن ، لذلك فمن الأفضل نقلها دائمًا إلى ECMA5 باستخدام بابل الخ ... لمزيد من المعلومات حول زيارة موقع babel


في ما يلي مثال للإضافة إلى ما كتبه الآخرون من قبل. لنفترض أنك تريد إنشاء صفيف من الدالات ، adderFunctions ، حيث تأخذ كل دالة وسيطة Number واحدة وترجع مجموع الوسيطة وفهرس الدالة في الصفيف. لن تعمل محاولة إنشاء adderFunctions باستخدام حلقة باستخدام الكلمة الرئيسية var بالطريقة التي قد يتوقعها شخص ما بسذاجة:

// An array of adder functions.
var adderFunctions = [];

for (var i = 0; i < 1000; i++) {
  // We want the function at index i to add the index to its argument.
  adderFunctions[i] = function(x) {
    // What is i bound to here?
    return x + i;
  };
}

var add12 = adderFunctions[12];

// Uh oh. The function is bound to i in the outer scope, which is currently 1000.
console.log(add12(8) === 20); // => false
console.log(add12(8) === 1008); // => true
console.log(i); // => 1000

// It gets worse.
i = -8;
console.log(add12(8) === 0); // => true

لا تؤدي العملية أعلاه إلى إنشاء مجموعة من الدالات المطلوبة لأن نطاق i يتجاوز نطاق التكرار for بالكتلة التي تم إنشاء كل دالة فيها. بدلاً من ذلك ، في نهاية الحلقة ، يشير i في كل إغلاق إلى قيمة i في نهاية الحلقة (1000) لكل وظيفة مجهولة في adderFunctions . هذا ليس ما أردناه على الإطلاق: لدينا الآن مجموعة من 1000 وظيفة مختلفة في الذاكرة مع نفس السلوك بالضبط. وإذا قمنا في وقت لاحق بتحديث قيمة i ، سوف تؤثر هذه الطفرة على كل adderFunctions .

ومع ذلك ، يمكننا إعادة المحاولة باستخدام الكلمة الرئيسية let :

// Let's try this again.
// NOTE: We're using another ES6 keyword, const, for values that won't
// be reassigned. const and let have similar scoping behavior.
const adderFunctions = [];

for (let i = 0; i < 1000; i++) {
  // NOTE: We're using the newer arrow function syntax this time, but 
  // using the "function(x) { ..." syntax from the previous example 
  // here would not change the behavior shown.
  adderFunctions[i] = x => x + i;
}

const add12 = adderFunctions[12];

// Yay! The behavior is as expected. 
console.log(add12(8) === 20); // => true

// i's scope doesn't extend outside the for loop.
console.log(i); // => ReferenceError: i is not defined

هذه المرة ، يتم ارتداد i على كل تكرار للحلقة. تحتفظ كل دالة الآن بقيمة i في وقت إنشاء الدالة ، وتتصرف adderFunctions كما هو متوقع.

الآن ، صورة تمزج بين السلوكين ، وربما ستعرف لماذا لا يوصى بخلط الأحدث و const مع const الأقدم في نفس النص. يمكن أن يؤدي ذلك إلى بعض الشفرات المربكة بشكل مذهل.

const doubleAdderFunctions = [];

for (var i = 0; i < 1000; i++) {
    const j = i;
    doubleAdderFunctions[i] = x => x + i + j;
}

const add18 = doubleAdderFunctions[9];
const add24 = doubleAdderFunctions[12];

// It's not fun debugging situations like this, especially when the
// code is more complex than in this example.
console.log(add18(24) === 42); // => false
console.log(add24(18) === 42); // => false
console.log(add18(24) === add24(18)); // => false
console.log(add18(24) === 2018); // => false
console.log(add24(18) === 2018); // => false
console.log(add18(24) === 1033); // => true
console.log(add24(18) === 1030); // => true

لا تدع هذا يحصل لك. استخدام لنتير.

ملاحظة: هذا مثال تعليمي يهدف إلى إظهار var/ letالسلوك في الحلقات وإغلاق الوظيفة التي يسهل فهمها أيضًا. ستكون هذه طريقة مروعة لإضافة أرقام. لكن التقنية العامة لالتقاط البيانات في إغلاق وظيفة مجهولة الهوية قد تصادف في العالم الحقيقي في سياقات أخرى. YMMV.


في ما يلي مثال للفرق بين الاثنين (الدعم الذي بدأ للتو على chrome):

كما ترى ، لا يزال متغير var j له قيمة خارج نطاق الحلقة (Block Scope) ، ولكن متغير let i غير معرف خارج نطاق الحلقة.

"use strict";
console.log("var:");
for (var j = 0; j < 2; j++) {
  console.log(j);
}

console.log(j);

console.log("let:");
for (let i = 0; i < 2; i++) {
  console.log(i);
}

console.log(i);


يفتقد الجواب المقبول إلى نقطة:

{
  let a = 123;
};

console.log(a); // ReferenceError: a is not defined


let أيضا يمكن استخدامها لتجنب المشاكل مع الإغلاق. وهو يربط قيمة جديدة بدلاً من الاحتفاظ بمرجع قديم كما هو موضح في الأمثلة أدناه.

DEMO

for(var i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

يوضح الكود أعلاه مشكلة إغلاق جافا سكريبت الكلاسيكية. يتم تخزين المرجع إلى متغير i في إغلاق معالج النقر ، بدلاً من القيمة الفعلية لـ i .

سيشير كل معالج نقرة منفرد إلى نفس الكائن نظرًا لوجود كائن عداد واحد يحمل 6 حتى تحصل على ستة لكل نقرة.

الحل العام هو التفاف هذا في دالة المجهولة وتمرير i كوسيطة. يمكن أيضًا تجنب مثل هذه المشكلات من خلال استخدام بدلاً من ذلك var كما هو موضح في التعليمة البرمجية أدناه.

DEMO (تم اختباره في Chrome وفايرفوكس 50)

'use strict';

for(let i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

var هو النطاق العالمي (رافعة) المتغير.

letو constهو نطاق كتلة.

test.js

{
    let l = 'let';
    const c = 'const';
    var v = 'var';
    v2 = 'var 2';
}

console.log(v, this.v);
console.log(v2, this.v2);
console.log(l); // ReferenceError: l is not defined
console.log(c); // ReferenceError: c is not defined


تحدد هذه المقالة بوضوح الفرق بين var و let و const

const هي إشارة إلى أنه لن يتم إعادة تعيين المعرف.

let، هي إشارة إلى أنه يمكن إعادة تعيين المتغير ، مثل عداد في حلقة ، أو تبديل قيمة في خوارزمية. كما أنه يشير إلى أن المتغير سوف يستخدم فقط في الكتلة التي تم تعريفها بها ، والتي ليست دائمًا الدالة المحتوية بالكامل.

varهو الآن أضعف إشارة متوفرة عند تحديد متغير في JavaScript. قد يتم إعادة تعيين المتغير أو قد لا يتم استخدامه ، وقد يتم استخدام المتغير أو لا يتم استخدامه لوظيفة كاملة ، أو فقط لغرض كتلة أو حلقة.

https://medium.com/javascript-scene/javascript-es6-var-let-or-const-ba58b8dcde75#.esmkpbg9b


قد تظهر الدالتان التاليتان الفرق:

function varTest() {
    var x = 31;
    if (true) {
        var x = 71;  // Same variable!
        console.log(x);  // 71
    }
    console.log(x);  // 71
}

function letTest() {
    let x = 31;
    if (true) {
        let x = 71;  // Different variable
        console.log(x);  // 71
    }
    console.log(x);  // 31
}

يبدو أيضًا أنه ، على الأقل في Visual Studio 2015 ، TypeScript 1.5 ، يسمح "var" بإعلانات متعددة لنفس اسم المتغير في كتلة ، و "let" لا.

لن يؤدي ذلك إلى إنشاء خطأ في الترجمة:

var x = 1;
var x = 2;

هذا سوف:

let x = 1;
let x = 2;

إذا قرأت المواصفات الحق في ذلك الحين let ولله الحمد كما يمكن الاستعانة بها لتجنب ظائف استحضار الذات استخدامها لمحاكاة أعضاء الوحيد الخاص - نمط تصميم شعبية أن يقلل قراءة رمز، ويعقد التصحيح، أن يضيف أي رمز الحماية الحقيقية أو أي منفعة أخرى - ربما باستثناء إرضاء شخص ما الرغبة في الدلالات ، لذلك توقف عن استخدامه. / خرف

var SomeConstructor;

{
    let privateScope = {};

    SomeConstructor = function SomeConstructor () {
        this.someProperty = "foo";
        privateScope.hiddenProperty = "bar";
    }

    SomeConstructor.prototype.showPublic = function () {
        console.log(this.someProperty); // foo
    }

    SomeConstructor.prototype.showPrivate = function () {
        console.log(privateScope.hiddenProperty); // bar
    }

}

var myInstance = new SomeConstructor();

myInstance.showPublic();
myInstance.showPrivate();

console.log(privateScope.hiddenProperty); // error

راجع " محاكاة واجهات خاصة "


الفرق في scope المتغيرات المعلن عنها مع كل منها.

في الواقع ، هناك عدد من النتائج المفيدة للاختلاف في النطاق:

  1. letالمتغيرات مرئية فقط في اقرب كتلة مغلقة ( { ... }).
  2. letتكون المتغيرات قابلة للاستخدام فقط في أسطر الكود التي تحدث بعد إعلان المتغير (على الرغم من أنه يتم رفعه !).
  3. letلا يجوز إعادة تعريف المتغيرات بواسطة لاحقة varأو let.
  4. letالمتغيرات العمومية لا تضاف إلى windowالكائن العام.
  5. letالمتغيرات هي سهلة الاستخدام مع إغلاق (أنها لا تسبب ظروف السباق ).

القيود المفروضة من خلال letالحد من وضوح المتغيرات وزيادة احتمالية حدوث اصطدامات اسم غير متوقعة في وقت مبكر. هذا يجعل من السهل تتبع المتغيرات والسبب فيها ، بما في ذلك reachability (المساعدة في استعادة الذاكرة غير المستخدمة).

ونتيجة لذلك ، letتقل احتمالية تسبب المتغيرات في حدوث مشكلات عند استخدامها في البرامج الكبيرة أو عندما يتم دمج الأطر المطورة بشكل مستقل بطرق جديدة وغير متوقعة.

varقد يكون مفيدًا إذا كنت متأكدًا من أنك تريد تأثير الربط المفرد عند استخدام الإغلاق في حلقة (# 5) أو لإعلان المتغيرات العامة المرئية خارجياً في التعليمات البرمجية (# 4). varقد يحل محل الاستخدام للصادرات إذا تم exportترحيلها من مساحة التحويل إلى لغة أساسية.

أمثلة

1. عدم الاستخدام خارج أقرب كتلة مرفقة: سيؤدي هذا الكود من التعليمات البرمجية إلى إلقاء خطأ مرجعي نظرًا لأن الاستخدام الثاني xيحدث خارج الكتلة التي تم الإعلان عنها باستخدام let:

{
    let x = 1;
}
console.log(`x is ${x}`);  // ReferenceError during parsing: "x is not defined".

في المقابل ، نفس المثال مع varالأعمال.

2. لا يوجد استخدام قبل الإعلان:
هذا القالب من التعليمات البرمجية سيلقي ReferenceErrorقبل تشغيل التعليمة البرمجية لأنه xيتم استخدامه قبل إعلانه:

{
    x = x + 1;  // ReferenceError during parsing: "x is not defined".
    let x;
    console.log(`x is ${x}`);  // Never runs.
}

في المقابل ، المثال نفسه مع varparses ويدير دون إلقاء أي استثناءات.

3. لا يوجد redeclaration: يوضح التعليمة البرمجية التالية أنه letقد لا يتم redeclared متغير مع تعريفه فيما بعد:

let x = 1;
let x = 2;  // SyntaxError: Identifier 'x' has already been declared

4. globals لا تعلق على window:

var button = "I cause accidents because my name is too common.";
let link = "Though my name is common, I am harder to access from other JS files.";
console.log(link);  // OK
console.log(window.link);  // undefined (GOOD!)
console.log(window.button);  // OK

5. سهل الاستخدام مع الإغلاق: المتغيرات المعلنة مع varلا تعمل بشكل جيد مع إغلاق داخل حلقات. وهنا حلقة بسيطة تخرج تسلسل القيم التي لدى المتغير iفي نقاط زمنية مختلفة:

for (let i = 0; i < 5; i++) {
    console.log(`i is ${i}`), 125/*ms*/);
}

على وجه التحديد ، هذه النواتج:

i is 0
i is 1
i is 2
i is 3
i is 4

في JavaScript ، غالبًا ما نستخدم المتغيرات في وقت لاحق بكثير من وقت إنشائها. عندما نوضح ذلك بتأخير الإخراج مع إغلاق الإغلاق إلى setTimeout:

for (let i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... يبقى الناتج دون تغيير طالما أننا نتمسك به let. في المقابل ، إذا استخدمنا var iبدلاً من ذلك:

for (var i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... تتسبب الحلقة بشكل غير متوقع في "i 5" خمس مرات:

i is 5
i is 5
i is 5
i is 5
i is 5

بعض الاختراقات مع let:

1.

    let statistics = [16, 170, 10];
    let [age, height, grade] = statistics;

    console.log(height)

2.

    let x = 120,
    y = 12;
    [x, y] = [y, x];
    console.log(`x: ${x} y: ${y}`);

3.

    let node = {
                   type: "Identifier",
                   name: "foo"
               };

    let { type, name, value } = node;

    console.log(type);      // "Identifier"
    console.log(name);      // "foo"
    console.log(value);     // undefined

    let node = {
        type: "Identifier"
    };

    let { type: localType, name: localName = "bar" } = node;

    console.log(localType);     // "Identifier"
    console.log(localName);     // "bar"

جتر واضعة مع let:

let jar = {
    numberOfCookies: 10,
    get cookies() {
        return this.numberOfCookies;
    },
    set cookies(value) {
        this.numberOfCookies = value;
    }
};

console.log(jar.cookies)
jar.cookies = 7;

console.log(jar.cookies)

دعونا هو جزء من es6. هذه الوظائف سوف تشرح الفرق بطريقة سهلة.

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}

في السابق لم يكن هناك سوى نطاقات في JavaScript ، أي وظيفية وعالمية. من خلال letالكلمة الأساسية "JavaScript" ، فقد أدخلت الآن block-levelمتغيرات.

للحصول على فهم كامل للكلمة الأساسية "let" ، ES6: "let" ستُستخدم الكلمة الرئيسية لإعلام المتغير في JavaScript .





let