摘要：所以我們又可以得出一個(gè)結(jié)論原型的屬性指向構(gòu)造函數(shù)，構(gòu)造函數(shù)又通過屬性指回原型，但是并不是所有函數(shù)都具有這個(gè)屬性，就沒有這個(gè)屬性。

boolean number string null undefined symbol
原始類型儲(chǔ)存的都是值，是沒有函數(shù)可以調(diào)用的，undefined.toString() 顯示報(bào)錯(cuò)，
但是"1".toString() // "1" ； 是因?yàn)?1"被強(qiáng)制轉(zhuǎn)換成了string類型，已經(jīng)不是原始類型而是對(duì)象類型了；
用typeOf可以判斷除了null的原始類型，typeOf null // OBJECT
判斷null為object類型，其實(shí)這是js的一個(gè)bug， JS的最初版使用32位系統(tǒng)，為了性能考慮使用低位儲(chǔ)存變量信息，000開頭表示對(duì)象，而null都是0，所以判斷null顯示為對(duì)象。

再JS中除了原始類型之外都是對(duì)象類型，原始類型儲(chǔ)存的是值，而對(duì)象類型儲(chǔ)存的是地址(指針),

const a = [];

我們假設(shè)常量a的指針是#001， 那么#001存放了值是[];

const a = [];
const b = a;
b.push(1);

根據(jù)上面所說，我們將常量a的值賦給b，其實(shí)是將a的指針傳給了b,即b也變成了#001，
那么當(dāng)我們改變b的值其實(shí)是改變了#001的值，同樣會(huì)導(dǎo)致a的值發(fā)生變化；

接下來我們看看函數(shù)參數(shù)是對(duì)象的情況來看看

function test(person) {
  person.age = 26
  person = {
    name: "yyy",
    age: 30
  }

  return person
}
const p1 = {
  name: "wpp",
  age: 25
}
const p2 = test(p1)
console.log(p1) // -> ?
console.log(p2) // -> ?

答案是什么呢？
我們來分析一下
首先，函數(shù)傳參是傳遞對(duì)象指針的副本，
到函數(shù)內(nèi)部修改參數(shù)的屬性這步，p1的值也被修改了，
但是我們重新為person分配了一個(gè)對(duì)象時(shí)就出現(xiàn)了分歧，
所以最后person擁有了一個(gè)新的指針，也就和p1沒有任何關(guān)系了，導(dǎo)致最終兩個(gè)的值是不一樣的。

typeOf對(duì)于原始類型除了null之外都能正確判斷，而對(duì)于判斷對(duì)象，除了函數(shù)都會(huì)顯示object，所以我們不能使用typeOf來判斷對(duì)象的類型；
如果我們想去判斷一個(gè)原始類型我們可以使用instanceof來判斷；其內(nèi)部機(jī)制是通過原型鏈來判斷的
對(duì)于原始類型我們直接使用instanceof來判斷是不行的，當(dāng)然我們還要辦法使用instanceof來判斷原始類型；

class PrimitiveString {
  static [Symbol.hasInstance](x) {
    return typeof x === "string"
  }
}
console.log("hello world" instanceof PrimitiveString) // true

你可能不知道 Symbol.hasInstance 是什么東西，其實(shí)就是一個(gè)能讓我們自定義 instanceof 行為的東西，以上代碼等同于 typeof "hello world" === "string"，所以結(jié)果自然是 true 了。這其實(shí)也側(cè)面反映了一個(gè)問題， instanceof 也不是百分之百可信的。

誰最后調(diào)用了this，this就指向誰

function foo() {
  console.log(this.a)
}
var a = 1
foo()

const obj = {
  a: 2,
  foo: foo
}
obj.foo()

const c = new foo()

我們來分析一下上面的級(jí)格場景

直接調(diào)用foo() ,this指向windows;

obj.foo obj最后調(diào)用foo，this指向obj;

對(duì)于new來說this被綁定在了c上面。不會(huì)被改變；

接下來我們看看箭頭函數(shù)中的this指向情況，

function a() {
  return () => {
    return () => {
      console.log(this)
    }
  }
}
console.log(a()()())

首先箭頭函數(shù)其實(shí)是沒有 this 的，箭頭函數(shù)中的 this 只取決包裹箭頭函數(shù)的第一個(gè)普通函數(shù)的 this。在這個(gè)例子中，因?yàn)榘^函數(shù)的第一個(gè)普通函數(shù)是 a，所以此時(shí)的 this 是 window。另外對(duì)箭頭函數(shù)使用 bind 這類函數(shù)是無效的。

最后種情況也就是 bind 這些改變上下文的 API 了，對(duì)于這些函數(shù)來說，this 取決于第一個(gè)參數(shù)，如果第一個(gè)參數(shù)為空，那么就是 window。
以上就是 this 的規(guī)則了，但是可能會(huì)發(fā)生多個(gè)規(guī)則同時(shí)出現(xiàn)的情況，這時(shí)候不同的規(guī)則之間會(huì)根據(jù)優(yōu)先級(jí)最高的來決定 this 最終指向哪里。

