注：この質問は、ECMAScriptバージョン3または5の観点から尋ねられました。ECMAScript6のリリースでの新機能の導入により、回答が古くなる可能性があります。

varJavaScript でのキーワードの機能とは何か、およびその違いは何ですか

var someNumber = 2;
var someFunction = function() { doSomething; }
var someObject = { }
var someObject.someProperty = 5;

そして

someNumber = 2;
someFunction = function() { doSomething; }
someObject = { }
someObject.someProperty = 5;

？

どちらを使用しますか、なぜ/何をしますか？

グローバルスコープの場合は、それほど大きな違いはありません。Kangaxの回答を読んで説明する

関数内にいる場合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ます。

ここで、グローバル変数を宣言しておらず、グローバルプロパティを作成しています。

2つの違いは微妙であり、変数の宣言でもプロパティが作成され（変数オブジェクトのみ）、Javascriptのすべてのプロパティ（ECMAScript）に、そのプロパティを説明する特定のフラグ（ReadOnly、DontEnum、およびDontDelete。

変数宣言はDontDeleteフラグを使用してプロパティを作成するため、var x = 1andとx = 1（グローバルスコープで実行した場合）の違いは、前者（変数宣言）がDontDelete可能なプロパティを作成し、後者は作成しないことです。結果として、この暗黙の割り当てによって作成されたプロパティはグローバルオブジェクトから削除でき、前のプロパティ（変数宣言によって作成されたプロパティ）は削除できません。

しかし、これはもちろん理論に過ぎず、実際には、実装のさまざまなバグ（IEのバグなど）のため、2つのにはさらに大きな違いがあります。

それがすべて理にかなっていることを願っています:)

[更新2010/12/16]

ES5（ECMAScript 5、最近標準化された第5版の言語）には、いわゆる「厳密モード」、つまり宣言されていない割り当ての動作をわずかに変更するオプトイン言語モードがあります。厳密モードでは、宣言されていない識別子への割り当てはReferenceErrorです。これの理由は、偶発的な割り当てをキャッチして、不要なグローバルプロパティの作成を防ぐことでした。新しいブラウザのいくつかは、ストリクトモードのサポートのローリングをすでに開始しています。たとえば、私の互換表を参照してください。

それが「ローカルとグローバル」の違いだと言うことは完全に正確ではありません。

「ローカル」と「最も近い」との違いと考えた方がいいかもしれません。最も近いものは確かにグローバルである可能性がありますが、常にそうであるとは限りません。

/* 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 ウィンドウ内で宣言することと宣言しないことの間に違いはありません。

違いは、関数の内部やブロックの内部など、ウィンドウ内に直接いない場合です。

を使用varすると、同じ名前の外部変数を非表示にできます。この方法で「プライベート」変数をシミュレートできますが、それは別のトピックです。

経験則では、常にを使用しますvar。そうしないと、微妙なバグが発生するリスクがあるためです。

編集：私が受け取った批評の後、私は以下を強調したいと思います：

• var現在のスコープで変数を宣言します
• グローバルスコープは window
• グローバルスコープ（ウィンドウ）でvar暗黙的に宣言を使用しないvar
• を使用してグローバルスコープ（ウィンドウ）で変数を宣言することは、変数varを省略することと同じです。
• ウィンドウの使用var とは異なるスコープで変数を宣言することは、変数なしで変数を宣言することと同じではありませんvar
• var良い習慣なので、常に明示的に宣言する

var変数を宣言するには、常にキーワードを使用します。どうして？コーディングの実践はそれ自体で十分な理由ですが、それを省略すると、グローバルスコープで宣言されます（このような変数は「暗黙の」グローバルと呼ばれます）。ダグラス・クロックフォードは、暗黙のグローバルを使用したことがないことをお勧めします、とによると、アップルはJavaScriptのコーディング・ガイドライン：

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！

var変数を宣言するES6以前の方法でした。私たちは今未来にいるので、あなたはそのようにコーディングするべきです。

使用constしてlet

constケースの95％に使用する必要があります。変数参照が変更されないようにするため、配列、オブジェクト、およびDOMノードのプロパティが変更され、変更される可能性がありますconst。

let再割り当てされると予想されるすべての変数に使用する必要があります。これにはforループ内が含まれます。varName =初期化を超えて書き込む場合は、を使用してくださいlet。

他のほとんどの言語で期待されているように、どちらにもブロックレベルのスコープがあります。

別の違い例えば

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

ながら

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

var変数を使用すると、グローバルスコープが乱雑になり、変数が互いに競合して不要な上書きが発生するのを防ぐことができます。

なしvar-グローバル変数。

強く推奨に常に利用var悪である-ローカルコンテキスト内のinitグローバル変数ので、声明。しかし、この汚いトリックが必要な場合は、ページの先頭にコメントを書く必要があります。

/* 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とno の実際的な違い（および危険性）を示す良い例を示しましたvar。これは別の問題です。違いは非同期環境でのみ確認できるため、テスト中に簡単にずれてしまう可能性があるため、これは特に危険です。

次のスニペット出力を期待するように["text"]：

function var_fun() {
  let array = []
  array.push('text')
  return array
}

console.log(var_fun())

次のスニペットもそうです（let前に欠落があることに注意してくださいarray）：

function var_fun() {
  array = []
  array.push('text')
  return array
}

console.log(var_fun())

データ操作を非同期で実行しても、1つのエグゼキューターで同じ結果が得られます。

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

出力はfalse、false、false、falseです

これは、ローカルスコープまたは関数で新しい変数を作成するのではなく、単にグローバル変数を使用してそれらをfalseに再割り当てするためです。

varの有無にかかわらず、関数の内部または外部で変数を宣言するときに、混乱しているようです。以下は、これらの手順を説明する深い例です。

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

結論

1. var（a、bなど）の有無に関係なく宣言されていても、それらが関数の外部で値を取得する場合、それらの値は保持され、スクリプトを介してさまざまな関数内に追加された他の値も保持されます。
2. 変数が（cなどの）関数内でvarなしで宣言されている場合、その変数は前のルールのように機能し、今後すべての関数にわたってその値を保持します。関数testVar1（）で最初の値を取得するか、値を保持し、関数testVar2（）で追加の値を取得します
3. 変数が関数内でのみ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 */
}

スコープの問題に加えて、一部の人々は巻き上げについても言及していますが、誰も例を挙げていません。これがグローバルスコープの1つです。

console.log(noErrorCase);
var noErrorCase = "you will reach that point";

console.log(runTimeError);
runTimeError = "you won't reach that point";

「var」変数を使用しない場合、変数は値を設定するときにのみ定義できます。例では：

my_var;

グローバルスコープやその他のスコープでは機能しません。次のような値である必要があります。

my_var = "value";

一方、次のような値を定義できます。

var my_var;

その値はundefined（その値ではなくnull、null興味深いことに等しくありません。）

ブラウザのウィンドウオブジェクトに変数をアタッチするつもりがない限り、varキーワードを使用する必要があります。スコープと、glocalスコープととwihtout varキーワードを使用したローカルスコープの違いを説明するリンクは次のとおりです。

varキーワードを使用せずに変数が定義された場合、その様子は単純な「代入」操作です。

JavaScriptで変数に値が割り当てられると、インタープリターは最初に、割り当てと同じコンテキスト/スコープで「変数宣言」を見つけようとします。インタープリターがを実行するdummyVariable = 20と、関数の先頭でdummyVariableの宣言を検索します。（すべての変数宣言はJavaScriptインタープリターによってコンテキストの先頭に移動され、これはホイストと呼ばれるため）

また、javascriptで巻き上げを確認することもできます