常見前端面試代碼題

1、this綁定

//this綁定，當即執行函數表達式
var num = 1;
var myObject = {
    num:2,
    add:function(){
        this.num = 3;
        (function(){
            console.log(this.num);
            this.num = 4;
        })();
        console.log(this.num);
    },
    sub:function(){
        console.log(this.num);
    }
}
myObject.add();
console.log(myObject.num);
console.log(num);
var sub = myObject.sub;
sub();
//結果  1 3 3 4 4

var number = 5;
var obj = {
    number: 3,
    fn1: (function () {
        var number;
        this.number *= 2;
        number = number * 2;
        number = 3;
        return function () {
            var num = this.number;
            this.number *= 2;
            console.log(num);
            number *= 3;
            console.log(number);
        }
    })()
}
var fn1 = obj.fn1;
fn1.call(null);
obj.fn1();
console.log(window.number);
//結果  10 9 3 27 20

2、函數調用（函數表達式、箭頭函數）

var name = 'window'
var person1 = {
    name:'person1',
    show1:function(){
        console.log(this.name);
    },
    show2:()=>console.log(this.name),
    show3:function(){
        return function(){
            console.log(this.name);
        }
    },
    show4:function(){
        return ()=>console.log(this.name)
    }
}
var person2 = {name:'person2'};
person1.show1();//person1
person1.show1.call(person2);//person2

person1.show2();//window
person1.show2.call(person2);//window

person1.show3()();//person1錯    window
person1.show3().call(person2);//person2
person1.show3.call(person2)();//person2錯   window

person1.show4()();//window錯     person1
person1.show4().call(person2);//person1
person1.show4.call(person2)();//window錯    person2

var name = "hanmeimei";
var f = function(){
    var name = "lilei";
    return function(){
        console.log(this.name);
    } 
}

f()();//hanmeimei

3、10個隨機數，不重複

function getRandom(num){
    var numb = [];
    var newArr = [];
    while(numb.length<num){
        let n = parseInt(Math.random() * 32);
        if(n>=2&&n<=32){
            numb.push(n);
            newArr = Array.from(new Set(numb));
        } 
    }
    console.log(newArr);
    //return newArr;
}
getRandom(10);

4、數組展開函數

// 寫出一個數組展開函數, 如輸入：[1,[2,[3,4,2],2],5,[6]],  則輸出：[1,2,3,4,2,2,5,6] 
// 由於和深度無關，因此說最簡單能夠這樣
function flatten(arr){
    var res = arr.join().split(',');
    res = res.map( ele => +ele)
    return res;
}
// 還有嗎，遞歸，寫一下
function flatten(arr){
    var array = [];
    arr.forEach(ele => {
        if(Array.isArray(ele)){
            array.push(...flatten(ele));
        } else {
            array.push(ele);
        }
    })
    return array;
}
var arr1 = [1,[2,[3,4,2],2],5,[6]];
flatten(arr1)

5、eventloop

console.log('begin');
setTimeout(() => {
    console.log('setTimeout 1');
    Promise.resolve().then(() => {
        console.log('promise 1');
        setTimeout(() => {
            console.log('setTimeout2 between promise1&2');
        })
    }).then(() => {
        console.log('promise 2');
    });
}, 0);
console.log('end');

begin
end
setTimeout 1
promise 1
promise 2
setTimeout2 between promise1&2

console.log('script start')

async function async1() {
  await async2()
  console.log('async1 end')
}
async function async2() {
  console.log('async2 end') 
}
async1()

setTimeout(function() {
  console.log('setTimeout')
}, 0)

new Promise(resolve => {
  console.log('Promise')
  resolve()
})
  .then(function() {
    console.log('promise1')
  })
  .then(function() {
    console.log('promise2')
  })

console.log('script end')
//結果
script start
end
Promise
end
end
promise1
promise2
undefined
setTimeout

6、基本數據類型判斷

console.log(Number([1]))
if([]==false){console.log(1)}//1
if({}==false){console.log(2)}
if([]){console.log(3)}//3
if([1]==[1]){console.log(4)}

