注意：该问题是从 ECMAScript 版本 3 或 5 的视角提出的。随着 ECMAScript 6 发布新功能，答案可能会过时。
var 关键字在 JavaScript 中起到了什么作用？与之相比，let 和 const 又有什么区别？
var someNumber = 2;
var someFunction = function() { doSomething; }
var someObject = { }
var someObject.someProperty = 5;
和
someNumber = 2;
someFunction = function() { doSomething; }
someObject = { }
someObject.someProperty = 5;
你什么时候会使用其中之一，为什么/它有什么作用？
没有使用 var - 全局变量。
强烈建议始终使用 var 语句，因为在本地上下文中初始化全局变量是有害的。但是，如果您需要这种不好的技巧，您应该在页面开头写注释：
/* global: varname1, varname2... */
这是我为了让您理解这个概念而编写的示例代码:
var foo = 5;
bar = 2;
fooba = 3;
// Execute an anonymous function
(function() {
bar = 100; //overwrites global scope bar
var foo = 4; //a new foo variable is created in this' function's scope
var fooba = 900; //same as above
document.write(foo); //prints 4
document.write(bar); //prints 100
document.write(fooba); //prints 900
})();
document.write('<br/>');
document.write('<br/>');
document.write(foo); //prints 5
document.write(bar); //prints 100
document.write(fooba); //prints 3
@Chris S举了一个很好的例子，展示了var和没有var之间实际的差异(和危险)。这里有另一个例子，我认为这个例子特别危险，因为它们之间的区别只在异步环境中可见，所以在测试期间很容易忽略。
正如你所预期的那样，以下片段输出["text"]：
function var_fun() {
let array = []
array.push('text')
return array
}
console.log(var_fun())array前缺少的 let）：
function var_fun() {
array = []
array.push('text')
return array
}
console.log(var_fun())异步执行数据操作仍然会产生与单个执行器相同的结果：
function var_fun() {
array = [];
return new Promise(resolve => resolve()).then(() => {
array.push('text')
return array
})
}
var_fun().then(result => {console.log(result)})但是在有多个时，其行为会有所不同：
function var_fun() {
array = [];
return new Promise(resolve => resolve()).then(() => {
array.push('text')
return array
})
}
[1,2,3].forEach(i => {
var_fun().then(result => {console.log(result)})
})然而，使用let：
function var_fun() {
let array = [];
return new Promise(resolve => resolve()).then(() => {
array.push('text')
return array
})
}
[1,2,3].forEach(i => {
var_fun().then(result => {console.log(result)})
})var local = true;
var global = true;
function test(){
var local = false;
var global = false;
console.log(local)
console.log(global)
}
test();
console.log(local);
console.log(global);
输出结果为：false，false，true，true。
这是因为它将函数内的变量视为与外部变量分开的变量，因此称为局部变量，这是因为我们在赋值时使用了 var。如果您从函数中去掉 var，使其像这样：
var local = true;
var global = true;
function test(){
local = false;
global = false;
console.log(local)
console.log(global)
}
test();
console.log(local);
console.log(global);
a = 1;// Defined outside the function without var
var b = 1;// Defined outside the function with var
alert("Starting outside of all functions... \n \n a, b defined but c, d not defined yet: \n a:" + a + "\n b:" + b + "\n \n (If I try to show the value of the undefined c or d, console.log would throw 'Uncaught ReferenceError: c is not defined' error and script would stop running!)");
function testVar1(){
c = 1;// Defined inside the function without var
var d = 1;// Defined inside the function with var
alert("Now inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
a = a + 5;
b = b + 5;
c = c + 5;
d = d + 5;
alert("After added values inside the 1. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};
testVar1();
alert("Run the 1. function again...");
testVar1();
function testVar2(){
var d = 1;// Defined inside the function with var
alert("Now inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
a = a + 5;
b = b + 5;
c = c + 5;
d = d + 5;
alert("After added values inside the 2. function: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n d:" + d);
};
testVar2();
alert("Now outside of all functions... \n \n Final Values: \n a:" + a + "\n b:" + b + "\n c:" + c + "\n You will not be able to see d here because then the value is requested, console.log would throw error 'Uncaught ReferenceError: d is not defined' and script would stop. \n ");
alert("**************\n Conclusion \n ************** \n \n 1. No matter declared with or without var (like a, b) if they get their value outside the function, they will preserve their value and also any other values that are added inside various functions through the script are preserved.\n 2. If the variable is declared without var inside a function (like c), it will act like the previous rule, it will preserve its value across all functions from now on. Either it got its first value in function testVar1() it still preserves the value and get additional value in function testVar2() \n 3. If the variable is declared with var inside a function only (like d in testVar1 or testVar2) it will will be undefined whenever the function ends. So it will be temporary variable in a function.");
alert("Now check console.log for the error when value d is requested next:");
alert(d);
结论
- 无论是声明带有还是不带有var（如a，b），如果它们在函数外获取其值，则它们将保留其值，并且通过脚本添加到各种函数中的任何其他值也将被保留。
- 如果变量在函数内部未使用var声明（如c），它将像上一个规则一样，将保留其值并跨所有函数。即使它在函数testVar1()中首次获取了其值，它仍会保留该值并在函数testVar2()中获取其他值。
- 如果变量仅在函数内部使用var声明（如testVar1或testVar2中的d），则在函数结束时它将为未定义。因此，它将是函数中的临时变量。
如果您在代码中使用变量却没有使用var，则会自动将变量名放置在全局作用域中，例如：
someFunction() {
var a = some_value; /*a has local scope and it cannot be accessed when this
function is not active*/
b = a; /*here it places "var b" at top of script i.e. gives b global scope or
uses already defined global variable b */
}
console.log(noErrorCase);
var noErrorCase = "you will reach that point";console.log(runTimeError);
runTimeError = "you won't reach that point";如果您不想将变量附加到浏览器窗口对象上，应使用var关键字。这是一个解释作用域和使用和不使用var关键字的全局作用域和局部作用域差异的链接。
当变量在JavaScript中定义时没有使用var关键字时，它看起来像是一个简单的“赋值”操作。
当值被分配给JavaScript变量时，解释器首先尝试在与分配相同的上下文/作用域中查找“变量声明”。当解释器执行dummyVariable = 20时，它会在函数开头查找dummyVariable的声明。
（由于JavaScript解释器将所有变量声明移至上下文的开头，这被称为提升）
您还可以查看JavaScript中的提升。
如果不使用“var”，变量只能在设置值时定义。例如：
my_var;
无法在全局作用域或任何其他作用域中工作。它应该具有像这样的值：
my_var = "value";
另一方面，您可以像这样定义一个变量：
var my_var;
它的值是 undefined （它的值不是 null，有趣的是它也不等于 null）。
my_var; 实际上是一个有效的表达式语句。 - lexicoremy_var;是一个有效的表达式语句。/my_var;将是一个无效的语句。但正如我所说，这是语法细节，我很抱歉，我的评论实际上不合适。 - lexicore
const和let吧！var不是现代的 JS。 - Gibolt