javascript - 차이 - swift let const




JavaScript에서 변수를 선언하기 위해 "let"과 "var"을 사용하는 것의 차이점은 무엇입니까? (18)

let

블록 범위

let 키워드를 사용하여 선언 된 변수는 블록 범위입니다. 즉, 변수가 선언 된 블록에서만 사용할 수 있습니다.

최상위 레벨 (함수 외부)

최상위 레벨에서 let 사용하여 선언 된 변수는 전역 객체에 대한 속성을 만들지 않습니다.

var globalVariable = 42;
let blockScopedVariable = 43;

console.log(globalVariable); // 42
console.log(blockScopedVariable); // 43

console.log(this.globalVariable); // 42
console.log(this.blockScopedVariable); // undefined

함수 내부

함수 내부 (블록 외부)에는 var 와 동일한 범위가 있습니다.

(() => {
  var functionScopedVariable = 42;
  let blockScopedVariable = 43;

  console.log(functionScopedVariable); // 42
  console.log(blockScopedVariable); // 43
})();

console.log(functionScopedVariable); // ReferenceError: functionScopedVariable is not defined
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

블록 내부

블록 내에서 let 사용하여 선언 된 변수는 해당 블록 외부에서 액세스 할 수 없습니다.

{
  var globalVariable = 42;
  let blockScopedVariable = 43;
  console.log(globalVariable); // 42
  console.log(blockScopedVariable); // 43
}

console.log(globalVariable); // 42
console.log(blockScopedVariable); // ReferenceError: blockScopedVariable is not defined

루프 내부

let in 루프로 선언 된 변수는 해당 루프 내에서만 참조 할 수 있습니다.

for (var i = 0; i < 3; i++) {
  var j = i * 2;
}
console.log(i); // 3
console.log(j); // 4

for (let k = 0; k < 3; k++) {
  let l = k * 2;
}
console.log(typeof k); // undefined
console.log(typeof l); // undefined
// Trying to do console.log(k) or console.log(l) here would throw a ReferenceError.

클로저가있는 루프

루프에서 var 대신 let 을 사용하면 각 반복마다 새로운 변수가 생깁니다. 즉, 루프 내에서 클로저를 안전하게 사용할 수 있습니다.

// Logs 3 thrice, not what we meant.
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

// Logs 0, 1 and 2, as expected.
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}

일시적인 데드 존

일시적인 데드 존 때문에 let 을 사용하여 선언 된 변수는 선언되기 전에 액세스 할 수 없습니다. 이렇게하면 오류가 발생합니다.

console.log(noTDZ); // undefined
var noTDZ = 43;
console.log(hasTDZ); // ReferenceError: hasTDZ is not defined
let hasTDZ = 42;

다시 선언하지 않아야 함

let 사용하여 동일한 변수를 여러 번 선언 할 수 없습니다. 또한 var 사용하여 선언 된 다른 변수와 동일한 식별자를 사용하여 let 을 사용하여 변수를 선언 할 수 없습니다.

var a;
var a; // Works fine.

let b;
let b; // SyntaxError: Identifier 'b' has already been declared

var c;
let c; // SyntaxError: Identifier 'c' has already been declared

const

constlet -it의 block-scoped와 매우 유사하며 TDZ를 가지고있다. 그러나 두 가지가 다릅니다.

다시 할당하지 않음

const 를 사용하여 선언 된 변수는 다시 할당 할 수 없습니다.

const a = 42;
a = 43; // TypeError: Assignment to constant variable.

값이 불변이라는 것을 의미하지는 않습니다. 그 속성은 여전히 ​​변경 될 수 있습니다.

const obj = {};
obj.a = 42;
console.log(obj.a); // 42

변경 불가능한 객체를 원한다면 Object.freeze() 를 사용해야합니다.

초기화 프로그램이 필요합니다.

const 사용하여 변수를 선언 할 때 항상 값을 지정해야합니다.

