摘要：值類型是將變量的值存在內(nèi)存中。說明幾種不同的使用場(chǎng)景作為構(gòu)造函數(shù)對(duì)象屬性普通函數(shù)執(zhí)行，創(chuàng)建個(gè)標(biāo)簽，點(diǎn)擊時(shí)彈出對(duì)應(yīng)序號(hào)如何理解作用域自由變量作用域鏈，即自由變量的尋找閉包的兩個(gè)場(chǎng)景。

//值類型
var a=100
var b=a
a=200
console.log(b) //100
//引用類型
var a={age:20}
var b=a
b.age=21
console.log(a.age) //21

// Numbers
typeof 37 === "number";
typeof 3.14 === "number";
typeof Math.LN2 === "number";
typeof Infinity === "number";
typeof NaN === "number"; // 盡管NaN是"Not-A-Number"的縮寫
typeof Number(1) === "number"; // 但不要使用這種形式!
// Strings
typeof "" === "string";
typeof "bla" === "string";
typeof (typeof 1) === "string"; // typeof總是返回一個(gè)字符串
typeof String("abc") === "string"; // 但不要使用這種形式!
// Booleans
typeof true === "boolean";
typeof false === "boolean";
typeof Boolean(true) === "boolean"; // 但不要使用這種形式!
// Symbols
typeof Symbol() === "symbol";
typeof Symbol("foo") === "symbol";
typeof Symbol.iterator === "symbol";
// Undefined
typeof undefined === "undefined";
typeof declaredButUndefinedVariable === "undefined";
typeof undeclaredVariable === "undefined"; 
// Objects
typeof {a:1} === "object";
// 使用Array.isArray 或者 Object.prototype.toString.call
// 區(qū)分?jǐn)?shù)組,普通對(duì)象
typeof [1, 2, 4] === "object";
typeof new Date() === "object";
// 下面的容易令人迷惑，不要使用！
typeof new Boolean(true) === "object";
typeof new Number(1) ==== "object";
typeof new String("abc") === "object";
// 函數(shù)
typeof function(){} === "function";
typeof Math.sin === "function";
//NaN
typeof 1/0 === "NaN";
//null
typeof null === "object";

//邏輯運(yùn)算符
console.log(10 & 0) //0  轉(zhuǎn)換為true&&0
console.log(""||"abc") //abc  轉(zhuǎn)換為false||"abc"
console.log(!window.abc) //true  !undefined為true
//if語句 false情況
null "" false 0 NaN undefined
//判斷一個(gè)變量是否當(dāng)作true或者false
var a = 100
console.log(!!a)

1.JS中使用typeof能得到哪些類型
undefined null string number object function boolean symbol
2.何時(shí)使用"==="，何時(shí)使用"=="
參考jQuery源碼 只有這種情況下使用"==":

if(obj.a == null) {
}
//這句相當(dāng)于obj.a === null || obj.a === undefined

3.JS有哪些內(nèi)置函數(shù)
Object Array String Number Function Boolean Date RegExp Error
4.JS變量按照存儲(chǔ)方式分為哪些類型，并描述其特點(diǎn)
值類型、引用類型。
值類型是將變量的值存在內(nèi)存中。
引用類型的變量是真實(shí)變量的指針（對(duì)象、數(shù)組、函數(shù)）?？梢詿o限擴(kuò)張屬性。
5.如何理解JSON
是JavaScript的對(duì)象，內(nèi)置兩個(gè)方法 JSON.stringify JSON.parse

function Foo(name, age) {
  this.name = name
  this.age = age 
  this.class = "class-1"
  //return this  默認(rèn)有這行
}

var f = new Foo("zs", 20)

//執(zhí)行過程：1.new函數(shù)執(zhí)行時(shí)this會(huì)變成空對(duì)象 2.this. 的時(shí)候賦值 3.return this 4.給f賦值


