JS有哪些基本数据范例呢？

值范例：undefined, Number, Boolean, String，null

援用范例：Object

值范例存放在栈中

援用范例将地点存放在栈中，将数据实体存放在堆中

null和undefined，not defined的区分？

not defined是未声明，当运用未声明变量时浏览器会抛出这个毛病

undefined是已声明未赋值，typeof undefined是undefined

null类似于空对象，是一个已定义，定义为空的值，typeof null 是 object

怎样推断数据范例？

假如是值范例，直接用typeof推断

假如是援用范例，运用instanceof推断，instanceof基于原型链，平经常使用于推断自定义对象

constructor是prototype上的一个属性，他轻易被重写掩盖，所以不可信任

Object.prototype.toString.call，挪用Object原型上的toString要领能够获得当前挪用者的详细范例

Object.prototype.toString.call().slice(8, -1); // Object|Array|Number|String|Boolean...

什么是原型链？

每个函数上都有一个prototype属性，称为原型对象

函数实例化发生对象

每个对象都有一个__proto__（藏匿原型）属性，指向组织它的原型对象。

原型对象本身也是对象，也有一个藏匿原型，指向它的原型对象。

沿着藏匿原型链终究会指向Object.prototype，它的原型对象是null

这就组成一个原型链

PS. 将原子范例赋给 prototype 的操纵将会被疏忽

function Foo() {}
Foo.prototype = 1; // 无效

instanceof的道理

A instanceof B
A的原型链是不是会抵达B.prototype

继续

经由过程原型链完成继续，原型对象上能够定义属性和要领。

当要在一个对象上寻觅某个属性，先在对象本身找，没有的话，再沿着原型链向上找原型对象里有无，向上查找找到为止，抵达顶部仍未找到，返回undefined

PS.推断对象上是不是有某个属性，而非其原型链上有，运用
hasOwnProperty 函数

实行高低文

在函数挪用时或许是全局代码最先运转时发生，处置惩罚的事变：变量声明，函数声明，函数声明情势的定义赋值，定义this，在函数内另有定义arguments的操纵

PS. arguments 变量不是一个数组（Array）。 只管在语法上它有数组相干的属性 length，但它不从 Array.prototype 继续，实际上它是一个对象（Object）。

因而，没法对 arguments 变量运用范例的数组要领，比方 push, pop 或许 slice。 虽然运用 for 轮回遍历也是能够的，然则为了更好的运用数组要领，最好把它转化为一个真正的数组。

Array.prototype.slice.call(arguments);

实行高低文栈

全局代码最先实行时，发生一个全局的实行高低文，压栈

代码实行到函数A挪用时，发生一个函数A的实行高低文，压栈

函数A中挪用函数B，发生一个函数B的实行高低文，压栈

函数B，实行终了，出栈烧毁实行高低文

函数A，实行终了，出栈并烧毁实行高低文

关于this的指向

this存在于实行高低文中

1. 作为组织函数挪用时，指向实例化的对象
2. 作为对象属性挪用时，指向对象
3. call, apply挪用时，指向参数指定高低文
4. 全局和一般函数都指向windows
5. ES6中，箭头函数本身没有this，致使以下三种征象：依据外层（函数或许全局）作用域来决议this，箭头函数不能作为组织函数运用，不能运用call, apply手动修正this

PS. 一些误会

// 1. 严厉根据范例
Foo.method = function() {
    // 在这，this是Foo的实例化对象
    function test() {
        // this 将会被设置为全局对象
    }
    test();
}

// 2. 函数别号
var test = someObject.methodTest;
test(); // this设置为全局对象

PS. apply和call的用法

function.apply(null, arguments);

function.call(null, arg1, arg2);

作用域

ES5中只需函数作用域的观点，作用域是一个假造观点，没有详细的数据范例或许构造。

一个函数的作用域在函数定义时肯定，建立函数的作用域成为该函数的上级作用域

在函数中寻觅变量，先找到函数作用域对应的实行高低文，在实行高低文中找变量。

没有找到的话，看上级函数作用域，向上查找到，找到为止。

假如找不到，则会抛出 ReferenceError非常。

PS. 比方，当接见函数内的 foo 变量时，JavaScript 会根据下面递次查找：

1. 当前作用域内是不是有 var foo 的定义。
2. 函数情势参数是不是有运用 foo 称号的。
3. 函数本身是不是叫做 foo。
4. 回溯到上一级作用域，然后从 #1 重新最先。

闭包

什么是闭包？
一个函数中有依靠外部变量，函数在建立它的作用域以外被挪用。
将会在实行高低文栈中保存上级作用域的实行高低文。
若在闭包运用终了以后不手动消除援用，相干实行高低文将会一向保存于实行高低文栈中，占有内存空间，若延续积聚，轻易形成内存走漏。

罕见运用，函数作为返回值，函数作为参数。

典范题目

for (var i = 0; i < 5; i++) {
    setTimeout(function() {  
      console.log(i);
      }, 1000);
} // 5，5，5，5，5

for (let i = 0; i < 5; i++) {
    setTimeout(function() {  
      console.log(i);
      }, 1000);
} // 0，1，2，3，4

for (var i = 0; i < 5; i++) {
    (function (i) {
        setTimeout(function() {  
          console.log(i);
          }, 1000);
    })(i)
} // 0, 1, 2, 3, 4

