var 关键字的用途是什么，我应该什么时候使用它（或省略它）？

如果您在全球范围内，那么差别不大。阅读Kangax's答案以获得解释

如果您在函数中，则 var 将创建一个局部变量，“no var”将查找范围链，直到找到变量或到达全局范围（此时它将创造它）：

// These are both globals
var foo = 1;
bar = 2;

function()
{
    var foo = 1; // Local
    bar = 2;     // Global

    // Execute an anonymous function
    (function()
    {
        var wibble = 1; // Local
        foo = 2; // Inherits from scope above (creating a closure)
        moo = 3; // Global
    }())
}

如果您没有做作业，那么您需要使用 var：

var x; // Declare x

---

有区别。

var x = 1 声明变量 x 在当前范围内（也称为执行上下文）。如果声明出现在函数中 - 声明了一个局部变量；如果它在全局范围内 - 声明一个全局变量。

另一方面，x = 1 仅仅是一个属性分配。它首先尝试针对范围链解析 x。如果它在该范围链中的任何位置找到它，它就会执行分配；如果它没有找到 x，那么只有 它会在全局对象上创建 x 属性（它是作用域链中的顶级对象）。

现在，请注意它没有声明一个全局变量，它创建了一个全局属性。

两者之间的区别是微妙的并且可能会令人困惑，除非您了解变量声明也会创建属性（仅在变量对象上）并且 Javascript（嗯，ECMAScript）中的每个属性都有某些描述其属性的标志 - ReadOnly、DontEnum 和不要删除。

由于变量声明创建带有 DontDelete 标志的属性，因此 var x = 1 和 x = 1 （在全局范围内执行时）之间的区别在于前者 - 变量声明 - 创建了 DontDelete'able 属性，而后者没有。因此，通过这个隐式赋值创建的属性可以从全局对象中删除，而前一个 - 通过变量声明创建的属性 - 不能被删除。

但这当然只是理论，实际上两者之间存在更多差异，这是由于实现中的各种错误（例如来自 IE 的错误）。

希望这一切都有意义:)

[2010/12/16 更新]

在 ES5（ECMAScript 5；最近标准化，该语言的第 5 版）中有一种所谓的“严格模式”——一种选择性加入的语言模式，它略微改变了未声明赋值的行为。在严格模式下，分配给未声明的标识符是 ReferenceError。这样做的基本原理是捕获意外分配，防止创建不需要的全局属性。一些较新的浏览器已经开始滚动支持严格模式。例如，参见 my compat table。

---

说这是“本地和全球”之间的区别并不完全准确。

将其视为“本地和最近”之间的区别可能会更好。最近的肯定可以是全球性的，但情况并非总是如此。

/* global scope */
var local = true;
var global = true;

function outer() {
    /* local scope */
    var local = true;
    var global = false;

    /* nearest scope = outer */
    local = !global;

    function inner() {
        /* nearest scope = outer */
        local = false;
        global = false;

        /* nearest scope = undefined */
        /* defaults to defining a global */
        public = global;
    }
}

---

在浏览器中执行 Javascript 时，所有代码都被 with 语句包围，如下所示：

with (window) {
    //Your code
}

有关 with - MDN 的更多信息

由于 var 在当前范围内声明了一个变量，因此声明 var inside window 和完全不声明它没有区别。

当您不在窗口内时，例如在函数内或块内时，差异就出现了。

使用 var 可以隐藏同名的外部变量。通过这种方式，您可以模拟“私有”变量，但这是另一个主题。

经验法则是始终使用 var，否则您将面临引入细微错误的风险。

编辑：在收到批评后，我想强调以下几点：

var 在当前作用域中声明一个变量

全局范围是窗口

不使用 var 隐式声明 var 在全局范围内（窗口）

使用 var 在全局范围（窗口）中声明变量与省略它相同。

使用 var 在不同于 window 的范围内声明变量与在没有 var 的情况下声明变量不同

始终明确声明 var 因为这是一个好习惯

---

始终使用 var 关键字来声明变量。为什么？良好的编码习惯本身就足够了，但省略它意味着它是在 global 范围内声明的（这样的变量称为“隐含”全局）。 Douglas Crockford recommends never using implied globals，并根据 Apple JavaScript Coding Guidelines：

没有使用 var 关键字创建的任何变量都是在全局范围内创建的，并且在函数返回时不会被垃圾收集（因为它不会超出范围），这会带来内存泄漏的机会。

---

下面是一个很好的例子，说明如何避免使用 var 声明局部变量：

<script>
one();

function one()
{
    for (i = 0;i < 10;i++)
    {
        two();
        alert(i);
    }
}

