js前端面试题2024

• 1.js的数据类型

  boolean number string null undefined bigint symbol object
  按存储方式分，前面七种为基本数据类型，存储在栈上，object是引用数据类型，存储在堆上，在栈中存储指针
  按es标准分，bigint 和symbol是es6新增的数据类型，bigint存储大整数，symbol解决全局属性名冲突的问题

• 2.js数据类型检测的方式

  typeof 2 //number
  typeof true //boolean
  typeof 'srt' //string
  typeof undefined //undefined
  typeof null //object
  typeof 1n //bigint
  typeof Symbol() //symbol
  typeof {} //object
  typeof [] //object
  typeof function(){} //function
  
  Object.prototype.toString().call()
  
  ([] instanceof Array)
  (function(){} instanceof Function)
  ({} instanceof Object)
  //instanceof只能用于对象,返回布尔值
    (2).constructor===Number//true
    (true).constructor===Boolean//true
  

• 3.判断数组类型的方式有那些

  //1.通过原型判断
  const a=[]
  const b={}
  a instanceof Array
  Array.prototype.isPrototypeOf(a)
  a.__proto__===Array.prototype
  //2.通过object.prototype.tostring.call()
  const a=[]
  Object.prototype.toString().call(a)
  //3.es6的array.isarray()
  Array.isArray(a)

• 4.null和undefined的区别

  undefinde代表为定义，变量声明了但未初始化是未定义
  null代表空对象，一般用作某些对象变量的初始化值
  undefined==void 0
  typeof null=object null的地址是0和对象的地址相同

• 5. 0.1+0.2！==0.3

     // 方法一：放大10倍之后相加在缩小十倍
     //方法二：封装浮点数相等的函数
     function feg(a,b){
       return Math.abs(a-b)<Number.EPSILON
     }
     feg(0.1+0.2,0.3)

• 6.空类型

  []==false//true
  Boolean([])//true
  Number([])//0

• 7.包装类型

  const a='abc'
  a.length//3
  a.toUpperCase()//'ABC'
  const c=Object('abc')
  const cc=Object('abc').valueOf()
  

• 8.new做了什么工作

  1.创建了一个新的空对象object
  2.将新空对象与构造函数通过原型链连接起来
  3.将构造函数中的this绑定到新建的object上并设置为新建对象result
  4.返回类型判断

  function MyNew(fn,...args){
    const obj={}
    obj.__proto__=fn.prototype
    let result=fn.apply(obj,args)
    return result instanceof Object?result:obj
  }
  function Person(name,age){
    this.name=name
    this.age=age
  }
  Person.prototype.sayHello=function(){
    console.log(this.name)
  }
  const person=MyNew(Person,'test',20)
  person.sayHello()

• 9.继承

  //1.原型链继承
    function Sup(){
        this.prop='sup'
    }
    Sup.prototype.show=function(){}
    function Sub(){
        this.prop='sub'
    }
    Sub.prototype=new Sup()
    Sub.prototype.constructor=Sub
    Sub.prototype.show=function(){}
  //2.构造函数继承
    function Person(name,age){
        this.name=name
        this.age=age
    }
    function Student(name,age,price){
        Person.call(this,name,age)
        this.price=price
    }
  //3.原型链加构造函数
    function Person(name,age){
        this.name=name
        this.age=age
    }
    Person.prototype.show=function(){}
    function Student(name,age,price){
        Person.call(this,name,age)
        this.price=price
    }
    Student.prototype=new Person()
    Student.prototype.constructor=Person
    Student.prototype.show=function(){}
    //4.class extends
    class Animal{
        constructor(kind){
            this.kind=kind
        }
    }
    class Cat extends Animal{
        constructor(kind) {
            super.constructor(kind);
        }
    }

• 10.深拷贝

    function deep(p,c){
        let c = c||{}
        for(let i in p){
            if(typeof p[i]==='object'){
                c[i]=p[i].constructor=='Array'?[]:{}
                deep(p[i],c[i])
            }else{
                c[i]=p[i]
            }
        }
        return c
    }