这篇随笔记录一下js中数据的各种类型转换的规则,虽然很基础,但是重新过一遍会发现有些规范还是挺意想不到的
首先介绍一下ToString, ToNumber, ToBoolean 的转换规则
1、ToString
规则1:null 转换为 “null” , undefined 转换为 “undefined” , true 转换为 “true” ;
规则2:普通对象,除非自定义,否则用 toString();
数组的toString()方法,先把所有单元字符串化,然后再用“,”连接;[1,2,3,4] // “1,2,3,4”;
2、ToNumber
规则1:布尔值 true 转换为 1, false 转换为 0; undefined 转换为 NaN; null 转换为 0;字符串处理失败时返回NaN;
规则2:以 0开头地十六进制数会被当成十进制;
规则3:对象会先被处理成相应地基本类型值,再按照值类型做相应处理;
对象做ToPrimitive操作规则:先valueOf(), 如果valueOf的结果不是基本类型,再进行 toString();如果均不返回基本类型,则报TypeError;
使用Object.create(null) 创建的对象,无valueOf 跟 toString 方法,故不能被强制类型转换
规则4:空数组和空字符串,都会被转换为0:
Number("") // 0; Number([]) // 0;
3、ToBoolean
规则1:undefined,null,false,+0,-0,NaN,“” 会被转换为false;但是对应的封装对象为true
规则2:js中 document.all 如果用在 if 语句中,会被转换为false;此条规则需要注意的是,在ie<= 10 的浏览器中,会返回true;
规则3:除规则1和规则2,其他都返回true
Boolean(undefined) // false; Boolean(null); // false; Boolean(false); // false; Boolean(+0); // false; Boolean(-0); // false; Boolean(""); // false; const a = new Boolean( false) ; // true const b = new Number(0); // true const c = new String("") ; // true if(document.all){ // ie10 及 以下,会被打印; console.log('document.all 在if语句中被强制类型转换,但转换的结果为false,这条语句不会被打印'); }
JSON.stringify 的规则与 强制类型转换关联,故也总结到这里:
JSON字符串化简单数值时,规则与toString大致相同;但是序列化的结果总是字符串:JSON.stringify("42") // ""42"";
undefined、function、symbol 和包含对象间循环引用的,都属于不安全的JSON值,这些值会被忽略,数组种则会返回 null,仪保证单元位置不变
例如:JSON.stringify([1,undefine,function(){},2]) // [1, null, null, 2];
JSON.stringify( {a:1, b: undefine, c: function(){} } ) // {a:1}; 此特性可用于发起请求时的无效参数过滤;
可自定义toJSON 函数,在JSON序列化时会被调用;该函数应该返回一个能够被字符串化的安全的JSON值,而不是直接返回一个字符串,因为处理逻辑是对toJSON返回的字符串做字符化;
JSON.stringify 支持传入可选参数replacer,用来指定对象序列化过程中属性的处理逻辑:
a、当replacer为数组时, JSON.stringify 只序列化数组中包含的属性,例如:
var a = { name: "Lily", age: 12 , hobby: ["basketball", "football"] } JSON.stringify(a, ["name", "age"]); // "{"name": "Lily" , "age": 12}"// 这个特性可以用来提取对象中指定属性
b、当replacer为函数时, 函数会对将要被序列化的对象做一个遍历,入参为key 和 value,可在函数中写处理逻辑:
var a = { name: "Lily", age: 12 , hobby: ["basketball", "football"] } JSON.stringify(a, function(key, value){ // "{"name":"Lily","hobby":["basketball","football"]}"
if(key !== "age") return value; });
这里有一个细节: 当replacer函数第一次被调用时,是对对象本身的调用,key 为 undefined;
属性的值为数组时,数组中的值也将被遍历,此时key为数组的索引,value为数组的单元值;
接下来,我们看下一些操作符在强制类型转换中的影响:
1、+ 操作符
+String : 会把字符串转换为数字;
+Date:会把时间对象转换为时间戳;同样使用 Date.now(); new Date().getTime()也可以得到时间戳;
String + other :首先 other 会被转换为字符串,再进行拼接操作;但是也有特殊情况:
{} + [] // "[Object Object]"
[] + {} // 0
Number + Boolean:Boolean 会先被转换为Number类型,再进行相加操作
- x / 等操作符,只针对Number类型有效,故这三个操作符会把操作数转换为数字类型;
2、位运算符 ~ 和 | 位运算符只适用于32位整数,故操作数会被ToInt32强制转换为32位格式;非数字类型的值会先通过ToNumber转换为 数字类型;
~ 运算(字位操作“非”)返回2的补码 ~x 大致等于 -(x+1);在~运算中,只有 x 为 -1 时,才会返回 0;这个特性可以用在将-1做为哨位值的运算中,避免暴露底层实现细节(抽象渗漏)
var a = "Hello world"; if(~a.indexOf("H")){ // 找到匹配 }
| 运算符(字位操作“或”)
0 | -0 // 0 0 | NaN // 0 0 | Infinity // 0 0 | -Infinity // 0
!运算符 :非运算符常出现在布尔值的隐式转换中;
3、&& 和 || 运算 : 该逻辑运算(更形象地可以说是操作数选择器运算)会返回其中一个操作数:
a && b : 条件判断结果为 true, 则返回 第二个操作数 b;如果为 false, 则返回第一个操作数a;
a || b : 条件判断结果为true,返回第一个操作数,条件判断结果为 false, 返回第二个操作数;
这里有一个细节,a || b 的条件判断语句中,如果 a为true,则不会再继续执行 b;在这个特性下,可以做个小小的优化:
a ? a : b 可被优化为: a || b;
另外一个优化点就是我们熟知的短路写法: b && b(); var a = b || 'default'; 等。
4、== 和 ===
宽松相等(==)和严格相等(===)的区别在于,宽松相等允许在相等比较中进行强制类型转换。他们都会对值类型进行检查,区别在于类型不同时他们的处理方式。
以下是 == 操作的一些规则:
规则1:NaN 不等于 NaN;+0 等于 -0;
规则2:对象的比较方式为:两个对象指向同一个值时,即为相等,不发生强制类型转换
强制转换规则:
a、字符串和数字之间:字符串先被转换成数字,再进行比较
b、其他类型和布尔值之间:布尔值要先被转换为数字,再进行比较
c、null 和 undefined之间的相等比较:null == undefined // 返回true
d、对象和非对象之间的比较:对象会被先转换为标量基本类型(字符串/数字/布尔值),然后再进行比较;
下面看一些容易被迷惑的例子:
var a = null; var b = Object(null); a == b // false; null 没有对应的对象类型,故 d 相当于Object()创建的一个普通对象 var c = undefined; var d = Object(d); c == d // false undefined 没有对应的对象类型,故 d 相当于Object()创建的一个普通对象 var e = NaN; var f = Object(NaN); e == f // false f被包装为Number类型,拆封后为NaN,NaN == NaN // false"0" == false // true 根据规则 b , 布尔值跟其他值比较,要先把布尔值转换为数字,false -> 0; "0" == 0 为truefalse == "" // true 根据规则b, false 被转换为 0; 根据规则a,字符串 "" 也被转换为 0false == [] // true [] 先调用 valueOf,返回数组本身,继续调用 toString, 返回空字符串 ""; false == "" 为 truefalse == {} // false {} 先调用 valueOf,返回 {} ; 继续调用 toString, 返回字符串 "[object Object]" , false == "[object Object]" 为 false[] == ![] // true 首先计算 ![] 根据布尔值的转换规则,[] 为 true , 那么 ![] 则为false 即 [] == false 结果为 true2 == [2] // true [2] 调用 valueOf 返回数组对象[2], 继续调用toString, 返回 "2" , 2 == "2" 结果为 true"" == [null] // true 同样valueOf 返回数组对象 [null], toString 返回 "" ;0 == "\n" //true 空字符串,或者空格,都会被ToNumber转换为0"true" == true // false 这个简单, 布尔值会先被转换为Number, "true" == 1 结果为 false
5、关于 <= 和 >=
这次最让人意外的就是这俩操作符,我们来看个例子:
var a = {b: 42}; var b = {b: 43}; a < b // false; a > b // false; a == b // false; a <= b // true; a >= b // true;
所以 <= 和 >= 为什么都为true?
首先,a 和 b都会先被处理成字符串 "[object Object]", 故 > 和 < 比较都为 false;根据对象的 == 运算规则,地址一致为相等, 故 == 比较也为false;
根据 规范 a <= b 会被处理成 b < a, 然后将结果反转。因为 b < a 为 false, 故 a <= b 为 true;也就是说,js中的 <= 其实是 “不大于” 的意思。。。
另外,还有一些对数据类型做了转换的函数,也值得关注
1、parseInt() 显示解析数字字符串
和 Number的显示转换 不同,解析允许字符串中含有非数字字符,而Number显示转换则不允许:
Number("42px"); // NaN; 显示转换 parseInt("42px"); // 42 显示解析Number(""); // 0parseInt("") // NaN
parseInt针对的是字符串值,如果向parseInt传入了一些奇奇怪怪的参数,那转换结果也是会出乎意料的:
parseInt先将参数强制类型转换为字符串再进行解析
parseInt(0.000008) // 0 首先被转换为字符串“0.000008”;然后被解析出 0; parseInt(0.0000008) // 8 首先被转换为字符串“8e-7”, 然后被解析出 8 parseInt(false, 16) // 250 "false" 进行 16进制转换,前面的两个字母 “fa” 在16进制的字母内,被转换为250 parseInt(parseInt, 16) // 15 首先被解析为字符串“function (){}...” 首字母 “f” 以十六进制转换规则,被转换为十进制 15 parseInt("0x10") // 16 0x开头为16进制,所以只看后两位0*16^0+1*16^1=16,所以0x10=16 parseInt("103", 2) // 2 字符串103 以2进制规则转换,前两位 "10" 符合二进制数,被转换为 2, "3" 不在二进制表达范围内,故被舍弃,最终转换为十进制的结果为2;
最后,提一下es6中符号类型,它的强制转换都必须是显式的,但转换为布尔值除外;并且符号不能够被强制类型转换为数字:
var s1 = Symbol("cool"); String(s1) // "Symbol(cool)"; var s2 = Symbol("not cool"); s2 + "" ; // TypeError Boolean(s1) ; // true !!s1 // trueif(s1){ console.log('这条语句可以被执行');}
来源:https://www.cnblogs.com/solaZhan/p/12163033.html