“睡服”面试官系列第一篇之let和const命令（建议收藏学习）

目录

1let命令

1.1基本用法

1.2for循环小案例

1.3不存在变量提升

1.4暂时性死区

1.5不允许重复声明

2块级作用域

2.1为什么需要块级作用域？

2.2ES6 的块级作用域

2.3块级作用域和函数声明

3const

3.1本质

4顶层对象的属性

5global对象

6总结

1let命令

1.1基本用法

ES6 新增了 let 命令，用来声明变量。它的用法类似于 var ，但是所声明的变量，只在 let 命令所在的代码块内有效。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>{let a = 10;var b = 1}console.log(a) // ReferenceError: a is not defined.console.log(b) //1</script>
</body></html>

上面代码在代码块之中，分别用 let 和 var 声明了两个变量。然后在代码块之外调用这两个变量，结果 let 声明的变量报错， var 声明的变量返回了正确
的值。这表明， let 声明的变量只在它所在的代码块有效

1.2for循环小案例

for 循环的计数器，就很合适使用 let 命令

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>for (let i = 0; i < 10; i++) {// ...}console.log(i);// ReferenceError: i is not defined</script>
</body></html>

上面代码中，计数器 i 只在 for 循环体内有效，在循环体外引用就会报错。

下面的代码如果使用 var ，最后输出的是 10 。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>var a = [];for (var i = 0; i < 10; i++) {a[i] = function() {console.log(i);};}a[6](); // 10</script>
</body></html>

上面代码中，变量 i 是 var 命令声明的，在全局范围内都有效，所以全局只有一个变量 i 。每一次循环，变量 i 的值都会发生改变，而循环内被赋给数组 a
的函数内部的 console.log(i) ，里面的 i 指向的就是全局的 i 。也就是说，所有数组 a 的成员里面的 i ，指向的都是同一个 i ，导致运行时输出的是最后
一轮的 i 的值，也就是 10。
如果使用 let ，声明的变量仅在块级作用域内有效，最后输出的是 6

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>var a = [];for (let i = 0; i < 10; i++) {a[i] = function() {console.log(i);};}a[6](); // 10</script>
</body></html>

上面代码中，变量 i 是 let 声明的，当前的 i 只在本轮循环有效，所以每一次循环的 i 其实都是一个新的变量，所以最后输出的是 6 。你可能会问，如果每
一轮循环的变量 i 都是重新声明的，那它怎么知道上一轮循环的值，从而计算出本轮循环的值？这是因为 JavaScript 引擎内部会记住上一轮循环的值，初
始化本轮的变量 i 时，就在上一轮循环的基础上进行计算。
另外， for 循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>for (let i = 0; i < 3; i++) {let i = 'abc';console.log(i);}// abc// abc// abc</script>
</body></html>

上面代码正确运行，输出了 3 次 abc 。这表明函数内部的变量 i 与循环变量 i 不在同一个作用域，有各自单独的作用域。

1.3不存在变量提升

var 命令会发生”变量提升“现象，即变量可以在声明之前使用，值为 undefined 。这种现象多多少少是有些奇怪的，按照一般的逻辑，变量应该在声明语
句之后才可以使用。
为了纠正这种现象， let 命令改变了语法行为，它所声明的变量一定要在声明后使用，否则报错

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// var 的情况console.log(foo); // 输出undefinedvar foo = 2;// let 的情况console.log(bar); // 报错ReferenceErrorlet bar = 2</script>
</body></html>

上面代码中，变量 foo 用 var 命令声明，会发生变量提升，即脚本开始运行时，变量 foo 已经存在了，但是没有值，所以会输出 undefined 。变量 bar 用
let 命令声明，不会发生变量提升。这表示在声明它之前，变量 bar 是不存在的，这时如果用到它，就会抛出一个错误。

1.4暂时性死区

只要块级作用域内存在 let 命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部的影响。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>var tmp = 123;if (true) {tmp = 'abc'; // ReferenceErrorlet tmp;}</script>
</body></html>

上面代码中，存在全局变量 tmp ，但是块级作用域内 let 又声明了一个局部变量 tmp ，导致后者绑定这个块级作用域，所以在 let 声明变量前，对 tmp 赋
值会报错。
ES6 明确规定，如果区块中存在 let 和 const 命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，
就会报错。
总之，在代码块内，使用 let 命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>if (true) {// TDZ开始tmp = 'abc'; // ReferenceErrorconsole.log(tmp); // ReferenceErrorlet tmp; // TDZ结束console.log(tmp); // undefinedtmp = 123;console.log(tmp); // 123}</script>
</body></html>

上面代码中，在 let 命令声明变量 tmp 之前，都属于变量 tmp 的“死区”。
“暂时性死区”也意味着 typeof 不再是一个百分之百安全的操作

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>typeof x; // ReferenceErrorlet x;</script>
</body></html>

上面代码中，变量 x 使用 let 命令声明，所以在声明之前，都属于 x 的“死区”，只要用到该变量就会报错。因此， typeof 运行时就会抛出一个
ReferenceError 。
作为比较，如果一个变量根本没有被声明，使用 typeof 反而不会报错

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>typeof undeclared_variable // "undefined"</script>
</body></html>

上面代码中， undeclared_variable 是一个不存在的变量名，结果返回“undefined”。所以，在没有 let 之前， typeof 运算符是百分之百安全的，永远不
会报错。现在这一点不成立了。这样的设计是为了让大家养成良好的编程习惯，变量一定要在声明之后使用，否则就报错。
有些“死区”比较隐蔽，不太容易发现

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>function bar(x = y, y = 2) {return [x, y];}bar(); // 报错</script>
</body></html>

上面代码中，调用 bar 函数之所以报错（某些实现可能不报错），是因为参数 x 默认值等于另一个参数 y ，而此时 y 还没有声明，属于”死区“。如果 y 的默
认值是 x ，就不会报错，因为此时 x 已经声明了。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>function bar(x = 2, y = x) {return [x, y];}bar(); // [2, 2]</script>
</body></html>

另外，下面的代码也会报错，与 var 的行为不同

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// 不报错var x = x;// 报错let x = x;// ReferenceError: x is not defined</script>
</body></html>

上面代码报错，也是因为暂时性死区。使用 let 声明变量时，只要变量在还没有声明完成前使用，就会报错。上面这行就属于这个情况，在变量 x 的声明
语句还没有执行完成前，就去取 x 的值，导致报错”x 未定义“。
ES6 规定暂时性死区和 let 、 const 语句不出现变量提升，主要是为了减少运行时错误，防止在变量声明前就使用这个变量，从而导致意料之外的行为。
这样的错误在 ES5 是很常见的，现在有了这种规定，避免此类错误就很容易了。
总之，暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行代码出现，才可以获
取和使用该变量。

1.5不允许重复声明

let 不允许在相同作用域内，重复声明同一个变量

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// 报错function func() {let a = 10;var a = 1;}// 报错function func() {let a = 10;let a = 1;}</script>
</body></html>

因此，不能在函数内部重新声明参数

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>function func(arg) {let arg; // 报错}function func(arg) {{let arg; // 不报错}}</script>
</body></html>

2块级作用域

2.1为什么需要块级作用域？

ES5 只有全局作用域和函数作用域，没有块级作用域，这带来很多不合理的场景。
第一种场景，内层变量可能会覆盖外层变量。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>var tmp = new Date();function f() {console.log(tmp);if (false) {var tmp = 'hello world';}}f(); // undefined</script>
</body></html>

上面代码的原意是， if 代码块的外部使用外层的 tmp 变量，内部使用内层的 tmp 变量。但是，函数 f 执行后，输出结果为 undefined ，原因在于变量提
升，导致内层的 tmp 变量覆盖了外层的 tmp 变量。
第二种场景，用来计数的循环变量泄露为全局变量

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>var s = 'hello';for (var i = 0; i < s.length; i++) {console.log(s[i]);}console.log(i); // 5</script>
</body></html>

上面代码中，变量 i 只用来控制循环，但是循环结束后，它并没有消失，泄露成了全局变量。

2.2ES6 的块级作用域

let 实际上为 JavaScript 新增了块级作用域。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>function f1() {let n = 5;if (true) {let n = 10;}console.log(n); // 5}</script>
</body></html>

上面的函数有两个代码块，都声明了变量 n ，运行后输出 5。这表示外层代码块不受内层代码块的影响。如果两次都使用 var 定义变量 n ，最后输出的值
才是 10。
ES6 允许块级作用域的任意嵌套。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>{{{{{let insane = 'Hello World'}}}}};</script>
</body></html>

上面代码使用了一个五层的块级作用域。外层作用域无法读取内层作用域的变量。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>{{{{{let insane = 'Hello World'}console.log(insane); // 报错}}}};</script>
</body></html>

内层作用域可以定义外层作用域的同名变量。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>{{{{let insane = 'Hello World'; {let insane = 'Hello World'}}}}};</script>
</body></html>

块级作用域的出现，实际上使得获得广泛应用的立即执行函数表达式（IIFE）不再必要了。

  // IIFE 写法(function() {var tmp = ...;...}());// 块级作用域写法{let tmp = ...;...}

2.3块级作用域和函数声明

函数能不能在块级作用域之中声明？这是一个相当令人混淆的问题。
ES5 规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// 情况一if (true) {function f() {}}// 情况二try {function f() {}} catch (e) {// ...}</script>
</body></html>

上面两种函数声明，根据 ES5 的规定都是非法的。
但是，浏览器没有遵守这个规定，为了兼容以前的旧代码，还是支持在块级作用域之中声明函数，因此上面两种情况实际都能运行，不会报错。ES6 引入了块级作用域，明确允许在块级作用域之中声明函数。ES6 规定，块级作用域之中，函数声明语句的行为类似于 let ，在块级作用域之外不可引
用

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>function f() {console.log('I am outside!');}(function() {if (false) {// 重复声明一次函数ffunction f() {console.log('I am inside!');}}f();}());</script>
</body></html>


上面代码在 ES5 中运行，会得到“I am inside!”，因为在 if 内声明的函数 f 会被提升到函数头部，实际运行的代码如下。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// ES5 环境function f() {console.log('I am outside!');}(function() {function f() {console.log('I am inside!');}if (false) {}f();}());</script>
</body></html>

ES6 就完全不一样了，理论上会得到“I am outside!”。因为块级作用域内声明的函数类似于 let ，对作用域之外没有影响。但是，如果你真的在 ES6 浏
览器中运行一下上面的代码，是会报错的，这是为什么呢？
原来，如果改变了块级作用域内声明的函数的处理规则，显然会对老代码产生很大影响。为了减轻因此产生的不兼容问题，ES6 在附录 B里面规定，浏览
器的实现可以不遵守上面的规定，有自己的行为方式。
允许在块级作用域内声明函数。
函数声明类似于 var ，即会提升到全局作用域或函数作用域的头部。
同时，函数声明还会提升到所在的块级作用域的头部。
注意，上面三条规则只对 ES6 的浏览器实现有效，其他环境的实现不用遵守，还是将块级作用域的函数声明当作 let 处理。
根据这三条规则，在浏览器的 ES6 环境中，块级作用域内声明的函数，行为类似于 var 声明的变量

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// 浏览器的 ES6 环境function f() {console.log('I am outside!');}(function() {if (false) {// 重复声明一次函数ffunction f() {console.log('I am inside!');}}f();}());// Uncaught TypeError: f is not a function</script>
</body></html>

上面的代码在符合 ES6 的浏览器中，都会报错，因为实际运行的是下面的代码。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// 浏览器的 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</script>
</body></html>

考虑到环境导致的行为差异太大，应该避免在块级作用域内声明函数。如果确实需要，也应该写成函数表达式，而不是函数声明语句。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// 函数声明语句{let a = 'secret';function f() {return a;}}// 函数表达式{let a = 'secret';let f = function() {return a;};}</script>
</body></html>

另外，还有一个需要注意的地方。ES6 的块级作用域允许声明函数的规则，只在使用大括号的情况下成立，如果没有使用大括号，就会报错

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>// 不报错'use strict';if (true) {function f() {}}// 报错'use strict';if (true)function f() {</script>
</body></html>

3const

const 声明一个只读的常量。一旦声明，常量的值就不能改变

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>const PI = 3.1415;PI // 3.1415PI = 3;// TypeError: Assignment to constant variable</script>
</body></html>

上面代码表明改变常量的值会报错。
const 声明的变量不得改变值，这意味着， const 一旦声明变量，就必须立即初始化，不能留到以后赋值。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>const foo;// SyntaxError: Missing initializer in const declaration</script>
</body></html>

上面代码表示，对于 const 来说，只声明不赋值，就会报错。
const 的作用域与 let 命令相同：只在声明所在的块级作用域内有效。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>if (true) {const MAX = 5;}MAX // Uncaught ReferenceError: MAX is not defined</script>
</body></html>

const 命令声明的常量也是不提升，同样存在暂时性死区，只能在声明的位置后面使用

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>if (true) {console.log(MAX); // ReferenceErrorconst MAX = 5;}</script>
</body></html>

上面代码在常量 MAX 声明之前就调用，结果报错。
const 声明的常量，也与 let 一样不可重复声明。

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>var message = "Hello!";let age = 25;// 以下两行都会报错const message = "Goodbye!";const age = 30</script>
</body></html>

3.1本质

const 实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在
变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指针， const 只能保
证这个指针是固定的，至于它指向的数据结构是不是可变的，就完全不能控制了。因此，将一个对象声明为常量必须非常小心

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>const foo = {};// 为 foo 添加一个属性，可以成功foo.prop = 123;foo.prop // 123// 将 foo 指向另一个对象，就会报错foo = {}; // TypeError: "foo" is read-only</script>
</body></html>

上面代码中，常量 foo 储存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能把 foo 指向另一个地址，但对象本身是可变的，所以
依然可以为其添加新属性

4顶层对象的属性

顶层对象，在浏览器环境指的是 window 对象，在 Node 指的是 global 对象。ES5 之中，顶层对象的属性与全局变量是等价的

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge"><title>test</title>
</head><body><script>window.a = 1;a // 1a = 2;window.a // 2</script>
</body></html>

 上面代码中，顶层对象的属性赋值与全局变量的赋值，是同一件事。
顶层对象的属性与全局变量挂钩，被认为是 JavaScript 语言最大的设计败笔之一。这样的设计带来了几个很大的问题，首先是没法在编译时就报出变量未
声明的错误，只有运行时才能知道（因为全局变量可能是顶层对象的属性创造的，而属性的创造是动态的）；其次，程序员很容易不知不觉地就创建了全
局变量（比如打字出错）；最后，顶层对象的属性是到处可以读写的，这非常不利于模块化编程。另一方面， window 对象有实体含义，指的是浏览器的窗
口对象，顶层对象是一个有实体含义的对象，也是不合适的。

5global对象

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 这些方法都可能无法使用。
综上所述，很难找到一种方法，可以在所有情况下，都取到顶层对象

6总结

本博客源于本人阅读相关书籍和视频总结，创作不易，谢谢点赞支持。学到就是赚到。我是歌谣，励志成为一名优秀的技术革新人员。

欢迎私信交流，一起学习，一起成长。

推荐链接 其他文件目录参照

“睡服“面试官系列之各系列目录汇总（建议学习收藏）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/419424.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Java命名规范和代码风格

Java命名规范和代码风格

Java命名规范和代码风格 基本命名规范 包命名 包名按照域名的范围从大到小逐步列出&#xff0c;恰好和Internet上的域名命名规则相反。 由一组以“.”连接的标识符构成&#xff0c;通常第一个标识符为符合网络域名的两个或者三个英文小写字母。 例:cn.edu.xupt.JavaTest 类&…
阅读更多...
jqgrid多选和禁止某行记录选择

jqgrid多选和禁止某行记录选择

在对一些特殊数据&#xff0c;我们总是要做一些防范手段。 在jqgrid中添加了多选属性后&#xff0c;默认是每一行都能自由选择。有时候&#xff0c;一些数据不满足某些情况是不让选中处理的。 怎么实现&#xff1f; 直接上代码&#xff1a; onSelectAll:function(rowid, status…
阅读更多...
SYN 攻击原理以及防范技术

SYN 攻击原理以及防范技术

转载自&#xff1a;http://netsecurity.51cto.com/art/200608/30428.htm 据统计&#xff0c;在所有黑客攻击事件中&#xff0c;SYN攻击是最常见又最容易被利用的一种攻击手法。相信很多人还记得2000年YAHOO网站遭受的攻击事例&#xff0c;当时黑客利用的就是简单而有效的SYN攻击…
阅读更多...
使用adb调试android

使用adb调试android

原来以为真机调试android应用只能用数据线连接手机&#xff0c;后来在公司经前辈推荐&#xff0c;发现adb wireless这个工具不错&#xff0c;只需要将该apk安装到设备上&#xff0c;然后和电脑连同一无线网&#xff0c;打开该工具&#xff0c;看到为设备分配了Ip地址就代表可以…
阅读更多...
总结css中单位px和em,rem的区别

总结css中单位px和em,rem的区别

国内的设计师大都喜欢用px&#xff0c;而国外的网站大都喜欢用em和rem&#xff0c;那么三者有什么区别&#xff0c;又各自有什么优劣呢&#xff1f; PX特点 1. IE无法调整那些使用px作为单位的字体大小&#xff1b; 2. 国外的大部分网站能够调整的原因在于其使用了em或rem作为字…
阅读更多...
计算机网络协议包头赏析-TCP

计算机网络协议包头赏析-TCP

转载自博客地址为http://roclinux.cn。 仍然先把TCP报文段的格式放在这里&#xff0c;然后我们看图说话&#xff1a; TCP报文段也分为首部和数据两部分&#xff0c;首部默认情况下一般是20字节长度&#xff0c;但在一些需求情况下&#xff0c;会使用“可选字段”&#xff0c;这…
阅读更多...
前端学习（1637）：前端系列实战课程之调试问题和规范

前端学习（1637）：前端系列实战课程之调试问题和规范

阅读更多...
使用adb查看数据库的一些命令

使用adb查看数据库的一些命令

1.需要配置adb环境变量。 2.打开命令窗口&#xff0c;输入&#xff1a;adb shell 3.进入该数据库所在目录&#xff1a;cd data/,,,, 4.然后打开该数据库&#xff1a;sqlite3 数据库名称.db 5.现在可以操作该数据库中的表。 a.使用.tables命令可以查看该数据库下的所有表。…
阅读更多...
String 类的重要方法与字段

String 类的重要方法与字段

Length():获取字串长度 《空格也算他的长度》得到一个字串的长度的实现&#xff1a;zichuan.length() charAt():获取指定位置的字符实现方法&#xff1a;zichuan.charAt() getChars():获取从指定位置起的子串复制到字符数组中&#xff08;它有四个参数&#xff0c;在示例中有介…
阅读更多...
Android使用webview控件加载本地html，通过Js与后台Java实现数据的传递

Android使用webview控件加载本地html，通过Js与后台Java实现数据的传递

1.在布局文件中加WebView控件&#xff0c;在java中获取WebView对象。 2.加载本地html文件。 webView.loadUrl("file:///android_asset/android.html"); 3.开启js功能。 webView.getSettings().setJavaScriptEnabled(true); 4.添加一个js交互接口&#xff…
阅读更多...
TreeMap的讲解

TreeMap的讲解

本文转载自&#xff1a;http://blog.csdn.net/chenssy/article/details/26668941点击打开链接 原文出自&#xff1a;http://cmsblogs.com/?p1013。尊重作者的成果&#xff0c;转载请注明出处&#xff01; 个人站点&#xff1a;http://cmsblogs.com ----------------------…
阅读更多...
[国嵌笔记][036][关闭MMU和CACHE]

[国嵌笔记][036][关闭MMU和CACHE]

关闭MMU和CACHE 1.Cache是一种容量小&#xff0c;但存取速度非常快的存储器&#xff0c;它保存最近用到的存储器中数据的拷贝。按功能分为ICache&#xff08;指令Cache&#xff09;和DCache&#xff08;数据Cache&#xff09; 2.虚拟地址就是程序中使用的地址&#xff1b;物理地…
阅读更多...
android蓝牙4.0使用方法

android蓝牙4.0使用方法

蓝牙介绍 Android 4.3(API Level 18)介绍了内置平台支持蓝牙低能量的核心作用,并提供了API,应用程序可以用它来发现设备,查询服务&#xff0c;和读写字符。与传统的蓝牙相比&#xff0c;Bluetooth Low Energy (BLE) 旨在提供显著降低功耗。这使得Android应用能够与具有BLE的低耗…
阅读更多...
java基础面试题整理（BAT）

java基础面试题整理（BAT）

转载自&#xff1a;http://www.nowcoder.com/discuss/5949?type2&order0&pos23&page5点击打开链接 在阿里面试之前总结了一下内推同学的面经&#xff0c;把面试题总结到一块&#xff0c;并进行了分类。有些题目我也总结了一下答案&#xff0c;大家可以参考一下&am…
阅读更多...
Android中设置输入法为数字输入

Android中设置输入法为数字输入

1.对于用XML布局的EditText 使用setInputType(EditorInfo.TYPE_CLASS_NUMBER); 2.对于用Java代码生成EditText 使用setInputType(EditorInfo.TYPE_CLASS_NUMBER); setKeyListener(new DigitsKeyListener(false,true));
阅读更多...
前端学习（1641）：前端系列实战课程之js的组成部分

前端学习（1641）：前端系列实战课程之js的组成部分

阅读更多...
n个数里找出前m个数（或者 从10亿个浮点数中找出最大的1万个）

n个数里找出前m个数（或者 从10亿个浮点数中找出最大的1万个）

转载自&#xff1a;http://blog.csdn.net/winsunxu/article/details/6219376点击打开链接 引子 每年十一月各大IT公司都不约而同、争后恐后地到各大高校进行全国巡回招聘。与此同时&#xff0c;网上也开始出现大量笔试面试题&#xff1b;网上流传的题目往往都很精巧&#xff0c…
阅读更多...
poj_3977 折半枚举

poj_3977 折半枚举

题目大意 给定N&#xff08;N<35)个数字&#xff0c;每个数字都< 2^15. 其中一个或多个数字加和可以得到s&#xff0c;求出s的绝对值的最小值&#xff0c;并给出当s取绝对值最小值时&#xff0c;需要加和的数字的个数。 题目分析 需要枚举集合的所有情况&#xff0c;2^35…
阅读更多...
Android 应用更新和在服务器下载android应用

Android 应用更新和在服务器下载android应用

下载android应用有两种表现形式&#xff1a;一种是交给Android系统的下载管理器;另一种是自己去监控下载。 1.使用Android下载管理器下载应用并安装 public class UpdateService extends Service {// 安卓系统下载管理类DownloadManager manager;// 接收下载完的广播DownloadCo…
阅读更多...
Linux如何查看进程、杀死进程、启动进程等常用命令

Linux如何查看进程、杀死进程、启动进程等常用命令

转载自&#xff1a;http://blog.csdn.net/wojiaopanpan/article/details/7286430/ 关键字: linux 查进程、杀进程、起进程 1.查进程 ps命令查找与进程相关的PID号&#xff1a; ps a 显示现行终端机下的所有程序&#xff0c;包括其他用户的程序。 ps -A 显示所有程…
阅读更多...
最新文章

Copyright @ 2022~2023