JS-高频面试算法题

发布订阅模式：

　　否有中间的调度中心。

1. 观察者模式把订阅者维护在发布者这里，需要发布消息时直接发消息给订阅者。在观察者模式中，发布者本身是知道订阅者存在的。
2. 而发布/订阅模式中，发布者并不维护订阅者，也不知道订阅者的存在，所以也不会直接通知订阅者，而是通知调度中心，由调度中心通知订阅者。

class EventBus {
  constructor () {
    this.events = Object.create(null)
  }
  on (event, fn) {
    this.events.event = this.events.event || []
    this.events.event.push(fn)
  }
  off (event, fn) {
    const index = (this.events.event || []).indexOf(fn)
    if (index < -1) {
      return
    } else {
      this.events.event.splice(index, 1)
    }
  }
  fire (event) {
    this.events.event.forEach(fn => fn())
  }
}
var bus = new EventBus()
bus.on('onclick', function () {
  console.log('click1 fire')
})
bus.on('onclick', fn=function () {
  console.log('click2 fire')
})
bus.fire('onclick')

 

观察者模式

class Observer {
  constructor (fn) {
    this.update = fn
  }
}
class Subject {
  constructor () {
    this.observers = []
  }
  addObserver (observer) {
    this.observers.push(observer)
  }
  removeObserver (observer) {
    const delIndex = this.observers.indexOf(observer)
    this.observers.splice(delIndex, 1)
  }
  notify () {
    this.observers.forEach(observer => {
      observer.update()
    })
  }
}

var subject = new Subject()
var ob1 = new Observer(function () {
  console.log('ob1 callback run')
})
subject.addObserver(ob1)
var ob2 = new Observer(function () {
  console.log('ob2 callback run')
})
subject.addObserver(ob2)
subject.notify()

防抖与节流

// 防抖，在一定事件内，多次触发事件，会重新计算时间进行执行
        // 防抖  input 校验   模糊搜索  resize
        function debounce (fn,delay) {
            // 记录上一次的延时器
            var timer = null;
            return function () {
                // 清除上一次的延时器
                clearTimeout(timer);
                // 重新设置新的延时器
                timer = setTimeout(function () {
                    fn.apply(this);
                },delay)
            }
        }

　　

        function throttle (fn, delay) {
            var lastTime = 0;
            return function () {
                var nowTime = Date.now();
                if (nowTime - lastTime > delay) {
                    fn.call(this);
                    lastTime = nowTime;
                }
            }
        }

　　

深拷贝

一：JSON.parse(JSON.stringify(obj));   采用 JSON 进行的深拷贝，无法拷贝到 undefined、function、symbol 这类数据，它是有小 bug 的深拷贝。



二
    function deepCopy (obj) {
    let result = obj;
    if (typeof(obj) === 'string' && obj !== null) {
        result = Object.prototype.toString.call(obj) === '[object Array]' ? [] : {};
        for (let prop in obj) {
            result[prop] = deepCopy(obj[prop]);
        }
    }
    return result;
}

var obj = {
    name: 'xiao',
    age: 24,
    run :{
        function () {
            console.log(1)
        }
    }
};

　　

function deepCopy (obj) {
    // 排除null
    if (obj === null) {
        return null;
    }
    // 判断是数组还是对象
    var result = Array.isArray(obj) ? [] : {}; 
    // 循环
    for (let key in obj) {
        // 判断属性是否存在
        if(obj.hasOwnProperty(key)) {
            if (typeof obj[key] === 'object') {
                // 如果还是对象，再次调用此方法
                result[key] = deepCopy(obj[key]);
            } else {
                result[key] = obj[key]
            }
        }
    }
}

　　

数组去重

var arr =[1,2,3,4,5,2,3];
var arr1 = [... new Set(arr)]

　　

var  arr =  [1,2,3,4,2,1];
var arr1 = arr.reduce(function(ar, item){
     if (!ar.includes(item)) {
        ar.push(item);
    }
    return ar;
},[]);

　　

字符串反转，代码句子位置反转

        function reverse(str) {
            return str
                .split('')
                .reverse()
                .join('')
        }
        console.log(reverse(str));

　　

二分法查找索引

var ary=[1,4,7,8,12,34,67,88,99,100]
        function getIndex(arr,num) {
            var len = arr.length;
            var st = 0;
            var end = len-1;
            while(str<end){
                var mid = Math.floor((st+end)/2);
                if (num = arr[mid]) {
                    return mid;
                } else if (num > arr[mid]) {
                    st = mid +1;
                } else {
                    end = mid-1;
                }
            }
        }

　　

冒泡排序

// 冒泡排序
//从小到大
function BubbleSort(arr){
    var i,j,temp;
    for(i=0;i<arr.length-1;i++){
        for(j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                temp=arr[j];
                arr[j]=arr[i];
                arr[i]=temp;
            }
        }
    }
    return arr;
}
var arr=[10,7,9,11,22,33,4,2,0,1000];
BubbleSort(arr);  
console.log(arr); //[0, 2, 4, 7, 9, 10, 11, 22, 33, 1000]

　　

代码继承

function a() {
    this.name = '张三';
}
a.prototype.getName = function() {
return this.name;
}

var instance = new a();
console.log(instance.getName());//'张三'

数组去重排序

　 var arr=[1,2,3,4,2,4,9,7,8];
  var arr2=[];
  //第一步去重
  for(let x of arr){
    arr2.indexOf(x)===-1?arr2.push(x):'';
  }
  console.log(arr2);//已经去重
  //第二步排序
  arr2.sort(function(a,b){return a-b;})
  console.log(arr2);//已经排序

数组[1,2,3,4,3]把最大数找出来；

for(var i=0; i<arr.length;i++){
    max = max<arr[i+1] ? arr[i+1] : max;
  }
 console.log(max)

字符串回文　　

        var  str = "abcba";  // 判断是否是回文

        function palindRome (str) {
            var tempArr = str.split('');
            return tempArr.reverse().join('') === str;
        }
        palindRome(str);

 给定一个数组和一个目标值target，找出两个数之和等于target，并返回下标

function getIndexArr(array,target){
	var map = new Map();
	for (var i=0;i < array.length; i++) {
		if (map.has(target-array[i]) && map.get(target-array[i]) !== i) {
			return [i,map.get(target-array[i])];
		}
		map.set(array[i],i);
	}
}

　　

function getIndexArr(array,target){
	for (var i = 0; i < array.length; i++) {
		for (var j = i + 1; j < array.length; j++) {
			if (array[i] + array[j] === target) {
				return [i,j]
			}
		}
	}
}