Merge branch 'master' of https://git.coding.net/mart_13221097537/Front-End-Interview-Map

# Conflicts:
#	Framework/framework-zh.md

Author: YuChengKai

Algorithm/algorithm-ch.md

@@ -26,6 +26,8 @@
     - [前驱节点](#%E5%89%8D%E9%A9%B1%E8%8A%82%E7%82%B9)
     - [后继节点](#%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9)
   - [树的深度](#%E6%A0%91%E7%9A%84%E6%B7%B1%E5%BA%A6)
+- [动态规划](#%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92)
+  - [斐波那契数列](#%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 

JS/JS-en.md

@@ -2,28 +2,40 @@
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
 **Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
 
-      - [Built-in Types](#built-in-types)
-      - [Typeof](#typeof)
-      - [New](#new)
-      - [This](#this)
-      - [instanceof](#instanceof)
-      - [scope](#scope)
-      - [Closure](#closure)
-      - [Prototypes](#prototypes)
-      - [inheritance](#inheritance)
-      - [Deep and Shallow Copy](#deep-and-shallow-copy)
-        - [shallow copy](#shallow-copy)
-        - [deep copy](#deep-copy)
-      - [the differences between call, apply, bind](#the-differences-between-call-apply-bind)
-        - [simulation to implement   `call` and  `apply`](#simulation-to-implement---call-and--apply)
-      - [Promise implementation](#promise-implementation)
-      - [Throttle](#throttle)
+- [Built-in Types](#built-in-types)
+- [Typeof](#typeof)
+- [Type Conversion](#type-conversion)
+  - [Converting to Boolean](#converting-to-boolean)
+  - [Objects to Primitive Types](#objects-to-primitive-types)
+  - [Arithmetic Operators](#arithmetic-operators)
+  - [`==` operator](#-operator)
+  - [Comparison Operator](#comparison-operator)
+- [New](#new)
+- [This](#this)
+- [Instanceof](#instanceof)
+- [Scope](#scope)
+- [Closure](#closure)
+- [Prototypes](#prototypes)
+- [Inheritance](#inheritance)
+- [Deep and Shallow Copy](#deep-and-shallow-copy)
+  - [Shallow copy](#shallow-copy)
+  - [Deep copy](#deep-copy)
+- [The differences between call, apply, bind](#the-differences-between-call-apply-bind)
+  - [simulation to implement   `call` and  `apply`](#simulation-to-implement---call-and--apply)
+- [Promise implementation](#promise-implementation)
+- [Throttle](#throttle)
 - [Map、FlapMap and Reduce](#mapflapmap-and-reduce)
-- [async and await](#async-and-await)
+- [Async and await](#async-and-await)
+- [Proxy](#proxy)
+- [Why 0.1 + 0.2 != 0.3](#why-01--02--03)
+- [Regular Expressions](#regular-expressions)
+  - [Metacharacters](#metacharacters)
+  - [Flags](#flags)
+  - [Character Shorthands](#character-shorthands)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
-#### Built-in Types
+# Built-in Types
 JavaScript defines seven built-in types, which can be broken down into two categories: `Primitive Type` and `Object`.
 
 There are six primitive types: `null` , `undefined` , `boolean` , `number` , `string` , `symbol `.
@@ -120,7 +132,7 @@ ToPrimitive([]) == 0
 1. If it's an object, `toPrimitive` is used.
 2. If it's a string, `unicode` character index is used to compare.
 
-#### Typeof
+# Typeof
 
  `typeof` can always display the correct type of the primitive types, except `null`
 ```js
@@ -160,7 +172,77 @@ let undefined = 1
 a === void 0
 ```
 
-#### New
+# Type Conversion
+
+## Converting to Boolean
+
+Except `undefined`， `null`， `false`， `NaN`， `''`， `0`， `-0`, all of the values, including objects, are converted to `true`.
+
+## Objects to Primitive Types
+
+When objects are converted, `valueOf` and `toString` will be called, respectively in order. These two methods can also be overridden.
+
+```js
+let a = {
+    valueOf() {
+        return 0
+    }
+}
+```
+
+## Arithmetic Operators
+
+Only for additions, if one of the parameters is a string, the other will be converted to the string as well. For all other operations, as long as one of the parameters is a number, the other will be converted to a number.
+
+Additions will invoke three types of type conversions: to primitive types, to numbers, and to string.
+
+```js
+1 + '1' // '11'
+2 * '2' // 4
+[1, 2] + [2, 1] // '1,22,1'
+// [1, 2].toString() -> '1,2'
+// [2, 1].toString() -> '2,1'
+// '1,2' + '2,1' = '1,22,1'
+```
+
+Note the expression `'a' + + 'b'` for addition.
+
+```js
+'a' + + 'b' // -> "aNaN"
+// since ++ 'b' -> NaN
+// You might have seen + '1' -> 1
+```
+
+## `==` operator
+
+![](https://user-gold-cdn.xitu.io/2018/3/30/16275cb21f5b19d7?w=1630&h=1208&f=png&s=496784)
+
+`toPrimitive` in the above figure is converting objects to primitive types.
+
+`===` is usually recommended to compare to values. However, if you would like to know if a value is `null`, you can use `xx == null`.
+
+Let's take a look at an example `[] == ![] // -> true`. The following explains why the expression evaluates to `true`.
+
+```js
+// [] converting to true, then take the opposite to false
+[] == false
+// with #8
+[] == ToNumber(false)
+[] == 0
+// with #10
+ToPrimitive([]) == 0
+// [].toString() -> ''
+'' == 0
+// with #6
+0 == 0 // -> true
+```
+
+## Comparison Operator
+
+1. If it's an object, `toPrimitive` is used.
+2. If it's a string, `unicode` character index is used to compare.
+
+# New
 
 1.   Create a new object
 2.   Chained to prototype
@@ -226,7 +308,7 @@ new (Foo.getName());
 For the first function, `Foo.getName()` is executed first, so the result is 1;
 As for the latter, it firstly executes `new Foo()` to create an instance, then finds the `getName` function on `Foo` via the prototype chain, so the result is 2.
 
-#### This
+# This
 
 `This`, a concept that many people will confuse, is not difficult to understand, as long as you remember the following rules
 
@@ -271,7 +353,7 @@ console.log(a()()());
 Actually , the arrow function does not have `this` , `this` in the above function only depends on the first function outside that is not arrow function . In above case , `this` is default to `window` because calling `a` matches the first situation in the above codes . And , what `this` is bound to will not be changed by any code once `this` is bound to the context
 
 
-#### instanceof
+# Instanceof
 
 The  `instanceof`  operator  can  correctly judge the type of the object , bacause  it’s  internal  mechanism is to find out  if `prototype` of this type  can be found in the prototype chain of the object
 let’s try to implement it
@@ -292,7 +374,7 @@ function instanceof(left, right) {
 }
 ```
 
-#### scope
+# Scope
 
 Executing JS code would generate execution environment , as long as the code is not written in a function , it belongs to the global execution environment . The code in a function will generate function execution environments , but only two (there’s an `eval`, which basically will not be used, so you can think of only two execution environments))
 
@@ -331,7 +413,7 @@ var b = 'Hello world'
 
 Using `var`  is more likely to make mistake , thus ES6 introduces a new keyword `let`  .  `let`  has an  important feature that it can’t be used before declared , which mismatches the often saying that `let` doesn’t  have the ability of hoisting . Indeed, `let`  hoists declared , but does not assign a value, because the temporary dead zone.
 
-#### Closure
+# Closure
 
 The definition of a closure is simple: Function A returns a function B, and function B uses a variable of function A, and the function B is called a closure.
 
@@ -415,7 +497,7 @@ For `let`, it will create a block-level scope, which is equivalent to:
 }
 ```
 
-#### Prototypes
+# Prototypes
 
 ![](https://camo.githubusercontent.com/71cab2efcf6fb8401a2f0ef49443dd94bffc1373/68747470733a2f2f757365722d676f6c642d63646e2e786974752e696f2f323031382f332f31332f313632316538613962636230383732643f773d34383826683d35393026663d706e6726733d313531373232)
 
@@ -426,7 +508,7 @@ Each object has an internal property, denoted as `__proto__` , which is a refere
 Objects can use `__proto__` to find properties that do not belong to the object, and `__proto__` connects objects together to form a prototype chain.
 
 
-#### inheritance
+# Inheritance
 
 In ES5, we can solve the problems of inheritance by using the following ways.
 
@@ -489,7 +571,7 @@ The Implement ideas of the above inheritance: firstly create the instance of par
 The inheritance implement with the above method can perfectly solve the restriction on low-level of JS.
 
 
-#### Deep and Shallow Copy
+# Deep and Shallow Copy
 
 ```js
 let a = {
@@ -504,7 +586,7 @@ From the above example, we can see that if you assign an object to a variable,
 
 Usually, we don't want such problem to appear during development, thus we can use shallow copy to solve this problem.
 
-##### shallow copy
+## Shallow copy
 
 Firstly we can solve the problem by `Object.assign`
 ```js
@@ -540,7 +622,7 @@ console.log(b.jobs.first) // native
 ```
 The shallow copy only solves the problem of the first layer. If the object contains objects, then it returns to the beginning topic that the values of both share the same reference. To solve the problem, we need to introduce deep copy.
 
-##### deep copy
+## Deep copy
 
 The problem can usually be solved by  `JSON.parse(JSON.stringify(object))`
 
@@ -614,7 +696,7 @@ var obj = {a: 1, b: {
 const clone = await structuralClone(obj);
 ```
 
-#### the differences between call, apply, bind
+# The differences between call, apply, bind
 
 Firstly, let’s tell the difference between the former two.
 
@@ -635,7 +717,7 @@ getValue.call(a, 'yck', '24')
 getValue.apply(a, ['yck', '24'])
 ```
 
-##### simulation to implement   `call` and  `apply`
+## simulation to implement   `call` and  `apply`
 
 We can consider how to implement them from the following points
 
@@ -701,7 +783,7 @@ Function.prototype.myBind = function (context) {
 }
 ```
 
-#### Promise implementation
+# Promise implementation
 
 `Promise` is a new syntax introduced by ES6, which resolves the problem of  callback hell.
 
@@ -894,7 +976,7 @@ The above codes, which is implemented based on the Promise / A+ specification,
 ![](https://user-gold-cdn.xitu.io/2018/3/29/162715e8e37e689d?w=1164&h=636&f=png&s=300285)
 
 
-#### Throttle
+# Throttle
 
 `Debounce` and `Throttle` are different in nature. `Debounce` is to turn multiple executions into the last execution, and `Throttle` is to turn multiple executions into execution at regular intervals.
 
@@ -1008,7 +1090,7 @@ function b() {
 ```
 
 
-# async and await
+# Async and await
 
 A function with `async`, then the function will return a `Promise`.
 
@@ -1063,4 +1145,110 @@ You may have doubts about the above code, here explain the principle
 - First the function `b` is executed. The variable `a` is still 0 before execution  `await 10`, Because the `generators` are implemented inside `await` and  `Generators` will keep things in the stack, so at this time `a = 0` is saved
 - Because `await` is an asynchronous operation, `console.log('1', a)` will be executed first.
 - At this point, the synchronization code is executed and asynchronous code is started. The saved value is used. At this time, `a = 10`
-- Then comes the usual code execution
+- Then comes the usual code execution
+
+# Proxy
+
+Proxy is a new feature since ES6. It can be used to define operations in objects.
+
+```js
+let p = new Proxy(target, handler);
+// `target` represents the object of need to add the proxy
+// `handler` customizes operations in the object
+```
+
+Proxy can be handly for the implementation of data binding and listening.
+
+```js
+let onWatch = (obj, setBind, getLogger) => {
+  let handler = {
+    get(target, property, receiver) {
+      getLogger(target, property)
+      return Reflect.get(target, property, receiver);
+    },
+    set(target, property, value, receiver) {
+      setBind(value);
+      return Reflect.set(target, property, value);
+    }
+  };
+  return new Proxy(obj, handler);
+};
+
+let obj = { a: 1 }
+let value
+let p = onWatch(obj, (v) => {
+  value = v
+}, (target, property) => {
+  console.log(`Get '${property}' = ${target[property]}`);
+})
+p.a = 2 // bind `value` to `2`
+p.a // -> Get 'a' = 2
+```
+
+# Why 0.1 + 0.2 != 0.3
+
+Because JS uses the IEEE 754 double-precision version (64-bit). Every language that uses this standard has this problem.
+
+As we know, computers uses binaries to represent decimals, so `0.1` in binary is represented as
+
+```js
+// (0011) represents cycle
+0.1 = 2^-4 * 1.10011(0011)
+```
+
+How did we come to this binary number? We can try computing it as below:
+
+![](https://user-gold-cdn.xitu.io/2018/4/26/162ffcb7fc1ca5a9?w=800&h=1300&f=png&s=83139)
+
+Binary computations in float numbers are different from those in integers. For multiplications, only the float bits are computed, while the integer bits are used for the binaries for each bit. Then the first bit is used as the most significant bit. Therefore we get `0.1 = 2^-4 * 1.10011(0011)`.
+
+`0.2` is similar. We just need to get rid of the first multiplcation and get `0.2 = 2^-3 * 1.10011(0011)`.
+
+Back to the double float for IEEE 754 standard. Among the 64 bits, one bit is used for signing, 11 used for integer bits, and the rest 52 bits are floats. Since `0.1` and `0.2` are infinitely cycling binaries, the last bit of the floats needs to indicate whether to round (same as rounding in decimals).
+
+After rounding, `2^-4 * 1.10011...001` becomes `2^-4 * 1.10011(0011 * 12 times)010`. After adding these two binaries we get `2^-2 * 1.0011(0011 * 11 times)0100`, which is `0.30000000000000004` in decimals.
+
+The native solution to this problem is shown below:
+
+```js
+parseFloat((0.1 + 0.2).toFixed(10))
+```
+
+# Regular Expressions
+
+## Metacharacters
+
+| Metacharacter |                            Effect                            |
+| :-----------: | :----------------------------------------------------------: |
+|       .       |     Matches any character except the new line character      |
+|      []       | matches anything within the brackets. For example, [0-9] can match any number |
+|       ^       | ^9 means matching anything that starts with '9'; [`^`9] means not matching characters except '9' in between brackets |
+|    {1, 2}     |               matches 1 or 2 digit characters                |
+|     (yck)     |            only matches strings the same as 'yck'            |
+|      \|       |          matches any character before and after \|           |
+|       \       |                       escape character                       |
+|       *       |       Matches the preceding expression 0 or more times       |
+|       +       |       Matches the preceding expression 1 or more times       |
+|       ?       |             the character before '?' is optional             |
+
+## Flags
+
+| Flag | Effect           |
+| :------: | :--------------: |
+| i        | Case-insensitive search |
+| g        | matches globally |
+| m        | multiline        |
+
+## Character Shorthands
+
+| shorthand |            Effect            |
+| :--: | :------------------------: |
+|  \w  | alphanumeric characters, underline character or Chinese characters |
+|  \W  |         the opposite of the above         |
+|  \s  |      any blank character      |
+|  \S  |         the opposite of the above         |
+|  \d  |          numbers          |
+|  \D  |         the opposite of the above         |
+|  \b  |    start or end of a word    |
+|  \B  |         the opposite of the above         |
+