摘要：函數內部重新聲明了一個，值為，這兩個是不一樣的，互相不產生影響，因此最后輸出。方法實現繼承相同的簡單使用用對象替換當前對象，如果為空，則為全局對象。

前端學習的摘錄，持續更新中...

① 使用set去重：set是ES6中提供的數據結構，不同于數組，所有的值都是不重復的，Set內部使用===來判斷是否相等，類似"1"和1會兩個都保存，NaN和NaN只會保存一個

let unique= [...new Set([1,"1",1,NaN,NaN,undefined,undefined,null,null])];
//[1, "1", NaN, undefined, null]

② 遍歷，將值添加到新數組，用indexOf()判斷值是否存在，已存在就不添加，達到去重效果。(對NaN去重失敗)

 let a = [1,"1",1,NaN,NaN,undefined,undefined,null,null];
 let unique = arr =>{
     let newA = [];
     arr.forEach(key => {
         if(newA.indexOf(key)<0){ //遍歷newA是否存在key，如果存在key會大于0就跳過push的那一步
            newA.push(key);
         }
     });
     return newA;
 }
 unique(a); // ["1", 1, NaN, NaN, undefined, null]

③ 遍歷，將數組的值添加到一個對象的屬性名里，并給屬性賦值。對象不能添加相同屬性名，以這個為依據可以實現數組去重，然后用Object.keys(對象)返回這個對象可枚舉屬性組成的數組，這個數組就是去重后的數組。(返回的都是字符串，對于1和"1"都當成"1")

let a = [1,"1",1,NaN,NaN,undefined,undefined,null,null];
let unique = arr => {
    var obj = {};
    arr.forEach(value => {
        obj[value] = 0; // 隨便賦值，為了將屬性添加進obj對象
    });
    return Object.keys(obj);
}
unique(a); // ["1", "NaN", "undefined", "null"]

深度遍歷屬性值拷貝

function deepcopy(obj) {
    var copyObj = Object.create(Object.getPrototypeOf(obj));
    Object.getOwnPropertyNames(obj).forEach((keyName) => {
        if ( typeof obj[keyName] == "object") {
            copyObj[keyName] = deepcopy(obj[keyName])
        } else {
            copyObj[keyName] = obj[keyName]
        } 
    });
    return copyObj;
}

采用JSON.parse(JSON.stringify(obj))，有局限性

function deepcopy(obj){
    return JSON.parse(JSON.stringify(obj));
}

函數length屬性的含義: 該函數預期傳入的參數個數。指定了默認值以后，length將返回沒有指定默認值的參數個數；指定了默認值后，length屬性將失真。

(function (a) {}).length // 1
(function (a = 5) {}).length // 0
(function (a, b, c = 5) {}).length // 2

如果設置了默認值的參數不是尾參數，那么length屬性也不再計入后面的參數了。

(function (a = 0, b, c) {}).length // 0
(function (a, b = 1, c) {}).length // 1

如果參數默認值是一個變量，則該變量所處的作用域，與其他變量的作用域規則是樣，即先是當前函數的作用域，然后才是全局作用域。

var x = 1;

function f(x, y = x) {
  console.log(y);
}

f(2) // 2

上面代碼中，參數y的默認值等于x。調用時，由于函數作用域內部的變量x已經生成，所以y等于參數x，而不是全局變量x；如果調用時，函數作用域內部的變量x沒有生成，結果則不同。

let x = 1;

function f(y = x) {
  let x = 2;
  console.log(y);
}

f() // 1

上面代碼中，函數調用時，y的默認值變量x尚未在函數內部生成，所以x指向全局變量。如果此時，全局變量x不存在，就會報錯：ReferenceError: x is not defined
一個復雜的例子：

var x = 1;

function foo(x, y = function() { x = 2; }) {
  var x = 3;
  y();
  console.log(x);
}

foo() // 3

上面代碼中，函數foo的參數y的默認值是一個匿名函數。函數foo調用時，它的參數x的值為undefined，所以y函數內部的x一開始是undefined，后來被重新賦值2。函數foo內部重新聲明了一個x，值為3，這兩個x是不一樣的，互相不產生影響，因此最后輸出3。

如果將var x = 3的var去除，兩個x就是一樣的，最后輸出的就是2。

call的簡單使用：obj1.method.call(obj2,argument1,argument2,...), 用對象obj2替換當前對象obj1，如果obj2為空，則為全局對象。簡單使用：

function add(a, b) { return a+b; }

function sub(a, b) { return a-b; }

add.call(sub, 3, 1);  // 4

繼承:

function Parent() {
    this.showMsg = function(msg) {
        return msg;
    }
}

function Child() {
    Parent.call(this);    // this.super()意味
}

const chi = new Child();
chi.showMsg("hello world");   // "hello world"

多重繼承:

function Parent1() {
    this.add = function(a, b) {
        return a + b;
    }
}

function Parent2() {
    this.sub = function(a, b) {
        return a - b;
    }
}

function Child() {
    Parent1.call(this);
    Parent2.call(this);
}

JavaScript是詞法作用域不是動態作用域，詞法作用域是寫代碼或說定義時確定的，動態作用域是在運行時確定的，詞法作用域關注函數在何處申明，動態作用域關注在何處調用。但是，JS中的this關注的也是函數的調用。

function foo() {
    console.log(a);   // 2
}
function bar () {
    var a = 3;
    foo();
}
var a = 2;
bar()

如果按照動態作用域理論運行結果是：3