7、裴波納鍥數列

function Fibonacci(n)
{
  if (n == 0) {
    return 1;
  }
  var pre = 1, // 前一個值
    cur = 1; // 當前值
  for (var i = 2; i <= n; i++) { // 更新兩個值
    cur += pre;
    pre = cur - pre;
  }
  return cur;
}

function Fibonacci2(n)
{
    var f = [0, 1];
    for(let i = 2; i <= n; i++) {
        f[i] = f[i - 1] + f[i - 2];
    }
    return f[n];
}

Fibonacci(5)

function fibonacci(n){
    if(n==1||n==2)
        return 1;
    return fibonacci(n-1)+fibonacci(n-2);
}

8、讀取url中的參數

var getUrlParam2 = function(sUrl, sKey){
    // 捕獲組兩枚,一枚負責Key 一枚負責獲取Value
    var reg = new RegExp('([0-9a-zA-Z%]+)=([0-9a-zA-Z%]+)&*', 'ig');
    // 結果集保存
    var result = {};
    var temp;
    var key, value;
    while(temp = reg.exec(sUrl)) {
        key = temp[1];
        value = temp[2];
        if (result[key] && !(result[key] instanceof Array)) {
            result[key] = [result[key], value];     // 若是發現了第二個同名參數,則從字符串變爲數組
        } else if (result[key] instanceof Array) {
            result[key].push(value);    // 已是數組,又找到了,就push進去
        } else {
            result[key] = value;    // 第一次,仍是普通保存
        }
    }
    if (sKey) {
        return result[sKey] ? result[sKey] : '';    // 爲了不undefined的狀況
    } else {
        return result;  // 返回所有的對象參數
    }
 
}
getUrlParam2("http://www.nowcoder.com?key=1&key=2&key=3&test=4#hehe")

9、jsonp

//http://www.baidu.com?aa=11&callback=my_jsonp04349289664328899
    var jsonp = function(url,param,callback){
        //處理url地址,查找？，若是沒有？這個變量就有一個"?"，有？這個變量接收一個&
        var querystring = url.indexOf("?") == -1?"?":"&";

        //處理參數{xx:xx}
        for(var k in param) {
            querystring += k + "=" + param[k] + '&';//?k=para[k]
        }
        //處理回調函數名
        var random = Math.random().toString().replace(".","");
        var cbval = "my_jsonp" + random;
        var cb = "callback="+cbval;
        querystring += cb;
        var script = document.createElement("script");
        script.src = url + querystring;
        //把回調函數的名字附給window
        window[cbval] = function(param) {
            //這裏執行回調的操做，用回調來處理參數
          callback(param);
          //拿到了就刪掉這個script
          document.body.removeChild(script);
        };
        document.body.appendChild(script);
    }
    jsonp(
        "https://www.baidu.com",
        {aa:11},
        function(){
            console.log(param);
        }
        );

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title></title>
    <script type="text/javascript">
    // 獲得航班信息查詢結果後的回調函數
    var flightHandler = function(data){
        alert('你查詢的航班結果是：票價 ' + data.price + ' 元，' + '餘票 ' + data.tickets + ' 張。');
    };
    // 提供jsonp服務的url地址（不論是什麼類型的地址，最終生成的返回值都是一段javascript代碼）
    var url = "http://flightQuery.com/jsonp/flightResult.aspx?code=CA1998&callback=flightHandler";
    // 建立script標籤，設置其屬性
    var script = document.createElement('script');
    script.setAttribute('src', url);
    // 把script標籤加入head，此時調用開始
    document.getElementsByTagName('head')[0].appendChild(script); 
    </script>
</head>
<body>
</body>
</html>

10、深克隆

//js的深克隆
function deepCopy(obj){
    //判斷是不是簡單數據類型，
    if(typeof obj == "object"){
        //複雜數據類型
        var result = obj.constructor == Array ? [] : {};
        for(let i in obj){
            result[i] = typeof obj[i] == "object" ? deepCopy(obj[i]) : obj[i];
        }
    }else {
        //簡單數據類型 直接 == 賦值
        var result = obj;
    }
    return result;
}

