【JS红宝书学习笔记】第3章 语言基础var/let/const/array

第3章 语言基础

1. 语法

• 标识符（变量、函数、属性或函数参数的名称）：一般使用驼峰法命名，关键字、保留字、true、false 和 null 不能作为标识符。
  标识符的第一个字符必须是一个字母、下划线（_）或美元符号（$）； 剩下的其他字符可以是字母、下划线、美元符号或数字。
• 严格模式：一种不同的 JavaScript 解析和执行模型，ECMAScript 3 的一些不规范写法在这种模式下会被处理，对于不安全的活动将抛出错误。要对整个脚本启用严格模式，在脚本开头加上这一行："use strict";
  也可以单独指定一个函数在严格模式下执行，只要把这个预处理指令放到函数体开头即可：

function doSomething() {
        "use strict";
        // 函数体
}

语句以分号结尾。省略分号意味着由解析器确定语句在哪里结尾。

2. 变量（面试重点！）

有 3 个关键字可以声明变量：var、const 和 let。其中，var 在ECMAScript 的所有版本中都可以使用，而 const 和 let 只能在 ECMAScript 6 及更晚的版本中使用。

(1) var

var定义的变量后面可以更改，不仅可以更改值，还可以更改类型。
JS作用域可以分为两大类：全局作用域 、局部作用域（函数作用域）

• var声明范围：函数作用域

使用 var 操作符定义的变量会成为包含它的函数的局部变量。比如，使用 var在一个函数内部定义一个变量，就意味着该变量将在函数退出时被销毁：

<script>
        function test() {
            var message = "hi"; // 局部变量
        }
        test();
        console.log(message); // 出错！
</script>

不过，在函数内定义变量时省略 var 操作符，可以创建一个全局变量：

<script>
        function test() {
            message = "hi"; // 全局变量
        }
        test();
        console.log(message); 
</script>

定义多个变量，可以 var message = "hi", found = false, age = 29;

• var声明提升
  “提升”（hoist），就是把所有变量声明都拉到函数作用域的顶部。此外，反复多次使用 var 声明同一个变量也没有问题（会输出最新的声明）

<script>
        function foo() {
            console.log(age);
            var age = 26;
        }
        foo(); // undefined
</script>

输出：（不报错，因为var声明的变量会自动提升到函数作用域顶部）

相当于：

<script>
        function foo() {
            var age;
            console.log(age);
            age = 26;
        }
        foo(); // undefined
</script>

(2) let

• let声明范围：块作用域

let 声明的范围是块作用域，而 var 声明的范围是函数作用域。
块作用域是编程中的一个概念，它指的是在代码中由一对大括号（{}）包围的一段代码，这段代码内部定义的变量在代码块外部是访问不到的，并且在代码块执行完成后，该代码块中定义的变量会被销毁。


let也不允许同一个块作用域中出现冗余声明。这样会导致报错。但var可以重复声明：

不是同一个块作用域可以用同一个变量名，因为同一个块中无重复声明（注释为输出结果）

<script>
        var name = 'Nicholas';
        console.log(name); // 'Nicholas'
        if (true) {
            var name = 'Matt';
            console.log(name); // 'Matt'
        }
        let age = 30;
        console.log(age); // 30
        if (true) {
            let age = 26;
            console.log(age); // 26
        }
</script>

由于var和let都是声明变量，故不能用于声明同一个变量：

• let 声明的变量不会在作用域中被提升（与var的重要区别）

<script>
        console.log(age); // ReferenceError：age 没有定义
        let age = 26;
</script>

但是这里把 let 改成 var 就不会报错（输出 undefined ），因为 var 声明变量可以被提升。
在 let 声明之前的执行瞬间被称为“暂时性死区”（temporal dead zone），在此阶段引用任何后面才声明的变量都会抛出ReferenceError。

• 关于全局变量

与 var 关键字不同，使用 let 在全局作用域中声明的变量不会成为 window 对象的属性（var 声明的变量则会）

在使用 var 声明变量时，由于声明会被提升，JavaScript 引擎会自动将多余的声明在作用域顶部合并为一个声明。因为 let 的作用域是块，所以不可能检查前面是否已经使用 let 声明过同名变量，同时也就不可能在没有声明的情况下声明它。

