关于node.js:javascript中的常量？什么时候用，有必要吗


Const in javascript? When to use it and is it necessary

我最近在javascript中遇到了const关键字。据我所知，它用于创建不可变变量，我已经测试过以确保它不能被重新定义(在node.js中)：

1
2
3
4
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，或者用var代替const，实际上有什么区别吗？

相关讨论

您的问题有两个方面：使用const而不是var的技术方面是什么？这样做与人类有关的方面是什么？

技术差异显著。在编译语言中，常量将在编译时被替换，它的使用将允许其他优化，如死码删除，以进一步提高代码的运行时效率。最近使用的(松散使用的术语)javascript引擎实际上编译JS代码以获得更好的性能，因此使用const关键字会通知它们，上面描述的优化是可能的，应该进行。这样可以获得更好的性能。

与人相关的方面是关于关键字的语义。变量是一种数据结构，它包含预期会更改的信息。常量是包含永远不会更改的信息的数据结构。如果存在错误空间，则应始终使用var。然而，并非所有在程序生命周期中从未改变的信息都需要用const声明。如果在不同的情况下信息应该改变，使用var来表示，即使实际的改变没有出现在代码中。

相关讨论

2017更新

这个答案仍然受到很多关注。值得注意的是，这个答案是在2014年初发布的，此后发生了很大变化。ECMAScript-6支持现在已成为常态。现在所有的现代浏览器都支持const，因此使用起来应该非常安全，不会出现任何问题。

2014年原始答案

尽管有相当不错的浏览器支持，我还是暂时避免使用它。摘自MDN关于const的文章：

The current implementation of const is a Mozilla-specific extension and is not part of ECMAScript 5. It is supported in Firefox & Chrome (V8). As of Safari 5.1.7 and Opera 12.00, if you define a variable with const in these browsers, you can still change its value later. It is not supported in Internet Explorer 6-10, but is included in Internet Explorer 11. The const keyword currently declares the constant in the function scope (like variables declared with var).

然后它继续说：

const is going to be defined by ECMAScript 6, but with different semantics. Similar to variables declared with the let statement, constants declared with const will be block-scoped.

如果使用const，则必须添加一个变通方法来支持稍旧的浏览器。

相关讨论

为了整合前面的答案，在声明常量变量方面有一个明显的优势，除了性能原因：如果您不小心试图在代码中更改或重新声明它们，程序将不会分别更改值或抛出错误。

例如，比较：

1
2
3
4
5
6
// Will output 'SECRET'

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

用：

1
2
3
4
5
6
// Will output 'ANOTHER_SECRET'

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

或

1
2
3
4
5
6
7
// Will throw TypeError: const 'x' has already been declared

const x ="SECRET"

/*  complex code */

var x = 0

具有

1
2
3
4
5
6
7
// Will reassign y and cause trouble

var y ="SECRET"

/*  complex code */

var y = 0
相关讨论

const不是不变的。

从MDN：

The const declaration creates a read-only reference to a value. It
does not mean the value it holds is immutable, just that the variable
identifier cannot be reassigned.

相关讨论

使用"为什么"的答案tibos const，好吗。

但你说：

From what i can tell, it is used to create immutable variables

这是错误的。一个变量的变异是不同的：从reassigning

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

一个常量，你需要做的是：

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

但你可以mutate的变量：

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

因此，任何过程的变化的变量的值是不使用=登录是静音。

注：+=例如…重新分配。

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

因此，底线是：const不能防止你从你的变异变量，它可防止从重新分配他们。

相关讨论

你有很好的答案，但让我们保持简单。

当您定义了一个常量(读作：它在程序执行期间不会改变)时，应该使用const。

例如：

1
const pi = 3.1415926535

如果您认为在以后的执行中可能会发生更改，那么使用var。

基于这个例子，实际的区别是，对于const，你总是认为π是3.14(0)，这是事实。

如果将其定义为var，则可能是3.14[…]或不是。