11、判斷是不是數組

//判斷是否爲數組  經過toString()方法  經過constructor 經過instanceof  Array.isArray
var arr = [1, 2, 3];
        var obj = {
            name: 'lyl',
            age: 18,
            1: 'name'
        }
        console.log(Object.prototype.toString.call(arr) === '[object Array]'); //true
        console.log(Object.prototype.toString.call(boj) === '[object Array]'); //false

12、promise

// 這裏咱們建立了一個構造函數 參數就是執行器
function Promise(exector) {
    // 這裏咱們將value 成功時候的值 reason失敗時候的值放入屬性中
    let self = this;
    // 這裏咱們加入一個狀態標識
    this.status = 'pending';
    this.value = undefined;
    this.reason = undefined;
    // 成功執行
    function resolve(value) {
        // 判斷是否處於pending狀態
        if (self.status === 'pending') {
            self.value = value;
            // 這裏咱們執行以後須要更改狀態
            self.status = 'resolved';
        }
    }   
    // 失敗執行
    function reject(reason) {
        // 判斷是否處於pending狀態
        if (self.status === 'pending') {
            self.reason = reason;
            // 這裏咱們執行以後須要更改狀態
            self.status = 'rejected';
        }
    }  
    // 這裏對異常進行處理
     try {
        exector(resolve, reject);
    } catch(e) {
        reject(e)
    }
}
// 咱們將then方法添加到構造函數的原型上 參數分別爲成功和失敗的回調
Promise.prototype.then = function(onFulfilled, onRejected) {
    // 獲取下this
    let self = this;
    if (this.status === 'resolved') {
        onFulfilled(self.value);
    }
    if (this.status === 'rejected') {
        onRejected(self.reason);
    }
}
//運行
let promise = new Promise((resolve, reject) => {
     resolve("haha");
})
promise.then(data => {
    console.log(data); //輸出 haha
}, err=> {
    console.log(err);
})
// 屢次調用
promise.then(data => {
    console.log(data); //輸出 haha
}, err=> {
    console.log(err);
})

//完整版實現
function MyPromise (executor) {
    var self = this;
    self.status = 'pending';
    self.resolveValue = null;
    self.rejectReason = null;
    self.ResolveCallBackList = [];
    self.RejectCallBackList = [];

    function resolve (value) {
        if (self.status === 'pending') {
            self.status = 'Fulfilled';
            self.resolveValue = value;
            self.ResolveCallBackList.forEach(function (ele) {
                ele();
            });
        }  
    }

    function reject (reason) {
        if (self.status === 'pending') {
            self.status = 'Rejected';
            self.rejectReason = reason;
            self.RejectCallBackList.forEach(function (ele) {
                ele();
            });            
        }  
    }
    
    try {
        executor(resolve, reject);
    }catch(e) {
        reject(e);
    } 
};
function ResolutionRetrunPromise (nextPromise, returnValue, res, rej) {
    if (returnValue instanceof MyPromise) {
        // Promise 對象
        returnValue.then(function (val) {
            res(val);
        }, function (reason) {
            rej(reason)
        });
    }else {
        res(returnValue);
    }
}

