Const ใน JavaScript: ควรใช้เมื่อใดและจำเป็นหรือไม่

ฉันเพิ่งเจอconstคำสำคัญใน JavaScript จากสิ่งที่ฉันสามารถบอกได้มันถูกใช้เพื่อสร้างตัวแปรที่ไม่เปลี่ยนรูปแบบและฉันได้ทดสอบเพื่อให้แน่ใจว่าไม่สามารถนิยามใหม่ได้ (ใน Node.js):

const x = 'const';
const x = 'not-const';

// Will give an error: 'constant 'x' has already been defined'

ฉันรู้ว่ามันยังไม่ได้มาตรฐานบนเบราว์เซอร์ทั้งหมด - แต่ฉันสนใจเฉพาะในบริบทของNode.js V8และฉันสังเกตเห็นว่าผู้พัฒนา / โครงการบางอย่างดูเหมือนจะให้ความสำคัญอย่างยิ่งเมื่อvarสามารถใช้คำหลักกับ ผลกระทบเดียวกัน

ดังนั้นคำถามของฉันคือ:

• เมื่อไรที่มันจะเหมาะสมที่จะใช้constในสถานที่ของvar?
• ควรใช้ทุกครั้งที่มีการประกาศตัวแปรที่ไม่ได้ถูกกำหนดใหม่หรือไม่?
• จริง ๆ แล้วมันสร้างความแตกต่างถ้าvarมีการใช้ในสถานที่ของ constหรือในทางกลับกัน?

คำถามของคุณมีอยู่สองด้าน: อะไรคือแง่มุมทางเทคนิคของการใช้constแทนvarและสิ่งที่เกี่ยวข้องกับมนุษย์ในการทำเช่นนั้น

ความแตกต่างทางเทคนิคมีความสำคัญ ในภาษาที่คอมไพล์ค่าคงที่จะถูกแทนที่ในเวลาคอมไพล์และการใช้งานจะช่วยให้การเพิ่มประสิทธิภาพอื่น ๆ เช่นการกำจัดรหัสที่ตายแล้วเพื่อเพิ่มประสิทธิภาพรันไทม์ของรหัสต่อไป เอ็นจิน JavaScript ล่าสุด (ใช้งานอย่างหลวม ๆ ) จริง ๆ แล้วรวบรวมรหัส JS เพื่อให้ได้ประสิทธิภาพที่ดีขึ้นดังนั้นการใช้คำหลัก const จะแจ้งให้พวกเขาทราบว่าการเพิ่มประสิทธิภาพที่อธิบายไว้ข้างต้นเป็นไปได้และควรทำ ส่งผลให้ประสิทธิภาพดีขึ้น

แง่มุมที่เกี่ยวข้องกับมนุษย์นั้นเกี่ยวกับความหมายของคำหลัก ตัวแปรคือโครงสร้างข้อมูลที่มีข้อมูลที่คาดว่าจะเปลี่ยนแปลง ค่าคงที่คือโครงสร้างข้อมูลที่มีข้อมูลที่จะไม่เปลี่ยนแปลง หากมีห้องสำหรับข้อผิดพลาดvarควรใช้เสมอ constแต่ไม่ข้อมูลที่ไม่เคยเปลี่ยนแปลงในชีวิตของโปรแกรมที่จะต้องมีการประกาศด้วย หากภายใต้สถานการณ์ต่าง ๆ ข้อมูลควรเปลี่ยนใช้varเพื่อระบุว่าแม้ว่าการเปลี่ยนแปลงที่แท้จริงจะไม่ปรากฏในรหัสของคุณ

2017 Update

