V8引擎(一)

const name = 'licodeao';
 
//	Parse(解析) = 词法分析 + 语法分析
1.词法分析：
    词法分析类似切割，将一段代码分成几部分
    JS代码经过Parse中的词法分析后
    					↓
    生成一个tokens数组，并且数组里面是一个个对象(类似JSON)，tokens = []
    					↓
    词法分析从左到右依次分析代码
        			↓
    遇见const时，会将它解析为关键字类型，并往tokens数组中添加
    tokens: [{ type: 'keyword', value: 'const' }]
    					↓
    随后遇见name，将它解析为标识符类型，往tokens数组中添加
    tokens: [
      { type: 'keyword', value: 'const'},
      { type: 'identifier', value: 'name' }]
    					↓
    再往后遇见'licodeao'，将它解析为字面量类型，往tokens数组中添加
    此时tokens: [
      { type: 'keyword', value: 'const'},
      { type: 'identifier', value: 'name' },
      { type: 'literal', value: 'licodeao'}]
2.语法分析：
	得益于词法分析的类切割效果，tokens数组中存储的是一个个对象，那么接下来就会对这些对象进行语法分析
    				↓
 	进而生成一个AST(抽象语法树)

// 过程概述
	语法分析生成了AST抽象语法树之后，再通过ignition转换器，将抽象语法树中的各个语法，转换为对应的字节码
	此时V8引擎就会将字节码转换为不同平台上的CPU指令
// 那么，如何执行这些CPU指令呢？
	在上一步中，字节码会先被转为汇编代码，通过汇编代码去执行CPU指令，进而得到最开始的JS代码的运行结果
	字节码 -> 汇编代码 -> 通过汇编代码执行CPU指令 -> 运行结果
	因此，实际上在字节码被转换为运行结果之间，需要被转换为汇编代码

// 过程概述
在JS代码中，可能会有部分函数被执行多次
    				↓
那么此时ignition会将该函数标记为hot(热函数)，并交给TurboFan进行转换
    				↓
转换为对应的MachineCode(优化的机器码)
    				↓
那么当下次再执行该函数时，即可不通过转换，就能直接执行机器指令，得到运行结果，提高了性能
--------------------------------------------------------------------------------------------------------
但会出现一个问题，例如一个sum求和函数
 
  function sum(num1, num2) {
    return num1 + num2;
  }
  sum(20,10) -> 第一次调用sum函数，参数为Number类型
  sum(30,20) -> 第二次调用sum函数，参数为Number类型，此时被ignition标记为hot(热函数)
  sum('aaa','bbb') -> 第三次调用sum函数，参数为String类型
 
第二次调用sum函数时，被ignition标记为hot(热函数)，交给TurboFan(编译器)转换为对应的MachineCode(优化机器码)
// 第三次调用sum函数时，会不用通过TurboFan转换，直接执行机器指令吗?
显然不会!
此时，问题出现了，前两次传的是Number类型，并返回的是一个Number类型
而第三次调用sum函数时，传的是String类型，那么此时返回的是字符串拼接的结果，显然与之前转换成的机器码相悖了
 
// 那么，如何解决这种传递不同类型参数的问题呢？
	V8引擎提供了一个Deoptimization(反向优化)的解决方案，这也是相比较于5.9版本之前的V8引擎所增添的一点
	当遇到了不同类型参数的问题时，V8引擎就会将原来的MachineCode(优化机器码)通过Deoptimization(反向优化)转换为bytecode(字节码),因为之前的MachineCode(优化机器码)不能正确地处理运算!
      							↓
  			bytecode(字节码)转换为汇编代码
      							↓
  				通过汇编代码去执行CPU指令
      							↓
    						 运行结果
解决了这问题，必然得浪费一点性能(因为执行了反向优化的过程)
 
// 假如用TypeScript重写sum函数，是否能提高一点性能呢？
function sum(num1:number, num2:number) {
    return num1 + num2;
}
	答案在某种意义上来说，是肯定的,因为TypeScript的强类型使得sum函数只能传递同样类型的参数，这就符合上面说的第一种情况，即没有出现传递不同类型参数的问题。

// 过程概况
1.首先Blink内核会将源码交给V8引擎，Stream获取到源码并且进行编码转换
      							↓
2.Scanner(词法分析器)会进行词法分析(lexical analysis)，将代码转换成tokens数组
      							↓
3.通过语法分析，将tokens转换成AST树，此时经过Parser和PreParser(预解析):
	// Parser就是直接将tokens转换成AST树架构
  // PreParser是预解析，为什么需要预解析呢？
  	1.并不是所有的JavaScript代码，在一开始时就会被执行。那么对所有的JavaScript代码进行解析，必然会影响网页的运行效率
    2.因此V8引擎就实现了Lazy Parsing(延迟解析)的方案，它的作用是将不必要的函数进行预解析，也就是只解析暂时需要的内容，而对函数的全量解析是在函数被调用时才会进行。
    // example
    function foo() {
      function sum() {
        var i = 0;
        console.log(i)
      }
    }
    foo()
		就如上方的代码，foo函数被调用了，执行该函数。
      							↓
    V8引擎会查看foo函数内部的成员，于是发现了sum函数，但sum函数并没有被调用，因此V8引擎知道了foo函数内部有个sum函数，但不会去管sum函数，先晾在一旁。也就是说：在foo函数内部定义了一个sum函数，那么sum函数就会进行预解析(大白话就是看到了不管它,因为sum函数没有被调用)
      							↓
4.生成AST树后，会被Ignition转换器转成字节码bytecode，字节码再转成汇编代码，通过汇编代码去运行不同平台上的CPU指令得到运行结果