<script>
        var name = 'Nicholas';
        let age = 26;
</script>
<script>
        // 假设脚本不确定页面中是否已经声明了同名变量
        // 那它可以假设还没有声明过
        var name = 'Matt';
        // 这里没问题，因为可以被作为一个提升声明来处理
        // 不需要检查之前是否声明过同名变量
        let age = 36;
        // 如果 age 之前声明过，这里会报错
</script>

多个script按script标签一块一块进行编译的。虽然编译不是同时进行的，但作用域始终还是一个，只是编译器编译的时候是一个块一个块从上向下进行编译的。

<script>
        alert(a);
</script>
<script>
        var a = 123;
</script>

这里会报错：

因为在第一个块中，并没有声明a变量，（这也证明了a变量并没有被声明提前，直到第二个script内部才被提前的。）所以才会弹出这个错误，而不是undefined。

<script>
        var b = 111;
</script>
<script>
        alert(b);
</script>

运行结果：（说明作用域只有一个，按script标签块往下编译）

• for循环中的 let 声明
  var 定义的变量会渗透到循环体外部：

for (var i = 0; i < 5; ++i) {
// 循环逻辑
}
console.log(i); // 5

let 定义的变量作用域仅限于循环体内部（类似C++用法）

for (let i = 0; i < 5; ++i) {
// 循环逻辑
}
console.log(i); // ReferenceError: i 没有定义

对迭代变量的奇特声明和修改：

for (var i = 0; i < 5; ++i) {
    setTimeout(() => console.log(i), 0)
}
// 你可能以为会输出 0、1、2、3、4
// 实际上会输出 5、5、5、5、5

在退出循环时，迭代变量保存的是导致循环退出的值：5。在之后执行超时逻辑时，所有的 i 都是同一个变量，因而输出的都是同一个最终值。

for (let i = 0; i < 5; ++i) {
    setTimeout(() => console.log(i), 0)
}
// 会输出 0、1、2、3、4

在使用 let 声明迭代变量时，JavaScript 引擎在后台会为每个迭代循环声明一个新的迭代变量。每个 setTimeout 引用的都是不同的变量实例，所以 console.log 输出的是我们期望的值，也就是循环执行过程中每个迭代变量的值。

(3) const

const （常量）与 let 用法基本相同，包括：作用域是块，不允许重复声明。

<script>
        const name = 'Matt';
        if (true) {
            const name = 'Nicholas';
        }
        console.log(name); // Matt
</script>

区别在于声明变量时一定要初始化，且之后不能修改（所以const不能用于声明for循环中的迭代变量，因为迭代变量会自增）。
若想用const声明一个不会被修改的for变量也是可以的：

<script>
        let i = 0;
        for (const j = 7; i < 5; ++i) {
            console.log(j);
        }
        // 7, 7, 7, 7, 7
        //for-in循环
        for (const key in { a: 1, b: 2 }) {
            console.log(key);
        }
        // a, b
        //for-of循环
        for (const value of [1, 2, 3, 4, 5]) {
            console.log(value);
        }
        // 1, 2, 3, 4, 5
</script>

const 声明的限制只适用于它指向的变量的引用。换句话说，如果 const 变量引用的是一个对象，那么修改这个对象内部的属性并不违反 const 的限制。

<script>
        const person = {};
        person.name = 'Tom'; // ok
        console.log(person.name); // Tom
</script>

(4) 声明风格建议

3. 数据类型（重点！）

JS数据类型有Undefined、Null、Boolean、Number、String、Symbol、Object（7种）。其中Symbol表示符号是ES6新增的。

(1) 判断数据类型 typeof

typeof的使用：

<script>
        let message = "some string";
        console.log(typeof message); // "string"
        console.log(typeof (message)); // "string"
        console.log(typeof 95); // "number"
</script>

因为 typeof 是一个操作符而不是函数，所以不需要参数（但可以使用参数）。typeof 会返回这些字符串："undefined"、"boolean"、"number"、"string"、"symbol"、"object"（表示值为对象或null）、"function"。

(2) Undefined 类型