คำตอบนี้ยังคงได้รับความสนใจอย่างมาก เป็นที่น่าสังเกตว่าคำตอบนี้ถูกโพสต์ย้อนกลับไปเมื่อต้นปี 2014 และมีการเปลี่ยนแปลงมากมายตั้งแต่นั้นมาECMAScript-6การสนับสนุนอยู่ในขณะนี้เป็นบรรทัดฐาน เบราว์เซอร์ที่ทันสมัยทั้งหมดรองรับการใช้งานconstดังนั้นมันจึงค่อนข้างปลอดภัยที่จะใช้โดยไม่มีปัญหา

คำตอบเดิมจาก 2014

แม้จะมีการสนับสนุนเบราว์เซอร์ที่ดีพอสมควรแต่ฉันก็ไม่ควรใช้มันในตอนนี้ จากบทความของ MDN เมื่อconst :

การใช้งาน const ปัจจุบันเป็นส่วนเสริมเฉพาะ Mozilla และไม่ได้เป็นส่วนหนึ่งของ ECMAScript 5 รองรับใน Firefox & Chrome (V8) ตั้งแต่ Safari 5.1.7 และ Opera 12.00 หากคุณกำหนดตัวแปรด้วย const ในเบราว์เซอร์เหล่านี้คุณยังสามารถเปลี่ยนค่าได้ในภายหลัง ไม่รองรับใน Internet Explorer 6-10 แต่รวมอยู่ใน Internet Explorer 11 คำหลัก const ปัจจุบันจะประกาศค่าคงที่ในขอบเขตฟังก์ชัน (เช่นตัวแปรที่ประกาศด้วย var)

จากนั้นจะกล่าวต่อไปว่า:

constจะถูกกำหนดโดย ECMAScript 6 แต่มีความหมายต่างกัน คล้ายกับตัวแปรที่ประกาศด้วยคำสั่ง let ค่าคงที่ที่ประกาศด้วย const จะถูกกำหนดขอบเขตแบบบล็อก

หากคุณใช้constคุณจะต้องเพิ่มวิธีแก้ไขปัญหาเพื่อรองรับเบราว์เซอร์รุ่นเก่ากว่าเล็กน้อย

ทำไมต้องใช้constคำตอบของ @ Tibos นั้นยอดเยี่ยม

แต่คุณพูดว่า:

จากสิ่งที่ฉันสามารถบอกได้มันถูกใช้เพื่อสร้างตัวแปรที่ไม่เปลี่ยนรูป

นั่นคือที่ไม่ถูกต้อง การกลายพันธุ์ตัวแปรนั้นแตกต่างจากการกำหนดใหม่:

var hello = 'world' // assigning
hello = 'bonjour!' // reassigning

ด้วย const คุณไม่สามารถทำได้:

const hello = 'world'
hello = 'bonjour!' // error

แต่คุณสามารถกลายพันธุ์ตัวแปรของคุณ:

const marks = [92, 83]
marks.push(95)
console.log(marks) // [92, 83, 95] -> the variable has been mutated.

ดังนั้นกระบวนการใด ๆ ที่เปลี่ยนแปลงค่าของตัวแปรโดยไม่ต้องใช้=เครื่องหมายจะทำการเปลี่ยนแปลงตัวแปร

หมายเหตุ: +=ตัวอย่างเช่น ... กำหนดใหม่!

var a = 5
a += 2 // is the same as a = a + 2

ดังนั้นบรรทัดล่างคือ: constไม่ป้องกันคุณจากการกลายพันธุ์ของตัวแปรมันป้องกันคุณจากการกำหนดมันใหม่

หากต้องการรวมคำตอบก่อนหน้านี้มีข้อได้เปรียบที่ชัดเจนในการประกาศตัวแปรคงที่นอกเหนือจากเหตุผลด้านประสิทธิภาพ: หากคุณพยายามเปลี่ยนหรือประกาศอีกครั้งในรหัสโดยไม่ตั้งใจโปรแกรมจะไม่เปลี่ยนค่าหรือโยนข้อผิดพลาดตามลำดับ

ตัวอย่างเช่นเปรียบเทียบ:

// Will output 'SECRET'

