JS知識—面試準備（一）

時間  2019-12-05
標籤 知識 面試 準備 欄目 JavaScript 简体版
原文   原文鏈接

1.JS內置類型

分爲基本數據類型和Object.
基本數據類型有：null,undefined,string,boolean,number,symbol.html

console.log(typeof null);//object
    console.log(typeof []);//object
    console.log(typeof {});//object

若是想要區分null，數組，對象，應該怎麼辦？程序員

console.log(Object.prototype.toString.call(null));//[object Null]
       console.log(Object.prototype.toString.call([]));//[object Array]
       console.log(Object.prototype.toString.call({}));//[object Object]

個人簡單理解：toString（數據）；做用：將數據轉化爲字符串。數組

2.類型轉化

類型轉化：分爲顯示類型轉化，和隱式類型轉化。閉包

1.Number（數據）app

若是數據內容式純粹的數字，才能夠轉化爲數字，不然式NaN。
var str2="12px";//NaN
var str2="1.2";//1.2
var str2="1.2.3";//NaN
var str2=null;//0
console.log(Number(str2));

2.NaN異步

NaN的數據類型書Number。注意：NaN和任何東西都不相等，包括本身。

3.isNaN（數據）函數

會先把數據用Number轉化，轉化完了以後在判斷是否是NaN，若是是NaN則返回爲true。不然返回爲fasle。
console.log(isNaN(1));//false
console.log(isNaN("123"));//false
console.log(isNaN("abc"));//true

4.parseInt(數據)和parseFloat(數據)this

parseInt(數據)：把數據變成整數，捨去小數點，取整數。
parseFloat(數據)：把數據轉化爲數字，能夠是小數。
注意:這兩個方法會從左往右開始，除去空格，找到第一位非0數字，開始進行轉換，直到轉換到不是數字的那位爲止，或者，轉換出合適的值爲止。
console.log( parseInt( "1" ) );//1
    console.log( parseInt( "1.9" ) );//1
    console.log( parseInt( "20px" ) );//20
    console.log( parseInt( "    25px" ) );//25
    console.log( parseInt( "    0.0026px" ) );//0

    console.log( parseFloat( "    0.0026px" ) );//0.0026

5.Stirng( )和Boolean（）也能夠進行顯示類型轉化，這裏不綴述.net

條件判斷中，除了null,undefined,'',NaN,false,0都轉化爲false，其他都轉化爲true。

6.隱式類型轉化prototype

只有當加法運算時，其中一方是字符串類型，就會把另外一個也轉爲字符串類型。其餘運算只要其中一方是數字，那麼另外一方就轉爲數字。而且加法運算會觸發三種類型轉換：將值轉換爲原始值，轉換爲數字，轉換爲字符串。
<script>
    console.log( "abc"-1 );//NaN
    console.log( NaN-1 );//NaN
    console.log( NaN+1 );//NaN
    console.log( NaN+"1" );//NaN1
//------------------------------------------
    console.log( "3"-1 );//轉成數字2
    console.log( "345" - 0 );//轉成數字345
    console.log( "345" * 1 );//轉成數字345
    console.log( "345" / 1 );//轉成數字345
    console.log( "345px" - 0 );//NaN
//------------------------------------------
    
    console.log( 123 + "" );//轉成字符串 "123"
//------------------------------------------
    
    console.log( !!234 );//轉成boolean類型 true
    console.log( !!0 );//轉成boolean類型 false
    console.log( !!{} );//轉成boolean類型 true
    console.log( !!null );//轉成boolean類型 false

3.運算符

==和===

==：
    1.若是類型相同的話，比較內容
        類型不相同，類型轉化在比較
        1）一個是undefined,一個是null，則相等。
        2）數字和字符串的的話，將字符串轉化爲數字再進行比較。
===：
    1.類型相同比教內容，類型不一樣則返回fasle。

4.原型，原型鏈，new

1.new

1.新生成了一個對象
2.連接到原型
3.綁定this
4.返回新對象

2.prototype 原型

prototype 原型
    當一個函數被申明的時候，該函數下默認有一個屬性：prototype，該屬性的值是一個對象
    
    當咱們去調用一個對象的屬性或者方法的時候，若是該對象自身沒有該屬性或方法，
    則會調用到該對象 的 構造函數的prototype的屬性或方法
    把經過構造函數構造出來的對象，共有的方法或者屬性，放在prototype身上


__proto__
    當一個對象被建立的時候，
    該對象會自動被添加上一個屬性：__proto__，
    他的值也是一個對象，而且該屬性 就是 當前這個對象的構造函數的prototype
    對象.__proto__ === 構造函數.prototype

3.原型鏈

Function.prototype.a = "a";
Object.prototype.b = "b";
function Person(){}
console.log(Person);    //function Person()
let p = new Person();
console.log(p);         //Person {} 對象
console.log(p.a);       //undefined
console.log(p.b);       //b

解析：

