数据类型转化、数据类型判断-优快云博客

本文链接：https://blog.youkuaiyun.com/Jsjdjbxjjwjd/article/details/146481716

赋值符运算都具有右结合性，操作符运算从左到右结合性
a=b=c=1 分解为 c=1 b=c a=b
a&&b 分解为a为true，执行b,a为false,不执行b

var a = { k1: 1 };
var b = a;
a.k3 = a = { k2: 2 };
console.log(a); //   {K2:2}
console.log(b); //   {K1:1,k3:{K2:2}}
    
分解为：
var a
var b
a={K1:1}
b=a
a.k3={k2:2}  //a、b指向同一堆内存，相互影响
a={k2:2}     //a指向新的堆，不影响b
创建一个对象a，并赋值为{k1: 1}。
创建一个变量b，并将a赋值给b，这时b和a都指向同一个对象。
对a进行修改，首先给a添加一个新的属性k3，然后将a的值修改为一个新的对象{k2: 2}。这时，a和b的引用关系变为：a指向新的对象{k2: 2}，b仍然指向原来的对象{k1: 1, k3: {k2: 2}}。

显示转换
Number()
parseInt()
String()
Boolean()

隐式转换
比较运算（==、!=、>、<）、if、while需要布尔值地方
算术运算（+、-、*、/、%）

var a='123'+1   //124
var a='123k'+1  //123k1
var a=true + 1  //2
var a=null + 1  //1
var a=undefined +1 //NaN
var a=NaN+1 //NaN

isNaN //先Number转换再跟NaN比较

console.log(isNaN(NaN))  // true
console.log(isNaN(123))  // false
console.log(isNaN('a'))  // true
console.log(isNaN(null))  // false
console.log(isNaN(undefined))  // true

自动转换为布尔值
在需要布尔值的地方，就会将非布尔值的参数自动转为布尔值，系统内部会调用Boolean函数
可以得出个小结：
undefined，null，false，+0，0，-0，NaN，""
除了上面几种会被转化成false，其他都换被转化成true

自动转换成字符串
遇到预期为字符串的地方，就会将非字符串的值自动转为字符串
具体规则是：先将复合类型的值转为原始类型的值，再将原始类型的值转为字符串
常发生在+运算中，一旦存在字符串，则会进行字符串拼接操作

自动转换成数值
除了+有可能把运算子转为字符串，其他运算符都会把运算子自动转成数值
Number(null) --> 0
Number(undefined) --> NaN
typeof(NaN) --> number
parseInt(true) --> NaN
parseInt(null) --> NaN
parseInt(undefined) --> NaN
parseInt(NaN) --> NaN

等于操作符（==）在比较中会先进行类型转换，再确定操作数是否相等
两个都为简单类型，字符串和布尔值都会转换成数值，再比较
简单类型与引用类型比较，对象转化成其原始类型的值，再比较
两个都为引用类型，则比较它们是否指向同一个对象
null 和 undefined 相等
存在 NaN 则返回 false

//如果任一操作数是布尔值，则将其转换为数值再比较是否相等
let result1 = (true == 1); //1==1 -> true
//如果一个操作数是字符串，另一个操作数是数值，则尝试将字符串转换为数值，再比较是否相等
let result1 = ("55" == 55); //55==55 -> true
//如果一个操作数是对象，另一个操作数不是，则调用对象的 valueOf()方法取得其原始值，再根据前面的规则进行比较
let obj = {valueOf:function(){return 1}}
let result1 = (obj == 1); // true

{} 的 valueOf 结果为 {} ，toString 的结果为 "[object Object]"
[] 的 valueOf 结果为 [] ，toString 的结果为 ""

数组==值数组转成数字/字符串 [5]==5,['5']==5,[5]=='5',['5']=='5'
引用==值引用类型转化为原始类型 {a:5} == '[object,object]'
值==值比较类型再转数字比大小
字符串==数字字符串先转数字再比较 '5'==5
其他==布尔值布尔值先转数字再比较 true==1 false==0，[]==![]

[]==![] //true //等号右边![]是false,[]==false,[]通过valueOf()\toString转化为''''==false,两边转数字0==0
null == undefined
对象 == 非对象非对象是 number,string,对象就原始类型比较，对象比较 valueOf，toString 方法原始类型比较 ['5','6']=='5,6'

== 在比较两个不同类型的值时会发生强制类型转换，而===不会
两者如果是表达式，先计算表达式。
1==2>1 先计算等号旁边的表达式 1==true，转化为1==1
两者中有一个是对象类型，则该对象类型执行ToPrimitive后再进行比较。
1==[] //false
两者都是基本类型，判断类型是否相同，不同，则同时执行ToNumber后再比较。
true==1 //true
特殊情况，null==underfined，两者在==比较中只与对方和自己本身相等。