const x = 'SECRET'
if (x = 'ANOTHER_SECRET') {  // Warning! assigning a value variable in an if condition
    console.log (x)
}

ด้วย:

// Will output 'ANOTHER_SECRET'

var y = 'SECRET'
if (y = 'ANOTHER_SECRET') { 
    console.log (y)
}

หรือ

// Will throw TypeError: const 'x' has already been declared

const x = "SECRET"

/*  complex code */

var x = 0

กับ

// Will reassign y and cause trouble

var y = "SECRET"

/*  complex code */

var y = 0

constคือไม่ได้เปลี่ยนรูป

จากMDN :

การประกาศ const สร้างการอ้างอิงแบบอ่านอย่างเดียวกับค่า ไม่ได้หมายความว่าค่าที่เก็บไว้นั้นไม่เปลี่ยนรูปเพียง แต่ตัวระบุตัวแปรไม่สามารถกำหนดใหม่ได้

var : ประกาศตัวแปรการกำหนดค่าเริ่มต้นเป็นตัวเลือก

ให้ : ประกาศตัวแปรท้องถิ่นที่มีขอบเขตบล็อก

const : ประกาศค่าคงที่ชื่อแบบอ่านอย่างเดียว

Ex:

var a;
a = 1;
a = 2;//re-initialize possible
var a = 3;//re-declare
console.log(a);//3

let b;
b = 5;
b = 6;//re-initiliaze possible
// let b = 7; //re-declare not possible
console.log(b);

// const c;
// c = 9;   //initialization and declaration at same place
const c = 9;
// const c = 9;// re-declare and initialization is not possible
console.log(c);//9
// NOTE: Constants can be declared with uppercase or lowercase, but a common
// convention is to use all-uppercase letters.

คุณมีคำตอบที่ดี แต่ขอให้ง่าย

const ควรใช้เมื่อคุณมีค่าคงที่ที่กำหนดไว้ (อ่านเป็น: มันจะไม่เปลี่ยนแปลงระหว่างการทำงานของโปรแกรม)

ตัวอย่างเช่น:

const pi = 3.1415926535

varถ้าคุณคิดว่ามันเป็นสิ่งที่อาจมีการเปลี่ยนแปลงในการดำเนินการภายหลังจากนั้นใช้

ความแตกต่างในทางปฏิบัติตามตัวอย่างคือเมื่อconstคุณคิดว่า pi จะเท่ากับ 3.14 [... ] มันเป็นเรื่องจริง

หากคุณกำหนดว่าเป็น a varอาจเป็น 3.14 [... ] หรือไม่

สำหรับคำตอบทางเทคนิคเพิ่มเติม @Tibos นั้นถูกต้องทางวิชาการ

จากประสบการณ์ของฉันฉันใช้constเมื่อฉันต้องการตั้งค่าบางอย่างฉันอาจต้องการเปลี่ยนในภายหลังโดยไม่ต้องค้นหารหัสที่ค้นหาบิตที่เข้ารหัสยากเช่นเส้นทางไฟล์หรือชื่อเซิร์ฟเวอร์

ข้อผิดพลาดในการทดสอบของคุณเป็นอีกสิ่งหนึ่งแม้ว่าคุณกำลังพยายามทำให้ตัวแปรอีกตัวหนึ่งเรียกว่า x นี่เป็นการทดสอบที่แม่นยำมากขึ้น

const x = 'const';
x = 'not-const';

ความชอบส่วนตัวจริงๆ คุณสามารถใช้ const ได้เมื่อคุณบอกว่ามันจะไม่ถูกกำหนดใหม่และคงที่ ตัวอย่างเช่นถ้าคุณต้องการกำหนดวันเกิดของคุณ วันเกิดของคุณจะไม่เปลี่ยนแปลงดังนั้นคุณสามารถใช้เป็นค่าคงที่ได้ แต่อายุของคุณมีการเปลี่ยนแปลงเพื่อที่จะเป็นตัวแปร