//var a = {}         ===> var a = new Object()
//var a =[]          ===> var a = new Array()
//function Foo(){}   ===> var Foo = new Function()
//instanceof 用于判斷一個(gè)函數(shù)是否是一個(gè)變量的構(gòu)造函數(shù)

//所有的引用類型（數(shù)組、對(duì)象、函數(shù)）都具有對(duì)象特性，除了null之外，都可以自由擴(kuò)展屬性
//所有的引用類型 都有__proto__ 隱式原型
//所有的函數(shù)都有 prototype 顯式原型   屬性值也是一個(gè)普通對(duì)象
//所有的引用類型（數(shù)組、對(duì)象、函數(shù)），__proto__屬性值指向它的構(gòu)造函數(shù)的prototype屬性值
var obj = {}; obj.a = 100
var arr = []; arr.a = 100
function fn () {}
fn.a = 100

console.log(obj.__proto__)
console.log(arr.__proto__)
console.log(fn.__proto__)

console.log(fn.prototype)

console.log(obj.__proto__ === Object.prototype)


//試圖得到一個(gè)對(duì)象的某個(gè)屬性時(shí)，如果這個(gè)對(duì)象本身沒有這個(gè)屬性，那么會(huì)去它的__proto__(構(gòu)造函數(shù)的prototype)中尋找
function Foo(name, age) {
  this.name = name
}

Foo.prototype.alertName = function () {
  alert(this.name)
}

var f = new Foo("zs")
f.printName = function () {
  console.log(this.name)
}

f.printName()
f.alertName()

//instanceof 是用于判斷引用類型屬于哪個(gè)構(gòu)造函數(shù)的方法
//構(gòu)造函數(shù)
function Foo(name, age) {
  this.name = name
}

Foo.prototype.alertName = function () {
  alert(this.name)
}

//創(chuàng)建實(shí)例
var f = new Foo("zs")
f.printName = function () {
  console.log(this.name)
}


f.printName()
f.alertName()
f.toString()


// f instanceof Foo 判斷過程：
// f 的 __proto__一層層往上找到是否對(duì)應(yīng)Foo.prototype
// 再判斷f instanceof Object

直角矩形是構(gòu)造函數(shù) 圓角矩形是對(duì)象

var obj={
x:100,
y:200,
z:300
}
var key
for(key in obj){
//hasOwnProperty會(huì)返回一個(gè)布爾值，判斷是否是原生的屬性，以此來排除原型鏈上的屬性
if(obj.hasOwnProperty(key)){
  console.log(key,obj[key]);
}
}
//x 100
//y 200
//z 300

6.如何準(zhǔn)確判斷一個(gè)變量是數(shù)組函數(shù)

var arr = []
arr instanceof Array
typeof arr //object, typeof 是無法判斷是否是數(shù)組的

7.寫一個(gè)原型鏈繼承的例子

function Elem(id) {
  this.elem = document.getElementById(id)
}

Elem.prototype.html = function (val) {
  var elem = this.elem
  if (val) {
    elem.innerHTML = val
    return this
  } else {
    return elem.innerHTML
  }
}

Elem.prototype.on = function (type, fn) {
  var elem = this.elem
  elem.addEventListener(type, fn)
  return this
}

