1.数组去重方法
ES6 Set关键字
const _uniq = array => {
return [...new Set(array)]
}
数组方法indexOf
const uniq = array => {
let result = [];
for(let i in array){
if(result.indexOf(array[i]) === -1) result.push(array[i])
}
return result;
}
数组方法sort
纯数字，先排序再用相邻的对象进行比较
const uniq = array => {
let result = [];
array.sort()
for(let i = 0;i<array.length;i++){
if(array[i]!== array[i-1]) result.push(array[i])
}
return result;
}
双指针 方法
指针所指的值不相等的时候才加一，并改变原数组，最后用slice方法和慢指针取值
[-1,1,2,2]
const uniq = array => {
let slow = 0,fast = 0;
while(fast<array.length){
if(array[slow] !== array[fast]){
slow++;
array[slow] = array[fast]
}
fast++
}
return array.slice(0,slow+1)
}
数组方法reduce
const uniq = array => {
return array.reduce((a,b)=>a.includes(b)?a:[...a,b],[])
}
2.reduce方法
for循环 方法
上一次输出的值作为下一次输入的值
Array.prototype._reduce = function(fn){
let num = 0;
for(let i = 0;i<this[i];i++){
num = fn(num,this[i],i,this)
}
return num;
}
3.map方法
for循环 方法
Array.prototype._map = function(fn){
let result = [];
for(let i in this){
result[i] = fn(this[i])
}
return result;
}
数组方法reduce
上一次输出的值作为下一次输入的值,a初始值为[]
Array.prototype._map = function(fn){
return this.reduce((a,b)=> [...a, fn(b)], [])
}
4.filter方法
for循环
Array.prototype._filter = function(fn){
let result = [];
for(let i in this){
if(fn(this[i],i,this)) result.push(this[i])
}
return result;
}
数组方法reduce
上一次输出的值作为下一次输入的值,a初始值为[]
Array.prototype._filter = function(fn){
return this.reduce((a, b) => fn(b) ? [...a, b] : a, []);
}
5.some方法
for循环 方法
有满足条件的就返回true
Array.prototype._some = function(fn){
for(let i in this){
if(fn(this[i])) return true;
}
return false;
}
数组方法reduce
上一次输出的值作为下一次输入的值,a初始值为[]
Array.prototype._filter = function(fn){
return this.reduce((a, b) => fn(b) ? [...a, b] : a, []);
}
6.flat方法
while 循环+ some方法
判断数组元素中是否还有数组，使用concat拼接，使数组扁平化
function flat(arr) {
while (arr.some(item=> Array.isArray(item))) {
arr = [].concat(...arr)
}
return arr
}
reduce 方法
上一次输出的值作为下一次输入的值,a初始值为[]
function flat(arr) {
return arr.reduce((a, b) => a.concat(Array.isArray(b) ? flat(b) : b), [])
};
使用堆栈避免递归 方法
使用数据结构栈的特性取代递归操作,减少时间复杂度
function flat(arr) {
const result = [];
const stack = [].concat(arr);
while (stack.length !== 0) {
const val = stack.pop();
if (Array.isArray(val)) stack.push(...val)
else result.unshift(val)
}
return result;
}
7.字符串全排列
递归 方法
const _permute = string => {
if(string.length<2) return [string];
let result = [];
for(let i of string){
let arr = string.split('').filter(e=>e!==i);
_permute(arr.join('')).forEach(item=>{
result.push(item+i)
})
}
return result;
}
8.instanceof
const _instanceof = (target, Fn) => {
while(true){
if(target === null) return false;
if(target.__proto__ === Fn.prototype) return true;
target = target.__proto__
}
9.实现函数 call 方法
Function.prototype._call = function(context,...arg){
if(!context) context !== window;
let fn = Symbol();
context[fn] = this;
return context[fn](...arg)
}
10.实现函数 bind 方法
Function.prototype._bind = function(context,...args){
let _this = this;
return function(...innerArg){
return _this.call(context,args.concat(innerArg))
}
}
11.防抖节流柯里化
防抖
search搜索联想，用户在不断输入值时，用防抖来节约请求资源（在输入完毕后执行）
const debounce = (fn,delay = 1000)=>{
let timer;
return function(){
let args = argumens;
clearTimeout(timer)
timer = setTimeout(()=>{
fn.apply(this,args)
},delay)
}
}
节流
——鼠标不断点击触发，单位时间内只触发一次
const throttle = (fn,delay = 1000)=>{
let flag = true;
return function(){
if(!flag) return;
flag = false;
setTimeout(()=>{
fn();
flag = ture;
},delay)
}
}
柯里化
const curryIt = (fn)=>{
let len = fn.length,args = [];
let result = function(arg){
args.push(arg);
len--;
if(len<=0) return fn.apply(this,args);
else return result;
}
return result;
}
let fn = (a, b, c)=> a + b + c;
curryIt(fn)(1)(2)(3); // 6
12.new 关键字
const _new = function(fn,...args) {
let obj = {}
obj.__proto__ = fn.prototype
fn.call(obj,...args)
return obj
}
13.深浅拷贝
浅拷贝
只复制指向某个对象的指针，而不复制对象本身，新旧对象共享一块内存
利用 = 赋值操作符实现浅拷贝
深拷贝
复制并创建一个一摸一样的对象，不共享内存，修改新对象，旧对象保持不变
const _cloneDeep = (target, map = new Map()) => {
if(target !== null && typeof target === 'object'){
let result = Array.isArray(target)?[]:{};
if(map.has(target)) return map.get(target);
map.set(target,result);
for(let i in target){
result[i] = _cloneDeep(target[i],map);
}
return result;
}
return target;
}
14.发布订阅模式
class EventEmitter {
constructor(){
this.eventList = {}
}
on(event,fn){
let fns = this.eventList[event] || [];
fns.push(fn);
this.eventList[event] = fns;
}
emit(event,...message){
let fns = this.eventList[event] ||[];
if(!fns) return;
fns.forEach(item=>{
item(...message)
})
}
}
15.斐波那契数列
function fibonacci(n) {
if(n<3) return 1;
return fibonacci(n-1) + fibonacci(n-2)
}