สรุป:

const สร้างการโยงที่ไม่เปลี่ยนรูปความหมายตัวระบุตัวแปร const ไม่สามารถกำหนดใหม่ได้

const a = "value1";

คุณไม่สามารถกำหนดใหม่ด้วย

a = "value2";

อย่างไรก็ตามหากตัวระบุ const เก็บวัตถุหรืออาร์เรย์ค่าของมันสามารถเปลี่ยนแปลงได้ตราบที่เราไม่ได้กำหนดค่าใหม่

const x = { a: 1 }

x.a = 2; //is possible and allowed

const numbers = [1, 2];
numbers.push(3); //is possible and allowed

โปรดทราบว่าconstเป็นบล็อกที่กำหนดขอบเขตเช่นเดียวกับอนุญาตซึ่งไม่เหมือนกับvar (ซึ่งเป็นฟังก์ชันที่กำหนดขอบเขต)

กล่าวโดยย่อเมื่อสิ่งที่ไม่น่าจะเปลี่ยนผ่านการกำหนดค่าใหม่ให้ใช้constอื่น ๆ ใช้letหรือvarขึ้นอยู่กับขอบเขตที่คุณต้องการ

มันง่ายกว่ามากที่จะให้เหตุผลเกี่ยวกับรหัสเมื่อมันตายไปอย่างชัดเจนว่าสิ่งใดที่สามารถเปลี่ยนแปลงได้ผ่านการมอบหมายใหม่และสิ่งที่ไม่สามารถทำได้ การเปลี่ยน const ให้เป็นปล่อยนั้นง่ายมาก และค่าคงที่โดยปริยายจะทำให้คุณคิดสองครั้งก่อนที่จะทำเช่นนั้น และนี่เป็นสิ่งที่ดีในหลาย ๆ กรณี

มันให้: 1) การอ้างอิงคงที่เช่น const x = [] - อาร์เรย์สามารถแก้ไขได้ แต่ x ไม่สามารถชี้ไปที่อาร์เรย์อื่นได้; และ 2) การกำหนดขอบเขตของบล็อก const และปล่อยให้ร่วมกันจะแทนที่ var ใน ecma6 / 2015 ดูการสนทนาที่https://strongloop.com/strongblog/es6-variable-declarations/

Main point is that how to decide which one identifier should be used during development.
In java-script here are three identifiers.