for(var i = 0; i < 5; i++) {
    setTimeout((function(e) {
        return function() {
            console.log(e);
        }
    })(i), 1000)
} // 0, 1, 2, 3, 4

JS中完成继续的要领

1. 基本继续

   var Bar = function () {};
   Bar.prototype = {
       greet: function (name) {
           console.log(name);
       }
   }
   var Foo = function () {}
   Foo.prototype.__proto__ = Bar.prototype;

   等价于

   var Bar = function () {};
   var Foo = function () {}
   Foo.prototype = new Bar();

   道理：完成原型链

   瑕玷：属性不自力

2. 组合继续

   var Bar = function (name) {
       this.name = name;
   }
   Bar.prototype = {
       greet: function () {
           console.log(this.name);
       }
   }
   var Foo = function (name) {
       Bar.apply(this, arguments);
   }
   Foo.prototype = new Bar();

   道理：把this属性赋值在子类的作用域实行一次，要领经由过程原型链继续
   瑕玷：this属性赋值举行了两次

3. 寄生组合式继续

   var Bar = function (name) {
       this.name = name;
   }
   Bar.prototype = {
       greet: function () {
           console.log(this.name);
       }
   }
   var Foo = function (name) {
       Bar.apply(this, arguments);
   }
   Foo.prototype = Object.create(Bar.prototype);
   Foo.prototype.constructor = Foo;

   道理： 把this属性赋值在子类的作用域实行一次，手动衔接原型对象的拷贝
   长处：处理组合继续的瑕玷

4. extends要领

   class Point {
       constructor(x, y) {
           this.x = x;
           this.y = y;
       }
       
       toString () {
           return this.x + ' ' + this.y;
       }
   }
   
   class ColorPoint extends Point {
     constructor(x, y, color) {
       super(x, y); // 挪用父类的constructor(x, y)
       this.color = color;
     }
   
     toString() {
       return this.color + ' ' + super.toString(); // 挪用父类的toString()
     }
   }

   子类本身的this对象，必须先经由过程父类的组织函数完成塑造，获得与父类一样的实例属性和要领，然后再对其举行加工，加上子类本身的实例属性和要领。假如不挪用super要领，子类就得不到this对象。

PS. new 运算符做了什么

// 1. 起首建立一个空对象
var o = new Object();
// 2. 将空对象的原型赋值为组织器函数的原型
o.__proto__ = A.prototype;
// 3. 变动组织器函数内部this，将其指向新建立的空对象
A.call(o);

范例转换

强迫转换

1. 转为字符串:：.toString(), String()

2. 转为数值：Number针对一切范例，parseInt和parseFloat针对字符串

   字符串转换为数字的经常使用要领：

   +'010' === 10
   Number('010') === 10
   parseInt('010', 10) === 10  // 用来转换为整数
   
   +'010.2' === 10.2
   Number('010.2') === 10.2
   parseInt('010.2', 10) === 10
   parseFloat('10.1.2') === 10.1 // 字符转换为浮点数
   
   Number(undefined) // NaN
   Number严厉转换，只需有一个字符没法转为数值输出NaN
   parseInt道理为从左往右读字符串，读到非数值字符为止
   parseFloat道理为从左往右读字符串，读到第二个小数点或许非数值非小数点字符为止

3. 转为布尔值：Boolean()，””、null、undefined、+0、-0 和 NaN 转为布尔型是 false，其他的都是 true

自动转换

1. 转为字符串：包含字符串的+法运算，'5' + 1 === '51'
2. 转为数值：不包含字符串的算术运算
3. 转为布尔值：前提语句推断，非运算

事宜轮询机制

主线程运转时发生堆和实行栈

主线程以外，还存在一个”使命行列”。只需异步使命有了运转结果，就在”使命行列”当中安排一个事宜。

一旦”实行栈”中的一切同步使命实行终了，体系就会读取”使命行列”，看看内里有哪些事宜。对应的异步使命，完毕守候状况，进入实行栈，最先实行

使命行列

使命行列分为宏使命行列和微使命行列

• 宏使命包含：script(全局使命), setTimeout, setInterval, setImmediate, I/O, UI rendering。
• 微使命包含: new Promise().then(回调), process.nextTick, Object.observe(已烧毁), MutationObserver(html5新特征)

实行同步使命 -> 处置惩罚微使命行列 -> 处置惩罚宏使命行列里队首使命 -> 处置惩罚微使命行列

Promise.resolve().then(()=>{
  console.log('Promise1')  
  setTimeout(()=>{
    console.log('setTimeout1')
  },0)
})
setTimeout(()=>{
  console.log('setTimeout2')
  Promise.resolve().then(()=>{
    console.log('Promise2')    
  })
  Promise.resolve().then(()=>{
  console.log('Promise3')    
  })
},0)
setTimeout(()=>{
  console.log('setTimeout4')
  Promise.resolve().then(()=>{
    console.log('Promise4')    
  })
},0)

Output: Promise1 setTimout2 Promise2 Promise3 setTimeout4 Promise4 setTimeout1

setTimeout和setInterval的区分

setTimeout：发生一个宏使命，在指定时候以后到场使命行列。

setInterval：轮回发生宏使命，但存在题目，若使命实行时候善于指定时候距离，会发生堆叠实行结果。