js基础面试题（一）

1.js数据类型

• 值类型：String, Number, Boolean, Symbol(ES6)
• 引用类型：Array ,Object , Function , Set(ES6) ,Map(ES6)

2.值类型和引用类型的区别

1. 值类型的key与value 都存储在js的内存栈中
2. 引用类型的key存储在栈中，真正的值存储在堆中；把引用类型的值给一个变量，其实是引用类型的地址指向对象

3.js判断数据类型

• typeof 只能判断是否为值类型或者引用类型，引用类型除函数外都返回的是 object

• instanceOf 是不是某个对象的实例 （是数组还是对象）

• constructor 构造函数

var a=[1,2,3]  
var b={name:’susu’}

• Object.prototype.toString.call( ) 最精准判断数据类型

function getType(obj){
return Object.prototype.toString.call(obj ).slice(8,-1) 
}

4.浅拷贝与深拷贝

4.1 浅拷贝

只拷贝值类型，引用类型的数据还是指向内存地址

Var obj1={name:”susu”,age:18,friend:[“小红“，”小绿”]

浅拷贝类型：

• Es6扩展

var obj2={…obj1} 

• 循环

var obj3={}
for(var k in obj1){
Obj3[k]=obj1[k]
}

• object.assign 把参数的两个对象进行合并，属性相同后面覆盖前面

var obj4=Object.assign(obj1,{})

4.2 深拷贝

目标对象与源对象相互之间切断联系

  var obj1={name:”susu”,age:18,friend:[“小红“，”小绿”]

a.JSON转字符，字符串转对象，json字符串的值智慧保留数组，对象，字符串，数字，null,undefined

var obj2=JSON.parse(JSON.stringify(obj1))

b.通过递归拷贝(递归就是函数自己调用自己，一定要有结束条件)
代码：

<script >
		function deepCopy(obj){
			if(typeof obj=="object"&obj!=null){
				var temp=null
				if(obj instanceof Array){
					var temp=[]
					for(var i=0;i<obj.length;i++){
						temp[i]=deepCopy(obj[i])
					}
				}else{
					var temp={}
					for(var k in obj){
						temp[k]=deepCopy(obj[k])
					}
				}
				return temp
			}else{
				return obj
			}
		}
		var obj1={name:"susu",age:19,friends:['one','two']},
		var obj2=deepCopy(obj1)
	</script>

4.3 斐波拉契数列

4.3.1 用递归方法

function fib(n){
			if(n==0||n==1){
				return 1
			}else{
				return fib(n-1)+fib(n-2)
			}
		}
		alert(fib(1))
		//n=2 return fib(1)+fib(0)=2
		//n=3 return fib(2)+fib(1)=3

4.3.2 用数组方法

function gitFib(n){
			if(n<=1){
				return 1
			}else{
				var arr=[1,1]
				for(var i=2;i<=n;i++){
					arr.push(arr[i-1]+arr[i-2])
				}
				return arr.pop()
			}
		}

5.数据类型转换

• 强制转换
  Number()转换成数字 ；String()转换成字符串 ；BooLean()转换成布尔值

• 隐式转换
  +字符串连接符（隐式转换成字符串）
  ± * / 数学运算（隐式转换成数字）

= <= || && ! 比较与逻辑

• 字符串和任意数据 + 连接都会转换成字符串
• 数学运算符会尝试隐式转换数据为数字，如果数据没有转换数字成功，结果就是NaN
• 逻辑比较运算符会把变量转换成布尔值
  空字符串,0,null,undefined,NaN,false 才会被转换成false,其他都会被转换成true,把以上变量值成为falsely变量值,其他变量都称为truly变量值
  Alert(!!null)

6. 严格等于与等于

6.1 等于

==判断转换后的值是否相等

console.log(100 == "100");  //true(如果两边类似数字会优先隐式转换为数字)
console.log("" == false);  //true
console.log(1 == true);// true
console.log(null == undefined);// true 隐式转换后都为fasle
console.log(null == null);  // true  空指针都指向一个地方(空)
console.log(undefined == undefined);//
console.log(null == NaN);false(特殊) 数字不等于空
console.log([] == []);//false  //两块不同的内存地址
console.log({}== {});//false  //两块不同的内存地址

6.2 严格等于

===严格等于 判断类型与值是否相等

// === 严格等于 判断类型 与值 是否相对
alert(0 === ""); //false
alert([] === []); //false
alert({} === {}); //false
alert(null === undefined); //false
alert(null === null); //true

//应该都用=== 严格等于
//判断是为null 还是undefined 可以用===

7.if判断

1. If 判断只要求()内表达式结果是否为truly变量
2. Falsely变量对变量取两次反!! 得到结果为false 的变量 称为falsely变量
3. False “” 0 NaN undefined null

8.逻辑运算符

• || 或 如果前面的变量是truly最终结果为第一个，如果为falsely结果为第二个
  Var a=15||0 //15 转换结果为true，a的值就是15
  Var b=false||50 //50 转换结果为false，b的值就是50
• && 且 前面是truly变量则返回后面的值，前面是falsely变量直接使用前面的值
  Var c=15&&19 //15
  Var c=false&&19 //false

9.原型与原型链

9.1 什么是类，什么是实例

类： 构造对象的一个模板。Array,Object,String
实例：就是由类创建的对象。[1,2,3],{name:”susu”}
本质上讲，类是个函数，实例是由一个函数创建的对象

9.2 什么是原型，什么原型链

9.2.1 原型

(1) 每一个类（构造函数）都有一个显式原型prototype
(2) 每一个实例都有一个隐式原型__proto__
(3) 类的显示原型prototype===其实例的隐式原型__proto__

var arr=[1,3,5]
  Array.prototype===arr.__proto__

9.2.3 原型链

当查找对象的一个属性时，先从自身找，找不到沿着__proto__的__proto__向上查找。
此时，我们就把__proto__形成的链条关系称为原型链。

原型链实现继承

  //01 创建people类
               function People(name,age){
                   this.name=name;
                   this.age=age;
               }
               //02 给people显示原型添加eat方法
               People.prototype.eat=function(){
                   console.log(this.name+"正在吃饭");
               }
               //03 创建学生类继承people类
               function Student(name,age,no){
                   //执行People构造函数，并把当前this传入函数
                   People.call(this,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+"正在海海学习");
               }
               //07 构建Student的实例s1
               var s1=new Student("冬至",19,1325)

原理图示

9.3 原型与原型链有什么作用

(1) 在js中实现继承
(2) 实现类的方法实列扩展

小方法：

• 把求数组最大最小值通用方法挂载到类的原型
  -Array.prototype.max=function(){ return Math.max(...this) }
• 字符串通用的翻转方法String.prototype.reverse=function(){ return this.split("").reverse().join("") }