基礎數(shù)據(jù)類型判斷
typeof 用于返回值的類型
typeof 1; //number
typeof '1'; //string
//instaceOf - 對于區(qū)分對象和數(shù)組
//typeof 不好使了
typeof {}; //object
typeof []; //object
//使用instaceOf
console.log([] instanceof Array);//true
console.log([] instanceof Object);//true,
console.log({} instanceof Array);//false
判斷null 的方法
var a = null;
(!a && typeof a === "object"); //true
關于NaN - 非數(shù)字數(shù)值類型
console.log(typeof NaN === "number"); //true NaN 是number
console.log(NaN === NaN); //false NaN 和任何東西都不相等，甚至它自己
console.log(isNaN('123')) //false isNaN在判斷類型的時候，會首先將它轉為Number，注意是使用Number(), 而不是parseInt(),轉化之后再判斷isNaN
console.log(isNaN({})) // true {}無法轉為數(shù)字
console.log(isNaN('uuu'));//true
什么是JS的包裝類型
在javascript中， 基本類型式沒有屬性和方法的，但是為了便于操作基本類型的值，在調用基本類型的屬性或方法時 Javascript會在后臺隱式的將基本類型的值轉換位對象
const a = "abc";
a.length; //3
a.toUpperCase(); //"ABC"
在訪問abc.length 時， Javascript將’abc' 在后臺轉換成String('abc')，然后再訪問其length屬性
任何new 出來的都是實例對象 ， 比如
var tt = new Boolean(false);
console.log(tt); //Boolean{false} 它是一個對象
如何使用Object.prototype.toString 來判斷值的類型，為什么使用它可以判斷值的類型？
在任何值上調用Object.prototype.toString 方法，都會返回一個[object NativeConstructorName] 格式的字符串。每個類在內部都有一個[[Class]] 屬性， 這個屬性中就指定了上述字符串中的構造函數(shù)名。
Object.prototype.toString.call({name:'Jack'}) //[object object]
Object.prototype.toString.call(function(){}) //[object Function]
Object.prototype.toString.call(/name/) //[object RegExp]
Object.prototype.toString.call(null); //"[object Null]"
Object.prototype.toString.call(undefined); //"[object Undefined]"
基本類型值式沒有構造函數(shù)的，為什么也能返回構造函數(shù)名呢？ 這是因為在toString被調用時， Javascript 將基本類型值轉換成了包裝類型
javascript中如何進行顯式類型轉換
Javascript的類型轉換的結果總是得到string、number和boolean類型的一種
string和number的相互轉換
const a = 18
const b = String(18) //'18'
const c = Number(b) //18
// 字符串變成number也可以像下面這樣
const a1 = 18
const b = a.toString()
const a = '18'
const b = +a //18
const a2 = '18px'
const b2 = parseInt(a2) //18
const c = Number(a2) //NaN
可以看出，parseInt 與 Number 不同的地方在于， parseInt允許傳入非數(shù)字字符，其從左往右解析，遇到非數(shù)字字符就會停下， 而Number不允許傳入非數(shù)字字符
任意值轉換boolean
使用Boolean函數(shù)來顯式地將任意值轉為boolean
const a = '123'
const b = undefined
const c = 0;
Boolean(a) //true
Boolean(b) //false
Boolean(c) //false
//實踐中最常用的方法是使用!! 符號
const a = '123'
const b = undefined
const c = 0
!!a //true
!!b //false
!!c //false
注意題目中的類型轉換是這種形式：String(123), 而不是這樣： new String(123), 因為第一個才是進行包裝類型轉換，而第二個是生成實例
關于一元操作符+ 還有一個用法，那就是將日期對象轉換成number
var date = new Date("Mon, 1Mar 2020 08:53:06")
+date //1583013186000
JavaScript 中如何進行隱式類型轉換
以下是基本類型的值在不同操作符的情況下隱式轉換的規(guī)則
- 操作符
當+操作符的兩邊有至少一個string 類型變量時，兩邊的變量都會被隱式轉換為字符串；其它情況下兩邊的變量都會被轉換為“數(shù)字”
- 操作符
1+'23' //'123'
1+false //1
1+true //2
'1' + false //'false'
false + true //1
2.-、*、\ 操作符
這三個操作符時為數(shù)字操作而設計的， 所以操作符兩邊的變量都會被轉換成數(shù)字， 注意NaN也是一個數(shù)字
1*'23' //23
1*false //0
1/'aa' //NaN
3.對于==操作符
操作符兩邊的值都盡量轉成number
3 == true //false, 3 轉為number為3，true 轉為number為1
'0' == false // true, '0' 轉為number為0， false轉為number 為0
'0' == 0 //true
- 對于 < 和 > 比較符
如果兩邊都是字符串，則比較字母表順序：
'ca' < 'bd' //false
'a'<'b' //true
其它情況下，轉換為數(shù)字再比較：
'12' < 13 //true
false > -1 //true
以上說的是基本類型的隱式轉換，而對象會被ToPrimitive 轉換為基本類型再進行轉換：
var a = {}
a>2 //false
其對比過程如下：
a.valueOf() // {}
a.toString() //"[object Object]", 現(xiàn)在是一個字符串了
Number(a.toString()) //NaN, 根據(jù)上面< 和 > 操作符的規(guī)則，要轉換成數(shù)字
NaN > 2 //false 得出比較結果
再來個例子
var a = {name:'Jack'}
var b = {age:18}
a+b //"[object Object][object Object]"
運算過程如下：
a.valueOf() //{}
a.toString() //"[object Object]"
b.valueOf() //{}
b.toString() //"[object Object]"
a + b //"[object Object][object Object]"
