登录  /  注册
首页 > web前端 > js教程 > 正文

JS基础知识必备—常见面试题目系统整理

php是最好的语言
发布: 2018-08-03 10:41:30
原创
4377人浏览过

JS基础知识必备—常见面试题目系统整理

1.JS内置类型

分为基本数据类型和Object.
基本数据类型有:null,undefined,string,boolean,number,symbol.

    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(数据);作用:将数据转化为字符串。

推荐相关文章2020年最全js面试题整理(最新)

2.类型转化

类型转化:分为显示类型转化,和隐式类型转化。

1.Number(数据)

如果数据内容式纯粹的数字,才可以转化为数字,否则式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(数据)

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()也可以进行显示类型转化,这里不缀述

条件判断中,除了null,undefined,'',NaN,false,0都转化为false,其余都转化为true。
登录后复制

6.隐式类型转化

只有当加法运算时,其中一方是字符串类型,就会把另一个也转为字符串类型。其他运算只要其中一方是数字,那么另一方就转为数字。并且加法运算会触发三种类型转换:将值转换为原始值,转换为数字,转换为字符串。
登录后复制
<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( &#39;我的名字叫 ${this.name}&#39;);
        }
    }
    
    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 = &#39;hosting&#39;;
            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;
}
登录后复制

相关文章:

JS的8个必须注意的基础知识

javascript基础知识整理

以上就是JS基础知识必备—常见面试题目系统整理的详细内容,更多请关注php中文网其它相关文章!

智能AI问答
PHP中文网智能助手能迅速回答你的编程问题,提供实时的代码和解决方案,帮助你解决各种难题。不仅如此,它还能提供编程资源和学习指导,帮助你快速提升编程技能。无论你是初学者还是专业人士,AI智能助手都能成为你的可靠助手,助力你在编程领域取得更大的成就。
来源:php中文网
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn
最新问题
热门教程
更多>
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责申明 意见反馈 讲师合作 广告合作 最新更新
php中文网:公益在线php培训,帮助PHP学习者快速成长!
关注服务号 技术交流群
PHP中文网订阅号
每天精选资源文章推送
PHP中文网APP
随时随地碎片化学习
PHP中文网抖音号
发现有趣的

Copyright 2014-2024 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号