Undefined 类型只有一个值 undefined。当使用 var 或 let 声明了变量但没有初始化时，就相当于给变量赋予了 undefined 值.
注意未初始化的变量与未定义的变量是有区别的。

    <script>
        let message; // 这个变量被声明了，只是值为 undefined
        // 确保没有声明过这个变量
        // let age
        console.log(message); // "undefined"
        console.log(age); // 报错
    </script>

但是未初始化的变量与未定义的变量在 typeof 下都是undefined。

    <script>
        let message; // 这个变量被声明了，只是值为 undefined
        // 确保没有声明过这个变量
        // let age
        console.log(typeof message); // "undefined"
        console.log(typeof age); // "undefined"
    </script>

实际应用 undefined（一个假值）：

    <script>
        let message; // 这个变量被声明了，只是值为 undefined
        // age 没有声明
        if (message) {
            // 这个块不会执行
        }
        if (!message) {
            // 这个块会执行
        }
        if (age) {
            // 这里会报错
        }
    </script>

(3) Null 类型

Null 类型同样只有一个值 null。逻辑上讲，null 值表示一个空对象指针，这也是给 typeof 传一个 null 会返回"object"的原因：

    <script>
        let car = null;
        console.log(typeof car); // "object"
    </script>

在定义将来要保存对象值的变量时，建议使用 null 来初始化，不要使用其他值。这样，只要检查这个变量的值是不是 null 就可以知道这个变量是否在后来被重新赋予了一个对象的引用。
undefined 值是由 null 值派生而来的，因此 ECMA-262 将它们定义为表面上相等：

    <script>
        console.log(null == undefined); // true
    </script>

与undefined区别：永远不必显式地将变量值设置为 undefined。但 null 不是这样的。任何时候，只要变量要保存对象，而当时又没有那个对象可保存，就要用 null 来填充该变量。
null 应用：

    <script>
        let message = null;
        let age;
        if (message) {
            // 这个块不会执行
        }
        if (!message) {
            // 这个块会执行
        }
        if (age) {
            // 这个块不会执行
        }
        if (!age) {
            // 这个块会执行
        }
    </script>

(4) Boolean 类型

Boolean（布尔值）类型有两个字面值：true 和 false。这两个布尔值不同于数值，因此 true 不等于 1，false 不等于 0。布尔值字面量 true 和 false 是区分大小写的，因此 True 和 False（及其他大小混写形式）是有效的标识符，但不是布尔值。
不同类型与布尔值之间的转换规则 Boolean(data)。

    <script>
        let message = "Hello world!";
        //这里会判断message是true
        if (message) {
            console.log("Value is true");
        }
    </script>

(5) Number 类型

十进制（直接正常输入即可）
八进制（第一个数字必须是零（0），然后是相应的八进制数字（数值 0~7））
十六进制（数值前缀 0x（区分大小写），然后是十六进制数字（0~9 以
及 A~F）。十六进制数字中的字母大小写均可）

    <script>
        let intNum = 55; // 整数
        let octalNum1 = 070; // 八进制的 56
        let octalNum2 = 079; // 无效的八进制值，当成 79 处理
        let octalNum3 = 08; // 无效的八进制值，当成 8 处理
        let hexNum1 = 0xA; // 十六进制 10
        let hexNum2 = 0x1f; // 十六进制 31
        console.log(octalNum1); // 56
        console.log(hexNum1);  // 10
    </script>

• 浮点数：

存储浮点数必须包含小数点，且小数点后要有有效数字（0不是有效数字），否则会被转换成整数；对于非常大或者非常小的数字，可采用科学计数法，如3.17e5 = 317000, 3e-3 = 0.003.
关于舍入误差

• 值的范围：

要确定一个值是不是有限大（即介于 JavaScript 能表示的最小值和最大值之间），可以使用 isFinite()函数。使用 Number.NEGATIVE_INFINITY 和Number.POSITIVE_INFINITY 也可以获取正、负 Infinity。这两个属性包含的值分别就是-Infinity 和 Infinity。

