他含着她的乳奶揉搓揉捏小说,乳妓h军妓调教hh文,影音先锋亚洲成aⅴ人在

let

基本用法

let命令，用來聲明變量。用法類似于var，但聲明的變量，只在let命令所在的代碼塊內有效。

{
  let a = 10;
  var b = 1;
}
a // ReferenceError: a is not defined.
b // 1

for循環的計數器，就很合適使用let命令。

for (let i = 0; i < arr.length; i++) {}
console.log(i); //ReferenceError: i is not defined

計數器i只在for循環體內有效，在循環體外引用就會報錯。

var a = [];
for (var i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 10

上面代碼中，變量i是var聲明的，在全局范圍內都有效。每一次循環，變量i的值都會發生改變，而循環內被賦給數組a的函數內部的console.log(i)，里面的i指向的就是全局的i。也就是說，所有數組a的成員里面的i，指向的都是同一個i，導致運行時輸出的是最后一輪的i的值，也就是10。

var a = [];
for (let i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 6

上面代碼中的變量i是let聲明的，當前的i只在本輪循環有效，所以每一次循環的i都是一個新的變量，所以最后輸出6。
for循環還有一個特別之處，就是設置循環變量的那部分是一個父作用域，而循環體內部是一個單獨的子作用域。

for (let i = 0; i < 3; i++) {
  let i = 'abc';
  console.log(i);// abc abc abc
}

上面代碼輸出了3次abc。這表明函數內部的變量i與循環變量i不在同一個作用域，有各自單獨的作用域。

不存在變量提升

var命令會發生“變量提升”現象，即變量可以在聲明之前使用，值為undefined。而let不會發生“變量提升”現象。所以，變量一定要在聲明后使用，否則報錯。

console.log(foo); // 輸出undefined
console.log(bar); // 報錯ReferenceError
var foo = 2;
let bar = 2;

暫時性死區

只要塊級作用域內存在let命令，它所聲明的變量就“綁定”這個區域，不再受外部的影響。

var tmp = 123;
if (true) {
  tmp = 'abc'; // ReferenceError
  let tmp;
}

ES6明確規定，如果區塊中存在let和const命令，這個區塊對這些命令聲明的變量，從一開始就形成了封閉作用域。凡是在聲明之前就使用這些變量，就會報錯。
總之，在代碼塊內，使用let命令聲明變量之前，該變量都是不可用的。這在語法上，稱為“暫時性死區”。

if (true) {
  tmp = 'abc'; // ReferenceError
  console.log(tmp); // ReferenceError
  let tmp; 
  console.log(tmp); // undefined
  tmp = 123;
  console.log(tmp); // 123
}

上面代碼中，在let命令聲明變量tmp之前，都屬于變量tmp的“死區”。
“暫時性死區”也意味著typeof不再是一個百分之百安全的操作。

typeof x; // ReferenceError
let x;

作為比較，如果一個變量根本沒有被聲明，使用typeof反而不會報錯。

typeof undeclared_variable // "undefined"

所以，在沒有let之前，typeof運算符是百分之百安全的，永遠不會報錯。現在這一點不成立了。
有些“死區”比較隱蔽，不太容易發現。

function bar(x = y, y = 2) {
  return [x, y];
}
bar(); // 報錯

上面代碼中，調用bar函數之所以報錯（某些實現可能不報錯），是因為參數x默認值等于另一個參數y，而此時y還沒有聲明，屬于”死區“。如果y的默認值是x，就不會報錯，因為此時x已經聲明了。

function bar(x = 2, y = x) {
  return [x, y];
}
bar(); // [2, 2]

另外，下面的代碼也會報錯，與var的行為不同。

// 不報錯
var x = x;
// 報錯
let x = x; // ReferenceError: x is not defined

上面代碼報錯，也是因為暫時性死區。使用let聲明變量時，只要變量在還沒有聲明完成前使用，就會報錯。上面這行就屬于這個情況，在變量x的聲明語句還沒有執行完成前，就去取x的值，導致報錯”x 未定義“。
ES6規定暫時性死區和let、const語句不出現變量提升，主要是為了減少運行時錯誤，防止在變量聲明前就使用這個變量，從而導致意料之外的行為。
總之，暫時性死區的本質就是，只要一進入當前作用域，所要使用的變量就已經存在了，但是不可獲取，只有等到聲明變量的那一行代碼出現，才可以獲取和使用該變量。

不允許重復聲明

let不允許在相同作用域內，重復聲明同一個變量。

// 報錯
function () {
  let a = 10;
  var a = 1;
}
// 報錯
function () {
  let a = 10;
  let a = 1;
}

因此，不能在函數內部重新聲明參數。

function func(arg) {
  let arg; // 報錯
}
function func(arg) {
  {
    let arg; // 不報錯
  }
}

塊級作用域

為什么需要塊級作用域

ES5只有全局作用域和函數作用域，沒有塊級作用域，這帶來很多不合理的場景。
第一種場景，內層變量可能會覆蓋外層變量。

var tmp = new Date();
function f() {
  console.log(tmp);
  if (false) {
    var tmp = "hello world";
  }
}
f(); // undefined

上面代碼中，函數f執行后，輸出結果為undefined，原因在于變量提升，導致內層的tmp變量覆蓋了外層的tmp變量。
第二種場景，用來計數的循環變量泄露為全局變量。

var s = 'hello';
for (var i = 0; i < s.length; i++) {
  console.log(s[i]);
}
console.log(i); // 5

上面代碼中，變量i只用來控制循環，但是循環結束后，它并沒有消失，泄露成了全局變量。

ES6的塊級作用域

let實際上為JavaScript新增了塊級作用域。

function f1() {
  let n = 5;
  if (true) {
    let n = 10;
  }
  console.log(n); // 5
}

上面的函數有兩個代碼塊，都聲明了變量n，運行后輸出5。這表示外層代碼塊不受內層代碼塊的影響。如果使用var定義變量n，最后輸出的值就是10。
ES6允許塊級作用域的任意嵌套。

{{{{{let insane = 'Hello World'}}}}};

上面代碼使用了一個五層的塊級作用域。外層作用域無法讀取內層作用域的變量。

{{{{
  {let insane = 'Hello World'}
  console.log(insane); // 報錯
}}}};

內層作用域可以定義外層作用域的同名變量。

{{{{
  let insane = 'Hello World';
  {let insane = 'Hello World'}
}}}};

塊級作用域的出現，實際上使得獲得廣泛應用的立即執行匿名函數(IIFE)不再必要了。

// IIFE寫法
(function () {
  var tmp = ...;
  ...
}());
// 塊級作用域寫法
{
  let tmp = ...;
  ...
}

塊級作用域與函數聲明

ES5規定，函數只能在頂層作用域和函數作用域之中聲明，不能在塊級作用域聲明。

// 情況一
if (true) {
  function f() {}
}
// 情況二
try {
  function f() {}
} catch(e) {
}

上面代碼的兩種函數聲明，根據ES5的規定都是非法的。
但是，瀏覽器沒有遵守這個規定，還是支持在塊級作用域之中聲明函數，因此上面兩種情況實際都能運行，不會報錯。不過，“嚴格模式”下還是會報錯。

// ES5嚴格模式
'use strict';
if (true) {
  function f() {}
}
// 報錯

ES6引入了塊級作用域，明確允許在塊級作用域之中聲明函數。

// ES6嚴格模式
'use strict';
if (true) {
  function f() {}
}
// 不報錯

并且ES6規定，塊級作用域之中，函數聲明語句的行為類似于let，在塊級作用域之外不可引用。

function f() { console.log('I am outside!'); }
(function () {
  if (false) {
    // 重復聲明一次函數f
    function f() { console.log('I am inside!'); }
  }
  f();
}());

上面代碼在ES5中運行，會得到“I am inside!”，因為在if內聲明的函數f會被提升到函數頭部，實際運行的代碼如下。

// ES5版本
function f() { console.log('I am outside!'); }
(function () {
  function f() { console.log('I am inside!'); }
  if (false) {
  }
  f();
}());

ES6的運行結果就完全不一樣了，會得到“I am outside!”。因為塊級作用域內聲明的函數類似于let，對作用域之外沒有影響，實際運行的代碼如下。

// ES6版本
function f() { console.log('I am outside!'); }
(function () {
  f();
}());

很顯然，這種行為差異會對老代碼產生很大影響。為了減輕因此產生的不兼容問題，ES6規定，瀏覽器的實現可以不遵守上面的規定，有自己的行為方式。

允許在塊級作用域內聲明函數。
函數聲明類似于var，即會提升到全局作用域或函數作用域的頭部。
同時，函數聲明還會提升到所在的塊級作用域的頭部。

注意，上面三條規則只對ES6的瀏覽器實現有效，其他環境的實現不用遵守，還是將塊級作用域的函數聲明當作let處理。
根據這三條規則，在瀏覽器的ES6環境中，塊級作用域內聲明的函數，行為類似于var聲明的變量。

// ES6的瀏覽器環境
function f() { console.log('I am outside!'); }
(function () {
  if (false) {
    // 重復聲明一次函數f
    function f() { console.log('I am inside!'); }
  }
  f();
}());
// Uncaught TypeError: f is not a function

上面的代碼報錯，是因為實際運行的是下面的代碼。

// ES6的瀏覽器環境
function f() { console.log('I am outside!'); }
(function () {
  var f = undefined;
  if (false) {
    function f() { console.log('I am inside!'); }
  }
  f();
}());
// Uncaught TypeError: f is not a function

考慮到環境導致的行為差異太大，應該避免在塊級作用域內聲明函數。如果確實需要，也應該寫成函數表達式，而不是函數聲明語句。

// 函數聲明語句
{
  let a = 'secret';
  function f() {
    return a;
  }
}
// 函數表達式
{
  let a = 'secret';
  let f = function () {
    return a;
  };
}

另外，還有一個需要注意的地方。ES6的塊級作用域允許聲明函數的規則，只在使用大括號的情況下成立，如果沒有使用大括號，就會報錯。

// 不報錯
'use strict';
if (true) {
  function f() {}
}
// 報錯
'use strict';
if (true)
  function f() {}

const命令

const聲明一個只讀的常量。一旦聲明，常量的值就不能改變，改變常量的值會報錯。

const PI = 3.1415;
PI // 3.1415
PI = 3; // TypeError: Assignment to constant variable.

const聲明的變量不得改變值，這意味著，const一旦聲明變量，就必須立即初始化，不能留到以后賦值。

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

const的作用域與let命令相同：只在聲明所在的塊級作用域內有效。

if (true) {
  const MAX = 5;
}
MAX // Uncaught ReferenceError: MAX is not defined

const命令聲明的常量也是不提升，同樣存在暫時性死區，只能在聲明的位置后面使用。

if (true) {
  console.log(MAX); // ReferenceError
  const MAX = 5;
}

const聲明的常量，也與let一樣不可重復聲明。

var message = "Hello!";
let age = 25;
// 以下兩行都會報錯
const message = "Goodbye!";
const age = 30;

對于復合類型的變量，變量名不指向數據，而是指向數據所在的地址。const命令只是保證變量名指向的地址不變，并不保證該地址的數據不變，所以將一個對象聲明為常量必須非常小心。

const foo = {};
foo.prop = 123;
foo.prop // 123
foo = {}; // TypeError: "foo" is read-only

上面代碼中，常量foo儲存的是一個地址，這個地址指向一個對象。不可變的只是這個地址，即不能把foo指向另一個地址，但對象本身是可變的，所以依然可以為其添加新屬性。
下面是另一個例子。

const a = [];
a.push('Hello'); // 可執行
a.length = 0;    // 可執行
a = ['Dave'];    // 報錯

上面代碼中，常量a是一個數組，這個數組本身是可寫的，但是如果將另一個數組賦值給a，就會報錯。
如果真的想將對象凍結，應該使用Object.freeze方法。

const foo = Object.freeze({});
// 常規模式時，下面一行不起作用；
// 嚴格模式時，該行會報錯
foo.prop = 123;

上面代碼中，常量foo指向一個凍結的對象，所以添加新屬性不起作用，嚴格模式時還會報錯。
除了將對象本身凍結，對象的屬性也應該凍結。下面是一個將對象徹底凍結的函數。

var constantize = (obj) => {
  Object.freeze(obj);
  Object.keys(obj).forEach( (key, value) => {
    if ( typeof obj[key] === 'object' ) {
      constantize( obj[key] );
    }
  });
};

ES5只有兩種聲明變量的方法：var命令和function命令。ES6除了添加let和const命令，另外兩種聲明變量的方法：import命令和class命令。所以，ES6一共有6種聲明變量的方法。

頂層對象的屬性

頂層對象，在瀏覽器環境指的是window對象，在Node指的是global對象。ES5中，頂層對象的屬性與全局變量是等價的。

window.a = 1;
a // 1
a = 2;
window.a // 2

頂層對象的屬性與全局變量掛鉤，被認為是JavaScript最大的設計敗筆之一。這樣的設計帶來了幾個很大的問題，首先是沒法在編譯時就報出變量未聲明的錯誤，只有運行時才能知道（因為全局變量可能是頂層對象的屬性創造的，而屬性的創造是動態的）；其次，很容易不知不覺地就創建了全局變量（比如打字出錯）；最后，頂層對象的屬性是到處可以讀寫的，這非常不利于模塊化編程。另一方面，window對象有實體含義，指的是瀏覽器的窗口對象，頂層對象是一個有實體含義的對象，也是不合適的。
ES6為了改變這一點，一方面規定，為了保持兼容性，var命令和function命令聲明的全局變量，依舊是頂層對象的屬性；另一方面規定，let命令、const命令、class命令聲明的全局變量，不屬于頂層對象的屬性。也就是說，從ES6開始，全局變量將逐步與頂層對象的屬性脫鉤。

var a = 1;
// 如果在 Node的REPL環境，可以寫成global.a
// 或者采用通用方法，寫成 this.a
window.a // 1
let b = 1;
window.b // undefined

global對象

ES5的頂層對象，本身也是一個問題，因為它在各種實現里面是不統一的。

瀏覽器里面，頂層對象是window，但Node和Web Worker沒有window。
瀏覽器和Web Worker里面，self也指向頂層對象，但是Node沒有self。
Node里面，頂層對象是global，但其他環境都不支持。

同一段代碼為了能夠在各種環境，都能取到頂層對象，現在一般是使用this變量，但是有局限性。

全局環境中，this會返回頂層對象。但是，Node模塊和ES6模塊中，this返回的是當前模塊。
函數里面的this，如果函數不是作為對象的方法運行，而是單純作為函數運行，this會指向頂層對象。但是，嚴格模式下，這時this會返回undefined。
不管是嚴格模式，還是普通模式，new Function('return this')()，總是會返回全局對象。但是，如果瀏覽器用了CSP（Content Security Policy，內容安全政策），那么eval、new Function這些方法都可能無法使用。

綜上所述，很難找到一種方法，可以在所有情況下，都取到頂層對象。下面是兩種勉強可以使用的方法。

// 方法一
(typeof window !== 'undefined'
   ? window
   : (typeof process === 'object' &&
      typeof require === 'function' &&
      typeof global === 'object')
     ? global
     : this);
// 方法二
var getGlobal = function () {
  if (typeof self !== 'undefined') { return self; }
  if (typeof window !== 'undefined') { return window; }
  if (typeof global !== 'undefined') { return global; }
  throw new Error('unable to locate global object');
};

現在有一個提案，在語言標準的層面，引入global作為頂層對象。也就是說，在所有環境下，global都是存在的，都可以從它拿到頂層對象。
墊片庫system.global模擬了這個提案，可以在所有環境拿到global。

// CommonJS 的寫法
require('system.global/shim')();
// ES6 模塊的寫法
import shim from 'system.global/shim'; shim();

上面代碼可以保證各種環境里面，global對象都是存在的。

// CommonJS 的寫法
var global = require('system.global')();
// ES6 模塊的寫法
import getGlobal from 'system.global';
const global = getGlobal();

上面代碼將頂層對象放入變量global。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

ES6學習?let和const

ES6學習?let和const

let

基本用法

不存在變量提升

暫時性死區

不允許重復聲明

塊級作用域

為什么需要塊級作用域

ES6的塊級作用域

塊級作用域與函數聲明

const命令

頂層對象的屬性

global對象

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

ES6學習?let和const

let

基本用法

不存在變量提升

暫時性死區

不允許重復聲明

塊級作用域

為什么需要塊級作用域

ES6的塊級作用域

塊級作用域與函數聲明

const命令

頂層對象的屬性

global對象

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频