會一直經過__proto__向上查找，最後當查找到Object.prototype時找到，最後打印出b，向上查找過程當中，獲得的是Object.prototype，而不是Function.prototype，找不到a屬性，因此結果爲undefined，這就是原型鏈，經過__proto__向上進行查找，最終到null結束
        //Function
        function Function(){}
        console.log(Function);  //Function()
        console.log(Function.prototype.constructor);    //Function()
        console.log(Function.prototype.__proto__);      //Object.prototype
        console.log(Function.prototype.__proto__.__proto__);    //NULL
        console.log(Function.prototype.__proto__.constructor);  //Object()
        console.log(Function.prototype.__proto__ === Object.prototype); //true

總結：

1.查找屬性，若是自己沒有，則會去__proto__中查找，也就是構造函數的顯式原型中查找，若是構造函數中也沒有該屬性，由於構造函數也是對象，也有__proto__，那麼會去它的顯式原型中查找，一直到null，若是沒有則返回undefined

2.p.__proto__.constructor  == function Person(){}

3.p.___proto__.__proto__== Object.prototype

4.p.___proto__.__proto__.__proto__== Object.prototype.__proto__ == null          

5.經過__proto__造成原型鏈而非protrotype

5.instanceof

檢測對象原型是否在要檢測對象的原型鏈上，返回值爲true或者false
使用：object instanceof constructor
function Fn () {}
    var f = new Fn();
    console.log( f instanceof Fn );//true
    console.log( f instanceof Object );//true
//    //str是字面量生成的，是由JS內部的String構造函數new出來的。
//    //可是str會馬上"壓扁"本身，讓本身不是對象。
//    //因此str都不是對象了，天然instanceof String 的獲得的值爲fasle
//    //但str.indexOf(),str仍是能夠調用indexOf()方法的緣由是，當它調用方法的時候，會從新將本身包裝成對象。
//    //使用結束後會從新"壓扁"本身，讓本身不是對象。
    var str = "123";
    console.log( str instanceof Array );//false
    console.log( str instanceof String);//false
    console.log( str instanceof Object);//false
//
    var obj = {};
    console.log( obj instanceof Array );//false
    console.log( obj instanceof Object);//true

6.hasOwnProperty

做用
        用來判斷某個對象是否含有 指定的 自身屬性
    語法
        boolean object.hasOwnProperty(prop)
    參數
        object
            要檢測的對象
        prop
            要檢測的屬性名稱。
    注意：不會沿着原型鏈查找屬性，只查找自身屬性
function Fn(name,gender){
        this.name = name;
        this.gender = gender;
    }
    Fn.prototype.kind = "human";
    Fn.prototype.say = function(){
        console.log(1);
    };
    
    var f = new Fn("kimoo","男");
    
    console.log( f.hasOwnProperty("name") ); //true
    
    console.log( f.hasOwnProperty("kind") ); //false
    console.log( f.hasOwnProperty("say") ); //false

8.call,bind,apply

call,bind,apply的做用都是修改this指向。

區別:

1.call:函數會當即執行,括號中的內容 第一個參數 就是 函數執行時候 ,內部的this指向。後面的參數就是函數內部的實參。
function foo (a,b) {
        console.log( this );
        console.log( a,b );
    }
    foo.call( document,2,3 );//運行結果：#document 2，3
2.apply:函數會當即執行,括號中的內容 第一個參數 就是 函數執行時候 ,內部的this指向。不過第二個參數接受數組。
function foo (a,b) {
        console.log( this );
        console.log( a,b );
    }
    foo.apply( document,[2,3] ); // 和call 類似 直接調用 , 不過第二個參數接受數組。運行結果：#document 2，3
3.bind:函數 不會 馬上執行,返回的是 修改了 this指向的新函數.第二個參數是參數列表。
function foo (a,b) {
        console.log( this );
        console.log( a,b );
    }
    var fn = foo.bind( document,2,3);// 函數 不會 馬上執行,返回的是 修改了 this指向的新函數
    fn();
       //運行結果:
    //#document
    //2 3

9.組合式繼承

<script>
    function Person(){
        this.arr = [1,2,3];
        this.age = 10;
    }
    Person.prototype.say = function(){
        console.log( "我會說話" );
    };
//    父類構造函數中的方法,使用借用構造函數的方式繼承
    function Coder(name,money) {
        Person.call(this);
        this.name = name;
        this.money = money;
        
    }
//    父類構造函數原型上的方法,使用原型鏈繼承
    Coder.prototype = new Person();
    Coder.prototype.constructor = Coder; // 從新修改 constructor
    
    Coder.prototype.say = function(){
        console.log( "我是程序員,我叫" + this.name +",我一個月:"+ this.money );
    }
    
    var p = new Person();
    console.log( p.age );  
    console.log( p.arr );
    console.log( p.kind );
    p.say();
    
    var c1 = new Coder("a",10000);
    console.log( c1.age );  
    c1.say();
    c1.arr.push(4);
    console.log( c1.arr );
    console.log( c1.name );
    console.log( c1.money );
    var c2 = new Coder("b",30000);
    c2.say();
    console.log( c2.age );  
    console.log( c2.arr );
    console.log( c2.name );
    console.log( c2.money );

    console.log(Coder.prototype.constructor);
</script>

10.拷貝式繼承

