摘要：，通過原型上的方法，判斷對象所屬類型數(shù)據(jù)的操作方法基本數(shù)據(jù)類型的所有方法操作都不改變原始值。對象類型的數(shù)據(jù)，操作過程中始終留意引用地址的中轉(zhuǎn)概念，其原型上方法有會改變和不改變原值的兩種類型。

基礎(chǔ)類型：string，number，boolean，undefined，null，symbol

對象類型：object

基礎(chǔ)類型為原始值，其值不能被修改；對象類型為引用類型，可以理解為指針，通過引用類型找到內(nèi)存中的地址，然后再進(jìn)行相關(guān)操作。

// 基本類型
var a = 10;
var b = a ;
a = 20;
console.log(b); // 10

// 對象類型
var c = { name:"hello"};
var d = c ;
c.name = "world";
console.log(d.name); // "world"

var str1 = "hello";
var str2 = new String("hello");
var str3 = `${"hello"}abc`

// 其他類型轉(zhuǎn)換成字符串
["h","e","l","l","o"].join(""); // "hello"
var num = 123;
num += "";
num.toString(); 
String(num); // "123"
String(true); // "true"

var num1 = 123;
var num2 = new Number(123);

var num3 = parseInt("12px"); // 12
var num4 = parseFloat("12.22px"); // 12.22
var num5 = Number("123");

var boo1 = true;
var boo2 = New Boolean(true);

var a = 1;
var boo2 = !!a; // true

var undef = undefined;
var a; 
a; // undefined

typeof，獲取值的所屬類型以字符串形式返回

typeof "hello"; // "string"
typeof 123; // "number"
typeof true; // "boolean"
typeof undefined; // "undefined"
typeof null; // "object" (特例1)
typeof Symbol("hello"); // "symbol"

typeof {a:1} ; // "object"
typeof function(){}; // "function" (特例2)

特例1，屬于基礎(chǔ)類型的 null 經(jīng)過 typeof 操作符操作后返回的是 object；特例2，函數(shù)隸屬于對象，typeof 操作直接返回 function。

instanceof，可以判斷通過 new 操作符生成的各種數(shù)據(jù)類型

var str = "hello";
str instanceof String ; // false
new String("hello") instanceof String; // true

// number，booelan 同理，(null,undefined,symbol沒有構(gòu)造函數(shù))
123 instanceof Number; // false
new Number(123) instanceof Number ; // true

true instanceof Boolean; // false
new Boolean(true) instanceof Boolean; // true

instanceof 的實(shí)質(zhì)是，判斷 instanceof 左邊對象的原型是不是在右邊對象的原型鏈中。

toString，通過 Object 原型上的 toString 方法，判斷對象所屬類型

Object.prototype.toString.call("hello"); // "[object String]"
Object.prototype.toString.call(123); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"
Object.prototype.toString.call(null); // "[object Null]"
Object.prototype.toString.call(undefined); // "[object Undefined]"
Object.prototype.toString.call(Symbol("hi")); // "[object Symbol]"

Object.prototype.toString.call(function(){}); // "[object Function]"
Object.prototype.toString.call([]); // "[object Array]"
Object.prototype.toString.call(new Date()); // "[object Date]"
Object.prototype.toString.call(/w+/); // "[object RegExp]"
Object.prototype.toString.call({}); // "[object Object]"

基本數(shù)據(jù)類型的所有方法操作都不改變原始值。
對象類型的數(shù)據(jù)，操作過程中始終留意引用地址的中轉(zhuǎn)概念，其原型上方法有會改變和不改變原值的兩種類型。

// 基本類型
var str = "hello";
str.toUpperCase(); // 僅返回值為 "HELLO"，并不是直接在原值上修改
console.log(str); // "hello"

// 對象類型
// 改變值
var arr1 = [1,2,3];
arr1.push(4); 
arr1; // [1,2,3,4]

// 不改變值
var arr2 = [5,6,7];
arr2.concat(arr1); // 返回 [5,6,7,1,2,3,4]
arr2; // [5,6,7]

// 引用地址示例
var arr3 = [8,9]; // arr3 實(shí)則對應(yīng)的是內(nèi)存中 [8,9] 數(shù)組的引用地址，比如 x0001
var arr4 = arr3; // arr4 為 arr3 的值，即為 x0001
arr4[0]= 10; // 在對地址進(jìn)行操作和讀值時，則又通過引用找到對應(yīng)的區(qū)域進(jìn)行讀寫操作
arr3; // [10，9]

引用類型可以簡單地類比成計算機(jī)中的快捷方式。

常用又較容易混淆的操作方法：

剪切

toFixed(length)，返回字符串；僅對小數(shù)點(diǎn)位后，做特定長度的截取，不夠長度則補(bǔ)0，四舍五入。

var num = 123.5368;
num.toFixed(2); // "123.54"
num.toFixed(1); // "123.5"
num.toFixed(6); // "123.536800"

slice 和 splice

var arr = [1,2,3,4,5,6,7,8];

// slice 
arr.slice(-4,-1); // [5,6,7]

// splice
var data = arr.splice(0,1,99); 
arr; // [99,2,3,4,5,6,7,8]
data; // [1]