前端面试题整理——Javascript基础

常见值类型：

let a; //undefined

let s = 'abc';

let n = 100;

let b = true;

let sb = Symbol('s');

let nn = NaN

 

常见引用类型：

const obj = {x: 100};

const arr = [1, 2, 3];

const n = null;//特殊引用类型，指针指向为空

// 特殊引用类型，但不用于存储数据，所以没有“拷贝，复制函数”这一说

function fn(){}

console.log(typeof obj) //obj

console.log(typeof arr) //obj

console.log(typeof n)   //obj

console.log(typeof fn)  //function

 

typeof运算符：

1、识别所有的值类型

2、识别函数

3、判断是否是引用类型 （不可再细分）

let a; //undefined
    let s = 'abc';
    let n = 100;
    let b = true;
    let sb = Symbol('s');
    console.log(typeof a);// 'undefined'
    console.log(typeof s);// 'string'
    console.log(typeof n);// 'number'
    console.log(typeof b);// 'boolean'
    console.log(typeof sb);// 'symbol'

    /*判断函数*/
    function fn(){}
    console.log(typeof fn); // 'function'

    /*判断是否是引用类型 （不可再细分）*/
    console.log(typeof null); // 'object'
    console.log(typeof []); // 'object'
    console.log(typeof {}); // 'object'

深拷贝：

const obj = {
        a: 100,
        b: {
            b1: [1, 2, 3],
            b2: 'string'
        },
        c: ['a', 'b', 'c']
    }

    /*
    *  没做深拷贝的效果
    const obj2 = obj
    obj2.a = 200
    obj2.b.b2 = 'abc123'
    obj2.c[0] = 'aa'
    console.log(obj)
    console.log(obj2)

    obj2修改的内容会影响obj的内容，因为他们修改的都是同一个堆内容
    * */

    const obj2 = deepClone(obj);
    obj2.a = 200
    obj2.b.b2 = 'abc123'
    obj2.c[0] = 'aa'
    console.log(obj)
    console.log(obj2)

    /**
     * 深拷贝
     * @param {Object} obj 要深拷贝的对象
     * */
    function deepClone(obj = {}) {
        // obj如果不是引用类型，或者是null，直接返回
        if (typeof obj !== 'object' || obj == null) {
            return obj
        }
        // 初始化返回结果
        let result;
        if (obj instanceof Array) {
            result = []
        } else {
            result = {}
        }
        // 遍历obj
        for (let key in obj) {
            // 保证key不是原型的属性
            if (obj.hasOwnProperty(key)) {
                // 递归调用
                result[key] = deepClone(obj[key])
            }
        }
        return result
    }

类型转换常考考点：

1、字符串拼接

let a = 100 + 10;//110

let b = 100 + '10';// '10010'

let c = true + '10';// 'true10'

 

2、==运算符

100 == '100' // true

0 == '' // true

0 == false // true

false == '' // true

null == undefined // true

 

// ==运算符的使用场景

// 除了==null之外，其他一律都用 === ，例如：

const obj = {x:100}

if(obj.a == null){}

// 相当于： if(obj.a === null || obj.a === undefined){}

 

3、if语句和逻辑运算

truly变量：!!a === true 的变量

falsely变量：!!a === false 的变量

以下是falsely变量，除此之外都是truly变量

    /*

    * !!0 === false

    * !!NaN === false

    * !!'' === false

    * !!null === false

    * !!undefined === false

    * !!false === false

    * */

在if语句中的判断就是判断是truly变量还是falsely变量。truly变量就是为真，falsely变量就是为false

 

逻辑判断 与或非 && || !

 

4、new运算符的实现机制

首先创建了一个新的 空对象

设置原型，将对象原型设置为函数的 prototype 对象

让函数的 this 指向这个对象，执行构造函数的代码（为这个新对象添加属性）

判断函数的返回值类型，如果是值类型，返回创建的对象。如果是引用类型，就返回这个引用类型的对象。