对于更专业的答案，@tibos在学术上是正确的。

声明变量的VAR值，可选的初始化。

我们将一个变量：本地块范围。

声明a为：只读命名的常数。

前：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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，而不必搜索代码，查找硬编码的位，例如文件路径或服务器名。

不过，测试中的错误是另一回事，您需要创建另一个名为x的变量，这将是一个更精确的测试。

1
2
const x = 'const';
x = 'not-const';
相关讨论

个人偏好真的。您可以使用const，正如您所说，它不会被重新分配并且是常量。例如，如果你想分配你的生日。你的生日永远不会改变，所以你可以把它作为一个常数。但你的年龄确实在变化，所以这可能是一个变量。

相关讨论

总结：

const const变量在创建不可变标识符结合，意思是不重录。

1
const a ="value1";

你不能重新分配它

1
a ="value2";

然而，如果const标识符持有的对象或数组，它的值可以是，只要我们需要重新分配它。

1
2
3
4
5
6
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范围取决于你想有。

它是多容易的一个原因代码时，它是死的，显而易见的是可以通过重新分配和什么不可能。让我们换一个const是死简单。和const默认要让你觉得在两次，这样做。在许多情况下，这是一件好事。

1
2
3
4
5
6
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' : At the time of codding when we talk about code-standard then we usually use name of identifier which one easy to understandable by other user/developer.
For example if we are working thought many functions where we use some input and process this and return some result, like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
**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;
}

In above examples both functions producing different-2 results but using same name of variables. Here we can see 'process' & 'result' both are used as variables and they should be.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 **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;
}

Before using 'let' in java-script we have to add ‘use strict’ on the top of js file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 **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);

In above example you can track which one function executed when & which one function not used during specific action.

它提供：1)常量引用，例如const x=[]-可以修改数组，但x不能指向另一个数组；以及2)区块范围界定。const和let将共同取代ECMA6/2015中的VaR。见https://strongloop.com/strongblog/es6-variable-declarations讨论。/

第一，三个有用的事情是const(其他比它的范围，改进和let股)：

  • 它的代码的人阅读文件后，必须改变价值困境。
  • 它(或任何人来防止你从你的价值的变化后)除非他们故意去改变的声明。
  • 它可能拯救一些JavaScript引擎的分析条件的优化。例如，你的价值是无法被更改，因此，引擎没有找到他们做的工作的价值的变化，所以它决定是否基于CAN to optimize的值需要改变。

你的问题：

When is it appropriate to use const in place of var?

任何时间你可以做你的性价值declaring a变量永不改变。你是否认为你的偏好是完全适当的降压转换器/你的团队的偏好。

Should it be used every time a variable which is not going to be re-assigned is declared?

这是你和你的团队。

Does it actually make any difference if var is used in place ofconst` or vice-versa?

是的：

  • var和const范围有不同的规则。(你可能有一个比我想的比较letvar。特别是const和let)：当使用一个中心块，在全球范围，Don’t create置业在全局对象(即使他们创建全局变量)。无论是全球范围var安切洛蒂(当在全球范围使用范围(即使)或函数中使用的块)，当使用在全球范围内创建一个全局对象的属性。
  • 我的"三海。以上所有东西"，他们应用到这个问题。

我需要专家在JS编写业务的理解，但它说，这使得使用const的V8酒店标志

低价格和售后declaring一堆变量改变，记忆变得分散和V8引擎是执行，停止和休息的时间，使一些几秒，让GC，或垃圾收集。

如果一个const变量是被有V8引擎，可以把它在一个固定大小的容器紧之间的其他const变量，因为它永远不会改变。因此，它可以适当的行动拯救那个datatypes自型不会变更。

"const"是指示到您的代码将不分配给标识符。这是一个很好的文章时，使用"const"，"让"或"var"http：／／medium.com /场景/ es6 JavaScript JavaScript VAR LET或常量ba58b8dcde75 # .ukgxpfhao