(隐式) 类型转换

一。

1，假如比较的是字符串：按位比较。字符编码：ASCII 码 A：65 a:97

数字<大写字母<小写字母

"98">"A"   //false     按位进行比较，9<A(65)

2.js是一个基于原形的动态类型的弱类型的脚本语言。

弱类型：声明变量的时候不需要给定数据类型，代码执行的时候灵活的改变类型。

动态类型：类型之间没有严格的隔离的，使用不同的类型进行计算：最终结果一定是6大类型之一。在运算过程中进行转换：A数据类型 =》B数据类型。如：123 =》“123”。

二.隐式类型转换。只是基本数据类型（数值，字符串，布尔，null,undefined,）和复杂数据类型（对象）

本质上不会改变原来的变量的值，只是在运算的时候，悄悄地转成能够计算的值。所以叫隐式类型转换

let a = 1
console.log(a + "1")   //11
console.log(a)  //1

1.转字符串：数据类型转换的桥梁（如果直接转别的类型不可以，则可以通过先转成字符串，再转对应类型）。

（1）数值类型转字符串。加法运算符中如果有字符串参与到加法中，会将数值转为字符串。

1 + ""   //"1"
1/0 // Infinity
1/-0  //-Infinity
-0 + "" // "0"   0分为0和-0，在某些运算的时候可能不一样
Infinty + ""  //"Infinity"
Infinity + ""  // "-Infinity"
NaN + ""  //"NaN"
-NaN +""  //"NaN"
le+300 + ""  //"le300"
oxff + ""  //255   会先转成十进制
"1" + 2 + 3  //"123"
3+2+"1"  //"51"
3+"2"+1  //"321"

（2）布尔类型转字符串。

true=》“true”

false=>“false”

(3) undefined转字符串

undefined=>“undefined”

(4)null转字符串

null=>“null”

(5)对象转字符串。分为多种情况。简单的理解：String() 反回字符串

eg：String(123)   //"123"
  String([1,2,3])  //"1,2,3"
  String({})    //""

1）。普通情况.自己手写的都会转换成"[object Object]"。如果是自带的或者dom结构中的其他内容，值可能不一样

{ } =》"[object Object]"

（{}+""）  //"[object Object]"

原理：任何一个对象身上都有一个toString方法,调用自己的这个方法就返回了字符串。

let obj1 = { }
obj1 + ""  //"[object Object]"
let obj2 ={
  toString:function(){
      return 666
  }
}
obj2 + ""   //"666"    //调用了自己身上toString方法

2）数组：[1,2,3,4,]转字符串。

直接去掉【】，然后加上字符串

[1,2,3,4,] + ""   //"1,2,3,4"
[] + ""  // ""
[].toString != {}.toString    //他两使用toString方法不一样

调用自身toString 方法.

let arr=[]
arr.toString = functioin(){
    return 123
}
arr + ""     //"123"

3)函数。转字符串，直接把代码拼接起来，

let foo = function(){}
foo +""    //"function(){}"

调用toString方法
foo.toString = () =>"666"
foo + ""  //"666"

2.转数值类型：

Number 强制转换成数值类型

Number("123")  //123
Number(undefined)  //NaN
Number(null)  //0
Number("")  //0

字符串转数值： - ， * ，/

"123" - 0   //123

如果字符串看上去像数值，则可以直接转。

"Infinity" - 0   //Infinity
"1.2.3" -0    //NaN
"123"  //123

布尔类型转数值。true=>1,false=>0

true -false    //1
true +true     //2
true-false -1   //0

对象转数值。普通对象：一般是不能直接转换成数值的。但是在代码底层中还是调用的是toString的方法。首先会尝试value0f的方法，如果不行然后才是toString，如果返回的不是数值那么他会再试一次

Nuber({})   //NaN
Number({toString:function(){return 1}})  //1

var obj = {
  toString:function(){
     return 123
  }
}
Number(obj)  //123

Number({toString:function(){return "234"}})   //234
Number({toString:function(){return true}}) //1
Number({
    toString:function(){
        return toString:function(){
             return 3
        }}})   //报错

let o = {
  valueOf:function(){
    return 4
  },
  toString:function(){
     return 3
  }
}    //4  优先执行它真正的方法

特殊对象转数值。

Number([])     //0
Number("")     //0
Number([9527])   //9527
Number([9527,12])  //NaN  因为这会转成Number("9527,12"),这不是数字

数组转数值。先toString转字符串，然后尝试字符串转数值。

函数转数值，转不了

3.转布尔类型。

“” 0 NaN false null undefined 这是会转成false的。其余为true

来源：CSDN

作者：快乐的二进制鸭

链接：https://blog.csdn.net/qq_41973526/article/details/104496928

标签

tostring

强制类型转换

字符串函数