• NaN（Not a Number）：
  用于表示本来要返回数值的操作失败了（而不是抛出错误）。比如，用 0 除任意数值在其他语言中通常都会导致错误，从而中止代码执行。但在 ECMAScript 中，0、+0 或-0 相除会返回 NaN：

    <script>
        console.log(0 / 0); // NaN
        console.log(-0 / +0); // NaN
    </script>

如果分子是非 0 值，分母是有符号 0 或无符号 0，则会返回 Infinity 或-Infinity：

    <script>
        console.log(5 / 0); // Infinity
        console.log(5 / -0); // -Infinity
    </script>

NaN的属性：任何涉及 NaN 的操作始终返回 NaN（如 NaN/10），在连续多步计算时这可能是个问题；NaN 不等于包括 NaN 在内的任何值。
isNaN()函数：该函数接收一个参数，可以是任意数据类型，然后判断这个参数是否“不是数值”。该函数会先尝试将参数转化为数值，某些非数值的值可以直接转换成数值，如字符串"10"或布尔值。任何不能转换为数值的值都会导致这个函数返回true。

    <script>
        console.log(isNaN(NaN)); // true
        console.log(isNaN(10)); // false，10 是数值
        console.log(isNaN("10")); // false，可以转换为数值 10
        console.log(isNaN("blue")); // true，不可以转换为数值
        console.log(isNaN(true)); // false，可以转换为数值 1
    </script>

• 数值转换：
  有 3 个函数可以将非数值转换为数值：Number()、parseInt()和 parseFloat()。
  Number()函数：
  

    <script>
        let num1 = Number("Hello world!"); // NaN
        let num2 = Number(""); // 0
        let num3 = Number("000011"); // 11
        let num4 = Number(true); // 1
    </script>

parseInt()函数：
parseInt()函数更专注于字符串是否包含数值模式。字符串最前面的空格会被忽略，从第一个非空格字符开始转换。如果第一个字符不是数值字符、加号或减号，parseInt()立即返回 NaN。这意味着空字符串也会返回 NaN（这一点跟 Number()不一样，它返回 0）。如果第一个字符是数值字符、加号或减号，则继续依次检测每个字符，直到字符串末尾，或碰到非数值字符。

    <script>
        let num1 = parseInt("1234blue"); // 1234
        let num2 = parseInt(""); // NaN
        let num3 = parseInt("0xA"); // 10，解释为十六进制整数
        let num4 = parseInt(22.5); // 22
        let num5 = parseInt("70"); // 70，解释为十进制值
        let num6 = parseInt("0xf"); // 15，解释为十六进制整数
    </script>

如果要指定转换的进制，可以输入第二个参数进制数：

let num = parseInt("0xAF", 16); // 175（可以省略0x）
let num1 = parseInt("10", 2); // 2，按二进制解析
let num2 = parseInt("10", 8); // 8，按八进制解析
let num3 = parseInt("10", 10); // 10，按十进制解析

parseFloat()函数：
parseFloat()函数的工作方式跟 parseInt()函数类似，都是从位置 0 开始检测每个字符。同样，
它也是解析到字符串末尾或者解析到一个无效的浮点数值字符为止。这意味着第一次出现的小数点是有效的，但第二次出现的小数点就无效了，此时字符串的剩余字符都会被忽略。因此，"22.34.5"将转换成 22.34。
但是parseFloat()函数只解析十进制值，它始终忽略字符串开头的零。

let num1 = parseFloat("1234blue"); // 1234，按整数解析
let num2 = parseFloat("0xA"); // 0
let num3 = parseFloat("22.5"); // 22.5
let num4 = parseFloat("22.34.5"); // 22.34
let num5 = parseFloat("0908.5"); // 908.5
let num6 = parseFloat("3.125e7"); // 31250000

(6) String 类型

字符串可以使用双引号（"）、单引号（'）或反引号（`）表示。在ECMAScript中，字符串的值不可变。要修改某个变量中的字符串值，必须先销毁原始的字符串，然后将包含新值的另一个字符串保存到该变量。
转换为字符串的方法：
toString()：可以接受一个参数转换为指定进制

let age = 11;
let ageAsString = age.toString(); // 字符串"11"
let found = true;
let foundAsString = found.toString(); // 字符串"true"