ToPimitive：执行该对象的valueOf函数，如果结果为基本类型则直接返回，否则返回该对象的toString函数的执行结果。
ToNumber：转化为数字类型。
[]toString转化为'',{}toString转化为'Object Object'
console.log('0' == false) // true
console.log(0 == false) // true
console.log('' == false) // true
console.log([] == false) // true
console.log('' == 0) // true
console.log('' == []) // true
console.log(0 == []) // true

console.log(null==undefined)  //true
console.log(null == 0)   //false   null>0  null<0  也为false
console.log(undefined == 0)   //false  undefined>0 undefined<0  为false
console.log(NaN==NaN) // false  NaN===NaN 为false
console.log(NaN==null) // false  NaN===null为false
console.log(NaN==undefined) // false  NaN===undefined为false

数据类型
基本类型：string,number,boolean,null,undefined,symbol,Bigint
引用类型：Object(Array，Object，Date，RegExp)

js数据类型判断一共有四种方法
typeof、instanceof、constructor、Object.prototype.toString.call()
typeof:(适用于基本数据类型，function，除了null)

console.log(typeof "");            // string
console.log(typeof 1 );            // number
console.log(typeof NaN );          // number
console.log(typeof true);          // boolean
console.log(typeof undefined);     // undefined
console.log(typeof function(){});  // function
console.log(typeof isNaN);         // function
console.log(typeof Symbol());      // symbol
console.log(typeof 123n);          // bigint
console.log(typeof []);            // object
console.log(typeof {});            // object
console.log(typeof null);          // object
console.log(typeof new Date());    // object
console.log(typeof new RegExp());  // object

instanceof (引用类型用来比较一个对象是否为某一个构造函数的实例.instanceof 检测的是原型）

console.log(12 instanceof Number);                 // false
console.log('22' instanceof String);               // false
console.log(true instanceof Boolean);              // false
console.log(null instanceof Object);               // false
console.log(undefined instanceof Object);          // false
console.log(function a() {} instanceof Function);  // true
console.log([] instanceof Array);                  // true
console.log({a: 1} instanceof Object);             // true
console.log(new Date() instanceof Date);           // true

constructor（引用类型对象都有一个constructor属性 null 和 undefined 是没有 constructor 存在的）

console.log('22'.constructor === String)             // true
console.log(true.constructor === Boolean)            // true
console.log([].constructor === Array)                // true
console.log(document.constructor === HTMLDocument)   // true
console.log(window.constructor === Window)           // true
console.log(new Number(22).constructor === Number)   // true
console.log(new Function().constructor === Function) // true
console.log(new Date().constructor === Date)         // true
console.log(new RegExp().constructor === RegExp)     // true
console.log(new Error().constructor === Error)       // true

Object.prototype.toString.call(）

console.log(Object.prototype.toString.call(1))          // [object Number]
console.log(Object.prototype.toString.call(1n))         // [object BigInt]
console.log(Object.prototype.toString.call('123'))      // [object String] console.log(Object.prototype.toString.call(true))       // [object Boolean]
console.log(Object.prototype.toString.call(undefined))  // [object Undefined]
console.log(Object.prototype.toString.call(null))       // [object Null]
console.log(Object.prototype.toString.call({}))         // [object Object]
console.log(Object.prototype.toString.call([]))         // [object Array]
console.log(Object.prototype.toString.call(function a() {}))  // [object Function]
console.log(Object.prototype.toString.call(Symbol()))         // [object Symbol]
console.log(Object.prototype.toString.call(Math))             // [object Math]
console.log(Object.prototype.toString.call(JSON))             // [object JSON]
console.log(Object.prototype.toString.call(new Date()))       // [object Date]
console.log(Object.prototype.toString.call(new RegExp()))     // [object RegExp]
console.log(Object.prototype.toString.call(new Error))        // [object Error]
console.log(Object.prototype.toString.call(window)            // [object Window]
console.log(Object.prototype.toString.call(document))         // [object HTMLDocument]

typeof(typeof(true))   // string   typeOf()转化完就是string
console.log(2>1>3);  //2>1返回true，true>3,布尔值true转化为1，1>3返回false
console.log(null == undefined) //true
console.log(null === undefined) //false
[]==![]  //true  //等号右边![]是false,[]==false,[]通过valueOf()\toString转化为'',''==false,两边转数字0==0