MyPromise.prototype.then = function (onFulfilled, onRejected) {
    if (!onFulfilled) {
        onFulfilled = function (val) {
            return val;
        }
    }
    if (!onRejected) {
        onRejected = function (reason) {
            throw new Error(reason);
        }
    }    
    var self = this;

    var nextPromise = new MyPromise(function (res, rej) {
        if (self.status === 'Fulfilled') {
            setTimeout(function () {
                try {
                    // var nextResolveValue = onFulfilled(self.resolveValue);
                    // res(nextResolveValue);
                    var nextResolveValue = onFulfilled(self.resolveValue);
                    ResolutionRetrunPromise(nextPromise, nextResolveValue, res, rej);
                }catch(e) {
                    rej(e);
                }

            }, 0);
        }
    
        if (self.status === 'Rejected') {
            setTimeout(function () {
                try {
                    var nextRejectValue = onRejected(self.rejectReason);
                    ResolutionRetrunPromise(nextPromise, nextRejectValue, res, rej);
                }catch(e) {
                    rej(e);
                }

            }, 0);
        }
    
        // 
        if (self.status === 'pending') { 
            self.ResolveCallBackList.push(function () {
                try {
                    var nextResolveValue = onFulfilled(self.resolveValue);
                    ResolutionRetrunPromise(nextPromise, nextResolveValue, res, rej);
                }catch(e) {
                    rej(e);
                }
            });
    
            self.RejectCallBackList.push(function () {
                setTimeout(function () {
                    try {
                        var nextRejectValue = onRejected(self.rejectReason);
                        ResolutionRetrunPromise(nextPromise, nextRejectValue, res, rej);
                    }catch(e) {
                        rej(e);
                    }
                }, 0);
            });        
        }
    });
    return nextPromise;
};

MyPromise.prototype.catch = function (onRejected) {
    return this.then(null, onRejected);
};

MyPromise.prototype.finally = function (callback) {
    return this.then(function (data) {
        callback();
        return data;
    }, function (reason) {
        callback();
        throw reason;
    });
};
MyPromise.all = function (promiseArr) {
    // console.log(0)
    return new MyPromise(function (res, rej) {
        // promiseArr 全部的值都看一下， 若是全都是成功 res
        // rej  
        // then
        var arr = [];
        var times = 0;
        function processResult (index, result) {
            arr[index] = result;
            times++;
            // arr.length == promiseArr.length
            if (times ==  promiseArr.length) {
                res(arr);
            }
        };

        for (let i = 0; i < promiseArr.length; i++) {
            var oPromise = promiseArr[i];
            if (typeof oPromise.then == 'function') {
                oPromise.then(function (val) {
                    // val
                    // 我要存一下這個val val -> arr -> i
                    processResult(i, val)
                }, function (reason) {
                    // reason
                    rej(reason);
                })
            }else {
                processResult(i, oPromise);
            }
        }
    });
};
MyPromise.race = function(promiseArr) {
    return new MyPromise(function (resolve, reject) {
        promiseArr.forEach(function (promise, index) {
           promise.then(resolve, reject);
        });
    });
};
MyPromise.reject = function (reason) {
    return new MyPromise(function (resolve, reject) {
        reject(reason);
    });
};


MyPromise.resolve = function (val) {
    return new MyPromise(function (resolve, reject) {
        resolve(val);
    });
};

十3、JS如何判斷一組數字是否連續

// 當出現連續數字的時候以‘-’輸出  [1, 2, 3, 4, 6, 8, 9, 10]
// 指望結果  ["1-4", 6, "8-10"]
var arrange = function(arr){
    var result = [],temp = [];
    arr.sort(function(source, dest){
        return source - dest;
    }).concat(Infinity).reduce(function(source, dest){
        temp.push(source);
        if(dest-source > 1){
            result.push(temp);
            temp = [];
        }
        return dest;
    });
    return result;
};
var formatarr = function(arr) {
    var newArr = []
    var arr1 = arrange(arr)
    for (var i in arr1) {
        var str = '';
        if (arr1[i].length > 1) {
            str = arr1[i][0] + '-' + arr1[i][arr1[i].length - 1];
            newArr.push(str)
        } else {
            newArr.push(arr1[i][0]);
        }
   }
   return newArr;
}

十4、請自定義一個函數，實現字符串反轉。

function revStr(str){
    var temStr = "";
    var len = str.length;
    for(var i=len-1;i>=0;i--){
        temStr = str.charAt(i);
    }
    return temStr;
}
//字符串的徹底翻轉
str.split("").reverse().join("")
//翻轉字符串中單詞順序,但單詞字母順序不變，注意:單詞間可能有多空格，而且先後可能也有空格
function reverseStr(param){
    var arr = param.split(/\s+/);
    var newArr = [];
    for(i=0;i<arr.length;i++){
        newArr[arr.length-i] = arr[i];
    }
    return newArr.join(" ").trim();
}
document.write(reverseStr("smile at life"));        