<script>
    
    function Person(){
        this.arr = [1,2,3];
        this.age = 10;
    }
    Person.prototype.say = function(){
        console.log( "我會說話" );
    }
    function Coder(){
        Person.call(this);
    }
    Coder.prototype = cloneFn( Person.prototype );
    Coder.prototype.constructor = Coder;
    Coder.prototype.say = function(){
        console.log( "我是程序員" );
    }
    
    var p = new Person();
    console.log( p.age );  
    console.log( p.arr );
    p.say();
    console.log( "----------------" );
    
    var c1 = new Coder();
    console.log( c1.age );  
    c1.say();
    c1.arr.push(4);
    console.log( c1.arr );
    console.log( "----------------" );
    var c2 = new Coder();
    console.log( c2.age );  
    console.log( c2.arr );
    c2.say();
    
//------------------------------------------
function cloneFn( sourse ){
    var o = Object.prototype.toString.call(sourse).toLowerCase().indexOf("array")!==-1 ? [] : {};
    for( var attr in sourse ){
        if( (typeof sourse[attr] === "object") && sourse[attr] !== null ){
            o[attr] = cloneFn( sourse[attr] ) ;
        }else{
            o[attr] = sourse[attr];
        }
    }
    return o;
}
    
</script>

11.class繼承

<script>
    class Person {
        constructor(name){
            this.name = name;
        }
        say(){
            console.log( '個人名字叫 ${this.name}');
        }
    }
    
    class Coder extends Person{
//        constructor( name,money ){
//            super(name); // 至關於 調用 父類的 構造函數,修改內部的this,
////                必定要先調用 super 再使用 this
//            this.money = money;
//        }
        say(){
            console.log( `個人名字叫 ${this.name}` );
        }
        eat(){
            console.log( "我會吃" );
        }
    }
    
    var p = new Person("kimoo");
//    console.log( p );
//    p.say();
//    p.eat(); // 報錯: p.eat is not a function
    
    var c = new Coder("zm");
    console.log( c );
    c.say();
    c.eat();
</script>

12.函數做用域，執行上下文，變量提高，閉包

1.做用域

JS做用域分爲全局做用域和函數做用域，函數做用域能夠訪問全局做用域中的變量，對象，函數等。可是函數做用域外部訪問不到函數內部的變量，對象，函數。

但在ES6中新增了塊級做用域。let，const在塊中聲明的變量，函數等，外部都訪問不到。
{
        var a=1;
        let b=2;
        console.log(b);//2
        {
            console.log(b);//2
        }
    }

    console.log(a);//1
    console.log(b);//報錯，b is not defined

2.執行上下文
這裏有篇很是好的js執行上下文的文章，能夠點擊連接查看

總結：

1. 調用函數是會爲其建立執行上下文，並壓入執行環境棧的棧頂，執行完畢彈出，執行上下文被銷燬，隨之VO也被銷燬
        2. EC建立階段分建立階段和代碼執行階段
        3. 建立階段初始變量值爲undefined，執行階段才爲變量賦值
        4. 函數申明先於變量申明

3.變量提高（域解析）

關鍵：變量提高過程當中函數優先級高於變量優先級

function foo() {
            console.log(f1);    //f1() {}
            console.log(f2);    //undefined
            
            var f1 = 'hosting';
            var f2 = function() {}
            function f1() {}
        }
        foo();

4.閉包

閉包：函數 A 返回了一個函數 B，而且函數 B 中使用了函數 A 的變量，函數 B 就被稱爲閉包。

for ( var i=1; i<=5; i++) {
    setTimeout( function timer() {
        console.log( i );
    }, i*1000 );
}

首先由於 setTimeout 是個異步函數，全部會先把循環所有執行完畢，這時候 i 就是 6 了，因此會輸出一堆 6。

解決方法一：

for (var i = 1; i <= 5; i++) {
  (function(j) {
    setTimeout(function timer() {
      console.log(j);
    }, j * 1000);
  })(i);
}

解決方法二：

for ( var i=1; i<=5; i++) {
    setTimeout( function timer(j) {
        console.log( j );
    }, i*1000, i);
}

解決方法三：

for ( let i=1; i<=5; i++) {
    setTimeout( function timer() {
        console.log( i );
    }, i*1000 );
}

點擊這裏，閉包進一步瞭解

13.深淺拷貝

1.淺拷貝

首先能夠經過 Object.assign 來解決這個問題。

let a = {
    age: 1
}
let b = Object.assign({}, a)
a.age = 2
console.log(b.age) // 1

固然咱們也能夠經過展開運算符（…）來解決

let a = {
    age: 1
}
let b = {...a}
a.age = 2
console.log(b.age) // 1

2.深拷貝

function cloneFn( sourse ){
    var o = Object.prototype.toString.call(sourse).toLowerCase().indexOf("array")!==-1 ? [] : {};
    for( var attr in sourse ){
        if( (typeof sourse[attr] === "object") && sourse[attr] !== null ){
            o[attr] = cloneFn( sourse[attr] ) ;
        }else{
            o[attr] = sourse[attr];
        }
    }
    return o;
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程