JavaScript 类型转换
一、typeof() 方法
typeof() 能区分数据是什么类型的，比如一个数字 123，一个字符串 "123"
var num = 123; console.log(typeof(num)); // number var num = "123"; console.log(typeof(num)); // string
true 返回 boolean 类型
var mode = true; console.log(typeof(mode)); // boolean
typeof 能返回六种数据类型，数字、字符串、布尔这是三种基本的值
1. number
2. string
3. boolean
4. object
5. undefined
6. function
什么样的值返回 object 呢？
对象是肯定返回的是 object，但这时候 object 指的不是单纯的对象，它是泛泛指的是一种引用值
var obj = {};
console.log(typeof(obj)); // object也就说数组返回的也是 object，泛泛的引用值它都返回的是 object
var arr = []; console.log(typeof(arr)); // object
还有一种数据叫 null 是原始值之一，会发现 null 返回的也是 object
var mode = null; console.log(typeof(mode)); // object
为什么原始值 null 返回的是 object 呢？
原始值和引用值没关系，这就涉及浏览器的一个历史遗留问题，
最早的 null 是作为代替空对象的形式出现的，它是给对象来占位的，所以那个时候系统认为 null 是对象，tpyeof 的时候就是对象了，直到现在也没改过来，null 是原始值不假，但 typeof 返回的是 object 类型。
undefined 返回的是 undeined
var a = undefined; console.log(typeof(a)); // undefined
function 函数会返回 function
var fn = function(){}
console.log(typeof(fn)); // functiontypeof()有两种写法
第一种写法加括号
第二种是不加括号用空格隔开，最好加括号看起来有归属感
var a = 123; console.log(typeof(a)); // number console.log(typeof a); // number
typeof 能帮我们区分数据是什么类型的下面马上就知道了
二、类型转换
数字 1 加上数字 1 肯定等于 2
var num = 1 + 1; console.log(typeof(num) + ": " + num); // number: 2
数字 1 加上字符串 "1"，返回的是字符 "11"
var num = 1 + "1"; console.log(typeof(num) + ": " + num); // string: 11
数字 1 乘以字符串 "1"，返回的是数字类型的 1
var num = 1 * "1"; console.log(typeof(num) + ": " + num); // number: 1
数字 1 减字符串 "1" 能减吗？
能减，返回的是数字类型的 0
var num = 1 - "1"; console.log(typeof(num) + ": " + num); // number: 0
字符串 "2" 减去字符串 "1"，这样还是可以的，返回的是数字类型的 1
var num = "2" - "1"; console.log(typeof(num) + ": " + num); // number: 1
字符串 "2" 乘 字符串 "1"，返回的是数字类型的 2
var num = "2" * "1"; console.log(typeof(num) + ": " + num); // number: 2
这种语法在其它语言里没有只有 js 独有，为什么可以这样？
因为 js 里有一个类型转换，
类型转换分两种，上面的是“隐士类型转换”，在这之前我们必须先了解“显式类型转换”。
三、显示类型转换
1. Number(mix)
2. parseInt(string,radix)
3. parseFloat(string)
4. toString(radix)
5. String(mix)
6. Boolean()
1. Number(mix)
Number() 方法执行完后会把字符串 "123"，转成数字 123 并返回给我们
var str = "123"; var num = Number(str); // 括号里面是字符串的"123" console.log(typeof(num) + ": " + num); // number: 123（转换成数子123了）
布尔值 true 转换成数字是 1
var bool = true; var num = Number(bool); console.log(typeof(num) + ": " + num); // number: 1
布尔值 false 转换成数字是 0
var bool = false; var num = Number(bool); console.log(typeof(num) + ": " + num); // number: 0
null 转换成数字是 0
var a = null; var num = Number(a); console.log(typeof(num) + ": " + num); // number: 0
undefined 不能被转成数字，这是特殊的一个，虽然返回的是 NaN 但依然是数字类型，也就是说经历 Number 方法后，不管能不能转换成真实的数，反正都会变成数字类型，转不成的都变成 NaN
var a = undefined; var num = Number(a); console.log(typeof(num) + ": " + num); // number: NaN
字符串 "a" 不能转化成数字返回 NaN，没有转成ASCII码97 ，这种看起来就不是数字的就转不成数字
var mode = "a"; var num = Number(mode); console.log(typeof(num) + ": " + num); // number: NaN
基本所有情况都在 Number 里面得出的结果试过了，现在如果字符串 "-123" 转成数字是 -123
var mode = "-123"; var num = Number(mode); console.log(typeof(num) + ": " + num); // number: -123
字符串 "123abc"，不能转成数字返回 NaN
var mode = "123abc"; var num = Number(mode); console.log(typeof(num) + ": " + num); // number : NaN
Number 是把给它的数据转化为数字，下面是 parseInt(string,radix)
2. parseInt(string,radix)
parse 是转化的意思，
Int 是整型的意思
parseInt(string, radix) 的目的不是转化成 数 而是转化成 整形的数，parseInt 就是转化成整数，凡是有小数点的都给去掉，Ps: 数学整数是 Z 来表示、Q 是有理数
parseInt 把字符串 "123" 转化数字 123
var mode = "123"; var num = parseInt(mode); console.log(typeof(num) + ": " + num); // number: 123
parseInt 好像也能转化数子
如果让 parseInt 转化布尔值 true 呢？true 转化成 NaN
var bool = true; var num = parseInt(bool); console.log(typeof(num) + ': ' + num); // number: NaN
false 也转成 NaN
var bool = false; var num = parseInt(bool); console.log(typeof(num) + ': ' + num); // number: NaN
parseInt 和 Number 的侧重点不一样
Number 是想把数据转换成数字，所以它会千方百计的转化成数字
parseInt 不管那么多，parseInt 是要把数转换成整的形
如果是字符串数 "123" 转化成数 123，如果是正常的数 123.3 这样的数给转化成整形 123，所以它不会关注 true、false、nudefined、null，这些 parseInt 转化全是 NaN
var mode = null; var num = parseInt(mode); console.log(typeof(num) + ': ' + num); // number: NaN var mode = undefined; var num = parseInt(mode); console.log(typeof(num) + ': ' + num); // number: NaN
如果是 123.3 转成 123
var mode = 123.3; var num = parseInt(mode); console.log(typeof(num) + ' : ' + num); // number : 123
不是四舍五入，是直接去掉小数点，123.9 直接去的小数返回 123
var mode = 123.9; var num = parseInt(mode); console.log(typeof(num) + ' : ' + num); // number : 123
如果是字符串 "123.9"，一样也是直接去小数点返回数字 123
var mode = "123.9"; var num = parseInt(mode); console.log(typeof(num) + ' : ' + num); // number : 123
这是 parseInt 的第一点用途转成整形，
它还有第二点用途 parseInt(demo ,radix)，后面参数英文名 radix 是基底的意思
什么是基底？
如果后面参数 radix 写 16，它就会认为 10（读一零）是十六进制的 10，
以十六进制为基底，把 10 转化为十进制。
把10（一零）当成十六进制转换为十进制的数是 16
var mode = "10"; var num = parseInt(mode ,16); // 以目标进制radix为基底转换成十进制（以十六进制为基底转换成十进制） console.log(typeof(num) + ': ' + num); // number: 16
Ps
这里说的基底，就是别的教程里，进制的权值
进制的意思
0 到 9在往上是 10，9 上面也可以不是 10，也可以是 a 因为进制不同，这个 10 之所以叫做十进制，满十就进一，1 就变成零 10，
还有一种进制叫十六进制，满 10 变成a，然后是 b、c、d、e、f
16（f）再加 1（f + 1 = 10）就变成一零了（10），这个10（一零）比较有含金量，这个 1 是十六进制的一，这一个 1 代表 16，这个 20 的 2 代表两个 16 是 32。
十六进制
0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F
如果换成 b，b 在十进制里是 11
var mode = "b"; var num = parseInt(mode ,16); console.log(typeof(num) + ': ' + num); // number: 11
radix 取值范围是 2 - 36 可能还要饶一个 0 没有 1，没有一进制，一进制太奔放了永远不可能有尽头，一进制不存在
如果 2 进制转换为 10 进制的数，3 能转化吗？
3 不行返回 NaN，二进制没有 3，连 2 都没有，只能写 1010……
var mode = "3"; var num = parseInt(mode ,2); console.log(typeof(num) + ': ' + num); // number: NaN
二进制里只有 1 和 0
var mode = "10101010"; var num = parseInt(mode ,2); console.log(typeof(num) + ': ' + num); // number: 170
Ps
没有一进制，一进制不存在
一些转换进制的练习
var mode = "20"; var num = parseInt(mode ,16); console.log(typeof(num) + ': ' + num);//number: 32 var mode = "21"; var num = parseInt(mode ,16); console.log(typeof(num) + ': ' + num);//number: 33 // 在二进制里，10是十进制的2 var mode = "10"; var num = parseInt(mode ,2); console.log(typeof(num) + ': ' + num);//number: 2 // 在三进制里，11是十进制的4 var mode = "11"; var num = parseInt(mode ,3); console.log(typeof(num) + ': ' + num);//number: 4
再看 parseInt 的基本用法，如果字符串 "123abc" 转化整形为 123
var mode = "123abc"; var num = parseInt(mode); console.log(typeof(num) + ': ' + num); // number: 123
parseInt 有一个独特都功能，
它是从数字位开始往后看，一直看到非数字位截止 123abc 把之前的返回，这是砍断原则。
所以字符串 123.3abc 这个小数点是非数字给砍断了，以数字位开始看，看到非数字位截止，直接返回前面数。
var mode = "123.3abc"; var num = parseInt(mode); console.log(typeof(num) + ': ' + num); // number: 123
后期会遇到最典型的例子 "100px" 是字符串值，把 100 取出来 parseInt 是最好的办法
var mode = "100px"; var num = parseInt(mode); console.log(typeof(num) + ': ' + num); // number: 100
3. parseFloat(string)
parseFloat 和 parseInt 极其相似，而且 parseFloat 没那么复杂，
parseFloat 就是把字符串 "100.2" 转化成浮点类型，换句话说转换成正常的数 100.2，浮点数就是正常的小数
var mode = "100.2"; var num = parseFloat(mode); console.log(typeof(num) + ': ' + num); // number: 100.2
字符串 "100.2.3" 转换还是 100.2
var mode = "100.2.3"; var num = parseFloat(mode); console.log(typeof(num) + ': ' + num); // number: 100.2
字符串 "100.2abcd" 转换成小数是 100.2，parseFloat 也是从数字位开始看，看到除了第一个点以外的非数字位截止，把前面的返回
var mode = "100.2abcd"; var num = parseFloat(mode); console.log(typeof(num) + ': ' + num); // number: 100.2
parseFloat 没有基底只有一个参数
4. String(radix)
String 和 Number是一样的，
Number 致力于把变量转化成数字，
String 致力于转化成字符串
下面 String 方法把数字 123.234 转化字符串 "123.234"，写什么都会转化成字符串
var demo = 123.234; var str = String(demo); console.log(typeof(str) + ': ' + str); // string: 123.234
写 undefined 会变成字符串 "undefined"
var demo = undefined; var str = String(demo); console.log(typeof(str) + ': ' + str); // string: undefined
写什么都会变字符串，写布尔值 true 转化成字符串 "true"
var demo = true; var str = String(demo); console.log(typeof(str) + ': ' + str); // string: true
只要放到 String(demo) 里面，它就会把这个东西转换成字符串
5. Boolean()
Boolean(demo) 试图把里面的东西转化成布尔值
布尔值的规则，除了认定为 false 的六值 undefined、null、NaN、 ""、0、false，其它都是 true。
"" 空字符串，转化为布尔值 false
var demo = ""; var bool = Boolean(demo); console.log(typeof(bool) + ': ' + bool); // boolean: false
字符串 "123" 转化为布尔值 true，Boolean 致力于把里面的东西转化成布尔类型
var demo = "123"; var bool = Boolean(demo); console.log(typeof(bool) + ': ' + bool); // boolean: true
6. toString(radix)
toString() 也是转化成字符串，只不过它的用法与 String() 有点区别
toString() 不在是填值了，是想把谁转化成字符串，就用谁取调用 .toString()
var demo = 123; var str = demo.toString(); // demo调用toString console.log(typeof(str) + ': ' + str); // string: 123
布尔值 true 调用 toString 转为字符串 "true"
var demo = true; var str = demo.toString(); console.log(typeof(str) + ' : ' + str); // string : true
toString() 和 String() 差不多，但有个特殊点，有两个不能用，undefined 和 null 不能用 toString()
试一下，
下面 undefined 调用 toString 方法会报错
var demo = undefined; var str = demo.toString(); // Uncaught TypeError: Cannot read property 'toString' of undefined
报错信 undefined 没有 toString 这个属性，为什么没有？讲原型的时候会知道的
这块记住
undefined 不能用 toString，null 也不能用 toString
var demo = null; var str = demo.toString(); // Uncaught TypeError: Cannot read property 'toString'
一般情况也没人用 toString 一般用 String，或者直接加空字符串直接变字符串，任何数据加空字符串都成转化为字符串形式。
toString 有另一个用法
toString(redix) 里面还可以写一个 redix 参数，参数 redix 也是基底的意思，但这个基底不在是 parseInt 那个基低的用途了，toString 的基低是以十进制为基底转化为目标进制。
比如数字 123 转化为八进制，123 转换成八进制是 173
var demo = 123; var str = demo.toString(8); // 8是目标进制，把123转化成八进制 console.log(typeof(str) + ': ' + str); // string: 173
来个简单点的，把 10 转化成八进制，toString(8) 就是以十进制为基底转换成目标进制，目标进制是八进制
var demo = 10; var str = demo.toString(8); // 以十进制为基低，把目标转换成八进制 console.log(typeof(str) + ': ' + str); // string: 12
20 转化成八进制是 24
var demo = 20; var str = demo.toString(8); console.log(typeof(str) + ': ' + str); // string : 24
24的2，代表2乘以8（2 * 8），24是16 + 4
看一道题
给你一个二进制的数 10101010 转成十六进制的怎么做？
思路：二进制可以转成十进制，十进制可以转成十六进制，先parseInt再toString
parseInt toString
2 --- 10 --- 16
var num = 10101010; var test = parseInt(num , 2); // 二进制转换为十进制，以目标进制2为基低转换为十进制 var test = test.toString(16); // 转换十六进制 console.log(test); // aa
二进制 10000 代表十进制16
var num = 10000; var test = parseInt(num ,2); // 16 var test = test.toString(16); // 10 console.log(test); // 10
parseInt做的是以目标进制转换为十进制的过程，toString做的是以十进制转换为目标进制的过程
四、隐式类型转换
隐式类型转换的特点，它内部隐式调用的都是显示类型转换的方法
1. isNaN() —> Number()
2. ++/—
3. +/-（一元正负）
4. +
5. */%
6. && || ！
7. < > <= >=
8. == !=
1、挨个看隐式类型转换
1. isNaN()
isNaN() —> Number()
把一个数放到 isNaN() 的括号里面，能判断这个数是不是 NaN，然后返回来 true 或 false
如果放的是一个 NaN 呢？判断 NaN 必须返回 true
console.log(isNaN(NaN)); // true
数字类型 123 不是 NaN，所以返回 false
console.log(isNaN(123)); // false
字符串 "123" 不是NaN，所以返回 false
console.log(isNaN("123")); // false见证奇迹的时刻，字符串 "abc" 是 NaN 吗？它是 NaN 返回 true
console.log(isNaN("abc")); // true为什么 isNaN("abc") 返回的是NaN呢？
1. isNaN("abc") 它内部做了一件事，它会把字符串 "abc" 先放到 Number("abc") 里面去转化
2. 通过Number转化 Number("abc") --> NaN ，转化出的结果再和 NaN 去比对，如果是 NaN 相等就返回 true
3. Number("abc") 转化出的结果是 NaN，所以说里面经历的内部隐式转化的过程是 Number 方法，这个 Number 没有显示的调用，但是隐式的调用了
既然知道里面隐式调用的是 Number() 方法了，如果 isNaN(null) 里面填null，返回的是 true 还是 false？
1. null 经历 Number(null) 的转化返回的是 0
2. 0 不是 NaN，所以 isNaN(null) 返回 false
console.log(Number(null)); // 0 console.log(isNaN(null)); // false
umdefined 经历 Number 转化为 NaN，所以 isNaN(umdefined) 返回的是 true
console.log(Number(undefined)); // NaN console.log(isNaN(undefined)); // true
这种隐式类型转换，要是不懂显示类型转换的规则，只能是干背了undefined是true、null是falase
2. ++加加、--减减
字符串类型 "123" 不是数字，能加加运算吗？能加加，运算返回数字类型 124
var a = "123"; a ++; console.log(typeof(mode) + ': ' + mode); // number: 124
为什么字符串 "123" 能加加运算？
1. a ++ 加加这个符号往这一立，还没有进行运算（运算分写前、写后）之前，它就把前面的变量 a 给转换了
2. 怎么转换？先调用 Number("123") 转化成数字再说，还是隐式的去调用显示的方法，先转成数字所以能计算返回数字类型的 124
那字符串 "abc" 能计算吗？
1. 有一个趋势调用 Number("abc") 转成数字，但是没转成数字转成 NaN 了
2. 所以最后 a++ 返回的是 NaN，
3. tpyeof a 返回的是 number 类型，经历这样隐式类型转换之后，即使转不能数字也是数字类型了
var a = "abc"; a ++; console.log(a); // NaN console.log(typeof(a)); // number
经历了加加运算后即使转不成数字，也是数字类型了
加加和减减类似，写前写后也类似，反正都会被转成数字类型，重点是下面
3. +、- （一元正和负，不是加减）
正号或负号都会把字符串 "abc" 变换成数字类型
var a = "abc"; + a; // 正号 - a; // 负号 console.log(typeof(a) + ": " + mode); // number: NaN
这样 +"abc" 正号直接加在字符串上，变量 a 变成 NaN 转成 nubmer 数字类型
var a = +"abc"; console.log(typeof(a) + ": " + mode); // number: NaN
尽管转的不是真实的数字，但也要转换成数字类型，因为里面调用的是 Number() 方法
负号的 -"abc" 字符串，隐式调用的也是 Number 方法
var mode = -"abc"; console.log(typeof(mode) + ": " + mode); // number: NaN
4. + 加号
加号的隐式类型转换调用的是 String() 方法
加号是一个特别特殊的语法，当加号两侧有一个是字符串，它就会调用 String() 把两边全变成字符串
var demo = "a" + 1; console.log(typeof(demo) + ": " + demo); // string: a1 var demo = "123" + 456; console.log(typeof(demo) + ": " + demo); // string: 123456
5. -、*、/、%（减号、乘号、除号、取模）
它们（减号、乘号、除号、取模）隐式类型转换调用的还是 Number() ，所以字符串 "1" 乘以数字 1，它居然等于数字类型的 1，只要相乘两侧必须转换成数字类型的
var demo = "1" * 1; console.log(typeof(demo) + ": " + demo); // number: 1
如果字符串 "a" 乘数字 1 呢？
1. 还是调用 Number 方法 Number("a") 的结果 * Number(1) 的结果
2. 最后是 NaN * 1 还是NaN，但是类型变 number 了
var demo = "a" * 1; console.log(typeof(demo) + ": " + demo); // number: NaN
加法、减法、除法、模2都一样就不说了
6. &&、||、!（与、或、非）
! 非的类型转换就不说了，是布尔在取反
&&与 、||或 的隐式类型转换，
1. 之前学的时候是看，第一个表达式的结果转化的布尔值，然后再看第二个表达式结果是 true 还是 false，
2. 还是有隐式类型转换的过程，只不过返回的是表达式的值，不是隐式类型转化的值，但判断的是类型转换的值，还是进行 boolen 去隐式类型转化。
7、< 、> 、<= 、>= (大于号、小于号、大于等于号、小于等于号)
数字 1 大于字符串 "2" 吗？有数字相比较的就会隐式类型转化成数字
var demo = 1 > "2"; console.log(typeof(demo) + ": " + demo); // boolean: false
字符串 "3" 与字符串 "2" 比较，这个没有类型转换，字符串和字符串比，比较的是 ASCII 码顺序
var demo = "3" > "2"; console.log(typeof(demo) + ": " + demo); // boolean: true
但是字符串 "3" 和数字 2 比较，字符串和数字比就把字符串会转化成数字了，调用 Number 转换成数字
var demo = "3" > 2; console.log(typeof(demo) + " : " + demo); // boolean : true
8. ==、!= （等号和非等号 ）
数字1 == 字符串"1" 吗？这里也有隐式类型转化，它是相等的
var demo = 1 == "1"; console.log(typeof(demo) + ": " + demo); // boolean: true
数字 1 等于布尔值 true 吗？它们是相等的，有隐式类型转化
var demo = 1 == true; console.log(typeof(demo) + ": " + demo); // boolean: true
非等于（不等于）也一样，有隐式类型转化
var demo = 1 != true; console.log(typeof(demo) + ": " + demo); // boolean: false
2、看几个特殊的
false > true 会转换成数字 0 > 1
var demo = false > true; console.log(typeof(demo) + ": " + demo); // boolean: false
2 > 1 > 3
1. 2 > 1 结果是 true
2. true > 3 转成 1 > 3
var demo = 2 > 1 > 3; console.log(typeof(demo) + ": " + demo); // boolean:false
2 > 3 < 1
var demo = 2 > 3 < 1; // false > 3 // 0 < 1 console.log(typeof(demo) + ": " + demo);//boolean: true
10 > 100 > 0
var demo = 10 > 100 > 0; //false > 0 //0 > 0 console.log(typeof(demo) + ": " + demo); // boolean: false
100 > 10 > 0
var demo = 100 > 10 > 0; // true > 0 // 1 > 0 console.log(typeof(demo) + ": " + demo); // boolean: true
上面这些是挨个算的，先算前面的结果得 true 或 false，再和后边的在比，挨个来比
3、下面看几个最好玩的
undefined 不大于 0，不小于 0，不等于0
var demo = undefined > 0; console.log(demo); // false var demo = undefined < 0; console.log(demo); // false var demo = undefined == 0; console.log(demo); // false
然后null不大于0，不小于0，不等于0
var demo = null > 0; console.log(demo); // false var demo = null < 0; console.log(demo); // false var demo = null == 0; console.log(demo); // false
null和undefined很像，他俩是相等的，这是隐式类型里面最特殊没有规则的，系统就这么规定的用Number解释不了
var demo = null == undefined; console.log(demo); // true
唯一自己都不等于自己的就是非数，NaN连自己都不等于自己，它就不可能等于任何东西
var demo = NaN == NaN; console.log(demo); // false
==（等于）有隐式类型转换有时候对我们是很不利的，比如字符串"1"和数字1是相等的，形式上是不等的，这样会造成误差，有没有不发生类型转换的？
4、绝对等于"==="、绝对不等于"!=="
不发生类型转换的绝对等于"===" 和绝对不等于"!=="
===三个等号叫绝对等于，数字1绝对等于数字1吗？绝对等于
var demo = 1 === 1; console.log(demo); // true
数字1绝对等于字符串"1"吗？不等于
var demo = 1 === "1"; console.log(demo); // false
数字1绝对不等于字符串"1"吗？绝对不等于
var demo = 1 !== "1"; console.log(demo); // true
数字1绝对不等于数字1吗？等于自己
var demo = 1 !== 1; console.log(demo); // false
这次左右两侧不发生类型转换，差一点都不行。
但是NaN在任何一种情况它都不等于自己，这是一个特例
var demo = NaN === NaN; console.log(demo); // false
5、再说一个特殊的
如果变量a没定义就访问肯定报错
// var a; console.log(a); // Uncaught ReferenceError: a is not defined
有一种级特殊的情况是不报错的，把未定位的变量放到了typeof a里面是不报错的，并打印出值 undefined
// var a; console.log(typeof(a)); // undefined
看下面 typeof(typeof(a))返回什么？里面的结果返回undefind，然后 typeof undefined ，考的是typeof返回的结果是什么类型，返回的是字符串"undefined"
console.log(typeof(typeof(a))); // string
一般笔试题会这样考，第一个typeof返回的是undefined，返回的是字符串的"undefined"
console.log(typeof(typeof(undefinede))); // var demo = typeof(undefinede); // 里面 // console.log(typeof(demo) + " : " + demo); // 外边
typeof返回的六种类型都是字符串类型
五、作业练习
01/
console.log(typeof(a)); // 返回结果是字符串类型的"undefined" console.log(typeof(undefined)); // 返回的也是字符串类型"undefined" console.log(typeof(NaN)); // number console.log(typeof(null)) // 历史遗留问题返回 object
02/
var a = "123abc"; console.log(typeof(+a)); // 一元正负运算符给它隐式类型转换成数字，不管能否转换成正式的数字反正是数字类型，转换完是NaN打印出来是number console.log(typeof(!!a));// bollen类型 console.log(typeof(a + "")); // a加空串转换字符串类型string
03/
console.log(1 == "1"); // 有隐式类型转换的等于，相等返回true console.log(NaN == NaN); // NaN不等于任何东西返回false console.log(NaN == undefined); // 都说NaN不等于任何东西了返回 false
04/
console.log("11" + 11); // 打印的是四个一 "1111" 千万不能是22
console.log(1 === "1"); // false05/
console.log(parseInt("123abc")); // parseInt有截断数字的作用返回12306/
toFixed是科学计数法保留几位有效数字， 123123.345789..toFixed(3) 参数放3就保留3位有效数字，并且四舍五入123123.346
var num = 123123.345789; console.log(num.toFixed(3)); // 参数放3就保留3位有效数字并且四舍五入123123.346
07/
typeof(typeof(a)) 第一点考的是未经声明使用的变量a，这种情况是唯一不报错的情况，然后返回一个字符串"undefined"，字符串的"undefined"再typeof字符串"undefined"返回string
console.log(typeof(typeof(a))); // string
08/
+ 200 + "3" 变成字符串
-*、% "200" - 3 变数字
>< "2" > 1 转换数字
!取反 !"ok" 转布尔值
!100
== "2" == 2 转字符串
===