首先，new 的方式優(yōu)先級(jí)最高，接下來是 bind 這些函數(shù)，然后是 obj.foo() 這種調(diào)用方式，最后是 foo 這種調(diào)用方式，同時(shí)，箭頭函數(shù)的 this 一旦被綁定，就不會(huì)再被任何方式所改變。

對(duì)于 == 來說，如果對(duì)比雙方的類型不一樣的話，就會(huì)進(jìn)行類型轉(zhuǎn)換
對(duì)于 === 來說就簡單多了，就是判斷兩者類型和值是否相同

簡單來講就是函數(shù)A內(nèi)有函數(shù)B，并且函數(shù)B可以訪問到函數(shù)A中的變量，函數(shù)B就叫做閉包。
JS中閉包存在的意義是什么呢？
是為了讓我們間接訪問到函數(shù)內(nèi)部的變量，
一個(gè)面試經(jīng)典問題

for (var i = 1; i <= 5; i++) {
  setTimeout(function timer() {
    console.log(i)
  }, i * 1000)
}

首先因?yàn)?setTimeout 是個(gè)異步函數(shù)，所以會(huì)先把循環(huán)全部執(zhí)行完畢，這時(shí)候 i 就是 6 了，所以會(huì)輸出一堆 6。
第一種方式

for (var i = 1; i <= 5; i++) {
  ;(function(j) {
    setTimeout(function timer() {
      console.log(j)
    }, j * 1000)
  })(i)
}

第二種方式

for (let i = 1; i <= 5; i++) {
  setTimeout(function timer() {
    console.log(i)
  }, i * 1000)
}

直接使用let來代替var 也能解決這個(gè)問題

我們了解了對(duì)象類型在賦值的過程中其實(shí)是復(fù)制了地址，從而會(huì)導(dǎo)致改變了一方其他也都被改變的情況。通常在開發(fā)中我們不希望出現(xiàn)這樣的問題，我們可以使用淺拷貝來解決這個(gè)情況

首先可以通過 Object.assign 來解決這個(gè)問題，很多人認(rèn)為這個(gè)函數(shù)是用來深拷貝的。其實(shí)并不是，Object.assign 只會(huì)拷貝所有的屬性值到新的對(duì)象中，如果屬性值是對(duì)象的話，拷貝的是地址，所以并不是深拷貝。

let a = {
  age: 1
}
let b = Object.assign({}, a)
a.age = 2
console.log(b.age) // 1

我們還可以使用...運(yùn)算符來解決這個(gè)問題

let a = {
  age: 1
}
let b = { ...a }
a.age = 2
console.log(b.age) // 1

通常淺拷貝就能解決大部分問題了，但是當(dāng)我們遇到如下情況就可能需要使用到深拷貝了

let a = {
  age: 1,
  jobs: {
    first: "FE"
  }
}
let b = { ...a }
a.jobs.first = "native"
console.log(b.jobs.first) // native

淺拷貝只解決了第一層的問題，如果接下去的值中還有對(duì)象的話，那么就又回到最開始的話題了，兩者享有相同的地址。要解決這個(gè)問題，我們就得使用深拷貝了。

這個(gè)問題通?？梢酝ㄟ^ JSON.parse(JSON.stringify(object)) 來解決。
但是這個(gè)方法也有局限性

會(huì)忽略u(píng)ndefined

會(huì)忽略symbol

不能序列化函數(shù)

不能解決循環(huán)引用的問題

但是大部分情況這個(gè)方法都可以適用

每個(gè) JS 對(duì)象都有 proto 屬性，這個(gè)屬性指向了原型。這個(gè)屬性在現(xiàn)在來說已經(jīng)不推薦直接去使用它了，這只是瀏覽器在早期為了讓我們訪問到內(nèi)部屬性 [[prototype]] 來實(shí)現(xiàn)的一個(gè)東西。
好像還是沒有弄明白什么是原型，接下來讓我們再看看 proto 里面有什么吧。

看到這里我們會(huì)發(fā)現(xiàn)原型也是對(duì)象，并且這個(gè)對(duì)象中包含了很多函數(shù)，所以我們可以得出一個(gè)結(jié)論：對(duì)于 obj 來說，可以通過 proto 找到一個(gè)原型對(duì)象，在該對(duì)象中定義了很多函數(shù)讓我們來使用。
在上面的圖中我們還可以發(fā)現(xiàn)一個(gè) constructor 屬性，也就是構(gòu)造函數(shù)
打開 constructor 屬性我們又可以發(fā)現(xiàn)其中還有一個(gè) prototype 屬性，并且這個(gè)屬性對(duì)應(yīng)的值和先前我們在 proto 中看到的一模一樣。所以我們又可以得出一個(gè)結(jié)論：原型的 constructor 屬性指向構(gòu)造函數(shù)，構(gòu)造函數(shù)又通過 prototype 屬性指回原型，但是并不是所有函數(shù)都具有這個(gè)屬性，F(xiàn)unction.prototype.bind() 就沒有這個(gè)屬性。

https://juejin.im/post/5c4fdb...
原型的詳細(xì)介紹

再JS中類型轉(zhuǎn)換只分三種情況：
轉(zhuǎn)換成布爾值，轉(zhuǎn)換成數(shù)字，轉(zhuǎn)換成字符串；