let num = 10;
console.log(num.toString()); // "10"
console.log(num.toString(2)); // "1010"
console.log(num.toString(8)); // "12"
console.log(num.toString(10)); // "10"
console.log(num.toString(16)); // "a"

(7) Symbol 类型

符号是原始值，且符号实例是唯一、不可变的。符号的用途是确保对象属性使用唯一标识符，不会发生属性冲突的危险。符号就是用来创建唯一记号，进而用作非字符串形式的对象属性。

• 基本使用

符号需要使用 Symbol()函数初始化。因为符号本身是原始类型，所以 typeof 操作符对符号返回symbol。

let sym = Symbol();
console.log(typeof sym); // symbol

使用Symbol()函数可以传入一个字符串参数，但是这个字符串参数与符号定义或标识完全无关

let genericSymbol = Symbol();
let otherGenericSymbol = Symbol();
let fooSymbol = Symbol('foo');
let otherFooSymbol = Symbol('foo');
console.log(genericSymbol == otherGenericSymbol); // false
console.log(fooSymbol == otherFooSymbol); // false

**Symbol()函数不能与 new 关键字一起作为构造函数使用。**这样做是为了避免创建符
号包装对象，像使用 Boolean、String 或 Number 那样，它们都支持构造函数且可用于初始化包含原始值的包装对象：

let myBoolean = new Boolean();
console.log(typeof myBoolean); // "object"
let myString = new String();
console.log(typeof myString); // "object"
let myNumber = new Number();
console.log(typeof myNumber); // "object"
let mySymbol = new Symbol(); // TypeError: Symbol is not a constructor

如果你确实想使用符号包装对象，可以借用 Object()函数：

let mySymbol = Symbol();
let myWrappedSymbol = Object(mySymbol);
console.log(typeof myWrappedSymbol); // "object"

• 使用全局符号注册表
  如果运行时的不同部分需要共享和重用符号实例，那么可以用一个字符串作为键，在全局符号注册表中创建并重用符号。
  为此，需要使用 Symbol.for()方法：

let fooGlobalSymbol = Symbol.for('foo');
console.log(typeof fooGlobalSymbol); // symbol

Symbol.for()对每个字符串键都执行幂等操作。第一次使用某个字符串调用时，它会检查全局运行时注册表，发现不存在对应的符号，于是就会生成一个新符号实例并添加到注册表中。后续使用相同字符串的调用同样会检查注册表，发现存在与该字符串对应的符号，然后就会返回该符号实例。

let fooGlobalSymbol = Symbol.for('foo'); // 创建新符号
let otherFooGlobalSymbol = Symbol.for('foo'); // 重用已有符号
console.log(fooGlobalSymbol === otherFooGlobalSymbol); // true
// 但是Symbol() 不会，即使是相同的符号也返回false

即使采用相同的符号描述，在全局注册表中定义的符号跟使用 Symbol()定义的符号也并不等同：

let localSymbol = Symbol('foo');
let globalSymbol = Symbol.for('foo');
console.log(localSymbol === globalSymbol); // false

全局注册表中的符号必须使用字符串键来创建，因此作为参数传给 Symbol.for()的任何值都会被转换为字符串。此外，注册表中使用的键同时也会被用作符号描述。

let emptyGlobalSymbol = Symbol.for();
console.log(emptyGlobalSymbol); // Symbol(undefined)

还可以使用 Symbol.keyFor()来查询全局注册表，这个方法接收符号，返回该全局符号对应的字符串键。如果查询的不是全局符号，则返回 undefined。

// 创建全局符号
let s = Symbol.for('foo');
console.log(Symbol.keyFor(s)); // foo
// 创建普通符号
let s2 = Symbol('bar');
console.log(Symbol.keyFor(s2)); // undefined

如果传给 Symbol.keyFor()的不是符号，则该方法抛出 TypeError：

Symbol.keyFor(123); // TypeError: 123 is not a symbol

• Symbol.asyncIterator（涉及异步处理，这里很难理解，后面再仔细看看）
  “一个方法，该方法返回对象默认的 AsyncIterator。由 for-await-of 语句使用”。换句话说，这个符号表示实现异步迭代器 API 的函数。
