javascript - "যাক" এবং "var" ব্যবহার করে জাভাস্ক্রিপ্টে একটি পরিবর্তনশীল ঘোষণা করার মধ্যে পার্থক্য কী?




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

একটি ফাংশন ভিতরে

একটি ফাংশন ভিতরে (কিন্তু একটি ব্লকের বাইরে), 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

একটি ব্লক ভিতরে

একটি ব্লক ভিতরে প্রবেশ ব্যবহার করে ঘোষিত ভেরিয়েবল যে ব্লকের বাইরে অ্যাক্সেস করা যাবে না।

{
  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

একটি লুপ ভিতরে

ভেতরে ঢুকতে let ভেরিয়েবলগুলি কেবল সেই লুপের ভিতরে উল্লেখ করা যেতে পারে।

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.

বন্ধ সঙ্গে loops

আপনি যদি লুপের পরিবর্তে var পরিবর্তে ব্যবহার করেন let প্রতিটি পুনরাবৃত্তি সহ আপনি একটি নতুন পরিবর্তনশীল পাবেন। এর মানে হল যে আপনি লুপের ভিতরে একটি বন্ধ করার জন্য নিরাপদে ব্যবহার করতে পারেন।

// 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);
}

সাময়িক মৃত অঞ্চল

সাময়িক মৃত জোনের কারণে , ঘোষিত হওয়ার আগে ঘোষিত ভেরিয়েবলগুলি প্রবেশের আগে অ্যাক্সেস করা যাবে না। তাই করার চেষ্টা একটি ত্রুটি ছুড়ে ফেলে।

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

কোন পুনরায় ঘোষণা

আপনি ব্যবহার করে একই পরিবর্তনশীল একাধিক বার ঘোষণা করতে পারবেন না। আপনি একই ভেরিফাইফায়ারের সাহায্যে অন্য ভেরিয়েবলের সাহায্যে একটি ভেরিয়েবল ঘোষণা করতে পারবেন না যা 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 লাইট-এর ব্লক-স্কোপডের মতই বেশিরভাগ এবং টিডিজেড রয়েছে। তবে, দুটি জিনিস যা ভিন্ন।

কোন পুনরায় নিয়োগ

কনস্টেবল ব্যবহার করে ঘোষণা করা পরিবর্তনশীল পুনরায় নিয়োগ করা যাবে না।

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

মনে রাখবেন যে মানটি অপরিবর্তনীয় নয়। তার বৈশিষ্ট্য এখনও পরিবর্তন করা যেতে পারে।

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

আপনি যদি একটি Object.freeze() বস্তু চান তবে আপনাকে Object.freeze() ব্যবহার করতে হবে।

সূচনাকারী প্রয়োজন

const ব্যবহার করে একটি পরিবর্তনশীল ঘোষণা যখন আপনি সবসময় একটি মান উল্লেখ করা আবশ্যক।

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

ECMAScript 6 let বিবৃতি চালু। আমি এটি একটি "স্থানীয়" পরিবর্তনশীল হিসাবে বর্ণনা করেছি শুনেছি, কিন্তু আমি এখনও var শব্দ থেকে ভিন্ন আচরণ কিভাবে তা নিশ্চিত না।

পার্থক্য কি? যখন var ব্যবহার করা উচিত?


ফাংশন ভি এস ব্লক সুযোগ:

মধ্যে মূল পার্থক্য varএবং letভেরিয়েবল ঘোষিত যে varহয় ফাংশন scopedব্লক scoped হয় সঙ্গে ফাংশন ঘোষণা করা 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পরিবর্তনশীল foo নামে ডাকা হয়, তখন ঘোষণা করা হয় var, এটি এখনও ifবিবৃতির বাইরে অ্যাক্সেসযোগ্য । এই পরিবর্তনশীল ফাংশন সুযোগ মধ্যে সর্বত্রfoo উপলব্ধ হবে ।testVar

সঙ্গে ভেরিয়েবল let:

যখন দ্বিতীয় ফাংশনটি testLetভেরিয়েবল বার বলা হয়, এর সাথে ঘোষণা করা হয় let, কেবল ifবিবৃতির মধ্যে অ্যাক্সেসযোগ্য । কারণ ভেরিয়েবল ঘোষিত letহয় ব্লক scoped (যেখানে একটি ব্লক কোঁকড়া বন্ধনী মধ্যে কোড উদাঃ if{}, for{}, function{})।

