摘要：文章中如果有錯誤或者有更好的解法，請多多指出。它類似于數組，但是成員的值都是唯一的，沒有重復的值。

文章中如果有錯誤或者有更好的解法，請多多指出。

1.字符串去重

思路：（1）利用對象key值唯一性

function unique(str){
      var _obj=str.split("");
        var length=str.length;
        var result="";
        var obj={};
        for(var i=0;i
（2）方法2  利用Set (謝謝道友們的分享)
  ES6提供了新的數據結構Set。它類似于數組，但是成員的值都是唯一的，沒有重復的值。
const unique = str => [...new Set(str.split(""))].join("");

var str="oooooooooooopppppppppppppollllllllllsssssssss"
console.log(unique(str)) // opls
2.查找出在字符串中只出現一次的第一個字符
舉例-str="pppwrtto"  ===> 輸出 w
思路：
1.str去重 [p,w,r,t,o] 同時將字符出現的次數記錄下來，組成如下結構
{p:3,w:1,r:1,t:2,o:1}
2.判斷當第一次obj[key]==1的時候就返回key值
function firstUnique(str){
    var arr=str.split("");
      var length=arr.length;
      var obj={};
      var num=0;
      for(var i=0;i
3.封裝typeof（重點區分 引用值---1.數組，2.對象，3.包裝類）
思路：1.區分原始值 引用值 2.原始值 引用值
function type(target){
        //原始值 引用值
        //區分引用值
        var template={
            "[object Array]":"array",
            "[object Object]":"object",
            "[object Number]":"number-object",
            "[object Boolean]":"boolean-object",
            "[object String]":"string-object"
        }
        if(target===null){
            return "null";
        }else if(typeof(target)=="object"){
            // 數組
            // 對象
            // 包裝類 Object.prototype.toString
            var str=Object.prototype.toString.call(target);
            return template[str];
        }else{
            return typeof(target)
        }
    }
    console.log(type("abc"))
    console.log(type(function(){}))
    console.log(type([]))
    console.log(type({}))
    console.log(type(new Number()))
    console.log(type(new Object()))
    console.log(type(new String()))
    console.log(type(new Boolean()))
    console.log(type(new Array()))
4.數組去重--在原型鏈上進行
 var arr=[1,1,2,2,"a","a"]
 arr.unique-->[1,2,a]
 思路：通過對象 hash方式
Array.prototype.unique=function(){
        var obj={};
        var result=[];
        var length=this.length;
        for(var i=0;i
function distinct(ary){
    var obj={};
    for(var i=0;i
5.Js實現方法連續調用
var demo={
        smoke:function(){
            console.log("吸煙")
            return this;
        },
        eat:function(){
            console.log("吃飯")
            return this;
        },
        perm:function() {
            console.log("燙頭")
            return this;
        }
    }
    demo.smoke().eat().perm()
6.低耦合寫出階乘函數
  --消除緊密耦合的現象，可以像下面這樣使用 arguments.callee(嚴格模式下callee失效)
function factorial(num){
        if(num<=1){
            return 1;
        }else{
            return num*arguments.callee(num-1)
        }
    }
    console.log(factorial(3))
7.&&與||運算符
 var a=1&&2; //&& 如果第一個表達式為真，將返回第二個表達式值返回
    console.log(a);
    var b=1&&2+2;
    console.log(b);
    var c=0&&2; //&& 如果第一個表達式為假，將返回第一個表達式值返回
    console.log(c)
    var d=1||2;//|| 第一個表達式為真，則直接返回
    console.log(d)
    var e=0||2;//|| 第一個表達式為假，則返回第二個值
    console.log(e)

    2>1&&document.write("hello");
    var data;
    data&&console.log("ni hao")
8.淺拷貝
我們知道引用類型的賦值其實是改變了變量的指向，那么如果在需要拷貝的對象中存在某個屬性的值是引用類型，如數組或子對象，那么淺拷貝后的原對象的屬性獲得的也只是這個指向。所以如果改變被拷貝對象的屬性值，那么原對象的相應屬性也會跟著改變
　　function extendCopy(p) {
　　　　var c = {};
　　　　for (var i in p) { 
　　　　　　c[i] = p[i];
　　　　}
　　　　c.uber = p;
　　　　return c;
　　}
9.深拷貝
遞歸
　　function deepCopy(p, c) {

　　　　var c = c || {};

　　　　for (var i in p) {

　　　　　　if (typeof p[i] === "object") {

　　　　　　　　c[i] = (p[i].constructor === Array) ? [] : {};

　　　　　　　　deepCopy(p[i], c[i]);

　　　　　　} else {

　　　　　　　　　c[i] = p[i];

　　　　　　}
　　　　}

　　　　return c;
　　}
  var chinese={
       nation:"中國",
       minzu:{name1:"漢族",name2:"苗族"}
     }
　var Doctor = deepCopy(Chinese);
數組&對象深拷貝
function deepCopy(origin) {
    if (typeof origin != "object") {
        return origin;
    }
    var result;
    if(Object.prototype.toString.call(origin)=== "[object Array]"){
        result=[];
        for(var i in origin){
            result[i]= typeof origin[i]==="object"?deepCopy(origin[i]):origin[i];
        }
    }else{
        result={};
        for (var key in origin) {
            if(origin.hasOwnProperty(key)){
                result[key]= typeof origin[key]==="object"?deepCopy(origin[key]):origin[key];
            }
        }
    }
    return result;
}
    var obj1={
        name:"小黃",
        sister:{name:"花花",age:20},
        grade:[10,20,30,[89,60]]
    };
    var obj2=deepCopy(obj1)

10.函數預編譯 GO與AO
最終
GO{
a:100，
demo:function(){}，
f:123
}
AO{
e:2,
b:undefined,
a:10
}
 a=100;
    function demo(e){
        function e(){}
        arguments[0]=2;
        console.log(e); //2
        if(a){
            var b=123;
        }
        a=10;
        var a;
        console.log(b);//undefined
        f=123;
        console.log(a);//10
    }
    var a;
    demo(1);
    console.log(a); //100
    console.log(f); //123
11.將 var obj={value0:"1",remark0:"備注1",value1:"2",remark1:"備注2"};  轉換為[{value0:"1",remark0:"備注1"},{value1:"2",remark1:"備注2"}]
    var obj={value0:"1",remark0:"備注1",value1:"2",remark1:"備注2"};
    var count=0;
    var result=[];
    var storage={};
    for(var key in obj){
        count++;
        storage[key]=obj[key]
        if(count%2==0){
            result[count/2-1]=storage;
            storage={};
        }
    }
    console.log(result);
12.輸入一個整形數組，數組中有正數也有負數，數組中連續的一個或多個數組組成一個子數組，每個子數組都有一個和，求所有子數組和的最大值。
  var s=[20,[1,2,10],[-2,30,[-1,-1,-8]]];
    function max(origin){
        var length=origin.length;
        var array=[]
        for(var i=0;i
13、call原理以及面試題
原理：
Function.prototype.call=function call(context){
   //native code
   //把指定函數中的this指向context =>也就是fn this改變 -------[把this（call中的this）中的this指向context]
   //把指定函數執行 fn執行---- [this執行] this()
}
//以下都是讓call方法執行
//fn.call(opp)  //call方法中的this 是fn
//fn.__proto__.call();  //call方法中的this是fn.__proto__
//Function.prototype.call(); //call this=>Function.prototype
題目：
function fn1(){
  console.log(1);
}
function fn2(){
  console.log(2)
}
fn1.call(fn2);
//fn1.call :fn1這個Function的實例通過__proto__找到Function.prototype上的call方法，然后讓call方法執行(傳遞fn2這個實參)  
//執行call的時候,call中的this：fn1，所此處是把fn1執行，讓fn1中的this執行fn2
fn1.call.call.call(fn2);
//f1.call.call.call 依然是找到原型上的call方法并且讓call執行。
//  call3中的this:fn1.call.call[原型上的call]
//  call3中的Context:fn2

// 1.  讓【原型中的call(fn1.call.call)】中的this指向fn2
// 2. 讓[原型上的call(fn1.call.call)]執行 
//    -1、第二次執行原型上的call,只不過此時的call已經變為了fn2
//   -2、讓指定函數fn2中的this指向undefined
//     -3、讓fn2執行
Function.prototype.call(fn2);
//  找到原型上的call方法，讓call執行
//    call執行：
//    this:Function.prototype
//    context:fn2
//
//   把Functon.prototype中的this關鍵字變為fn2
//   讓Function.prototype執行
//   ==>無輸出(匿名空函數執行無輸出)
Function.prototype.call.call.call(fn2);
// 等價于 fn1.call.call.call(fn2)
14、阿里面試題目
    function Foo(){
        getName=function(){
            console.log(1)
        };
        return this;
    }
    Foo.getName=function(){
        console.log(2);
    }
    Foo.prototype.getName=function(){
        console.log(3)
    }
    var getName=function(){
        console.log(4)
    }
    function getName(){
        console.log(5)
    }
    Foo.getName() //把Foo作為對象，找其私有屬性
    getName();// 執行全局下的getName
    Foo().getName(); //先將Foo作為普通函數執行，然后在調取getName
    getName();
    new Foo.getName()//先獲取Foo.getName的值(假設B)，然后在new B()相當于創建B的實例
    new Foo().getName() //先new Foo() 獲取實例(new Foo()相當于將Foo函數有重新執行了一遍,此時getName->1)，把得到的實例再調取getName

    new new Foo().getName();//=>var f=new Foo() new f.getName() =>[new (f.getName)]()
15、數組去重《鏈式寫法》
Array.prototype.myDistinct=function myDistinct(){
    var obj={};
    for (var i = 0; i < this.length; i++) {
        var item=this[i];
        if(typeof obj[item]!=="undefined"){
            this[i]=this[this.length-1];
            this.length-1;
            i--;
            continue;
        }
        obj[item]=item;
    }
    obj=null;
    return this;
}
    var ary=[1,2,3,4,1,2,44,3]
    ary.myDistinct();
    ayy.myDistinct.sort();
16.閉包、作用域、變量提升
 var num=1,
        obj={
            num:2,
            fn:(function(num){
                this.num*=2;
                num+=2;
                return function(){
                    this.num*=3;
                    num++;
                    console.log(num)
                }
            })(num)
        }
    var fn=obj.fn;
    fn();
    obj.fn();
    console.log(num,obj.num)