js基础面试题

数据类型

什么是引用类型，值类型？

值类型key与value存储在栈中(量小)；引用类型在栈存储的引用地址，在堆中存储是数据(量大)；把引用类型赋值给一个变量， 是把变量的引用地址指向引用类型堆中地址

哪些值类型

String字符，Number数字，Boolean 布尔，undefined未定义，null空(特殊)， Symbol符号

哪些引用类型

Object对象 Array数字 Function函数 Map图 Set集合

判断数据类型

typeof类型
instanceof实例
constructor构造函数
Array.isArray)是否为数组
Object.prototype.toStringcall(obj)原型                                                                                 

typeof判断

  	typeof "abC"           string 
    typeof 123             number
    typeof  true           boolean
    typeof undefined       undefined
    typeof null            object
    typeof Symbol()        symbol
    typeof {}              object
    typeof []              abject
    typeof function(){}  function
    typeof new Map()     object
    typeof new Set()     object
    //适合判断值与引用类型不能判断具体引用类型

instanceof判断

 	[] instanceof Array true
    [] instanceof Object true
    {} instanceof Array false
    {} instanceof Object true
    判断是否是其原型链上的实例只要这个构造函数在原型链都返回true
    ([]由Array创建的，Array是 Object的子类，instanceofArray和Object都返回true )

construtor

判断实例对象构造函数
｜ [].constructor === Array true

最精确

Object.prototype.toString.call(obj).slice(8,-1)
//返回数据的精确类型

浅拷贝

扩展{...obj}
for遍历
Object.assgin()

深拷贝

1.JSON.parse(SON.stringify(数据))
2. 通过判断类型 递归深拷贝
    递归就是函数调用自己 一定要有结束条件

隐式转换

看符号
   1. +字符串连接符号 会尝试把其他类型转换为字符串
   2. +-*/ ==会尝试把其他类型转换为数字
       1) 转换失败NAN
        2)false转换为0
       3) true转换为1
   3. ><>=<=!!===判断与逻辑返回会尝试把其他类型转换布尔值
         falsely变量转换为false
         "" null NaN undefined 0转换为false

严格等于

===
判断类型和值是否都相对
应该在任何时候都使用===
	(当判断是否为null或者为undefined可以为特例)
null === null true
==
    判断隐式转换后的值
    "100"== 100 // true
    null == undefined //true
    0== false //true
   	特例: NaN === null // false

{}== {}// false
[] == {}//false
指向不同的内存地址

if判断

if()中判断的是否为truely变量
falsely变量: false ”" 0 NaN undefined null
除了falsely变量其他都为truely变量

逻辑且逻辑或

A||B
    A为真（truely）结果为A，否则结果为B
A&&B
    A为加（faslely）结果为A,否则结果为B
判断对象
    if(a&&a.b&&a.b.c){}
    if(a?.b?.c){}
    如果有a并且有a.b并且有a.b.c
    ❌if(a.b.C){}

原型与原型链

名词

类:(创建对象实例的模板)本质.上都是函数
        构造函数用new来执行的函数
        class XXX{}
实例:由类创建的对象(本质上讲就是对象)
显示原型
    类/构造函数都一个显示显示原型prototype
        （本质上讲就是对象）
隐式原型
    每个实例都有一个隐私原型__proto__
显与隐关系
    类显示原型protype等于其创建的实例的隐式原型__proto__
原型链
    查找对象实例的方法和属性时，先在自身找，找不到则沿着__proto__向上查找，__proto__ 形成的链条关系我们称为原型链(实现了js继承)

原型与原型链的作用

    实现了js的继承
    实现了实例的公用属性和方法

显与隐关系

var arr = [];
arr.__proto__ === Array.prototype
类显示原型protype等于其创建的实例的隐式原型__proto__

原型链

//创建2个类解释原型与原型链People Student
// People eat方法 age属性 name属性
// Student 继承People类 study方法 age属性 name属性 no学号
// 01创建People类
function People(name,age){
	this.name = name;
	this.age = age;
}
//02给pepole显示原型添加eat方法
People.prototype.eat=function(){
	console.log(this.name+"正在吃饭");
}
//03 创建学生类继承People类
function Student(name,age,no){
	//执行People构造按函数(执行people 函数并把当前的this传入函数，当前peoplethis)
	People.call(ths.name,age);
//定义学号
this.no = no;
}
//04 让Student原型链继承People的原型链
Student.prototype = Object.create(People.prototype);
//05修正Student 显示原型上的构造函数
Student.prototype.constructor = Student;
//06在Student.显示原型链添加方法
Student.prototype.study = function(){
	console.log(this.name+"正在好好学习，daydayup");
}
//07构建Student的实例s1
var s1 = new Student("mumu",18,9527)

js实现继承

class的extends方法

    class Student extends People{
        ​constructor(name,age,no){
         //类中继承构造函数
        super(name,age)
         ...
        }
	}

使用原型链

 1. Stuent构造函数中继承People
 function Student(name,age,no){
 People.call(this,name,age)
  ...
 }
2.继承原型链
  Student.prototype = Object.create(People.prototype)
3.修正Student构造函数
    Stuent.prototype.constructor = Student

实例公用方法（扩展）

Array.prototype.max = function(){return Math.max(...this))}
//所有数组将拥有max方法
String.prototype.reverse = function(){ return this.split("").reverse().join("")}
//所有字符串将拥有 reverse  方法      
注意：一般不要修改默认对象上的方法，扩展也谨慎