js高频面试题

function fnArr(arr){
	var newArr = [];
	arr.forEach((item,index)=>{
		newArr.push( Math.max(...item)  )
	})
	return newArr;
}
console.log(fnArr([
	[4,5,1,3],
	[13,27,18,26],
	[32,35,37,39],
	[1000,1001,857,1]
]));

给字符串对象定义一个addPrefix函数，当传入一个字符串str时，它会返回新的带有指定前缀的字符串，例如：

console.log( 'world'.addPrefix('hello') ) 控制台会输出helloworld

String.prototype.addPrefix = function(str){
	return str  + this;
}
console.log( 'world'.addPrefix('hello') )

    var str = 'aaasdwqeasdaqwd';
    var o = {};
    for (var i = 0; i < str.length; i++) {
      var index = str[i];
      if (!o[index]) {
        o[index] = 1;
      } else {
        o[index]++;
      }
    }

    var max = 0;
    var str1 = '';
    for (var k in o) {
      if (o[k] > max) {
        max = o[k];
        str1 = k;
      }
    }

    console.log('出现最多的次数:' + max + '及其字母为:' + str1);

1. 闭包是什么
    闭包是一个函数加上到创建函数的作用域的连接，闭包“关闭”了函数的自由变量。

 优点：1.可以访问到函数内部的局部变量，

            2.可以避免全局变量的污染，

            3.这些变量的值始终保持在内存中，不会在外层函数调用后被自动清除。

缺点：会增大内存使用量，滥用闭包会影响性能，导致内存泄漏【如果说一定要提到ie】等问题。

解决方法：在退出函数之前，将不使用的局部变量全部删除，可以使变量赋值为null。

1. 原型可以解决什么问题

2. 谁有原型

3. 对象查找属性或者方法的顺序

4. 原型链
    4.1 是什么？：就是把原型串联起来
    4.2 原型链的最顶端是null

class Parent{
	constructor(){
		this.age = 18;
	}
}

class Child extends Parent{
	constructor(){
		super();
		this.name = '张三';
	}
}
let o1 = new Child();
console.log( o1,o1.name,o1.age );

function Parent(){
	this.age = 20;
}
function Child(){
	this.name = '张三'
}
Child.prototype = new Parent();
let o2 = new Child();
console.log( o2,o2.name,o2.age );

function Parent(){
	this.age = 22;
}
function Child(){
	this.name = '张三'
	Parent.call(this);
}
let o3 = new Child();
console.log( o3,o3.name,o3.age );

function Parent(){
	this.age = 100;
}
function Child(){
	Parent.call(this);
	this.name = '张三'
}
Child.prototype = new Parent();
let o4 = new Child();
console.log( o4,o4.name,o4.age );

共同点：功能一致

可以改变this指向

语法： 函数.call()、函数.apply()、函数.bind()

区别：

场景：

1. 用apply的情况
var arr1 = [1,2,4,5,7,3,321];
console.log( Math.max.apply(null,arr1) )

2. 用bind的情况
var btn = document.getElementById('btn');
var h1s = document.getElementById('h1s');
btn.onclick = function(){
	console.log( this.id );
}.bind(h1s)

V8 引擎 sort 函数只给出了两种排序 InsertionSort 和 QuickSort，数量小于10的数组使用 InsertionSort，比10大的数组则使用 QuickSort。

之前的版本是：插入排序和快排，现在是冒泡

原理实现链接：https://github.com/v8/v8/blob/ad82a40509c5b5b4680d4299c8f08d6c6d31af3c/src/js/array.js

***710行代码开始***

共同点：复制
 

1. 浅拷贝：只复制引用，而未复制真正的值。

var arr1 = ['a','b','c','d'];
var arr2 = arr1;

var obj1 = {a:1,b:2}
var obj2 = Object.assign(obj1);

2. 深拷贝：是复制真正的值 （不同引用）

var obj3 = {
	a:1,
	b:2
}
var obj4 = JSON.parse(JSON.stringify( obj3 ));

//递归的形式

var oldObj = {
      a: 1,
      b: 2,
      arr: ['1', '2', '3']
    };
    var newObj = {};

    function recursion(newObj, oldObj) {
      for (var k in oldObj) {
        var item = oldObj[k];
        if (item instanceof Array) {
          newObj[k] = [];
          recursion(newObj[k], item);
        } else if (item instanceof Object) {
          newObj[k] = {};
          recursion(newObj[k], item);
        } else {
          newObj[k] = item;
        }
      }
      return newObj;
    }
    recursion(newObj, oldObj);
    newObj.a = '我是你爸爸真伟大'
    console.log(newObj);
    console.log(oldObj);

公共点：在客户端存放数据

区别：

1. 数据存放有效期

2. localStorage、sessionStorage不可以设置过期时间

3. 存储大小的限制

        ****根据不同的浏览器存储的大小是不同的。

防抖：高频的触发事件，规定时间内触发会被清除，只有当超过规定时间触发，然后执行最后一次事件
节流：高频的触发事件，限制触发次数，规定时间内只能触发一次

var、let、const 共同点都是可以声明变量的

区别一：

区别二：

区别三：

区别四：

考题一：let和const没有变量提升性

console.log( str );//undefined
var str = '你好';

console.log( num );//报错
let num = 10;

考题二：

function demo(){
	var n = 2;
	if( true ){
		var n = 1;
	}
	console.log( n );//1
}
demo();


function demo(){
	let n = 2;
	if( true ){
		let n = 1;
	}
	console.log( n );//2
}
demo();

考题三：可以修改

const obj = {
	a:1
}
obj.a = 11111;
console.log( obj )

const arr = ['a','b','c'];
arr[0]= 'aaaaa';
console.log( arr );

方式一：Object.assign

const a = {a:1,b:4};
const b = {b:2,c:3};

let obj1 = Object.assign(a,b);
console.log( obj1 );

方式二：...

let obj2 = {...a,...b};
console.log( obj2 );

方式三：自己封装方法

function extend( target,  source ){
	for(var key in source){
		target[key] = source[key];
	}
	return target;
}
console.log( extend(a,b) );

1. this指向的问题

2. 箭头函数不能new（不能当作构造函数）
3. 箭头函数prototype
4. 箭头函数arguments

有三种状态：

区别一：返回的内容不同

区别二：