function two()
{
    i = 1;
}
</script>

（i 在循环的每次迭代中都会重置，因为它不是在 for 循环中本地声明而是全局声明）最终导致无限循环

---

我会说在大多数情况下使用 var 会更好。

局部变量总是比全局范围内的变量快。

如果您不使用 var 声明变量，则该变量将在全局范围内。

更多信息，您可以在 Google 中搜索“范围链 JavaScript”。

---

不要使用变量！

var 是 ES6 之前声明变量的方式。我们现在是未来，你应该这样编码。

使用 const 并让

const 应用于约 95% 的情况。它使得变量引用不能改变，因此数组、对象和 DOM 节点属性可以改变并且应该是 const。

let 应用于希望重新分配的任何变量。这包括在 for 循环中。如果您在初始化之外写过 varName =，请使用 let。

正如大多数其他语言所预期的那样，两者都具有块级范围。

---

另一个区别，例如

var a = a || [] ; // works 

尽管

a = a || [] ; // a is undefined error.

---

使用 var 始终是防止变量混淆全局范围和变量相互冲突的好主意，从而导致不必要的覆盖。

---

没有 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"]：

函数 var_fun() { 让数组 = [] array.push('text') 返回数组 } console.log(var_fun())

以下代码段也是如此（注意 array 之前缺少的 let）：

函数 var_fun() { array = [] array.push('text') 返回数组 } console.log(var_fun())

异步执行数据操作仍然会使用单个执行器产生相同的结果：

函数 var_fun() { 数组 = []; return new Promise(resolve => resolve()).then(() => { array.push('text') return array }) } var_fun().then(result => {console.log(result)})

但与多个不同的行为不同：

函数 var_fun() { 数组 = []; return new Promise(resolve => resolve()).then(() => { array.push('text') return array }) } [1,2,3].forEach(i => { var_fun().然后（结果 => {console.log（结果）}）}）

但是使用 let ：

函数 var_fun() { 让数组 = []; return new Promise(resolve => resolve()).then(() => { array.push('text') return array }) } [1,2,3].forEach(i => { var_fun().然后（结果 => {console.log（结果）}）}）

---

作为试图学习这一点的人，这就是我的看法。对于初学者来说，上面的例子可能有点过于复杂。

如果您运行此代码：

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

输出将读取为：假，假，真，真

因为它认为函数中的变量与函数外部的变量是分开的，所以术语局部变量是因为我们在赋值中使用了 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);

输出为假，假，假，假

这是因为它不是在本地范围或函数中创建新变量，而是简单地使用全局变量并将它们重新分配为 false。

---

我看到人们在声明带有或不带有 var 以及在函数内部或外部的变量时感到困惑。这是一个深入的示例，将引导您完成这些步骤：

See the script below in action here at jsfiddle

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），如果它们在函数之外获取值，它们将保留它们的值，并且通过脚本添加到各种函数内的任何其他值也将被保留。如果在函数（如 c）中声明变量时没有 var，它将像之前的规则一样，从现在开始在所有函数中保留其值。它要么在函数 testVar1() 中获得第一个值，它仍然保留该值并在函数 testVar2() 中获得附加值如果仅在函数内部使用 var 声明变量（如 testVar1 或 testVar2 中的 d）函数结束。所以它将是函数中的临时变量。

---

在代码中，如果您在不使用 var 的情况下使用变量，那么会自动将 var var_name 放置在全局范围内，例如：

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 */
}

---

除了范围问题，有些人还提到了hoisting，但没有人举个例子。这是全球范围的一个：

console.log(noErrorCase); var noErrorCase = "你会到达那个点";

控制台.log(runTimeError); runTimeError = "你不会达到那个点";

---

不使用“var”的变量只能在设置值时定义。例如：

my_var;

不能在全局范围或任何其他范围内工作。它应该具有如下值：

my_var = "value";

另一方面，您可以定义一个 vaiable like；

var my_var;

它的值是 undefined （它的值不是 null 并且有趣的是它不等于 null。）。

---

除非您打算将变量附加到浏览器中的窗口对象，否则您应该使用 var 关键字。 Here's a link that explains scoping and difference between glocal scoping and local scoping with and wihtout var keyword.

当变量在不使用 var 关键字的情况下定义时，它看起来像是一个简单的“赋值”操作。

当值被分配给 javascript 中的变量时，解释器首先尝试在与分配相同的上下文/范围中找到“变量声明”。当解释器执行 dummyVariable = 20 时，它会在函数开头查找 dummyVariable 的声明。 （由于所有变量声明都被 javascript 解释器移动到上下文的开头，这称为提升）

您可能还想查看 hoisting in javascript

---