前端面の質問ブラシタイトルノート（A）

1.バブルソート、挿入ソート、クイックソート、ヒープソート？

バブル：

関数バブル（A）{ 
    せTEMP 
    ため（; iは=端<I ++はせ、I = 0、終了= a.length-1 {）
          TEMP = [i]は
             のために（LET J = I; J <= END; J ++ ）{
                 場合（[J] < TEMP）{ 
                    [[I]、[J]] = [[J]、[I]] 
                } 
            } 
        } 
 }

挿入された行： 

 関数の挿入（ARR）{ 
     ましょうハンドル = ∞と
      するためには、（LEN = arr.length、I = 0せ; iがLEN <; Iは++ ）{
           ため（J = 0、HLEN = handle.lengthせ; J <HLEN、J ++ ）{
              場合（ARR [I] <=ハンドル[J] || J === HLEN-1 ）{ 
                handle.splice（j、 0 、ARR [i]）と
                 ブレーク
             } 
          } 
     } 
     handle.pop（）
     戻りハンドル
}

高速行：

機能クイック（ARR、L、R）{
     場合（L> = r）はリターン
    する場合（arguments.lengthを=== 1 ）{ 
        L = 0 
        、R = arr.length-1 
    } 
    iはせ = L、J = rは
    せ = [I] ARR 
    右せ = trueの
    一方（iは< j）を{
         場合（右）{
             場合（ARR [J] < A）{ 
                ARR [I] =のARR [J] 
                [j]はARR = 
                右 = 偽を
            } 他{ 
                J - 
            } 
        } 他{
             場合（ARR [I]> A）{ 
                ARR [J] = ARR [I] 
                ARR [I] = 
                右 = 真
            } 他{ 
                iは ++ 
            } 
        } 
    } 
    クイック（ARR、Lを、I）
    クイックソート（ARR、I +1 、R）
}

ヒープ行：

関数ヒープソート（ARR、banLen = 0 ）{ 
    せて長さ = arr.length
     場合（長=== banLen）リターン
    グレードせ = Math.floor（Math.log2（長banLenを）） - 1 
    LET maxPos =長banLen- 1 
    せadjustHeap =（ARR、指数）=> { 
        LENせ = Math.pow（2 、インデックス）
        させ、最大、leftLeaf、rightLeaf 
        ために（LET I = lenの-1; iがLEN <; iは++ ）{ 
            leftLeaf = 2 * I 1> maxPos -Infinity：？ARR [2 * I + 1 ] 
            rightLeaf = 2 * I + 2> maxPos -Infinity：？ARR [2 * I + 2 ] 
            最大 =Math.max（ARR [i]は、leftLeaf、rightLeaf）
             であれば（ARR [2 * I + 1] === MAX）[ARR [i]は、ARR [2 * I + 1] = [ARR [2 * I +1 ]、[I]] ARR
             場合（ARR [2 * I + 2] === MAX）[2 * I + 2] = [2 * I + 2 ARR ARR、[I] ARR 、】 ARR [I]] 
        } 
    } 
    のための（I =グレードせ; I> = 0; i-- ）{ 
        adjustHeap（ARR、I）
    } 
    [[ARR 0]、ARR [maxPos] =、ARR [maxPos ARR] [0 ] 
    ヒープソート（ARR、 ++ banLen）
}

2.スロットルと画像安定化？

スロットリング：

機能スロットル（FN、遅延）{ 
    ましょうタイマー = nullの
    リターン 機能（...引数）{
         場合（タイマー=== ヌル）{ 
            fn.apply（この、引数）
            タイマー =のsetTimeout（（）=> { 
                てclearTimeout（タイマー）
                タイマ = NULL 
            }、遅延）
        } 
    } 
}

画像安定化：

関数デバウンス（FN、遅延）{ 
    タイマーせ = NULL 
    戻り 機能を（...引数）{ 
        てclearTimeout（タイマー）
        のタイマー =のsetTimeout（（）=> { 
             fn.apply（この、引数）
        }、遅延）
    } 
}

3.重複排除アレイ？

constのユニーク=（ARR）=> [... 新しいセット（ARR）]

4.コールを実装し、適用し、バインド？

コール：

Function.prototype.myCall = 機能（自己、...引数）{ 
    ましょうsが = 記号（）
    自己 =自己|| 窓の
    自己.__プロト__ [S] = この
    自己[S]（... argsを）
    削除自己.__プロト__ [S] 
}

適用されます。

Function.prototype.myApply = 機能（自己、引数）{
    場合（！（引数のinstanceofアレイ））スローは（ '不是数组' ）
    しましょうsが = 記号（）
    自己 =自己|| 窓の
    自己.__プロト__ [S] = この
    自己[S]（... argsを）
    削除自己.__プロト__ [S] 
}

バインド：

Function.prototype.myBind = 関数（自己、... bindArgs）{ 
    FNせ = この
    リターン 機能（...引数）{ 
        fn.apply（自己、[... bindArgs、...引数]）
    } 
}

5.どのように変数Aがオブジェクトではないかを決定するには？

instanceofのプロトタイプチェーンに沿って見ている、typeof演算変数の型は、低符号化の数に基づいて判断されます。

000：オブジェクト

1：整数

100：文字列

110：ブール

ヌル：マシンコードに対応するNULLポインタ、全て0

未定義：と - （2 ^ 30）を表します

ヌルので全て0で、0は、自然に低く、ヌル===「オブジェクト」typeof演算ので、

裁判官は、変数のオブジェクトではありません。

// Aは、オブジェクトである 
Object.prototype.toString.call（A）=== '[オブジェクトのオブジェクト]' // Aが配列 
=== Object.prototype.toString.call（A） '[配列オブジェクト]' // AがNULL 
Object.prototype.toString.call（A）=== '[nullオブジェクト]が' // （nullは===ヌルを向けると判定され、説明の目的のためにヌル本明細書ではこれを決定することができます）