隐式类型转换：没有主动做，在执行过程中转换了，执行结束后，原数据没有改变
- 场景：什么情况下会发生转换
- 运算符：算术、关系、逻辑
- 规则：转换规则是什么
- 算术：`+`:只要一边是字符，结果就都是字符
`-、*、/、%`：都是转成数值
- 关系：只要一边是数值，就会转成数值后进行比较
- 逻辑：转成布尔
<script>
// 字符和数值之间的算术运算
var a = "1";
console.log( a - 0 ); // 数据类型为number，运行检测结果为1
console.log(typeof (a - 0) );
console.log( a ); // 数据类型为string，运行检测结果为1
console.log(typeof (a) );
console.log( a + 1 ); // 数据类型为string，运行检测结果为11
console.log(typeof (a + 1) );
console.log( a * 1 ); // 数据类型为number，运行检测结果为1
console.log(typeof (a * 1) );
console.log( a / 1 ); // 数据类型为number，运行检测结果为1
console.log(typeof (a / 1) );
console.log( a % 2 ); // 数据类型为number，运行检测结果为1
console.log(typeof (a % 2) );
// - 场景：什么情况下会发生转换
// - 运算符：算术、关系、逻辑
// - 规则：转换规则是什么
// - 算术：`+`:只要一边是字符，结果就都是字符
// `-、*、/、%`：都是转成数值
// 字符和数值之间的关系运算
var a1 = "230";
var a2 = 32;
console.log(a1 > a2); // 数据类型为boolean，运行的结果是true
console.log(typeof (a1 > a2) );
console.log(a1 >= a2); // 数据类型为boolean，运行的结果是true
console.log(typeof (a1 >= a2) );
console.log(a1 < a2); // 数据类型为boolean，运行的结果是false
console.log(typeof (a1 < a2) );
console.log(a1 == a2); // 数据类型为boolean，运行的结果是false
console.log(typeof (a1 == a2) );
console.log(a1 != a2); // 数据类型为boolean，运行的结果是true
console.log(typeof (a1 != a2) );
console.log(a1 === a2); // 数据类型为boolean，运行的结果是false
console.log(typeof (a1 === a2) );
console.log(a1 !== a2); // 数据类型为boolean，运行的结果是true
console.log(typeof (a1 !== a2) );
// !==代表两边的数据类型和数值都不相等
// !=只代表两边的数值不相等
// 只要出现数值，就是数值的比较规则
// 非数值会自动转换成数值进行比较
</script>
强制类型转换：主动转换，可以拿到转换结果
- 字符转数值
- `parseInt(要转换的字符)`
- 将字符转换成整数，从左向右依次检测，
- 能转则转，不能转则停，
- 第一位不能转，运行检测结果为NaN,
- 不识别小数点
- `parseFloat(要转换的字符)`
- 将字符转换成小数，从左向右依次检测，
- 能转则转，不能转则停，（转换结果可能是小数，也可能是整数或者NaN）
- 第一位不能转，运行检测结果为NaN
- `Math.round(要转换的字符)`
- 不是专门做数据转换，处理数据的过程中，可以转换，
- 严格转换，不允许任何位置出现非数字的字符，（一旦出现，运行检测结果为NaN）
- 四舍五入取最近的整数（转换结果一定是是整数或者NaN）
- `Number(要转换的字符)`
- 不是专门做数据转换，处理数据的过程中，可以转换，
- 严格转换，不允许任何位置出现非数值的字符（一旦出现，运行检测结果为NaN）（转换结果可能是小数，也可能是整数或者NaN）
- （可以识别小数）
- 数值转字符
- `要转换的数值.toString()`
直接转，没有规则，（数字转出来还是是数字，可以识别小数，NaN转出来还是NaN）
- `要转换的数值.toFixed(n)`
直接转，根据输入的数字，决定保留n位小数，不够的位数补零，NaN转出来还是NaN数字的小数取舍与浏览器兼容有关
- `String(要转换的数值)`
- 不是专门做数据的转换，处理数据的过程中，可以转换，
- 直接转，没有规则，（数字转出来还是是数字，可以识别小数，NaN转出来还是NaN）
- 其他转布尔
- `Boolean()`
- 不是专门做数据转换，处理数据的过程中，可以转换
- 数值：非0为true，0为false。
- 字符：非空为true，空为false。
- undefined，null，NaN，都是false。
- 对象{}，数组[]，函数function(){}，都是true。
<JavaScript 对象是变量的容器。数据值类型(基本类型)：字符串（String）、数字(Number)、布尔(Boolean)、对空（Null）、未定义（Undefined）、Symbol。引用数据类型：对象(Object)、数组(Array)、函数(Function)。>
<script>
// 第一类：字符转数值
// var x = "356.789"; // console.log(parseInt(x))=356
// var x = "356"; // console.log(parseInt(x))=356
// var x = "35a6"; // console.log(parseInt(x))=35
// var x = "35a6.789"; // console.log(parseInt(x))=35
// var x = "a356.789"; // console.log(parseInt(x))=NaN
// var x = "a356"; // console.log(parseInt(x))=NaN
console.log(parseInt(x));
// parseInt(要转换的字符)将字符转换成整数，从左向右依次检测，能转则转，不能转则停，第一位不能转，运行检测结果为NaN,不识别小数点。
// var x = "356.789"; // 356.789
// var x = "356"; // 356
// var x = "35a6"; // 35
// var x = "356.7a89"; // 356.7
// var x = "35a6.789"; // 35
// var x = "a356.789"; // NaN
// var x = "a356"; // NaN
console.log(parseFloat(x));
// parseFloat(要转换的字符)将字符转换成小数，从左向右依次检测，能转则转，不能转则停，（转换结果可能是小数，也可能是整数）第一位不能转，运行检测结果为NaN。
// var x = "356.789"; // 357
// var x = "356.4"; // 356
// var x = "356"; // 356
// var x = "35a6"; // NaN
// var x = "356.7a89"; // NaN
// var x = "35a6.789"; // NaN
// var x = "a356.789"; // NaN
// var x = "a356"; // NaN
console.log(Math.round(x));
// Math.round(要转换的字符)不是专门做数据转换，处理数据的过程中，可以转换，属于严格转换，不允许任何位置出现非数字的字符，一旦出现，运行检测结果为NaN，四舍五入取最近的整数。
// var x = "356.789"; // 356.789
// var x = "356.4"; // 356.4
// var x = "356"; // 356
// var x = "35a6"; // NaN
// var x = "356.7a89"; // NaN
// var x = "35a6.789"; // NaN
// var x = "a356.789"; // NaN
// var x = "a356"; // NaN
console.log(Number(x));
// Number(要转换的字符)不是专门做数据转换，处理数据的过程中，可以转换，属于严格转换，不允许任何位置出现非数字的字符，一旦出现，运行检测结果为Na，（可以识别小数）。
// 第二类：数值转字符
// var n = 123.345; // console.log(n.toString())=123.345
// var n = 123.3; // console.log(n.toString())=123.3
// var n = 123.5; // console.log(n.toString())=123.5
// var n = 123; // console.log(n.toString())=123
// var n = NaN; // console.log(n.toString())=NaN
console.log(n.toString());
// 要转换的数值.toString()是直接转，没有规则，有多少数值数据就转出来多少。
// var n = 123.345; // console.log(n.toFixed(1))=123.3
// console.log(n.toFixed(2))=123.34
// var n = 123.34; // console.log(n.toFixed(1))=123.3
// console.log(n.toFixed(2))=123.34
// var n = 123.255; // console.log(n.toFixed(1))=123.3！！！！
// console.log(n.toFixed(2))=123.25
//存在疑问！！！！！！！！！
// var n = 123.555; // console.log(n.toFixed(1))=123.6！！！！
// console.log(n.toFixed(2))=123.56！！！
// var n = 123.3; // console.log(n.toFixed(1))=123.3
// console.log(n.toFixed(2))=123.30
// var n = 123; // console.log(n.toFixed(1))=123.0
// console.log(n.toFixed(2))=123.00
// var n = NaN; // console.log(n.toFixed(1))=NaN
// console.log(n.toFixed(2))=NaN
console.log(n.toFixed(1))
console.log(n.toFixed(2))
// 要转换的数值.toFFixed(n)是直接转，根据输入的数字，决定保留n位小数，不够的位数补零，NaN转出来还是NaN。
// var n = 123.345; // console.log(String(n))=123.345
// var n = 123.3; // console.log(String(n))=123.3
// var n = 123.5; // console.log(String(n))=123.5
// var n = 123; // console.log(String(n))=123
// var n = NaN; // console.log(String(n))=NaN
console.log(String(n))
//String(要转换的数值)不是专门做数据的转换，处理数据的过程中，可以转换，直接转，没有规则，NaN转出来还是NaN。
// 第三类：其他转布尔
console.log( Boolean( 123.456 ) ); // true
console.log( Boolean( 123 ) ); // true
console.log( Boolean( -123 ) ); // true
console.log( Boolean( -123.456 ) ); // true
console.log( Boolean( 0 ) ); // false
console.log( Boolean( NaN ) ); // false
// 数值：非0为true，0、NaN 为false。
console.log( Boolean( "0" ) ); // true
console.log( Boolean( " " ) ); // true
console.log( Boolean( "" ) ); // false
console.log( Boolean( "false" ) ); // true
console.log( Boolean( "hello" ) ); // true
// 字符：非空为true，空为false。
console.log( Boolean( undefined ) ); // false
console.log( Boolean( null ) ); // false
console.log( Boolean( {} ) ); // true
console.log( Boolean( [] ) ); // true
console.log( Boolean( function(){} ) ); // true
// undefined，null，NaN，都是false。
// 对象{}，数组[]，函数function(){}，都是true。
</script>