const a; // SyntaxError: Missing initializer in const declaration

ECMAScript 6에서는 let 문을 도입 했습니다 . 나는 그것이 "local"변수로 묘사되었다고 들었다. 그러나 아직도 var 키워드와 다르게 행동하는 방법을 확실히 모르겠다.

차이점은 무엇입니까? var 위에는 언제 사용해야합니까?


함수 VS 블록 범위 :

주요 차이점 varlet선언 변수이다 var있는 기능 범위 . 선언 된 함수 let블록 범위 입니다. 예 :

function testVar () {
  if(true) {
    var foo = 'foo';
  }

  console.log(foo);
}

testVar();  
// logs 'foo'


function testLet () {
  if(true) {
    let bar = 'bar';
  }

  console.log(bar);
}

testLet(); 
// reference error
// bar is scoped to the block of the if statement 

변수들 var:

첫 번째 함수 testVar가 호출 될 때 with var,로 선언 된 변수 foo 는 여전히 if문 외부에서 액세스 할 수 있습니다 . 이 변수 foo함수 범위 내에서 사용할 수 있습니다 .testVar

변수들 let:

두 번째 함수 testLet가 호출되면 with로 선언 된 변수 막대 letif명령문 내에서만 액세스 할 수 있습니다 . 변수 선언 때문 let이다 블록 범위 (블록 중괄호 사이에 코드가 어디 예 if{}, for{}, function{}).

let 변수가 끌어 올려지지 않습니다.

또 다른 차이점 varlet선언과 변수입니다 let 게양되지 않습니다 . 예를 들어이 동작을 설명하는 가장 좋은 방법은 다음과 같습니다.

게양 let 되지 않는 변수 :

console.log(letVar);

let letVar = 10;
// referenceError, the variable doesn't get hoisted

var 할 일 이있는 변수 :

console.log(varVar);

var varVar = 10;
// logs undefined, the variable gets hoisted

글로벌 let이 첨부되지 않음 window:

let전역 범위에서 선언 된 변수 (함수에없는 코드)는 전역 window객체 의 속성으로 추가되지 않습니다 . 예를 들어 (이 코드는 전역 범위에 있습니다) :

var bar = 5;
let foo  = 10;

console.log(bar); // logs 5
console.log(foo); // logs 10

console.log(window.bar);  
// logs 5, variable added to window object

console.log(window.foo);
// logs undefined, variable not added to window object


때해야 let이상 사용할 수 var?

사용 let을 통해 var당신이 더 구체적인 범위 단순히 수 있기 때문에 때마다. 이렇게하면 많은 수의 변수를 처리 할 때 발생할 수있는 잠재적 인 명명 충돌을 줄입니다. var전역 변수가 명시 적으로 window객체 에 있어야 할 때 사용할 수 있습니다 (이것이 정말로 필요한지 항상 신중히 고려하십시오).


가장 큰 차이점은 범위 차이입니다. let 은 for 루프와 같이 선언 된 범위 내에서만 사용할 수 있지만 var 는 루프 외부에서 액세스 할 수 있습니다. MDN 의 문서 ( MDN의 예에서도) :

let을 사용하면 범위가 제한된 변수를 사용되는 블록, 명령문 또는 표현식에 선언 할 수 있습니다. 변수를 전역 적으로 정의하거나 블록 범위와 관계없이 전체 함수에 로컬로 정의하는 var 키워드와는 다릅니다.