• Symbol.hasInstance
  一个方法，该方法决定一个构造器对象是否认可一个对象是它的实例。由 instanceof 操作符使用。

class Bar {}
let b = new Bar();
console.log(b instanceof Bar); // true
console.log(Bar[Symbol.hasInstance](b)); // true

• Symbol.isConcatSpreadable
  一个布尔值，如果是 true，则意味着对象应该用 Array.prototype.concat()打平其数组元素。
• Symbol.iterator（后面再深入了解）
  一个方法，该方法返回对象默认的迭代器。由 for-of 语句使用。这个符号表示实现迭代器 API 的函数。
• Symbol.match
  一个正则表达式方法，该方法用正则表达式去匹配字符串。由 String.prototype.match()方法使用。
• Symbol.replace
  一个正则表达式方法，该方法替换一个字符串中匹配的子串。由 String.prototype.replace()方法使用。
• Symbol.search
  一个正则表达式方法，该方法返回字符串中匹配正则表达式的索引。由String.prototype.search()方法使用。
• Symbol.species
  一个函数值，该函数作为创建派生对象的构造函数。
• Symbol.split
  一个正则表达式方法，该方法在匹配正则表达式的索引位置拆分字符串。由 String.prototype.split()方法使用。
• Symbol.toPrimitive
  一个方法，该方法将对象转换为相应的原始值。由 ToPrimitive 抽象操作使用。
• Symbol.toStringTag
  一个字符串，该字符串用于创建对象的默认字符串描述。由内置方法 Object.prototype.toString()使用。
• Symbol.unscopables
  一个对象，该对象所有的以及继承的属性，都会从关联对象的 with 环境绑定中排除。

(8) Object 类型

对象十一组数据和功能的集合。对象通过 new 操作符后跟对象类型的名称来创建。开发者可以通过创建 Object 类型的实例来创建自己的对象，然后再给对象添加属性和方法：

let o = new Object();

每个 Object 实例都有如下属性和方法。

• constructor：用于创建当前对象的函数。在前面的例子中，这个属性的值就是 Object() 函数。
• hasOwnProperty(propertyName)：用于判断当前对象实例（不是原型）上是否存在给定的属性。要检查的属性名必须是字符串（如 o.hasOwnProperty(“name”)）或符号。
• isPrototypeOf(object)：用于判断当前对象是否为另一个对象的原型。（第 8 章将详细介绍 原型。）
• propertyIsEnumerable(propertyName)：用于判断给定的属性是否可以使用for-in 语句枚举。与 hasOwnProperty()一样，属性名必须是字符串。
• toLocaleString()：返回对象的字符串表示，该字符串反映对象所在的本地化执行环境。
• toString()：返回对象的字符串表示。
• valueOf()：返回对象对应的字符串、数值或布尔值表示。通常与toString()的返回值相同。

4. 操作符

(1) 一元操作符

• 递增/递减操作符（与C语言用法完全相同，包括前缀版与后缀版）

//前缀版
let num1 = 2;
let num2 = 20;
let num3 = --num1 + num2;
let num4 = num1 + num2;
console.log(num3); // 21
console.log(num4); // 21

//后缀版
let num1 = 2;
let num2 = 20;
let num3 = num1-- + num2;
let num4 = num1 + num2;
console.log(num3); // 22
console.log(num4); // 21

+/-/++/–可以作用于任何值，意思是不限于整数——字符串、布尔值、浮点值，甚至对象都可
以。递增和递减操作符遵循如下规则。

• 对于字符串，如果是有效的数值形式，则转换为数值再应用改变。变量类型从字符串变成数值。
• 对于字符串，如果不是有效的数值形式，则将变量的值设置为 NaN 。变量类型从字符串变成数值。
• 对于布尔值，如果是 false，则转换为 0 再应用改变。变量类型从布尔值变成数值。
• 对于布尔值，如果是 true，则转换为 1 再应用改变。变量类型从布尔值变成数值。
• 对于浮点值，加 1 或减 1。
• 如果是对象，则调用其valueOf()方法取得可以操作的值。对得到的值应用上述规则。如果是 NaN，则调用 toString()并再次应用其他规则。变量类型从对象变成数值。

