关于js你必须掌握的数据类型转换
//关于数据类型转换
Number()
/*
1、undefined NaN
2、null 0
3、布尔值 true为1，false为0
4、字符串
1、空字符串，空格字符串转为0
2、非空字符串，并且内容为纯数字（包含进制与科学表示法）转成对应的数字
3、其余都是NaN
5、数字 原来的数字
6、对象
1、对象、函数转成NaN
2、空数组转为0，数组里只有一个数据并且这个数据能转成数字，则转成对应的数字，其它都转成NaN
*/
console.log(
Number(undefined), //NaN
Number(null), //0
Number(true), //1
Number(false), //0
Number(''), //0
Number(' '), //0
Number('12'), //12
Number('012'), //12
Number('0xff90'), //65424
Number('5e5'), //500000
Number('k'), //NaN
Number({}), //NaN
Number([]), //0
Number(function(){}), //NaN
Number(['']), //0
Number([2]), //2
Number(['2']), //2
Number([2,3]), //NaN
);
/*
String()
1、基本数据类型、null、undefined的结果就是给数据加上引号变成字符串
2、对象
1、数组的结果为把所有中括号去掉，外面加个引号
2、对象的结果为'[object Object]'
3、函数的结果为在函数整体外面加个引号
*/
console.log(
String(null), //'null'
String([1,[2]]), //1,2
String(function(){}), //function(){}
String({}), //[object Object]
);
/*
Boolean()
1、undefined false
2、null false
3、数字
+0、-0、NaN转布尔值的结果为false，其它的转布尔值的结果为true
4、布尔值 转为对应的值
5、字符串
空字符串转布尔值的结果为false，其它（包括空格字符串）的都转成true
6、对象转布尔值都是true
*/
console.log(
Boolean(''), //false
Boolean(' '), //true
Boolean('0'), //true
);
const data=[
{type:'数字',value:10},
{type:'字符串',value:'kaivon'},
{type:'布尔值',value:true},
{type:'数组',value:[1,2]},
{type:'函数',value:function(){}},
{type:'对象',value:{a:10,b:20}}
]
/*
valueOf 返回对象对应的原始值
toString 返回对象的字符串的表现形式
*/
//console.dir(Function);
/*
1、数字、字符串、布尔值
valueOf 数据本身（原始值形式）
toString 数据转成字符串的形式
2、数组
valueOf 数据本身（对象形式）
toString 去掉中括号，外面加个引号（本质为调用数组join(',')后的结果）
3、函数
valueOf 数据本身（对象形式）
toString 在数据外面加了个引号
4、对象
valueOf 数据本身（对象形式）
toString "[object Object]"
*/
for(var i=0;i<data.length;i++){
console.log(data[i].type+'的valueOf的结果为',data[i].value.valueOf());
console.log(data[i].type+'的toString的结果为',data[i].value.toString());
}
//Number方法
//1、调用对象的valueOf方法。如果返回原始类型的值，再使用Number函数，不再进行后续步骤
//2、如果valueOf方法返回的还是对象，则调用toString方法
//3、如果toString方法返回原始类型的值，则对该值使用Number方法，不再进行后续步骤
//4、如果toString方法后返回的是还是对象，就报错（一般不会出现）
var obj={a:12};
obj.valueOf=function(){
//alert('你调用了valueOf方法了！');
//return 88; //Number(88)=88
//return '88'; //Number('88')=88
return {a:12};
};
obj.toString=function(){
//alert('你调用了toString方法了');
// return 60; //Number(60)=60
//return '60'; //Number('60')=60
return "[object Object]";
}
console.log(Number(obj)); //NaN
//String
/*
String参数为对象的转换原理
1、调用对象的toString方法。如果返回原始类型的值，再使用String函数，不再进行后续步骤
2、如果toString方法返回的还是对象，再调用对象的valueOf方法
3、如果valueOf方法返回原始类型的值，则对该值使用String函数，不再进行以下步骤
4、如果valueOf方法返回的是还是对象，就报错（一般不会出现）
*/
var obj1={a:12};
obj1.toString=function(){
//alert('你调用了toString方法了');
return "[object Object]"; //String(90)='90'
}
obj1.valueOf=function(){
alert('你调用了valueOf方法了！');
return 'kaivon';//String('kaivon');
};
console.log(String(obj1)); //[object Object]
/*
隐式类型转换出现场景
1、不同类型的数据间运算、比较
2、对非布尔值类型的数据求布尔值
3、条件语句的括号里
隐式转数字出现的场景
1、数学运算符（+ - * / %），但是加号运算里不能出现字符串或对象类型数据
2、一元+-（正负操作符）后的数据
3、某些比较运算符
*/
console.log(
1+undefined, //NaN
1+null, //1
null+undefined, //NaN
true+false, //1+0=1
3+'6', //'36'
2+[], //'2'
2+{a:12}, //'2[object Object]'
[]+{}, //'[object Object]'
{}+[],
3+{},
{}+3
);
console.log(
[]-5, //-5
'a'-'b' //NaN-NaN=NaN
);
console.log('6'*[]); // 6*0
console.log(null%true); //0%1=0
console.log(true/[7]); //1/7=0.14285714285714285
console.log("A"-"A"+2); //NaN
console.log(1,2,3); //1 2 3
console.log((1,2,3)); //3
/*
隐式转字符串出现场景
1、有字符串的加法运算
2、有对象的加法运算
3、某些比较运算符
4、调用alert、document.write方法
*/
console.log(
'1'+2, //'12'
'20'+'k', //'1k'
'1'+undefined, //'1undefined'
'1'+[], //'1'
'1'+{}, //'1[object Object]'
);
console.log(
2+[2,3], //22,3
2+function(){}, //'2'+'function(){}'='2function(){}'
2+{}, //'2[object Object]'
);
console.log(
[]+{}, //[object Object]
{}+null,
[]+undefined, //'undefined'
);
//alert({a:12});
//alert(function(){});
document.write({a:12});
console.log(++[[]][+[]]+[+[]]); //'10'
/*
++[[]][+[]]+[+[]]
++[[]][+[]] + [+[]]
++[[]][+[]] + [+[]]
++[[]][0] + [+[]]
++[] + [+[]]
++0 + [+[]]
1 + [+[]]
1 + [0]
'1' + '0'='10'
*/
/*
隐式转布尔值出现场景
1、取反运算
1、1个叹号表示，把这个数据转成布尔值后取它的反值
2、2个叹号表示，把这个数据转成布尔值
2、三目运算符
3、条件语句的小括号里
4、逻辑运算符
*/
var data=[10,'kaivon',true,null,undefined,function(){},{a:12},[0,1]];
for(var i=0;i<data.length;i++){
//console.log(!data[i]);
//console.log(!!data[i]);
//console.log(data[i]?20:30);
if(data[i]){
console.log(1);
}
}
var a=[0];
if([0]){
console.log(a==true); //1
}else{
console.log('kaivon'); //2
}
/*
大小比较
1、如果比较两边有字符串，那会对比它们各自对应的Unicode码值
Unicode码值查询地址 http://tool.oschina.net/encode
2、如果比较两边都为原始类型数据，那把所有数据转成数字进行对比
NaN与任何数据对比都是false
3、有对象数据的比较，先调用valueOf再调用toString方法，然后看另一数据的类型，如果另一个数据为字符串，则转为字符串对比，如果另一个数据为数字则转为数字对比
总结：
1、字符串与字符串、字符串与对象、对象与对象比较时，都会转成字符串，然后对比Unicode码值
2、其它类型数据，转成数字对比
*/
console.log(
'A'>'a', //false 65>97
'大'>'小', //false 22823>23567
);
console.log(
true>false, //true
'k'>5, //false NaN
undefined>false, //false NaN
null>='' //true 0>=0
);
console.log(
[]>0, //false 0>0
{}>1, //false NaN
{}>true, //false NaN
{}>'[', //[object Object]>[ 91>91
);
console.log(
{a:12}<function(){}, //true '[object Object]'<'function(){}' 91<102
);
//console.log(1+ +'2')
//'1'+ +2
//转数字
console.log(
12=='12', //true 12==12
0=='', //true 0==0
1==true, //true 1==1
2==false, //false 2==0
'true'==true, //false NaN==1
' '==false, //true //0==0
);
console.log(
undefined==0, //false
undefined=='', //false
undefined==false, //false
undefined==undefined, //true
null==0, //false
null=='', //false
null==false, //false
null==undefined, //true
);
console.log(
[1]==1, //true '1'==1 1==1
[]==0, //true ''==0 0==0
[1]==true, //true '1'==true 1==1
[1,'a',3]=='1,a,3', //true '1,a,3'=='1,a,3'
[]==undefined, //false
{a:1}==1, //false '[object Object]'==1 NaN==1
[null]==null, //false
);
console.log(
[]==[],
{}=={}
);
var fn1=function(){
return 1;
}
var fn2=function(){
return 1;
}
var fn3=fn1;
console.log(fn1==fn2); //false
console.log(fn1==fn3); //true
/*
相等比较
1、不同类型的原始类型数据，把所有的数据转成数字后进行对比
2、null与undefined除了它们自己与自己、自己与对方相等，与其它的任何数据都不相等
3、对象与原始类型数据比较时，把对象转成原始值，再进行比较
4、对象与对象类型比较时，比较的是他们的引用地址，除非引用地址相同，否则都不相等
总结：
1、原始类型对比，转成数字对比
2、对象类型对比，把对象转成字符串，然后看对方的类型，如果不一样，都转成数字对比。对象与对象比较，比较引用地址
3、null与undefined，自己与自己、自己与对方相等。与其它任何数据都不相等
*/
//逻辑比较
//&& ||
console.log('kaivon' && 2 + 1);
console.log(![] && '你好！siri!'); //false
var n1=1;
n1-1&&(n1+=5);
console.log(n1); //1
function fn1(){
console.log('陈');
}
n1==1&&fn1();
/* if(n1==1){
fn1();
} */
console.log(true&&'kaivon'&&(3-2)&&'abc'&&true&&(2+2)); //4
console.log('change'||2+1); //change
var n2=1;
n2-1||(n2+=5);
console.log(n2); //6
function fn3(text){
text=text||'kaivon';
console.log(text);
}
fn3('陈');
</script>
浙公网安备 33010602011771号