let ভেরিয়েবলগুলি ফরোয়ার্ড করা হয় না:

মধ্যে অন্য পার্থক্য varএবং letঘোষণা সঙ্গে পরিবর্তনশীল হয় let hoisted না । এই আচরণকে চিত্রিত করার সেরা উপায় হল একটি উদাহরণ:

ঝাঁকনি 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যখনই আপনি কারণ এটি সহজভাবে আরও নির্দিষ্ট scoped হয় পারবেন না। এটি সম্ভাব্য নামকরণ দ্বন্দ্ব হ্রাস করে যা প্রচুর সংখ্যক ভেরিয়েবলগুলির সাথে ডিল করার সময় ঘটতে পারে। varআপনি গ্লোবাল ভেরিয়েবল স্পষ্টভাবে windowবস্তুর উপর হতে চান যখন ব্যবহার করা যেতে পারে (এটি সত্যিই প্রয়োজন হলে সাবধানে বিবেচনা করুন)।


অন্যদের ইতিমধ্যে লিখিত আছে কি যোগ করার জন্য এখানে একটি উদাহরণ। ধরুন আপনি ফাংশনগুলির অ্যারে তৈরি করতে চান, adderFunctions , যেখানে প্রতিটি ফাংশন একটি সংখ্যা সংখ্যার আর্গুমেন্ট নেয় এবং অ্যারের মধ্যে আর্গুমেন্ট এবং ফাংশনের সূচী যোগ করে। var শব্দ ব্যবহার করে একটি লুপ সহ adderFunctions জেনারেট করার চেষ্টা করছে কেউ adderFunctions প্রত্যাশা হতে পারে উপায় কাজ করবে না:

// 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 ফোকাসটি প্রতিটি ফাংশন তৈরির ব্লকের পুনরাবৃত্তি ছাড়িয়ে প্রসারিত হয়। এর পরিবর্তে, লুপের শেষে, প্রতিটি ফাংশনের ক্লোজারে i adderFunctions ফাংশনগুলির প্রতিটি বেনামী ফাংশনের জন্য লুপ (1000) এর শেষে মান নির্ধারণ adderFunctions । আমরা যা চেয়েছি তা এই নয়: আমাদের কাছে এখন একই রকম আচরণের সাথে স্মৃতিতে 1000 টি ভিন্ন ফাংশন রয়েছে। এবং আমরা যদি পরবর্তীতে i মান আপডেট i , তবে মিউটেশন সমস্ত adderFunctions প্রভাবিত করবে।

যাইহোক, আমরা কীওয়ার্ড ব্যবহার করে আবার চেষ্টা করতে পারি:

// 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 লুপ for প্রতিটি পুনরাবৃত্তি উপর rebound হয়। প্রতিটি ফাংশন এখন ফাংশনের তৈরির সময় 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

এই আপনি ঘটতে না। একটি linter ব্যবহার করুন।

দ্রষ্টব্য: এটি একটি শিক্ষণ উদাহরণ যা লুপগুলির মধ্যে আচরণ var/ letআচরণ এবং ফাংশন ক্লোজারগুলি প্রদর্শনের উদ্দেশ্যে যা বোঝা সহজ হবে। এই সংখ্যা যোগ করার একটি ভয়ঙ্কর উপায় হতে হবে। কিন্তু বেনামী ফাংশন ক্লোজারে ডেটা ক্যাপচার করার সাধারণ কৌশল অন্যান্য প্রসঙ্গে আসল জগতে সম্মুখীন হতে পারে। YMMV।


এখানে কিছু উদাহরণ দিয়ে let শব্দ একটি ব্যাখ্যা

যাক var মত খুব কাজ করে। প্রধান পার্থক্য হল একটি var পরিবর্তনশীল সুযোগটি পুরো এনক্লোজিং ফাংশন

উইকিপিডিয়াতে এই টেবিলটি দেখায় যে কোন ব্রাউজার জাভাস্ক্রিপ্ট 1.7 সমর্থন করে।