let에 의해 선언 된 변수는 포함 된 하위 블록뿐만 아니라 정의 된 블록을 범위로 갖습니다. 이런 식으로 하자 . var 와 매우 비슷하게 작동합니다. 가장 큰 차이점은 var 변수의 범위가 전체를 감싸는 함수라는 것입니다.

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}`

프로그램과 함수의 최상위 레벨에서는 var 와 달리 전역 객체에 속성을 만들지 않습니다. 예 :

var x = 'global';
let y = 'global';
console.log(this.x); // "global"
console.log(this.y); // undefined

블록 내에서 사용될 때 let은 변수의 범위를 해당 블록으로 제한합니다. 변수 가 선언 된 함수 안에있는 var 의 차이점에 유의하십시오.

var a = 1;
var b = 2;

if (a === 1) {
  var a = 11; // the scope is global
  let b = 22; // the scope is inside the if-block

  console.log(a);  // 11
  console.log(b);  // 22
} 

console.log(a); // 11
console.log(b); // 2

ECMA6 기능도 잊지 마십시오. 아직 완벽하게 지원되지 않으므로 Babel 등을 사용하여 ECMA5로 변환하는 것이 좋습니다 ... 방문 babel 웹 사이트 에 대한 자세한 정보


다음 let 키워드에 대한 설명입니다 .

var와 매우 흡사하게 작업하십시오. 가장 큰 차이점은 var 변수의 범위는 전체 둘러보기 기능입니다.

Wikipedia 의이 테이블 은 Javascript 1.7을 지원하는 브라우저를 보여줍니다.

Mozilla 및 Chrome 브라우저 만 지원합니다. IE, 사파리 및 잠재적으로 다른 사람들은 그렇지 않습니다.


미묘한 차이점이 있습니다. 범위 지정은 변수 범위 지정이 다른 언어와 다소 비슷하게 동작 let 합니다.

예 : 둘러싸는 블록으로 범위 지정, 선언되기 전에 존재하지 않습니다.

그러나 let 은 새로운 Javascript 구현의 일부일 뿐이며 다양한 수준의 브라우저 지원을 제공 합니다.


수락 된 대답에 요점이 누락되었습니다.

{
  let a = 123;
};

console.log(a); // ReferenceError: a is not defined

차이점은 각 변수로 선언 된 변수의 scope 에 있습니다.

실제로 범위의 차이로 인해 여러 가지 유용한 결과가 있습니다.

  1. let변수는 가장 가까운 블록 ( { ... }) 에서만 볼 수 있습니다 .
  2. let변수는 변수가 선언 된 후에 발생하는 코드 행에서만 사용할 수 있습니다 ( 커서가 올려 졌지만 !).
  3. let변수는 다음 var또는에 의해 다시 선언 될 수 없습니다 let.
  4. 전역 let변수는 전역 window개체에 추가되지 않습니다 .
  5. let변수는 클로저와 함께 사용하기 쉽습니다 ( 경쟁 조건이 발생하지 않음 ).

에 의해 부과 된 제한 let은 변수의 가시성을 감소시키고 예기치 않은 이름 충돌이 조기에 발견 될 가능성을 높입니다. 이렇게하면 reachability (사용하지 않는 메모리 회수)을 비롯하여 변수를 추적하고 추론하는 것이 더 쉬워집니다 .

결과적으로, let큰 프로그램에서 또는 독립적으로 개발 된 프레임 워크가 새롭고 예상치 못한 방식으로 결합 될 때 변수가 문제를 일으킬 가능성이 적습니다.

var루프 (# 5)에서 클로저를 사용할 때 또는 코드에서 외부에서 볼 수있는 전역 변수 (# 4)를 선언 할 때 단일 바인딩 효과를 원한다면 여전히 유용 할 수 있습니다. 의 사용 var수출이 경우 대체 할 수있다 exporttranspiler 공간이 부족하고 핵심 언어로 마이그레이션합니다.

예제들

1. 가장 가까운 둘러싸는 블록의 외부에서 사용 : 이 코드 블록은 두 번째 사용이 다음 xlet같이 선언 된 블록 외부에서 발생 하기 때문에 참조 오류를 발생시킵니다 .

{
    let x = 1;
}
console.log(`x is ${x}`);  // ReferenceError during parsing: "x is not defined".

대조적으로, var작품을 사용한 동일한 예 .

2. 선언 전에 사용하지 않음 :
이 코드 블록 은 선언되기 전에 사용되기 ReferenceError때문에 코드를 실행하기 전에 throw x됩니다.

{
    x = x + 1;  // ReferenceError during parsing: "x is not defined".
    let x;
    console.log(`x is ${x}`);  // Never runs.
}

반대로, var예외를 던지지 않고 구문 분석 및 실행을 수행 하는 동일한 예입니다 .

3. 다시 선언하지 않음 : 다음 코드는 with로 선언 된 변수가 let나중에 다시 선언되지 않을 수도 있음을 보여줍니다 .

let x = 1;
let x = 2;  // SyntaxError: Identifier 'x' has already been declared

4. 세계에 붙어 있지 않은 지구 window:

var button = "I cause accidents because my name is too common.";
let link = "Though my name is common, I am harder to access from other JS files.";
console.log(link);  // OK
console.log(window.link);  // undefined (GOOD!)
console.log(window.button);  // OK

5. 클로저와 함께 사용하기 쉽습니다. 선언 된 변수는 var루프 내부의 클로저와 잘 작동하지 않습니다. 다음은 변수 i가 다른 시점에 가지고있는 값의 순서를 출력하는 간단한 루프입니다 .

for (let i = 0; i < 5; i++) {
    console.log(`i is ${i}`), 125/*ms*/);
}

특히, 다음과 같이 출력됩니다.

i is 0
i is 1
i is 2
i is 3
i is 4

자바 스크립트에서는 종종 변수가 생성 될 때보 다 훨씬 더 늦은 시간에 변수를 사용합니다. 다음과 같이 전달 된 클로저를 사용하여 출력을 지연시킴으로써이를 증명할 수 있습니다 setTimeout.

for (let i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... 출력은 우리가 고수하는 한 변함없이 남아 있습니다 let. 대조적으로, 우리가 var i대신 사용한 경우 :

for (var i = 0; i < 5; i++) {
    setTimeout(_ => console.log(`i is ${i}`), 125/*ms*/);
}

... 루프가 예기치 않게 "i is 5"를 다섯 번 출력합니다.

i is 5
i is 5
i is 5
i is 5
i is 5

차이점이 있습니다. var 는 가장 가까운 함수 블록으로 범위 지정되고 let 은 함수 블록보다 작을 수있는 가장 가까운 둘러싸는 블록으로 범위가 지정됩니다. 블록 외부에 있으면 둘 다 전역입니다.

또한 let 으로 선언 된 변수는 둘러 쌀 블록에서 선언되기 전에 액세스 할 수 없습니다. 데모에서 보았 듯이 ReferenceError 예외가 발생합니다.

Demo :

var html = '';

write('#### global ####\n');
write('globalVar: ' + globalVar); //undefined, but visible

try {
  write('globalLet: ' + globalLet); //undefined, *not* visible
} catch (exception) {
  write('globalLet: exception');
}

write('\nset variables');

var globalVar = 'globalVar';
let globalLet = 'globalLet';

write('\nglobalVar: ' + globalVar);
write('globalLet: ' + globalLet);

function functionScoped() {
  write('\n#### function ####');
  write('\nfunctionVar: ' + functionVar); //undefined, but visible

  try {
    write('functionLet: ' + functionLet); //undefined, *not* visible
  } catch (exception) {
    write('functionLet: exception');
  }

  write('\nset variables');

  var functionVar = 'functionVar';
  let functionLet = 'functionLet';

  write('\nfunctionVar: ' + functionVar);
  write('functionLet: ' + functionLet);
}

function blockScoped() {
  write('\n#### block ####');
  write('\nblockVar: ' + blockVar); //undefined, but visible

  try {
    write('blockLet: ' + blockLet); //undefined, *not* visible
  } catch (exception) {
    write('blockLet: exception');
  }

  for (var blockVar = 'blockVar', blockIndex = 0; blockIndex < 1; blockIndex++) {
    write('\nblockVar: ' + blockVar); // visible here and whole function
  };

  for (let blockLet = 'blockLet', letIndex = 0; letIndex < 1; letIndex++) {
    write('blockLet: ' + blockLet); // visible only here
  };

  write('\nblockVar: ' + blockVar);

  try {
    write('blockLet: ' + blockLet); //undefined, *not* visible
  } catch (exception) {
    write('blockLet: exception');
  }
}

function write(line) {
  html += (line ? line : '') + '<br />';
}

functionScoped();
blockScoped();

document.getElementById('results').innerHTML = html;
<pre id="results"></pre>

글로벌 :

이들은 기능 블록 외부에서 이와 같이 사용될 때 매우 유사합니다.

let me = 'go';  // globally scoped
var i = 'able'; // globally scoped

그러나 let 정의 된 전역 변수는 var 정의 된 것과 같은 전역 window 객체의 속성으로 추가되지 않습니다.

console.log(window.me); // undefined
console.log(window.i); // 'able'

기능:

기능 블록에서 이와 같이 사용하면 동일합니다.

function ingWithinEstablishedParameters() {
    let terOfRecommendation = 'awesome worker!'; //function block scoped
    var sityCheerleading = 'go!'; //function block scoped
}

블록:

차이점은 다음과 같습니다. letfor() 루프에서만 볼 수 있고 var 는 전체 함수에서 볼 수 있습니다.

function allyIlliterate() {
    //tuce is *not* visible out here

    for( let tuce = 0; tuce < 5; tuce++ ) {
        //tuce is only visible in here (and in the for() parentheses)
        //and there is a separate tuce variable for each iteration of the loop
    }

    //tuce is *not* visible out here
}

function byE40() {
    //nish *is* visible out here

    for( var nish = 0; nish < 5; nish++ ) {
        //nish is visible to the whole function
    }

    //nish *is* visible out here
}

재 선언 :

strict 모드를 가정하면 var 은 동일한 범위에서 동일한 변수를 다시 선언 할 수있게합니다. 다른 한편 let 하지 마십시오.

'use strict';
let me = 'foo';
let me = 'bar'; // SyntaxError: Identifier 'me' has already been declared
'use strict';
var me = 'foo';
var me = 'bar'; // No problem, `me` is replaced.

let 우리가 다음과 같이 할 수 있기 때문에 흥미 롭습니다.

(() => {
    var count = 0;

    for (let i = 0; i < 2; ++i) {
        for (let i = 0; i < 2; ++i) {
            for (let i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();

그 결과 [0, 7]이 계산됩니다.

이므로

(() => {
    var count = 0;

    for (var i = 0; i < 2; ++i) {
        for (var i = 0; i < 2; ++i) {
            for (var i = 0; i < 2; ++i) {
                console.log(count++);
            }
        }
    }
})();

[0, 1] 만 계산합니다.


let 은 또한 클로저의 문제점을 피하기 위해 사용될 수 있습니다. 아래 예와 같이 이전 참조를 유지하는 것이 아니라 새로운 값을 바인딩합니다.

DEMO

for(var i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

위의 코드는 고전적인 JavaScript 클로저 문제를 보여줍니다. i 변수에 대한 참조는 i 의 실제 값이 아니라 클릭 핸들러 클로저에 저장됩니다.

모든 클릭 클릭 핸들러는 6을 보유하는 카운터 오브젝트가 하나뿐이기 때문에 동일한 오브젝트를 참조하므로 각 클릭에서 6을 얻습니다.

일반적인 해결 방법은 이것을 익명 함수로 묶고 i 를 인수로 전달하는 것입니다. 아래의 코드와 같이 let 대신 var 를 사용하면 이러한 문제를 피할 수 있습니다.

DEMO (Chrome 및 Firefox 50에서 테스트 됨)

'use strict';

for(let i = 1; i < 6; i++) {
  document.getElementById('my-element' + i)
    .addEventListener('click', function() { alert(i) })
}

사용할 때 let

let키워드는 어떤 블록 (일반적으로의 범위에 변수 선언 부착 { .. }이에 포함 된 것 쌍). 즉, let암시 적으로 그 변수 선언에 대한 모든 블록의 범위를 공중 납치.

let변수는 window전역 적으로 액세스 할 수 없기 때문에 객체 에서 액세스 할 수 없습니다.

function a(){
    { // this is the Max Scope for let variable
        let x = 12;
    }
    console.log(x);
}
a(); // Uncaught ReferenceError: x is not defined

사용할 때 var

var ES5의 변수는 변수가 함수 내에서 유효하고 함수 자체 외부에서 유효하지 않음을 의미하는 함수 범위가 있습니다.

var변수는 window전역 적으로 액세스 할 수 없기 때문에 객체 에서 액세스 할 수 있습니다.

function a(){ // this is the Max Scope for var variable
    { 
        var x = 12;
    }
    console.log(x);
}
a(); // 12

더 많은 것을 알고 싶다면 계속해서 아래를 읽으십시오.

범위에 대한 가장 유명한 인터뷰 질문 중 하나는 다음 letvar같이 정확한 사용을 충족 할 수 있습니다.

사용할 때 let

for (let i = 0; i < 10 ; i++) {
    setTimeout(
        function a() {
            console.log(i); //print 0 to 9, that is literally AWW!!!
        }, 
        100 * i);
}

왜냐하면 let모든 루프 반복마다 변수를 사용하고 자체 복사본을 가지고 있기 때문 입니다.

사용할 때 var

for (var i = 0; i < 10 ; i++) {
    setTimeout(
        function a() {
            console.log(i); //print 10 times 10
        }, 
        100 * i);
}

이는 사용할 때 var마다 모든 루프 반복에 대해 변수의 유효 범위가 지정되어 공유 사본 이 있기 때문 입니다.


다음 두 가지 기능이 차이점을 나타낼 수 있습니다.

function varTest() {
    var x = 31;
    if (true) {
        var x = 71;  // Same variable!
        console.log(x);  // 71
    }
    console.log(x);  // 71
}

function letTest() {
    let x = 31;
    if (true) {
        let x = 71;  // Different variable
        console.log(x);  // 71
    }
    console.log(x);  // 31
}

상술 한 바와 같이:

차이점이 있습니다. var가까운 범위로되는 기능 블록let받는 범위가 가까운 바깥 블록 기능 블록보다 작을 수있다. 모든 블록 외부에 있으면 둘 다 전역입니다. 예를 참조하십시오.

예제 1 :

두 가지 예에서 나는 기능을 가지고있다 myfunc. myfunc변수 myvar가 10과 같습니다. 첫 번째 예에서는 myvar10과 같음을 확인합니다 ( myvar==10). 예인 경우, 키워드를 myvar사용 하는 변수 (이제 myvar 변수가 두 개 있습니다)를 선언 var하고 새 값 (20)을 할당합니다. 다음 줄에서는 콘솔에 값을 인쇄합니다. 조건부 블록 후에 다시 myvar콘솔 의 값을 출력합니다 . 당신의 출력을 보면 myfunc, myvar값이 20로 동일있다.

예제 2 :var 내 조건부 블록에서 키워드 를 사용하는 대신 두 번째 예제 에서 키워드 myvar사용을 선언 let합니다. 내가 전화 할 때 이제 myfunc나는 두 개의 서로 다른 출력을 얻을 : myvar=20myvar=10.

차이점은 매우 간단합니다.


이 기사에서는 var, let 및 const의 차이점을 명확하게 정의합니다.

const 식별자가 재 할당되지 않는다는 신호입니다.

let는 루프의 카운터 또는 알고리즘의 값 스왑과 같이 변수를 다시 할당 할 수있는 신호입니다. 또한 변수가 정의 된 블록에서만 사용된다는 신호를 보냅니다.이 블록은 항상 함수를 포함하는 전체가 아닙니다.

varJavaScript에서 변수를 정의 할 때 가장 약한 신호입니다. 변수는 재 할당 될 수도 있고 재 할당되지 않을 수도 있으며, 변수는 전체 함수 또는 블록이나 루프의 용도로만 사용되거나 사용되지 않을 수 있습니다.

https://medium.com/javascript-scene/javascript-es6-var-let-or-const-ba58b8dcde75#.esmkpbg9b


let은 es6의 일부입니다. 이 기능들은 차이점을 쉬운 방법으로 설명합니다.

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}

function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // different variable
    console.log(x);  // 2
  }
  console.log(x);  // 1
}

내가 스펙을 읽으면 let 고맙게도 개인 전용 멤버를 시뮬레이트하는 데 사용되는 자체 호출 함수 ( 코드 가독성을 떨어 뜨리고 디버깅을 복잡하게 만들며 실제 코드 보호 또는 기타 이점을 추가하지 못하는 인기있는 디자인 패턴) 를 피할 수 있습니다. 의미에 대한 욕망, 그래서 그것을 사용을 중지하십시오. / 폭언

var SomeConstructor;

{
    let privateScope = {};

    SomeConstructor = function SomeConstructor () {
        this.someProperty = "foo";
        privateScope.hiddenProperty = "bar";
    }

    SomeConstructor.prototype.showPublic = function () {
        console.log(this.someProperty); // foo
    }

    SomeConstructor.prototype.showPrivate = function () {
        console.log(privateScope.hiddenProperty); // bar
    }

}

var myInstance = new SomeConstructor();

myInstance.showPublic();
myInstance.showPrivate();

console.log(privateScope.hiddenProperty); // error

'보기 개인 인터페이스를 에뮬레이션 '


이제는 let다음을 사용하여 문장 블록에 변수 범위를 지정하는 것이 더 효과적이라고 생각합니다 .

function printnums()
{
    // i is not accessible here
    for(let i = 0; i <10; i+=)
    {
       console.log(i);
    }
    // i is not accessible here

    // j is accessible here
    for(var j = 0; j <10; j++)
    {
       console.log(j);
    }
    // j is accessible here
}

나는 사람들이 다른 언어, 자바, C # 등과 같이 자바 스크립트에서 비슷한 범위를 가질 수 있도록하자.

자바 스크립트의 범위 지정에 대한 명확한 이해가없는 사람들은 이전에 실수를 저 지르곤했습니다.

호이 스팅은을 (를) 사용하여 지원되지 않습니다 let.

이 방법을 사용하면 JavaScript에있는 오류가 제거됩니다.

ES6 in Depth : let과 const 를 더 잘 이해하기를 참조하십시오 .


일부 해킹 let:

1.

    let statistics = [16, 170, 10];
    let [age, height, grade] = statistics;

    console.log(height)

2.

    let x = 120,
    y = 12;
    [x, y] = [y, x];
    console.log(`x: ${x} y: ${y}`);

삼.

    let node = {
                   type: "Identifier",
                   name: "foo"
               };

    let { type, name, value } = node;

    console.log(type);      // "Identifier"
    console.log(name);      // "foo"
    console.log(value);     // undefined

    let node = {
        type: "Identifier"
    };

    let { type: localType, name: localName = "bar" } = node;

    console.log(localType);     // "Identifier"
    console.log(localName);     // "bar"

Getter and setter with let:

let jar = {
    numberOfCookies: 10,
    get cookies() {
        return this.numberOfCookies;
    },
    set cookies(value) {
        this.numberOfCookies = value;
    }
};

console.log(jar.cookies)
jar.cookies = 7;

console.log(jar.cookies)




let