var div1 = new Elem("wrapper")
div1.html("
hello
").on("click", function () {
  alert("clicked")
}).html("
javascript
")

8.描述new一個(gè)對(duì)象的過程

//創(chuàng)建一個(gè)對(duì)象
//this指向這個(gè)對(duì)象
//執(zhí)行代碼  即對(duì)this賦值
//返回this
function Foo(name, age) {
  this.name = name 
  this.age = age
  this.class = "class-1"
  //return this   構(gòu)造函數(shù)最好不要寫return
}

var f = new Foo("zs", 20)

//執(zhí)行上下文：當(dāng)前被執(zhí)行代碼的環(huán)境/作用域
console.log(a)
var a = 100

fn("zs")
//函數(shù)聲明
function fn(name) {

  console.log(this)
  console.log(arguments)

  age = 20
  console.log(name, age)
  var age

  bar(100)

  function bar(num) {
    console.log(num)
  }
}
//函數(shù)表達(dá)式： var fn = function () {}


//在全局代碼執(zhí)行前，會(huì)將變量定義和函數(shù)聲明先提出來
//在函數(shù)代碼執(zhí)行前，會(huì)將變量定義，函數(shù)聲明，this，arguments(所有參數(shù)的集合)先提出來

//this的值執(zhí)行時(shí)才能確定
var a = {
  name: "A",
  fn: function () {
    console.log(this.name)  //這個(gè)階段的this無法確定值
  }
}


a.fn()                  //this === a
a.fn.call({name: "B"})  //this === {name: "B"}
var fn1 = a.fn
fn1()                   //this === window

//作為構(gòu)造函數(shù)執(zhí)行
function Foo(name) {
  // this = {}
  this.name = name
  // return this
}
var f = new Foo("zs")
//作為對(duì)象屬性執(zhí)行
var obj = {
  name: "A",
  printName: function () {
    console.log(this.name)    //這里this就是obj
  }
}
obj.printName
//作為普通函數(shù)執(zhí)行
function fn() {
  console.log(this)       //這里的this就是window
}
fn
//call apply bind
function fn1(name, age) {
  console.log(name)
  console.log(this)       //這里的this是{x:100}
}
fn1.call({x:100}, "zs", 20)


var fn2h = function fn2(name, age) {
  console.log(name)
  console.log(this)       //這里的this是{y:200}
}.bind({y:200})
fn2("zs", 20)

//不斷向父級(jí)作用域?qū)ふ易兞康倪^程形成了作用域鏈
//沒有塊級(jí)作用域概念
if (true) {
  var name = "zs"
}
console.log(name)


//函數(shù)、全局作用域
var a = 10
function fn() {
  var a = 200
  console.log("fn", a)
}
console.log("global", a)
fn()


var b = 100
function fn() {
  var c = 200

  console.log(b)  //當(dāng)前作用域沒有定義的變量叫做自由變量
  console.log(c)  
}
fn()

var a = 100
function f1() {
  var b = 200
  function f2() {
    var c = 300

    console.log(a)
    console.log(b)
    console.log(c)
  }
  f2()
}
f1()
//哪個(gè)作用域定義了f1這個(gè)函數(shù),f1的父級(jí)作用域就是誰

//閉包應(yīng)用：1.函數(shù)作為返回值
function F1() {
  var a = 100

  //返回一個(gè)函數(shù)  
  return function () {
    console.log(a)     //100
  }
}

//f1得到一個(gè)函數(shù)
var f1 = F1()
var a = 200
f1()


//2.函數(shù)作為參數(shù)傳遞
function F1() {
  var a = 100
  return function() {
    console.log(a)  //100
  }
}

var f1 = F1()

function F2(fn) {
  var a = 200
  fn()
}
F2(f1)

9.說一下對(duì)變量提升的理解
變量定義、函數(shù)聲明會(huì)提前。
10.說明this幾種不同的使用場(chǎng)景
作為構(gòu)造函數(shù)、對(duì)象屬性、普通函數(shù)執(zhí)行，call apply bind
11.創(chuàng)建10個(gè)標(biāo)簽，點(diǎn)擊時(shí)彈出對(duì)應(yīng)序號(hào)

var i
  for (i = 0; i < 10; i++) {
    (function (i) {
      var a = document.createElement("a")
      a.innerHTML = i + "
"
      a.addEventListener("click", function (e) {
        e.preventDefault()
        alert(i)
      })
      document.body.appendChild(a)
    })(i)
  }

function isFirstLoad() {
  var _list = []
  return function (id) {
    if (_list.indexOf(id) >=0) {
      return false
    } else {
      _list.push(id)
      return true
    }
  }
}

var firstLoad = isFirstLoad()
console.log(firstLoad(10))
console.log(firstLoad(10))
console.log(firstLoad(20))
console.log(firstLoad(20))