মনে রাখবেন শুধুমাত্র মোজিলা এবং Chrome ব্রাউজার এটি সমর্থন করে। IE, সাফারি, এবং সম্ভাব্য অন্যদের না।


এছাড়াও বন্ধ সঙ্গে সমস্যা এড়ানোর জন্য ব্যবহার করা যেতে পারে। এটি নীচের উদাহরণ হিসাবে দেখানো পুরানো রেফারেন্স রাখা পরিবর্তে তাজা মান আবদ্ধ।

DEMO

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

উপরে কোড একটি ক্লাসিক জাভাস্ক্রিপ্ট বন্ধ সমস্যা প্রদর্শন করে। i ভেরিয়েবলের রেফারেন্সটি i এর প্রকৃত মানের পরিবর্তে ক্লিক হ্যান্ডলার বন্ধে সংরক্ষণ করা হচ্ছে।

প্রতিটি একক হ্যান্ডলার হ্যান্ডলার একই বস্তুর কথা উল্লেখ করবে কারণ সেখানে কেবল একটি পাল্টা অবজেক্ট রয়েছে যা 6 ধরে থাকে তাই আপনি প্রতিটি ক্লিকে ছয়টি পেতে পারেন।

সাধারণ কার্যকারিতাটি একটি বেনামী ফাংশনে এটি মোড়ানো এবং i যুক্তি হিসাবে পাস i । এই ধরনের সমস্যাগুলি এখন নীচের কোড দেখানো let পরিবর্তে var ব্যবহার করে এড়াতে পারে।

DEMO (ক্রোম এবং ফায়ারফক্স 50 পরীক্ষা)

'use strict';

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

কিছু সূক্ষ্ম পার্থক্য রয়েছে - স্কোপিংকে আরও পরিবর্তনশীল স্কোপিংয়ের মতো আচরণ করা let যেগুলি অন্য কোনও ভাষায় কম বা কম।

উদাহরণস্বরূপ এটি এনক্লোজিং ব্লকের দিকে ঝুঁকে পড়েছে, তারা ঘোষিত হওয়ার আগে অস্তিত্ব নেই, ইত্যাদি।

তবে এটি জাভাস্ক্রিপ্ট বাস্তবায়নগুলির একটি অংশ মাত্র এবং এটির ব্রাউজার সমর্থনের বিভিন্ন ডিগ্রী রয়েছে তা উল্লেখযোগ্য।


পার্থক্য scoping হয়। var সবচেয়ে কাছের ফাংশন ব্লক এ scoped হয় এবং let নিকটতম এনক্লোজিং ব্লক, যা একটি ফাংশন ব্লক চেয়ে ছোট হতে পারে scoped করা হয়। উভয় ব্লক বাইরে যদি উভয় গ্লোবাল হয়।

এছাড়াও, উল্লিখিত ঘোষিত ভেরিয়েবলগুলি তাদের অবরোধকারী ব্লকটিতে ঘোষিত হওয়ার আগে অ্যাক্সেসযোগ্য নয়। ডেমো হিসাবে দেখা যায়, এটি একটি রেফারেন্স ইরাক ব্যতিক্রম নিক্ষেপ করা হবে।

Demo

var html = '';

write('#### global ####\n');
write('globalVar: ' + globalVar); //undefined, but visible

try {
  write('globalLet: ' + globalLet); //undefined, *not* visible
} catch (exception) {
  write('globalLet: exception');
}

write('\nset variables');

var globalVar = 'globalVar';
let globalLet = 'globalLet';

write('\nglobalVar: ' + globalVar);
write('globalLet: ' + globalLet);

function functionScoped() {
  write('\n#### function ####');
  write('\nfunctionVar: ' + functionVar); //undefined, but visible

  try {
    write('functionLet: ' + functionLet); //undefined, *not* visible
  } catch (exception) {
    write('functionLet: exception');
  }

  write('\nset variables');

  var functionVar = 'functionVar';
  let functionLet = 'functionLet';

  write('\nfunctionVar: ' + functionVar);
  write('functionLet: ' + functionLet);
}