1. var (Can re-declared & re-initialize)
2. const (Can't re-declared & re-initialize, can update array values by using push)
3. let (Can re-initialize but can't re-declare)

'var': ในช่วงเวลาของการโค้ดเมื่อเราพูดถึงมาตรฐานโค้ดเรามักจะใช้ชื่อของตัวระบุซึ่งผู้ใช้ / นักพัฒนาคนอื่นเข้าใจได้ง่าย ตัวอย่างเช่นถ้าเรากำลังคิดฟังก์ชั่นมากมายที่เราใช้อินพุตและประมวลผลและคืนผลลัพธ์บางอย่างเช่น:

**Example of variable use**

function firstFunction(input1,input2)
{
 var process = input1 + 2; 
 var result = process - input2;
 return result;
}


function otherFunction(input1,input2)
{
 var process = input1 + 8; 
 var result = process * input2;
 return result;
}

ในตัวอย่างข้างต้นทั้งสองฟังก์ชั่นให้ผลลัพธ์ที่ต่างกัน -2 แต่ใช้ชื่อตัวแปรแบบเดียวกัน ที่นี่เราสามารถเห็น 'กระบวนการ' และ 'ผลลัพธ์' ทั้งคู่ถูกใช้เป็นตัวแปรและควรจะเป็น

 **Example of constant with variable**

 const tax = 10; 
 const pi = 3.1415926535; 

function firstFunction(input1,input2)
{
 var process = input1 + 2; 
 var result = process - input2;
 result = (result * tax)/100; 
 return result;
}


function otherFunction(input1,input2)
{
 var process = input1 + 8; 
 var result = process * input2 * pi;
 return result;
}

ก่อนที่จะใช้ 'ให้' ในจาวาสคริปต์เราต้องเพิ่ม 'ใช้เข้มงวด' ที่ด้านบนของไฟล์ js

 **Example of let with constant & variable**

 const tax = 10; 
 const pi = 3.1415926535; 
 let trackExecution = '';

function firstFunction(input1,input2)
{
 trackExecution += 'On firstFunction'; 
 var process = input1 + 2; 
 var result = process - input2;
 result = (result * tax)/100; 
 return result;
}


function otherFunction(input1,input2)
{
 trackExecution += 'On otherFunction'; # can add current time 
 var process = input1 + 8; 
 var result = process * input2 * pi;
 return result;
}

 firstFunction();
 otherFunction();
 console.log(trackExecution);

ในตัวอย่างข้างต้นคุณสามารถติดตามได้ว่าฟังก์ชั่นใดทำงานเมื่อ & ไม่ใช้ฟังก์ชั่นใดในระหว่างการดำเนินการเฉพาะ

ก่อนสามสิ่งที่มีประโยชน์เกี่ยวกับconst(นอกเหนือจากการปรับปรุงขอบเขตที่แบ่งปันกับlet):

• เป็นเอกสารสำหรับผู้ที่อ่านรหัสในภายหลังว่าค่าต้องไม่เปลี่ยนแปลง
• มันป้องกันคุณ (หรือใครก็ตามที่ตามมา) ไม่ให้เปลี่ยนค่าเว้นแต่พวกเขาจะกลับไปและเปลี่ยนการประกาศโดยเจตนา
• มันอาจจะช่วยเอ็นจิ้น JavaScript วิเคราะห์บางอย่างในแง่ของการปรับให้เหมาะสม ตัวอย่างเช่นคุณได้ประกาศว่าค่าไม่สามารถเปลี่ยนแปลงได้ดังนั้นเครื่องยนต์จึงไม่ต้องทำงานเพื่อหาว่าค่าเปลี่ยนแปลงหรือไม่เพื่อให้สามารถตัดสินใจได้ว่าจะปรับให้เหมาะสมตามค่าที่ไม่เปลี่ยนแปลงหรือไม่

คำถามของคุณ:

เมื่อไรที่มันจะเหมาะสมที่จะใช้constในสถานที่ของvar?

คุณสามารถทำได้ทุกเมื่อที่คุณประกาศตัวแปรที่ค่าไม่เคยเปลี่ยนแปลง ไม่ว่าคุณจะพิจารณาว่าเหมาะสมนั้นขึ้นอยู่กับความชอบ / ความชอบของทีมของคุณ

ควรใช้ทุกครั้งที่มีการประกาศตัวแปรที่ไม่ได้ถูกกำหนดใหม่หรือไม่?

ขึ้นอยู่กับคุณ / ทีมของคุณ

จริง ๆ แล้วมันสร้างความแตกต่างใด ๆ ถ้าvar is used in place ofconst` หรือในทางกลับกัน?

ใช่:

• varและconstมีกฎขอบเขตที่แตกต่างกัน (คุณอาจต้องการเปรียบเทียบletมากกว่าvar) โดยเฉพาะ: constและletมีการกำหนดขอบเขตแบบบล็อกและเมื่อใช้ที่ขอบเขตทั่วโลกอย่าสร้างคุณสมบัติบนวัตถุทั่วโลก (แม้ว่าพวกเขาจะสร้างกลม) varมีขอบเขตโกลบอล (เมื่อใช้ที่ขอบเขตโกลบอล) หรือขอบเขตฟังก์ชัน (แม้ว่าจะใช้ในบล็อก) และเมื่อใช้ที่ขอบเขตโกลบอลให้สร้างคุณสมบัติบนวัตถุโกลบอล
• ดู "สามสิ่งที่มีประโยชน์" ของฉันด้านบนพวกเขาทั้งหมดใช้กับคำถามนี้

ความหมายของvarและlet

varและletเป็นคำสั่งให้กับเครื่องและโปรแกรมเมอร์อื่น ๆ :

ฉันตั้งใจว่ามูลค่าของการมอบหมายนี้จะเปลี่ยนไประหว่างการดำเนินการ อย่าพึ่งพาค่าที่สุดของการมอบหมายนี้

ผลกระทบของการใช้varและlet

varและletบังคับให้โปรแกรมเมอร์รายอื่นอ่านโค้ดที่แทรกเข้าไปทั้งหมดจากการประกาศไปจนถึงการใช้งานในที่สุดและเหตุผลเกี่ยวกับมูลค่าของการมอบหมาย ณ จุดนั้นในการดำเนินการของโปรแกรม

พวกเขาทำให้เหตุผลที่เครื่องอ่อนแอสำหรับ ESLint และบริการภาษาอื่น ๆ เพื่อตรวจสอบชื่อตัวแปรที่พิมพ์ผิดในการกำหนดและการใช้ขอบเขตของชื่อตัวแปรขอบเขตด้านนอกในภายหลังซึ่งขอบเขตด้านในลืมประกาศ

พวกเขายังทำให้ runtimes เรียกใช้การวนซ้ำจำนวนมากบน codepaths ทั้งหมดเพื่อตรวจสอบว่าจริง ๆ แล้วมันคือค่าคงที่ก่อนที่พวกเขาจะสามารถปรับให้เหมาะสม แม้ว่าจะมีปัญหาน้อยกว่าการตรวจจับข้อบกพร่องและความเข้าใจของนักพัฒนา

ควรใช้เมื่อไร const

constถ้าค่าของการอ้างอิงไม่เปลี่ยนแปลงในช่วงเวลาของการดำเนินการไวยากรณ์ที่ถูกต้องในการแสดงของโปรแกรมเมอร์เจตนาคือ สำหรับวัตถุการเปลี่ยนค่าของการอ้างอิงหมายถึงการชี้ไปยังวัตถุอื่นเนื่องจากการอ้างอิงนั้นไม่เปลี่ยนรูป แต่วัตถุนั้นไม่ได้

" constวัตถุ"

สำหรับการอ้างอิงวัตถุตัวชี้ไม่สามารถเปลี่ยนเป็นวัตถุอื่น แต่วัตถุที่สร้างและกำหนดให้กับการconstประกาศนั้นไม่แน่นอน คุณสามารถเพิ่มหรือลบรายการออกจากconstอาร์เรย์ที่อ้างอิงและกลายพันธุ์คีย์คุณสมบัติบนconstวัตถุที่ถูกอ้างอิง

เพื่อให้บรรลุวัตถุที่ไม่เปลี่ยนรูป (ซึ่งทำให้รหัสของคุณง่ายขึ้นสำหรับเหตุผลเกี่ยวกับมนุษย์และเครื่องจักร) คุณสามารถObject.freezeวัตถุที่ประกาศ / การมอบหมาย / การสร้างเช่นนี้:

const Options = Object.freeze(['YES', 'NO'])

Object.freeze มีผลกระทบต่อประสิทธิภาพการทำงาน แต่รหัสของคุณอาจช้าด้วยเหตุผลอื่น คุณต้องการโปรไฟล์

นอกจากนี้คุณยังสามารถห่อหุ้มวัตถุที่ไม่แน่นอนในเครื่องของรัฐและส่งกลับสำเนาลึกเป็นค่า (นี่คือการทำงานของ Redux และ React state) ดูที่การหลีกเลี่ยงสถานะโกลบอลที่ไม่แน่นอนใน Browser JSสำหรับตัวอย่างของวิธีการสร้างสิ่งนี้จากหลักการแรก

เมื่อใดvarและletเป็นคู่ที่ดี

letและvarเป็นตัวแทนของรัฐที่ไม่แน่นอน ในความคิดของฉันควรใช้เพื่อจำลองสถานการณ์ที่ไม่แน่นอนที่เกิดขึ้นจริงเท่านั้น สิ่งที่ต้องการ " การเชื่อมต่อยังมีชีวิตอยู่? "

สิ่งเหล่านี้ถูกห่อหุ้มอย่างดีที่สุดในเครื่องสถานะที่ทดสอบได้ซึ่งแสดงค่าคงที่ที่แสดง " สถานะปัจจุบันของการเชื่อมต่อ " ซึ่งเป็นค่าคงที่ ณ จุดใดก็ได้ในเวลาและสิ่งที่เหลืออยู่ในรหัสของคุณสนใจจริง ๆ

การเขียนโปรแกรมนั้นยากพอกับการเขียนผลข้างเคียงและการแปลงข้อมูล เปลี่ยนทุกฟังก์ชั่นให้กลายเป็นเครื่องสถานะที่ไม่สามารถทดสอบได้โดยการสร้างสถานะที่ไม่แน่นอนด้วยตัวแปรที่มีเพียงความซับซ้อน

สำหรับคำอธิบายที่เหมาะสมยิ่งขึ้นดูชุนกลายพันธุ์ - constกรณีสำหรับ

'const' เป็นตัวบ่งชี้รหัสของคุณที่ตัวระบุจะไม่ถูกกำหนดใหม่ นี่เป็นบทความที่ดีเกี่ยวกับเวลาที่จะใช้ 'const', 'let' หรือ 'var' https://medium.com/javascript-scene/javascript-es6-var-let-or-const-ba58b8dcde75#.ukgxpfhao

ฉันไม่ใช่ผู้เชี่ยวชาญในการรวบรวมธุรกิจของ JS แต่มันก็สมเหตุสมผลที่จะพูดว่า v8 ใช้ประโยชน์จากค่าสถานะ const

โดยปกติ a หลังจากการประกาศและการเปลี่ยนกลุ่มของตัวแปรหน่วยความจำจะได้รับการแยกส่วนและ v8 จะหยุดการทำงานทำให้หยุดชั่วคราวสักครู่หนึ่งเพื่อสร้าง gc หรือการรวบรวมขยะ

หากตัวแปรถูกประกาศด้วย const v8 สามารถมั่นใจได้ว่าจะใส่ไว้ในคอนเทนเนอร์ขนาดคงที่แน่นระหว่างตัวแปร const อื่น ๆ เนื่องจากจะไม่มีการเปลี่ยนแปลง นอกจากนี้ยังสามารถบันทึกการดำเนินการที่เหมาะสมสำหรับประเภทข้อมูลนั้นได้เนื่องจากประเภทจะไม่เปลี่ยนแปลง

เมื่อมันมาถึงการตัดสินใจระหว่างขอและconst , มักจะชอบconstเพื่อให้การใช้งานมีความชัดเจนในรหัส ด้วยวิธีนี้หากคุณพยายามประกาศตัวแปรอีกครั้งคุณจะได้รับข้อผิดพลาด ถ้าไม่มีทางเลือกอื่น ๆ แต่ redeclare มันเพียงแค่สลับสำหรับปล่อย โปรดสังเกตว่าอย่างที่Anthonyพูดว่าค่าไม่เปลี่ยนรูป (ตัวอย่างเช่นวัตถุconstสามารถมีคุณสมบัติกลายพันธุ์)

เมื่อพูดถึงvarเนื่องจาก ES6 ไม่ทำงานฉันไม่เคยใช้มันในรหัสการผลิตและไม่สามารถนึกถึงกรณีการใช้งานได้ อย่างไรก็ตามโปรดระวังว่าตัวแปรที่ประกาศด้วยvarไม่มีขอบเขตบล็อก