let s1 = "2";
let s2 = "z";
let b = false;
let f = 1.1;
let o = {
valueOf() {
return -1;
}
};
s1++; // s1值变成数值 3
s2++; // s2值变成 NaN
b++; // b值变成数值 1
f--; // f值变成 0.10000000000000009（因为浮点数不精确）
o--; // o值变成-2

• 一元加和减

相当于正负号，对数值取正负

let s1 = "01";
let s2 = "1.1";
let s3 = "z";
let b = false;
let f = 1.1;
let o = {
valueOf() {
return -1;
}
};
s1 = -s1; // 值变成数值-1
s2 = -s2; // 值变成数值-1.1
s3 = -s3; // 值变成 NaN
b = -b; // 值变成数值 0
f = -f; // 变成-1.1
o = -o; // 值变成数值 1

(2) 位操作符

• 按位非（~）
• 按位与（&）
• 按位或（|）
• 按位异或（^）：有一个 1 时返回 1，否则都返回0
• 左移（<<）：左移n位，*$2^n$。左移会保留它所操作数值的符号。
• 有符号右移（>>）：右移n位，*$2^{-n}$。右移会保留它所操作数值的符号。
• 无符号右移（>>>）：对于正数，无符号右移与有符号右移结果相同。无符号右移操作符将负数的二进制表示当成正数的二进制表示来处理。因为负数是其绝对值的二补数，所以右移之后结果变得非常之大

let oldValue = -64; // 等于二进制 11111111111111111111111111000000
let newValue = oldValue >>> 5; // 等于十进制 134217726

在对64 无符号右移 5 位后，结果是 134 217 726。这是因为64 的二进制表示是11111111111111111111111111000000，无符号右移却将它当成正值，也就是 4 294 967 232。把这个值右移 5 位后，结果是00000111111111111111111111111110，即 134 217 726。

(3) 布尔操作符

• 逻辑非（!）：遵循如下规则

逻辑非操作符也可以用于把任意值转换为布尔值。同时使用两个叹号（!!），相当于调用了转型函数 Boolean()。

• 逻辑与（&&）：针对true / false。逻辑与操作符是一种短路操作符，意思就是如果第一个操作数决定了结果，那么永远不会对第二个操作数求值。对逻辑与操作符来说，如果第一个操作数是 false，那么无论第二个操作数是什么值，结果也不可能等于 true。
  

let found = true;
let result = (found && someUndeclaredVariable); 
// 这里会出错，因为someUndeclaredVariable未声明
console.log(result); // 不会执行这一行

let found = false;
let result = (found && someUndeclaredVariable); // 不会出错
console.log(result); // 会执行，返回false

• 逻辑或（||）：与逻辑与类似，具有短路特征
  

let found = true;
let result = (found || someUndeclaredVariable); // 不会出错
console.log(result); // 会执行

let found = false;
let result = (found || someUndeclaredVariable); // 这里会出错
console.log(result); // 不会执行这一行

(4) 乘性操作符

• 乘法（*）
• 除法（/）
• 取模（%）

(5) 指数操作符

Math.pow()可以用 ** 表示，指数赋值操作符 **=，该操作符执行指数运算和结果的赋值操作