function blockScoped() {
  write('\n#### block ####');
  write('\nblockVar: ' + blockVar); //undefined, but visible

  try {
    write('blockLet: ' + blockLet); //undefined, *not* visible
  } catch (exception) {
    write('blockLet: exception');
  }

  for (var blockVar = 'blockVar', blockIndex = 0; blockIndex < 1; blockIndex++) {
    write('\nblockVar: ' + blockVar); // visible here and whole function
  };

  for (let blockLet = 'blockLet', letIndex = 0; letIndex < 1; letIndex++) {
    write('blockLet: ' + blockLet); // visible only here
  };

  write('\nblockVar: ' + blockVar);

  try {
    write('blockLet: ' + blockLet); //undefined, *not* visible
  } catch (exception) {
    write('blockLet: exception');
  }
}

function write(line) {
  html += (line ? line : '') + '<br />';
}

functionScoped();
blockScoped();

document.getElementById('results').innerHTML = html;
<pre id="results"></pre>

বিশ্ব:

একটি ফাংশন ব্লক বাইরে এই মত ব্যবহৃত যখন তারা খুব অনুরূপ।

let me = 'go';  // globally scoped
var i = 'able'; // globally scoped

যাইহোক, গ্লোবাল ভেরিয়েবলগুলিকে let দিয়ে সংজ্ঞায়িত করা হবে গ্লোবাল window অবজেক্টের বৈশিষ্ট্যের সাথে ভ্যারের সাথে সংজ্ঞায়িত করা হবে না।

console.log(window.me); // undefined
console.log(window.i); // 'able'

ফাংশন:

একটি ফাংশন ব্লক এই মত ব্যবহৃত যখন তারা অভিন্ন।

function ingWithinEstablishedParameters() {
    let terOfRecommendation = 'awesome worker!'; //function block scoped
    var sityCheerleading = 'go!'; //function block scoped
}

ব্লক:

এখানে পার্থক্য। let জন্য শুধুমাত্র দৃশ্যমান for() লুপ এবং var পুরো ফাংশন দৃশ্যমান।

function allyIlliterate() {
    //tuce is *not* visible out here

    for( let tuce = 0; tuce < 5; tuce++ ) {
        //tuce is only visible in here (and in the for() parentheses)
        //and there is a separate tuce variable for each iteration of the loop
    }

    //tuce is *not* visible out here
}

function byE40() {
    //nish *is* visible out here

    for( var nish = 0; nish < 5; nish++ ) {
        //nish is visible to the whole function
    }

    //nish *is* visible out here
}

পুনঃঘোষণা:

কঠোর মোড অনুমান, var আপনি একই একই পরিবর্তনশীল একই পরিবর্তনশীল করতে হবে। অন্যদিকে, চলবে না:

'use strict';
let me = 'foo';
let me = 'bar'; // SyntaxError: Identifier 'me' has already been declared
'use strict';
var me = 'foo';
var me = 'bar'; // No problem, `me` is replaced.

প্রধান পার্থক্য হল সুযোগের পার্থক্য, যখন এটি কেবল ঘোষিত সুযোগের ভিতরেই পাওয়া যেতে পারে, উদাহরণস্বরূপ লুপের জন্য, 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 x = 'global';
let y = 'global';
console.log(this.x); // "global"
console.log(this.y); // undefined

যখন একটি ব্লকের ভিতরে ব্যবহার করা হয়, সেই ব্লকে পরিবর্তনশীলের সুযোগ সীমাবদ্ধ করুন। ভ্যারের মধ্যে পার্থক্যটি লক্ষ্য করুন ফাংশনটির ভিতরে যেখানে এটি ঘোষণা করা হয়।

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 এ সর্বদা এটি স্বচ্ছ করে ...


let আকর্ষণীয়, কারণ এটি আমাদেরকে এমন কিছু করার অনুমতি দেয়:

(() => {
    var count = 0;

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

গণনা যা ফলাফল [0, 7]।

যেহেতু

(() => {
    var count = 0;

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

শুধুমাত্র গণনা [0, 1]।


var বৈশ্বিক সুযোগ (hoist-সক্ষম) পরিবর্তনশীল।

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


উপরে উল্লিখিত:

পার্থক্য scoping হয়। varনিকটতম করার scoped হয় ফাংশন ব্লক এবং letকরতে scoped হয় নিকটতম এনক্লোজিং ব্লক , যা একটি ফাংশন ব্লক চেয়ে ছোট হতে পারে। উভয় ব্লক বাইরে যদি কোনো ব্লক। একটি উদাহরণ দেখতে দেওয়া যাক:

Example1:

আমার উভয় উদাহরণে আমার একটি ফাংশন আছে myfuncmyfuncএকটি পরিবর্তনশীল myvarসমান 10 আছে। আমার প্রথম উদাহরণে আমি myvar10 ( myvar==10) সমান কিনা চেক । যদি হ্যাঁ, আমি কীওয়ার্ড myvarব্যবহার করে একটি পরিবর্তনশীল (এখন আমার দুটি ম্যাইভার ভেরিয়েবল আছে) ঘোষণা করে varএবং এটি একটি নতুন মান নির্ধারণ করে (20)। পরবর্তী লাইনে আমি আমার কনসোলের উপর তার মান মুদ্রণ করি। শর্তাধীন ব্লক পরে আমি আবার myvarআমার কনসোলের মান মুদ্রণ । আপনি আউটপুট তাকান myfunc, myvarমান সমান 20 আছে।

উদাহরণ 2 : আমার দ্বিতীয় উদাহরণে varআমার শর্তাধীন ব্লকের কীওয়ার্ড ব্যবহার করার পরিবর্তে আমি কীওয়ার্ড myvarব্যবহার করে ঘোষণা করছি let। এখন আমি কল যখন আমি myfuncদুটি বিভিন্ন আউটপুট পেতে: myvar=20এবং myvar=10

সুতরাং পার্থক্য তার সহজ সুযোগ মানে খুব সহজ।


এই নিবন্ধটি পরিষ্কারভাবে var, let এবং const এর মধ্যে পার্থক্য সংজ্ঞায়িত করে

const একটি সংকেত সনাক্তকারী সনাক্ত করা হবে না।

let, একটি সংকেত যে পরিবর্তনশীল পুনরায় reassigned করা যেতে পারে, যেমন একটি লুপ একটি পাল্টা, অথবা একটি অ্যালগরিদম একটি মান সোয়াপ। এটি সংকেত দেয় যে ভেরিয়েবলটি শুধুমাত্র সেই ব্লকটিতে ব্যবহার করা হবে যা এটি সংজ্ঞায়িত করা হয়েছে, যা সর্বদা সম্পূর্ণ ধারণকারী ফাংশন নয়।

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
}

MDN এই লিঙ্কটি পরীক্ষা করে দেখুন

let x = 1;

if (x === 1) {
let x = 2;

console.log(x);
// expected output: 2
}

console.log(x);
// expected output: 1

এস 6 এর একটি অংশ যাক। এই ফাংশন সহজ ভাবে পার্থক্য ব্যাখ্যা করবে।

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
}

কিছু হ্যাক সঙ্গে 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"

সঙ্গে গেট্টার এবং Setter 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)

পূর্বে জাভাস্ক্রিপ্টে শুধুমাত্র দুটি স্কোপ ছিল, অর্থাৎ কার্যকরী এবং বিশ্বব্যাপী। 'Keyword' দিয়ে letজাভাস্ক্রিপ্ট এখন block-levelভেরিয়েবল চালু করেছে ।

'লেট' কীওয়ার্ডের সম্পূর্ণ বোঝার জন্য, ES6: জাভাস্ক্রিপ্টে পরিবর্তনশীল ঘোষণা করতে 'কী' শব্দটি সাহায্য করবে।


যদি আমি ডান তারপর চশমা পড়া let সৌভাগ্যক্রমে এছাড়াও বেসরকারী শুধুমাত্র সদস্যদের ভান ব্যবহৃত স্ব আবাহন ফাংশন এড়াতে leveraged যাবে না - হয়তো পরিতৃপ্ত কেউ আছে ব্যতীত - একটি জনপ্রিয় নকশা প্যাটার্ন যে কোড পাঠযোগ্যতা কমে ডিবাগিং, কোন বাস্তব কোড সুরক্ষা বা অন্যান্য সুবিধা বলেছেন যে complicates semantics জন্য ইচ্ছা, তাই এটি ব্যবহার বন্ধ করুন। / গলাবাজি

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

'দেখুন ব্যক্তিগত ইন্টারফেসগুলি এমুলেট '







let