几道经典js面试题

关于堆栈内存的几道题

1对象属性名数字和字符串数字是相等的

           let a={},b="0",c=0;  
			a[b] = "呵呵"; //a["0"] = "呵呵"
			a[c] = "hh"; //a["0"] = "hh"
			console.log(a[b]); //hh
			/*一个对象中属性名不能重复，属性名一般都是字符串（数字0和字符串0是相等的）*/

2对象的属性名可以是Symbol和其他基本类型

            let a = {},
			b = Symbol("1")  //Symbol（es6新增原始数据类型）特点是创建唯一值,
			c = Symbol("1")
			a[b] = "呵呵"  
			a[c] = "hh"
			console.log(a[b])  //呵呵
			/*对象的属性名可以是Symbol和其他基本类型（ string  number boolean undefined null）值，需要注意的是数值和字符串数字是相等的
			
			*/

3对象的属性名是引用类型会转成字符串存储

	
			let a = {},
			b ={n:"1"}
			c = {m:"2"}
			a[b] = "呵呵" //a[Object object] =  "呵呵" 
			a[c] = "hh" //a[Object object] =  "hh"
			console.log(a[b])  //hh

执行上下文和闭包

1

var test = (function(i){  //
    return function(){	
				alert(i *2) ; //alert输出的值都是toString后的字符串
		}
})(2)    //函数自执行创建了执行上下文//test等于的是函数执行
test(5);//"4" 

2

		    var a = 0,b=0;  
			function A(a){ 
				A=function(b){ 
					alert(a+b++)
				};  //重写了全局方法A
				alert(a++)
			}
			A(1);//"1"
			
			A(2);//"4"

对象（数组）的深克隆和浅克隆

1浅克隆

let obj ={
				a:100,
				b:[10,20,30],
				c:{x:10},
				d:/^\d+$/
			};
let obj2 = {};

//用es6三点运算符浅克隆
//let obj2={...obj};

//不用es6,循环浅克隆
for(let key in obj){
	if(obj.hasOwnProperty(key)){ //不是私有属性就不遍历
		 obj2[key] = obj[key]
	}
   
}
console.log(obj==obj2) //false

2

	//深克隆
			let obj2=JSON.stringify(obj);//先把obj对象转为字符串  ，注意：函数/日期格式数据/正则在JSON.stringify()上都会出现问题
			
			
			function deepClone(obj){
				//过滤特殊情况
				if(typeof obj == null) return null;
				if(typeof obj!= "object") return obj;
				if(obj instanceof RegExp){
					return new RegExp(obj);  //创建一个新实例，不用原来的地址
				}
				if(obj instanceof Date){
					return new Date(obj);  
				}
				//不直接创建空对象目的：克隆结果和之前保持相同的所属类
				let newObj = new obj.constructor; 
				for(let key in obj){
					if(obj.hasOwnProperty(key)){
						 newObj[key] = deepClone(obj[key]) //递归调用
					}
				   
				}
				return newObj ;
			}

面向对象

	function Foo(){
			getName = function(){
				console,log(1)
			}
			return this;
		}
		Foo.getName = function(){
			console.log(2)
		}
		Foo.prototype.getName = function(){
			console.log(3)
		}
		var getName = Function(){
			console.log(4)
		}
		function getName(){  //函数变量提升
			console.log(5)
		}
		Foo.getName();//2
		getName();//4
		Foo().getName();//1
		getName();//1
		new Foo.getName(); //2
		new Foo().getName(); //3 //实例的getName要去找原型的getName
		new  new Foo().getName(); //	3

同步异步

        async function async1(){
			console.log("async1 start")
			await async2()
			console.log("async1 end")
		}
		async function async2(){
			console.log("async2")
		}
		console.log("script start")
		setTimeout(fucntion(){
			console.log("setTimeout")
		},0)
		async1()
		new Promise(function(resolve){
			console.log("promise1")
			resolve()
		}).then(function(){
			console.log("promise2")
		})
		console.log("script end")
		/*
		输出结果：
     script start
	 async1 start
	 async2
	 promise1
	 script end 
	 async1 end
	 promise2
	 setTimeout
	 		*/
		

数据类型转换

var a=?;
if (a==1 && a==2 && a==3){
	console.log("条件成立")
}
//a等于什么输出条件成立？

答案1：（通过重写toString(）)

1.对象 == 字符串 是对象.toString()变为字符串再比较
2.null == undefined 相等，但是和其他值比较就不相等了
3.NAN 与任何包括自己不相等
4.剩下的都转换为数字

var a={
    i :0,
	toString(){  //也可以用valueOf
		return ++this.i;
	}
}

答案2（通过数据劫持）
…