2-3-6 symbol 类型
ES5中包含5种原始类型：字符串、数字、布尔值、null和undefined。ES6引入了第6种原始类 型:symbol
ES5的对象属性名都是字符串，很容易造成属性名冲突。比如，使用了一个他人提供的对象，想 为这个对象添加新的方法，新方法的名字就有可能与现有方法产生冲突。如果有一种机制，保证 每个属性的名字都是独一无二的，这样就从根本上防止了属性名冲突。这就是ES6引入symb。l的 原因。
我们在讲解面向对象的时候再具体来讲解symbol类型。
2-3-7简单值和复杂值的区别（扩展）
至此，在JavaScript中除了 symbol以外的简单数据类型，就给大家介绍完了。还剩下一种复杂数 据类型，那就是对象，我们会在第6章进行详细的介绍。
这里要给大家扩展的一个知识点，那就是简单数据类型所创建的值被称之为简单值，而复杂数据 类型所创建的值被称之为复杂值。
那么简单值和复杂值具体有什么区别呢？下面我们一个一个来看：
1.简单值（或原始值）
简单值是表示JS中可用的数据或信息的最底层形式或最简单形式。简单类型的值被称为简单值， 是因为它们是不可细化的。
也就是说，数字是数字，字符是字符，布尔值是true或false, null和undefined就是null和 undefined。这些值本身很简单，不能够再进行拆分。由于简单值的数据大小是固定的，所以简 单值的数据是存储于内存中的栈区里面的。
let str = "Hello World";
let num = 10;
let bol = true;
let myNull = null;
let undef = undefined;
这里面就null和undefined比较特殊，打印出来的数据类型分别是object和undefined。因为 这两个数据类型没有对应的构造函数，当然什么是构造函数我们后面再说，现在我们只需要将 null和undefined看作是特殊的操作符来使用即可。
2.复杂值
在JavaScript中，对象就是一个复杂值。因为对象可以向下拆分，拆分成多个简单值或者复杂 值。复杂值在内存中的大小是未知的，因为复杂值可以包含任何值，而不是一个特定的已知值。 所以复杂值的数据都是存储于堆区里面。
//简单值
let str = "Hello World";
let num = 10;
let bol = true;
let myNull = null;
let undef = undefined;
//复杂值
let obj = {
name : 'xiejie', age : 18, isPassed : true
};
let arr = [1,2,3,"Hello",true];
- 1. 访问方式
按值访问
简单值是作为不可细化的值进行存储和使用的，引用它们会转移其值
let str = "Hello";
let str2 = str;
str = null;
console.log(str,str2);//null "Hello"
引用访问
复杂值是通过引用进行存储和操作的，而不是实际的值。创建一个包含复杂对象的变量时，其值 是内存中的一个引用地址。引用一个复杂对象时，使用它的名称(即变量或对象属性)通过内存中 的引用地址获取该对象值
let obj = {};
let obj2 = obj;
obj.name = "xiejie";
console.log(obj.name);//xiejie console.log(obj2.name);//xiejie
- 2. 比较方式
简单值采用值比较，而复杂值采用引用比较。复杂值只有在引用相同的对象(即有相同的地址)时 才相等。即使是包含相同对象的两个变量也彼此不相等，因为它们并不指向同一个对象
示例1:
let a = 10;
let b = 10;
let c = new Number(10);
let d = c;
console.log(a === b);//true
console.log(a === c);//false
console.log(a == c);//true
d = 10;
console.log(d == c);//true
console.log(d === c);//false
示例2:
let obj = {name : 'xiejie'};
let obj2 = {name : 'xiejie'};
console.log(obj == obj2);//false
console.log(obj === obj2);//false
let obj3 = {name : 'xiejie'};
let obj4 = obj3;
console.log(obj3 == obj4);//true
console.log(obj3 === obj4);//ture
5.动态属性
对于复杂值，可以为其添加属性和方法，也可以改变和删除其属性和方法；但简单值不可以添加 属性和方法
let str = 'test';
str.abc = true;
console.log(str.abc);//undefined
let obj = {};
obj.abc = true;
console.log(obj.abc);//true
复杂值支持动态对象属性，因为我们可以定义对象，然后创建引用，再更新对象，并且所有指向 该对象的变量都会获得更新。
—个新变量指向现有的复杂对象，并没有复制该对象。这就是复杂值有时被称为引用值的原因。 复杂值可以根据需求有任意多个引用，即使对象改变，它们也总是指向同一个对象
let obj = {name : 'xiejie'};
let obj2 = obj;
let obj3 = obj2;
obj.name = 'abc';
console.log(obj.name,obj2.name,obj3.name);
//abc abc abc
6.变量赋值
最后说一下关于变量的赋值，其实是可以分为直接赋值和引用赋值的。直接赋值，就是指将简单 值赋值给变量，而引用赋值是指将一个复杂值的引用赋值给变量，这个引用指向堆区实际存在的 数据。
直接赋值
let a = 3;
let b = a;
b = 5;
console.log(a);//3
引用赋值
let a = {value : 1};
let b = a;
b.value = 10;
console.log(a.value);//10
2-3-8类型转换
通过前面的介绍，我们已经知道了在JavaScript中有好几种不同的数据类型。然而这些数据类型 都是可以相互转换的。类型转换可以分为两种，隐性转换和强制转换。
1.隐性转换
当不同数据类型进行相互运算的时候，
当对非布尔类型的数据求布尔值的时候
预期为数字的时候：
算术运算的时候，我们的结果和运算的数都是数字，数据会转换为数字进行计算(-* / %)
| 类型 |
转换前 |
转换后 |
| number |
4 |
4 |
| string |
T |
1 |
| string |
'abc' |
NaN |
| string |
0 |
|
| boolean |
true |
1 |
| boolean |
false |
0 |
| undefined |
undefined |
NaN |
| null |
null |
0 |
预期为字符串的时候：
转为字符串使用+号时候，会自动转换为字符串 预期为布尔的时候：
转换为布尔值，undefined, null, 0, NaN转为false，其余转为true
2.强制转换
转换为数值 number() , parseInt() , parseFloat()转换函数
小技巧：
・转换字符串：a=""+数据
-转换布尔：！数据类型
-转换数值:数据类型*或/I
2-4运算符
任何编程语言基本上都离不开运算符。在JavaScript中也是支持众多运算符的。例如最常见的算 数运算符，比较运算符，逻辑运算符等。接下来，就让我们一起来看一下JavaScript中这几种常 见的运算符。
2-4-1算数运算符
常见的算数运算符有加减乘除和取模运算。主要需要注意的就是，在动态语言中做除法运算时， 能够得到小数。下面是关于算数运算符的示例：
console.log(5 + 3.14);//8.14
console.log(6 - 11);//-5
console.log(7 * 3);//21
console.log(5 / 2);//2.5
console.log(10 % 3);//1
从ES6开始新增加了求富运算，使用两个*号代表求富。以此可以代替以前的Math.pow()方法
console.log(2 ** 3);//8
2-4-2 一元运算符
所谓一元运算符，就是指只作用于一个操作数的运算符。常见的一元运算符有两种，赋值运算符 和递增递减运算符。
- 1. 赋值运算符
关于赋值运算符，前面我们已经见到过了。最常见的就是=，代表将右边的内容赋值给左边。除 此之外，还有+=、-=、*=等一系列赋值运算符，具体的示例如下：
let a = 5;
a += 5;
console.log(a); // 10
a -= 3;
console.log(a); // 7
a *= 5;
console.log(a); // 35
a /= 5;
console.log(a); // 7
a %= 2;
console.log(a); // 1
2.递增和递减
除了上面所介绍的赋值运算符以外，常见的一元运算符还有递增和递减。在递增递减中，主要需 要注意前置和后置的区别。如果是前置，那么是先自增或自减，然后参与运算。如果是后置，则 是先参与运算，然后再自增或者自减，示例如下：
前置示例：
let a = 2;
let b = 10;
let c = 一a + b;
let d = a + b;
console.log(a,b,c,d);//1 10 11 11
后置示例：
let a = 2;
let b = 10;
let c = a一 + b;
let d = a + b;
console.log(a,b,c,d);//1 10 12 11
需要注意的是，我们的自增自减操作符不仅仅局限于数值，其他类型也可以，遵循下面的规则：
・在应用于一个包含有效数字字符的字符串时，现将其转换为数字值，再执行加减1操作。字 符串变量变为了数值变量。
-在应用于一个不包含有效数字字符的字符串时，将变量的值设置为NaN,字符串变量变成数 值变量。
-遇布尔值false时，先将其转换为0再执行加减1操作，布尔值变量变成数值变量。
-遇布尔值true时，先将其转换为1再执行加减1操作，布尔值变量变成数值变量。
・在应用浮点数数值时，执行加减1操作。
示例：
let si = "123";
let s2 = "123Hello";
let s3 = "Hello";
let s4 = true;
let s5 = 3.14;
console.log(一s1);//122 console.log(一s2);//NaN console.log(一s3);//NaN console.log(一s4);//0 console.log(一s5);//2.14
2-4-3比较运算符
1.关系运算符
小于，大于，小于等于，大于等于 数的比较就不用说了，如下：
console.log(5 > 3);//true console.log(3 > 5);//false
主要说一下字符串的比较，如下:
console.log("c" > "b");//true console.log("c" > "box");//true
这里的比较主要是按照ASCII码来进行比较的。
如果是一个字符串和一个数字进行比较，那么会将字符串先转换为数字，如果不能转换为数字, 则转换为NaN
console.log("5" > 3);//true,因为''5"转为了5
//任何一个数与NaN进行关系比较,返回的都是false
console.log("Hello" > 3);//false,因为"Hello"转为了NaN
完整的特殊规则如下:
则比较两个字符串对应的字符编码
则将另一个操作数转换为一个数值，然后执行数值的比较 则调用这个对象的valueOf()方法，用得到的结果按照前面的规
贝U执行比较。如果对象没有valueOf()方法，则调用toString()方法，并用得到的结果 根据前面的规则执行比较。
•如果一个数是布尔值，则先将其转换为数值，然后再进行比较
还需要注意，任何数和NaN进行比较返回的都是false
console.log(10 > NaN);//false console.log(10 < NaN);//false
- 2. 相等和不相等
==表示相等，!=表示不相等，数据类型不同的数据进行相等比较的话会自动转换数据类型, 还有一些其他的转换规则如下：
• null和undefined是相等的
•如果有一^操作数是NaN,则返回false, NaN和NaN比较也是false
-如果是数字的字符串和数字进行比较，会先将字符串转换为数字
•布尔值里面true转换为1, false转换为0
下表列出了一些特殊的情况
表达式 值
null == undefined true
"NaN" == NaN false
5 == NaN false
NaN == NaN false
NaN != NaN true
false == 0 true
true == 1 true
true == 2 false
undefined == 0 false
null == 0 false
"5" == 5 true
- 3. 全等和不全等
全等是===,不全等是!==这个就是必须数据类型和数值都相等，如下：
2-4-4逻辑运算符
- 1. 非
所谓非，就是取反，非真即假，非假即真
let i = true;
console.log(!i);//false
非运算符不仅仅只能用于布尔值，其他数据类型也是可以的，如下:
•如果操作数是一个对象，返回false
•如果操作数是一个空字符串，返回true
•如果操作数是一个非空字符串，返回false
•如果操作数是数值0,返回true
•如果操作数是任意非0数值(包括Infinity)，返回false
•如果操作数是null，返回true
•如果操作数是NaN,返回true
•如果操作数是undefined,返回true
console.log(!false);//true console.log(!"blue");//false console.log(!0);//true console.log(!NaN);//true console.log(!"");//true console.log(!12);//false
可使用双否定!!来判定一个值是真值还是假值，如下：
console.log(!!'');//false console.log(!!NaN);//false console.log(!!'Hello');//true
- 2. 与
作用于两到多个值，并且只有所有的操作数都是真值时，才为true
JavaScript里面的与存在短路现象，具体说明如下：
・第一个操作数为真：会进入第二个操作数的判断，且无论第二个操作数真假，都会返回第二 个操作数。
•第一个操作数为假：不会进入第二个操作数的判断，直接返回第一个操作数。
来看下面的例子：
console.log(3 && 5);//5 console.log("Hello" && 20);//20 console.log("Hello" && false);//false console.log("" && "shoe");//"" console.log("Hello" && '');//''
下面是关于与运算符的一道经典练习题：
let a = true;
let b = a && c;//因为a是true,所以会判断第2个数
console.log(b);
//ReferenceError: c is not defined
let a = false;
let b = a && c;//因为a是false,所以不会判断第2个数
console.log(b);//false
如果你看《JavaScript高级程序设计》这本书，里面还讲了诸如下面这些杂七杂八的规则：
-如果第一个操作数是对象，则返回第二个操作数
•如果第二个操作数是对象，则只有在第一个操作数的求值结果为true的情况下才会返回该对 象
-如果两个操作数都是对象，则返回第二个操作数
•如果有一个操作数是null,则返回null
•如果有一个操作数是NaN,则返回NaN
•如果有一^操作数是undefined,则返回undefined
console.log(3 && 5);//5
console.log(NaN && NaN);//NaN
console.log(null && null);//null console.log(undefined && undefined);//undefined
但是这些规则大多都是可以使用短路现象来解释的，所以不需要你去记，大致了解即可。
3.或
同样是作用于两到多个值，但是只要有一个操作数为真，就返回真
console.log(false || true);//true console.log(true || false);//true
JavaScript里面的或同样存在短路现象，具体说明如下:
・如果第一个操作数为真，则不会进入第二个数的判断。所以无论第二个操作数真假，都直接 返回第一个操作数
•如果第一个操作数为假，则会进入第二个数的判断。但是无论第二个操作数真假，都直接返 回第二个操作数
来看下面的例子:
console.log(false || true);//true console.log("Hello" || "");//Hello console.log("Hello" || "str");//Hello console.log(NaN || "");//"" console.log(0 || "Hello World");//Hello World console.log(11 || 'str');//str console.log(11 || false);//false
下面是关于或运算符的一道经典练习题:
let a = false;
let b = a || c;//因为a是false,所以会判断第2个数console.log(b);
//ReferenceError: c is not defined
let a = true;
let b = a || c;//因为a是false,所以会判断第2个数console.log(b);//true
如果你看《JavaScript高级程序设计》这本书，里面也讲了诸如下面这些杂七杂八的规则:
-如果第一个操作数是对象，则返回第一个操作数
•如果第一个操作数的求值结果为false，则返回第二个操作数
-如果两个操作数都是对象，则返回第一个操作数
•如果两个数都是null,则返回null
•如果两个数都是NaN,则返回NaN
•如果两个数都是undefined,则返回undefined
console.log(3 || 5);//3 console.log(NaN || NaN);//NaN
console.log(null || null);//null console.log(undefined || undefined);//undefined
不过这些规则大多也都是可以使用短路现象来解释的，所以根本不需要你去记，大致了解即可。
2-4-5位运算符（扩展）
按位运算符是将操作数换算成32位的二进制整数，然后按每一位来进行运输。例如：
・5 的 32 位为 00000000000000000000000000000101
・100 的 32 位为 00000000000000000000000001100100
・15 的 32 位为 00000000000000000000000000001111
- 1. 按位非
按位非运算符~会把数字转为32位二进制整数，然后反转每一位
所有的1变为0,所有的0变为1
5 的 32 位为 00000000000000000000000000000101
〜5： 11111111111111111111111111111010 转换出来就为-6
按位非，实质上是对操作数求负，然后减去1
- 2. 按位与
按位或运算符&会把两个数字转为32位二进制整数，并对两个数的每一位执行按位与运算
第一个数字第二个数字结果
1 1 1
0 0 0
具体示例：
console.log(12 & 10);//8
12的32位二进制表示为：1100
10的32位二进制表示为：1010
结果为：1000
3.按位或
按位或运算符|会把两个数字转为32位二进制整数，并对两个数的每一位执行按位或运算
| 第一个数字 |
第二个数字 |
结果 |
| 1 |
1 |
1 |
| 1 |
0 |
1 |
| 0 |
1 |
1 |
| 0 |
0 |
0 |
具体示例：
console.log(12 | 10);//14
12的32位二进制表示为：1100
10的32位二进制表示为：1010
结果为：1110
- 4. 按位异或
按位或运算符人会把两个数字转为32位二进制整数，并对两个数的每一位执行按位异或运算, 两位不同返回1,两位相同返回0
第一个数字第二个数字结果
1 0 1
0 1 1
0 0 0
具体示例：
console.log(12 人 10);//6
12的32位二进制表示为：1100
10的32位二进制表示为：1010
结果为：0110
按位异或如果是非整数值，如果两个操作数中只有一个为真，就返回1,如果两个操作数都是 真，或者都是假，就返回0
console.log(true 人"Hello");//1
console.log(false 人"Hello");//。
console.log(true 人 true);//0
console.log("Hello"人"Hello");//0
console.log(false 人 false);//0
console.log(true 人 false);//1
注意这里的Hello被转换为了 NaN
- 5. 按位移位
按位移位运算符VV和 >> 会将所有位向左或者向右移动指定的数量，实际上就是高效率地将数 字乘以或者除以2的指定数的次方
<< :乘以2的指定数次方
console.log(2«2);//8
2乘以2的2次方
00000010转换为 00001000
>> :除以2的指定数次方
16除以2的1次方
00010000转换为 00001000