十5、JavaScript中如何檢測一個變量是一個string/數組類型？

var str = "hello world";
function isString(str){
    if(typeof str == "string" || str.constructor == String){
        return true;
    }else{
        return false;
    }
}
if(typeof Array.isArray==='undefined'){ 
　　Array.isArray=function(arg){ 
　　　　return Object.prototype.tostring.call(rag)==='[Object Array]'; 
　　}; 
}

十6、找到第一個數組array1中出現，而在第二個數組array2中沒有出現的數字

function findNullOfNum(arr1,arr2){
    var str = arr2.split("");
    var result = [];
    for(var i=0,x=0;i<arr1.length;i++){
        if(str.indexOf(arr1[i] == -1){
           result[x] = arr1[i];
           x++;
        }
     }
    return result;
}

十7、數組去重

function select(arr){
  var temp=[];
  for(var i = 0;i < arr.length;i++){
    //indexOf() 方法可返回某個指定的字符串值在字符串中首次出現的位置。ie8不兼容
    if(temp.indexOf(arr[i]) == -1){
      temp.push(arr[i]);
    }
  }
  return temp;
}
//具體驗證
var arr=[4,5,1,53,5,1,3];
console.log(select(arr));

//includes():判斷當前數組是否包含某個值，如有則返回true,若沒有則返回false;
function select(arr){
  var temp=[];
  arr.forEach((v)=>{
    temp.includes(v)||temp.push(v);
  })
  return temp;
}
//循環判斷
function select(arr){
  var temp=[];
  for(var i = 0; i < arr.length; i++){
    for(var j = i+1; j < arr.length; j++){
      if(arr[i] === arr[j]){
        j = ++i;
      }
    }
    temp.push(arr[i]);
  }
  return temp;
}

//輸入[false, true, undefined, null, NaN, 0, 1, {}, {}, 'a', 'a', NaN]
//輸出[false, true, undefined, null, NaN, 0, 1, {}, {}, 'a']
Array.prototype.uniq = function () {
   var resArr = [];
   var flag = true;  
   for(var i=0;i<this.length;i++){
       if(resArr.indexOf(this[i]) == -1){
           if(this[i] != this[i]){   //排除 NaN
              if(flag){
                   resArr.push(this[i]);
                   flag = false;
              }
           }else{
                resArr.push(this[i]);
           }
       }
   }
    return resArr;
}

十8、字符串全排列

function Permutation(str)
{
    let res=[];
    if(str.length<=0) return res;
    arr=str.split("");//將字符串轉化爲字符數組
    res=permutate(arr,0,res);
    res=[...new Set(res)];//去重
    res.sort();//排序
    return res;
}
function permutate(arr,index,res){
    if(arr.length==index){
        let s="";
        for(let i=0;i<arr.length;i++){
            s+=arr[i];
        }
        return res.push(s);
    }else{
        for(let i=index;i<arr.length;i++){
            [arr[index],arr[i]]=[arr[i],arr[index]];//交換
            permutate(arr,index+1,res);
            [arr[index],arr[i]]=[arr[i],arr[index]];//交換
        }
    }
    return res;
}

十9、找出數組中重複數字

function findSame(arr) {
    let map = {}, res=[];
    for (let i = 0; i < arr.length; i++) {
        if (!map[arr[i]]) {
            map[arr[i]] = 1;
        } else {
            map[arr[i]]++;
        }
    }
    for (let i in map) {
        if (map[i] > 1) {
            res.push(i);
        }
    }
    return res;
}

二10、轉換obj

var obj =[
    {id: 1, parent: null},
    {id: 2, parent: 1},
    {id: 3, parent: 2},
]
function transform(obj, index) {
    let node;
    if(obj.length - 1 == index){
        node = {
            id: obj[index].id,
            parent: obj[index].parent
        }
    }else{
        node = {
            id: obj[index].id,
            parent: obj[index].parent,
            child: transform(obj,++index)
        }
    }
    return node;
}
let obj2 = {
    obj: transform(obj, 0)
}
console.log(obj2);

二11、實現log函數

function log(...args){
    let str = args.join(" ");
    return "(app)"+str;
}

二12、動態插入p標籤

let p = document.createElement("p");
p.setAttribute("class", "pdd-slogan");
p.textContent = "多拼多實惠"
div.appendChild(p);
document.body.appendChild(div);

二十3、let a = new A("test")；發生了什麼？（筆試簡答題）

1.先對A構造函數RHS查詢標識符。

2.使用new 調用構造函數A

//建立一個新的對象,並設置__proto__
//將構造函數的做用域賦值給新對象（所以this就指向了這個新對象）
//執行函數中的代碼（爲這個對象添加新的屬性）
//返回這個新的對象

3.建立變量a，並把以前的調用結果賦值給變量a

下面是new的原理實現

//實現一個new方法
function New(f) {
    //返回一個func
    return function () {
        var o = {"__proto__": f.prototype};
        f.apply(o, arguments);//繼承父類的屬性
        return o; //返回一個Object
    }
}

二十4、輸入一個數字，不以0開頭，找到相同數字組合的最小數字

function nextSmaller (num) {
  // your code here 例：輸入：210215，輸出：101225   輸入：21，輸出：12  找不到知足的輸出-1
    var arr = num.toString().split("");
    if(arr[0]!=0){
        arr.sort();
        console.log(arr);
        var i = 0;
        while(arr[i]==0){
            i = i+1;
        }
        if(i!=0){
            arr[0] = arr[i];
            arr[i] = 0;
        }
        if(num>=parseInt(arr.join(""))){
           return parseInt(arr.join(""));
        }else{
           return -1;
        }
    }else{
        return -1;
    }
}

二十5、圖片懶加載和預加載

function throttle(fn, delay, atleast) {//函數綁定在 scroll 事件上，當頁面滾動時，避免函數被高頻觸發，
        var timeout = null,//進行去抖處理
        startTime = new Date();
        return function() {
        var curTime = new Date();
        clearTimeout(timeout);
        if(curTime - startTime >= atleast) {
            fn();
            startTime = curTime;
        }else {
            timeout = setTimeout(fn, delay);
        }
        }
    }
    function lazyload() {
        var images = document.getElementsByTagName('img');
        var len    = images.length;
        var n      = 0;      //存儲圖片加載到的位置，避免每次都從第一張圖片開始遍歷        
        return function() {
        var seeHeight = document.documentElement.clientHeight;
        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
        for(var i = n; i < len; i++) {
            if(images[i].offsetTop < seeHeight + scrollTop) {
                if(images[i].getAttribute('src') === 'images/loading.gif') {
                 images[i].src = images[i].getAttribute('data-src');
                }
            n = n + 1;
             }
        }
        }
    }
    var loadImages = lazyload();
    loadImages();          //初始化首頁的頁面圖片
    window.addEventListener('scroll', throttle(loadImages, 500, 1000), false);
　　//函數節流（throttle）與函數去抖（debounce）處理,
//500ms 的延遲，和 1000ms 的間隔，當超過 1000ms 未觸發該函數，則當即執行該函數，否則則延遲 500ms 執行該函數

/**
 * 遍歷imgs數組，將全部圖片加載出來
 * 能夠經過控制檯查看網絡請求，會發現全部圖片均已加載
 */
for (let i = 0; i < len; i++) {
    let imgObj = new Image(); // 建立圖片對象
    imgObj.src = imgs[i];

    imgObj.addEventListener('load', function () { // 這裏沒有考慮error，實際上要考慮
        console.log('imgs' + i + '加載完畢');
    }, false);
}

二十6、二叉樹前序遍歷

function Node (data, left, right) {
    this.data = data;
    this.left = left;
    this.right = right;
    this.show = function () {
        return this.data;
    };
}


function BST () {
    this.root = null;
    this.insert = function (data) {
        var node = new Node(data, null, null);
        if (this.root === null) {
            this.root = node;
        } else {
            var current = this.root;
            var parent;
            while (true) {
                parent = current;
                if (data < current.data) {
                    current = current.left;
                    if (current === null) {
                        parent.left = node;
                        break;
                    }
                } else {
                    current = current.right;
                    if(current === null) {
                        parent.right = node;
                        break;
                    }
                }
            }
        }
    };
    // 中序遍歷
    this.inOrder = function (node) {
        if (node !== null) {
            this.inOrder(node.left);
            console.log(node.show());
            this.inOrder(node.right);
        }
    };
    // 先序遍歷
    this.preOrder = function (node) {
        if (node !== null) {
            console.log(node.show());
            this.preOrder(node.left);
            this.preOrder(node.right);
        }
    };
    // 後序遍歷
    this.afterOrder = function (node) {
        if (node !== null) {
            this.afterOrder(node.left);
            this.afterOrder(node.right);
            console.log(node.show());
        }
    };

    this.getMin = function () {
        var current = this.root;
        while (current.left !== null) {
            current = current.left;
        }
        return current.data;
    };


    this.getMax = function () {
        var current = this.root;
        while (current.right !== null) {
            current = current.right;
        }
        return current.data;
    };

    this.find = function (data) {
        var current = this.root;
        while (current !== null) {
            if (data < current.data) {
                current = current.left;
            } else if (data > current.data) {
                current = current.right;
            } else {
                return current;
            }
        }
        return null;
    };

    

    this.remove = function (data) {
        this.root = this._removeNode(this.root, data); //將根節點轉換
    };

    this._getSmallest = function (node) {
        while(node.left!=null){
            node=node.left;
        }
        return node;
    };


    this._removeNode = function (node, data) {
        if (node === null) {
            return null;
        }
        if (data === node.data) {
            // 若是沒有子節點
            if (node.right === null && node.left === null) {
                return null;
            }
            // 若是沒有左子節點
            if (node.left === null) {
                return node.right;//直接指向其右節點
            }
            // 若是沒有右子節點
            if (node.right === null) {
                return node.left;
            }
            // 若是有兩個節點
            if (node.right !== null && node.left !== null) {
                var tempNode = this._getSmallest(node.right);   // 找到最小的右節點
                node.data = tempNode.data;
                node.right = this._removeNode(node.right, tempNode.data);    // 依次尋找
                return node;
            }
        } else if (data < node.data){
            node.left = this._removeNode(node.left, data);
            return node;
        } else {
            node.right = this._removeNode(node.right, data);
            return node;
        }
    };
}

 二十7、js大數相加

原文鏈接：https://blog.csdn.net/u013362969/article/details/86544785

function add (str1, str2) {
    let len1 = str1.length;
    let len2 = str2.length;
    // let len = len1<len2 ? len1 : len2;
    let len = Math.max(len1, len2);
    let res = '';
    let jin = 0;
    for (let i = 0; i < len; i++) {
      let ad1 = str1.charAt(len1 - i - 1) ;
      let ad2 = str2.charAt(len2 - i - 1) ;
      //str1.charAt(-1)==='';Number('')===0;
      let sum = Number(ad1) + Number(ad2) + jin;
      res = sum % 10 + res;
      jin=sum>9
      // jin = Math.floor(sum / 10);
    }
    return res.replace(/^0+/, '');
  };

function addBigNumber(a, b) {
  var res = '',
    temp = 0;
  a = a.split('');
  b = b.split('');
  while (a.length || b.length || temp) {
    temp += ~~a.pop() + ~~b.pop();
    res = (temp % 10) + res;
    temp = temp > 9;
  }
  return res.replace(/^0+/, '');
}

二十8、sort方法將數組內的對象進行排序

var presonArr = [
    { name:'freddy', age:24, score:97 },
    { name:'nick', age:18, score:87 },
    { name:'mike', age:26, score:80 },
    { name:'james', age:34, score:90 },
    { name:'curry', age:30, score:83 }
];
//年齡升序排序
presonArr.sort(function(a,b){
    return a.age - b.age;    
});
console.log(presonArr);

後續會繼續補充······