js04----数据类型转化

2.2.3 数据类型转化

强制类型转换：指将一个数据类型强制转换为其他的数据类型。

包含三种转换：转换为字符串类型；转换为数字型；转换为布尔型

2.2.3.1、转换为字符串类型

（1）toString()方法

let a1 = 1;
a1 = false;
a1 = true;
//a1 = undefined; //没有toString()方式
//a1 = null;
let c3 = Object.prototype.toString.call(a1);

let a2 = a1.toString();//类型转换成string

let c4 = Object.prototype.toString.call(a2);
console.log(`原值：${a1},原值的类型是${c3}`);//原值：true,原值的类型是[object Boolean]
console.log(`新值：${a2},新值的类型是${c4}`);//新值：true,新值的类型是[object String]

（2）String()

let b1 = 1;
b1 = true; //更新b1的值
b1 = undefined;
//b1 = null;
let c1 = Object.prototype.toString.call(b1)

let b2 = String(b1);//类型转换成string

let c2 = Object.prototype.toString.call(b2);
console.log(`原值：${b1},原值的类型是${c1}`); //原值：undefined,原值的类型是[object Undefined]
console.log(`新值：${b2},新值的类型是${c2}`); //新值：undefined,新值的类型是[object String]

（3）拼接字符串（隐式转换）

let d1 = 1;
d1 = true;
d1 = undefined;
d1 = null;
let e1 = Object.prototype.toString.call(d1);

let d2 = d1 + ''; //类型转换成string

let e2 = Object.prototype.toString.call(d2);
console.log("原值3："+d1+",原值3的类型:"+e1); //原值3：null,原值3的类型:[object Null]
console.log("新值3:"+d2+",新值3的类型:"+e2); //新值3:null,新值3的类型:[object String]

2.2.3.2、转换为数字型（重点）

（1）、 使用Number()函数

字符串–>数字

1:如果是纯数字的字符串，则直接将其转换为数字

2:如果字符串中有非法的数字的内容，则转换为NaN

3:如果字符串是一个空串，或者全是空格的字符串，则转换为0

//方式一、调用Number(变量)函数
let a1 = 'hello'; //NaN
//除了空串，其它字符串转number,都是NaN
//a1 = '你好'; //NaN
//a1 = ''; //0
a1 = 'abc'; //NaN
a1 = '123'; //123
//a1 = true; //1 //布尔值转成number,true为1，false为0
// a1 = false; //0

//a1 = undefined; //NaN //undefined转成number,为NaN
//a1 = null; //0 //null转成number,为0

let p1 = Object.prototype.toString.call(a1);
//进行类型转换
let a2 = Number(a1);
let p2 = Object.prototype.toString.call(a2);
console.log(`原值：${a1},原值的类型是${p1}`);
console.log(`新值：${a2},新值的类型是${p2}`);

（2）、parseInt(变量)：取有效整数

（3）、parseFloat(变量)：取有效浮点数

注意：如果对非String使用parseFloat()跟parseInt(),它会先将其转换为String，然后再操作

let b1 = '123abc';
b1 = "abc123"; //abc123
b1 = true; //'true'
b1 = undefined; //undefined
b1 = null; //null
b1 = "1.23abc"; //1.23abc
//b1 = false; //false
let q1 = Object.prototype.toString.call(b1);
let b2 = parseInt(b1); //取整
let b3 = parseFloat(b1); //取浮点数

let q2 = Object.prototype.toString.call(b2);
let q3 = Object.prototype.toString.call(b3);
console.log(`原值：${b1},原值的类型是${q1}`);//原值：1.23abc,原值的类型是[object String]
console.log(`新值：${b2},新值的类型是${q2}`);//新值：1,新值的类型是[object Number]
console.log(`新值：${b3},新值的类型是${q3}`);//新值：1.23,新值的类型是[object Number]

（4）、- * / 隐式转换

利用算术运算 – * / 隐式转换为数值型

let a = "123";
a = a – 10; //113
a = a / 1; //123
a = a * 1; //123
console.log(a, typeof a);

（5）、正号 隐式转换

/* 方式五、 正号+隐式转换 */
let e1 = "hello";
e1 = "123";
e1 = "";
e1 = undefined;
e1 = null;
e1 = true;
e1 = false;
let x1 = Object.prototype.toString.call(e1);
let e2 = +e1;
let x2 = Object.prototype.toString.call(e2);
console.log(`原值5：${e1},原值类型5：${x1}`); //原值5：false,原值类型5：[object Boolean]
console.log(`新值5：${e2},新值类型5：${x2}`); //新值5：0,新值类型5：[object Number]

2.2.3.3、转换为布尔型

Boolean()函数转布尔值

//方式一、Boolean()函数转布尔值
let a1 = 1;
let b1 = Object.prototype.toString.call(a1);
let a2 = Boolean(a1);
let b2 = Object.prototype.toString.call(a2) ;
console.log("原值"+a1+",原值类型"+b1); //原值1,原值类型[object Number]
console.log("现在值"+a1+",现在值类型"+b2); //现在值1,现在值类型[object Boolean]

两次取反 !!双非

//方式二、隐式转换（双非）
let c1 = 1;
c1 = 0;
c1 = '';
c1 = "12abc";
//c1 = undefined;

let d1 = Object.prototype.toString.call(c1);
let c2 = !!c1; //类型转换
let d2 = Object.prototype.toString.call(c2) ;
console.log("原值:"+c1+",原值类型:"+d1); //原值:12abc,原值类型:[object String]
console.log("现在值"+c2+",现在值类型"+d2); //现在值true,现在值类型[object Boolean]

面试题1：

布尔值为false的几种情况？

答：0，'',false,undefined,null,NaN