console.log(Math.pow(16, 0.5); // 4
console.log(16** 0.5); // 4
let squared = 3;
squared **= 2;
console.log(squared); // 9

(6) 加性操作符

• 加法（+）
• 减法（-）

(7) 关系操作符

关系操作符执行比较两个值的操作，包括小于（<）、大于（>）、小于等于（<=）和大于等于（>=），用法跟数学课上学的一样。这几个操作符都返回布尔值。
在比较 NaN 时，无论是小于还是大于等于，比较的结果都会返回 false。

(8) 相等操作符（面试重点）

• 等于（==）和不等于（!=）
  在比较之前执行类型转换（通常称为强制类型转换）再确定操作数是否相等。
  
  

• 全等（===）和不全等（!==）

• 在比较之前不执行类型转换。只有类型和数值完全相同时才全等

let result1 = ("55" == 55); // true，转换后相等
let result2 = ("55" === 55); // false，不相等，因为数据类型不同

不全等操作符用一个叹号和两个等于号（!==）表示，只有两个操作数在不转换的前提下不相等才返回 true。

let result1 = ("55" != 55); // false，转换后相等
let result2 = ("55" !== 55); // true，不相等，因为数据类型不同

虽然 null == undefined 是 true（因为这两个值类似），但 null === undefined 是
false，因为它们不是相同的数据类型。

(9) 条件操作符

类似C++三元运算符

variable = boolean_expression ? true_value : false_value;

(10) 赋值操作符

(11) 逗号操作符

逗号操作符可以用来在一条语句中执行多个操作

let num1 = 1, num2 = 2, num3 = 3;

在赋值时使用逗号操作符分隔值，最终会返回表达式中最后一个值：

let num = (5, 1, 4, 8, 0); // num 的值为 0

5. 语句

• if 语句
• do-while 语句
  do-while 语句是一种后测试循环语句，即循环体中的代码执行后才会对退出条件进行求值。换句话说，循环体内的代码至少执行一次

do {
	statement
} while (expression);

• while 语句
• for 语句
• for-in 语句
  for-in 语句是一种严格的迭代语句，用于枚举对象中的非符号键属性，语法如下：

 for (property in expression) statement

for (const propName in window) {
	document.write(propName);
}

这个例子使用 for-in 循环显示了 BOM 对象 window 的所有属性。每次执行循环，都会给变量
propName 赋予一个 window 对象的属性作为值，直到 window 的所有属性都被枚举一遍。与 for 循环一样，这里控制语句中的 const 也不是必需的。但为了确保这个局部变量不被修改，推荐使用 const。
如果 for-in 循环要迭代的变量是 null 或 undefined，则不执行循环体

• for-of 语句
  for-of 语句是一种严格的迭代语句，用于遍历可迭代对象的元素，语法如下：

for (property of expression) statement

for (const el of [2,4,6,8]) {
	document.write(el);
}

• 标签语句
  标签语句用于给语句加标签

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

在这个例子中，start 是一个标签，可以在后面通过 break 或 continue 语句引用。标签语句的
典型应用场景是嵌套循环

• break 和 continue 语句
  break 语句用于立即退出循环，强制执行循环后的下一条语句。而 continue 语句也用于立即退出循环，但会再次从循环顶部开始执行。

        let num = 0;
        outermost:
        for (let i = 0; i < 10; i++) {
            for (let j = 0; j < 10; j++) {
                if (i == 5 && j == 5) {
                    break outermost;
                }
                console.log(i, j);
                num++;
            }
        }
        console.log(num); // 55

        let num = 0;
        outermost:
        for (let i = 0; i < 10; i++) {
            for (let j = 0; j < 10; j++) {
                if (i == 5 && j == 5) {
                    continue outermost;
                }
                console.log(i, j);
                num++;
            }
        }
        console.log(num); // 95

• with 语句
  with 语句的用途是将代码作用域设置为特定的对象。
  使用 with 语句的主要场景是针对一个对象反复操作，这时候将代码作用域设置为该对象能提供便利

with(location) {
	let qs = search.substring(1);
	let hostName = hostname;
	let url = href;
}

// 等价于下面这种方式：
let qs = location.search.substring(1);
let hostName = location.hostname;
let url = location.href;

• switch 语句（与C语言类似）

        switch (i) {
            case 25:
                console.log("25");
                break;
            case 35:
                console.log("35");
                break;
            case 45:
                console.log("45");
                break;
            default:
                console.log("Other");
        }

与其他语言不同之处：switch 语句可以用于所有数据类型（在很多语言中，它只能用于数值），因此可以使用字符串甚至对象。其次，条件的值不需要是常量，也可以是变量或表达式。

        switch ("hello world") {
            case "hello" + " world":
                console.log("Greeting was found.");
                break;
            case "goodbye":
                console.log("Closing was found.");
                break;
            default:
                console.log("Unexpected message was found.");
        }

6. 函数

不需要指定函数的返回值，因为任何函数可以在任何时候返回任何值。
不指定返回值的函数实际上会返回特殊值 undefined。

        function sayHi(name, message) {
            console.log("Hello " + name + ", " + message);
        }
        sayHi("Nicholas", "how are you today?");