참고 :이 질문은 ECMAScript 버전 3 또는 5의 관점에서 질문되었습니다. ECMAScript 6 릴리스에 새로운 기능이 도입되어 답변이 오래 될 수 있습니다.

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전역 객체에 속성을 (범위 체인의 최상위 개체입니다).

이제 전역 변수를 선언하지 않고 전역 속성을 만듭니다.

둘 사이의 차이는 미묘하고 당신이 이해하지 혼동 될 수있는 변수 선언은 또한 속성 생성 (만 변수 객체에를) 자바 스크립트 (물론, ECMAScript를)의 모든 속성은 특정 속성을 설명하는 플래그가 그 - 읽기 전용, DontEnum 및 삭제하지 마십시오.

변수 선언이 DontDelete 플래그 차이와 속성을 생성하기 때문에 var x = 1그리고 x = 1(전역에서 실행되는 경우에) 이전의 하나이다 - 변수 선언 - DontDelete'able 속성을 생성하고, 후자는하지 않는다. 결과적으로이 암시 적 할당을 통해 생성 된 속성은 전역 객체에서 삭제 될 수 있으며 이전 속성 (변수 선언을 통해 생성 된 속성)은 삭제할 수 없습니다.

그러나 이것은 물론 이론 일 뿐이며 실제로 구현의 다양한 버그 (IE의 버그)로 인해 둘 사이에 더 많은 차이점이 있습니다.

모든 것이 이해되기를 바랍니다. :)

[2010/12/16 업데이트]

ES5 (ECMAScript 5; 최근 표준화 된 5 번째 언어 버전)에는 소위 "엄격 모드"(선택 언어 모드)가 있으며 선언되지 않은 할당의 동작을 약간 변경합니다. 엄격 모드에서 선언되지 않은 식별자에 대한 지정은 ReferenceError 입니다. 이에 대한 이론적 근거는 우발적 인 할당을 포착하여 원하지 않는 글로벌 속성의 생성을 방지하는 것이 었습니다. 최신 브라우저 중 일부는 이미 엄격 모드 지원을 시작했습니다. 예를 들어 내 compat 테이블 을 참조하십시오 .

" 로컬 과 글로벌 " 의 차이점 이 완전히 정확하지 않다고 말하면됩니다.

" local 과 가장 가까운 " 의 차이점으로 생각하는 것이 좋습니다 . 가장 가까운 것이 반드시 전역일 수는 있지만 항상 그런 것은 아닙니다.

/* 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변수를 선언 하려면 항상 키워드를 사용하십시오 . 왜? 좋은 코딩 관행은 그 자체로 충분한 이유가되지만, 생략하면 전역 범위 에서 선언된다는 것을 의미합니다 (이와 같은 변수를 "암시 적"전역이라고 함). Douglas Crockford 는 암시 적 글로벌을 사용하지 말고 Apple 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에서 "scope chain JavaScript"를 검색하십시오.

사용하지 마십시오 var!

var변수를 선언하는 ES6 이전의 방법이었습니다. 우리는 지금 미래에 있으며, 당신은 그렇게 코딩해야합니다.

사용 const및let

const95 %의 경우에 사용해야합니다. 변수 참조를 변경할 수 없으므로 배열, 객체 및 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는 varno와 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())

데이터 조작을 비동기 적으로 실행하면 단일 실행 프로그램에서 여전히 동일한 결과가 생성됩니다.

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

스코프 문제 외에도 일부 사람들은 게양 을 언급 하지만 아무도 예를 제시하지 못했습니다. 글로벌 범위에 대한 내용은 다음과 같습니다.

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

반면에 vaiable을 정의 할 수 있습니다.

var my_var;

그것의 가치는 undefined(그것의 가치는 흥미롭지 null않다 null.).

브라우저에서 변수를 window 객체에 첨부하지 않으려면 var 키워드를 사용해야합니다. 다음은 var 키워드를 사용하여 glocal 범위 지정과 로컬 범위 지정의 차이점과 차이점을 설명하는 링크입니다.

var 키워드를 사용하지 않고 변수를 정의하면 간단한 "할당"작업이 나타납니다.

자바 스크립트에서 변수에 값을 할당하면 인터프리터는 먼저 할당과 동일한 컨텍스트 / 범위에서 "변수 선언"을 찾습니다. 인터프리터가 실행되면 dummyVariable = 20함수 시작시 dummyVariable 선언을 찾습니다. (모든 변수 선언이 자바 스크립트 인터프리터에 의해 컨텍스트의 시작으로 이동되므로이를 호이 스팅이라고 함)

당신은 또한 자바 스크립트 에서 게양 을보고 싶을 수도 있습니다