常见的代码实现

Github 代码实现案例

• 二叉搜索树 中序、先序、后序遍历 搜索树中的值
• vue设计原理简单实现:数据劫持、依赖收集、模板编译、双向绑定、计算属性
• spa单页路由设计简单实现
• 浏览器缓存交互实现
• npm发布li-server静态服务器编写
• node events模块实现 发布订阅

  JavaScript数据结构与算法pdf资源

  百度网盘 密码:ll8d
  如果不喜欢看pdf可以看下面在网上发现一个博客讲解
  数据结构与算法讲解.html)

  高阶函数实现AOP（面向切面编程）

  什么是面向切面编程? ```javascript Function.prototype.before = function (beforefn) { let _self = this; // 缓存原函数的引用 return function () { // 代理函数

    beforefn.apply(this, arguments); // 执行前置函数
    return _self.apply(this, arguments); // 执行原函数

  } }

Function.prototype.after = function (afterfn) { let _self = this; return function () { let set = _self.apply(this, arguments); afterfn.apply(this, arguments); return set; } } let func = () => console.log(‘func’); func = func.before(() => { console.log(‘===before===’); }).after(() => { console.log(‘===after===’); });

func();

输出结果：

1. ===before===
2. func
3. ===after===
4. 复制代码 ```

   斐波那契数列

   斐波那契数列从第三项开始，每一项都等于前两项之和。指的是这样一个数列：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144 …

得到数列中第n项指向的数值是多少
1.递归

function fib(n) {
  if (n === 1 || n === 2) return n - 1;
  return fib(n - 1) + fib(n - 2);
}
console.log(fib(10)); // 34

时间复杂度为O(2^n)
2.非递归

1. function fib(n) {
2. let a = 0;
3. let b = 1;
4. let c = a + b;
5. for (let i = 3; i < n; i++) {
6. a = b;
7. b = c;
8. c = a + b;
9. }
10. return c;
11. }
12. console.log(fib(10)); // 34
13. 复制代码

时间复杂度为O(n)

一道关于Array push的JS题

1. // 类数组
2. let obj = {
3. '1': 'a',
4. '2': 'b',
5. length: 2
6. };
7. 
8. Array.prototype.push.call(obj, 'c');
9. 
10. console.log(obj); // { '1': 'a', '2': 'c', length: 3 }
11. 
12. 复制代码

push和pop实现

Array的push底层实现是依赖于 数组的length属性的

1. Array.prototype.push2 = function(){
2. this.splice.apply(this, [this.length, 0].concat(Array.prototype.slice.apply(arguments)));
3. return this.length;
4. }
5. 复制代码

对于 pop也是一样

1. Array.prototype.pop2 = function(){
2. return this.splice(this.length - 1, 1)[0];
3. }
4. 复制代码

算法题

1.在一个数组中 找出里面其中两项相加后的和为num，如果存在就返回两个数的索引位置，否则false

1. function fn(num = 0, ary = []) {
2. for (let i = 0; i < ary.length; i++) {
3. let diff = num - ary[i];
4. let diffIndex = ary.indexOf(diff);
5. if (diffIndex !== -1) {
6. return [i, diffIndex];
7. }
8. }
9. return false;
10. }
11. 
12. let num = 3;
13. let arr = [-1, 4, 6, 2];
14. 
15. console.log(fn(num, arr)); // [0, 1]
16. 复制代码

2. 将两个有序数组合并为一个排好序的大数组

1. function mergeAry(left = [], right = []) {
2. const result = [];
3. while (left.length && right.length) {
4. result.push(left[0] <= right[0] ? left.shift() : right.shift());
5. }
6. return result.concat(left, right);
7. }
8. 
9. console.log(mergeAry([1, 2, 3], [1, 4, 8, 9])); // [ 1, 1, 2, 3, 4, 8, 9 ]
10. 复制代码

字符串repeat实现

1. // 原生repeat
2. 'ni'.repeat(3); // 'ninini'
3. 
4. // 实现一
5. String.prototype.repeatString1 = function (n) {
6. return Array(n + 1).join(this);
7. }
8. console.log('ni'.repeatString1(3));
9. 
10. // 实现二
11. String.prototype.repeatString2 = function (n) {
12. return Array(n).fill(this).join('');
13. }
14. console.log('ni'.repeatString2(3));
15. 复制代码

当我们 new 一个类的时候 都发生了什么

1. /**
2. * new2 new关键字的代码实现演示
3. * @param {function} func 被new的类 (构造函数)
4. */
5. function new2(func) {
6. // 创建了一个实例对象 o，并且这个对象__proto__指向func这个类的原型对象
7. let o = Object.create(func.prototype);
8. // (在构造函数中this指向当前实例)让这个类作为普通函数值行 并且里面this为实例对象
9. let k = func.call(o);
10. // 最后再将实例对象返回 如果你在类中显示指定返回值k，
11. // 注意如果返回的是引用类型则将默认返回的实例对象o替代掉
12. return typeof k === 'object' ? k : o;
13. }
14. 
15. // 实验
16. function M() { // 即将被new的类
17. this.name = 'liwenli';
18. }
19. 
20. let m = new2(M); // 等价于 new M 这里只是模拟
21. console.log(m instanceof M); // instanceof 检测实例
22. console.log(m instanceof Object);
23. console.log(m.__proto__.constructor === M);
24. 复制代码

this/bind

1. let obj = { a: 1};
2. function fn() {
3. this.b = 100;
4. return this.a;
5. }
6. let fe = fn.bind(obj);
7. console.log(fe()); // 1  里面this是obj
8. console.log(obj); // { a: 1, b: 100 }
9. console.log(new fe()); // 里面this是当前创建实例对象 { b: 100 }
10. 
11. 复制代码

Object.create 兼容实现

1. let obj1 = {id: 1};
2. Object._create = (o) => {
3. let Fn = function() {}; // 临时的构造函数
4. Fn.prototype = o;
5. return new Fn;
6. }
7. 
8. let obj2 = Object._create(obj1);
9. console.log(obj2.__proto__ === obj1); // true
10. console.log(obj2.id); // 1
11. 
12. // 原生的Object.create
13. let obj3 = Object.create(obj1);
14. console.log(obj3.__proto__ === obj1); // true
15. console.log(obj3.id); // 1
16. 复制代码

一道面试题

解法一

1. function CodingMan(name) { // 主要考察的是 面向对象以及JS运行机制（同步 异步 任务队列 事件循环）
2.     function Man(name) {
3.         setTimeout(() => { // 异步
4.             console.log(`Hi! This is ${name}`);
5.         }, 0);
6.     }
7. 
8.     Man.prototype.sleep = function(time) {
9.         let curTime = new Date();
10.         let delay = time * 1000;
11.         setTimeout(() => { // 异步
12.             while (new Date() - curTime < delay) {} // 阻塞当前主线程
13.             console.log(`Wake up after ${time}`);
14.         }, 0);
15.         return this;
16.     }
17. 
18.     Man.prototype.sleepFirst = function(time) {
19.         let curTime = new Date();
20.         let delay = time * 1000;
21.         while (new Date() - curTime < delay) {} // 阻塞当前主线程
22.         console.log(`Wake up after ${time}`);
23.         return this;
24.     }
25. 
26.     Man.prototype.eat = function(food) {
27.         setTimeout(() => { // 异步
28.             console.log(`Eat ${food}~~`);
29.         }, 0)
30.         return this;
31.     }
32. 
33.     return new Man(name);
34. }
35. 
36. // CodingMan('Peter');
37. // CodingMan('Peter').sleep(3).eat('dinner');
38. // CodingMan('Peter').eat('dinner').eat('supper');
39. // CodingMan('Peter').sleepFirst(5).eat('supper');
40. 复制代码

解法二

1. function CodingMan(name) {
2. function fe() {
3. fe.flag = true;
4. console.log(`Hi! This is ${name}`);
5. }
6. fe.flag = false;
7. fe.timer = setTimeout(() => {
8. clearTimeout(fe.timer);
9. if (!fe.flag) fe();
10. }, 0);
11. return fe;
12. }
13. 
14. Function.prototype.sleep = function (delay) {
15. this()
16. this.await(delay);
17. return this;
18. }
19. 
20. Function.prototype.sleepFirst = function (delay) {
21. this.await(delay);
22. this();
23. return this;
24. }
25. 
26. Function.prototype.eat = function (dinner) {
27. setTimeout(() => {
28. console.log(`Eat ${dinner}~`);
29. });
30. return this;
31. };
32. 
33. Function.prototype.await = function (delay) {
34. delay = isNaN(delay) ? 0 : delay;
35. let startTime = new Date();
36. let delayTime = delay * 1000;
37. while (new Date() - startTime <= delayTime) {
38. }
39. console.log(`Wake up after ${delayTime}ms`);
40. }
41. // CodingMan('peter')
42. // CodingMan('peter').sleep(2).eat('hanbao');
43. // CodingMan('peter').sleepFirst(2).eat('hanbao');
44. CodingMan('peter').eat('haha').eat('hanbao');
45. 复制代码

currying 函数柯理化

bind 柯理化

1. function add(a, b, c) {
2. return a + b + c;
3. }
4. let f1 = add.bind(undefined, 100);
5. console.log(f1(2, 3)); // 105 = 100 + 2 + 3
6. let f2 = f1.bind(undefined, 200);
7. console.log(f2(3)); // 303 = 100 + 200 + 3
8. 
9. 复制代码

curry 柯理化的实现（递归调用 + valueOf）

知识点：对象的valueOf浏览器环境下 隐式转化为基本数据类型（一元操作符+object/字符串拼接 ‘’+object）时，会调用自身的valueOf方法取值，如果自身也存在toString方法 先调用valueOf 如果valueOf返回值不是基本数据类型 则调用toString， toString的返回值也不是基本数据类型就报错。

valueOf调用场景

1. let obj = { x: 1, y: 2 };
2. 
3. obj.toString = function() {
4. return this.x + this.y;
5. }
6. 
7. obj.valueOf = function() {
8. return this.x + this.y + 100;
9. }
10. 
11. // 以下情况下自身valueOf被调用
12. console.log('' + obj); // 103
13. console.log(+obj); // 103
14. 复制代码

1. function fn() {};
2. fn.valueOf = () => console.log('valueof');
3. console.log(fn); // valueof
4. 复制代码

1. const mul = x => {
2. const result = y => mul(x * y); // 递归调用mul
3. result.valueOf = () => x;
4. return result;
5. }
6. console.log(mul(2)(3)); // 6
7. 
8. // 在上面mul每执行一次,就会返回一个valueOf被改写后的新函数result 并且result执行会在里面调用mul(x * y)
9. // 在result函数的valueOf里保存着 由上一次x * y 传进来的结果x, 也就是上一次x*y 会作为这一次的输出 依然叫x
10. 
11. // 第一次mul(2) 此时 x为2  return result
12. result 为 result = y => mul(2 * y);
13. // 第二次 mul(2)(3) 等价于 第一个mul返回的result(3), result执行 => mul(2 * 3) 再次调用mul 将2*3 = 6 的结果作为mul参数
14. // 最后mul(6) x = 6 在返回一个新函数result 此时result的valueOf = () => 6
15. 
16. // log(mul(2)(3)) 相当于log的最后返回的result 隐式调用valueOf 返回 6
17. 复制代码

curry 将多参数函数转换为接收单一参数的函数

1. function fe(a, b, c) {
2. return a + b + c;
3. }
4. 
5. function curry(fe) {
6. let args = []; // 参数集合
7. let len = args.length;
8. return function bar() {
9. args = [...args, ...arguments]; // 收集参数
10. if (args.length >= fe.length) {
11. return fe.apply(this, args);
12. }
13. return bar;
14. }
15. }
16. 
17. console.log(curry(fe)(1)(2)(3)); // 6
18. 复制代码

currying 部分求值

1. // currying 函数柯理化
2. let currying = function(fn) {
3. let args = [];
4. return function fe() {
5. if (arguments.length === 0) {
6. return fn.apply(this, args);
7. }
8. [].push.apply(args, arguments);
9. return fe;
10. }
11. }
12. let count = currying(function (...rest) {
13. return rest.reduce((prev, cur) => prev + cur, 0);
14. });
15. 
16. console.log(count(100)(200)(10)()); // 310
17. 复制代码

收集参数 延迟执行 到达指定次数才执行

1. // 参数收集 指定次数后执行
2. function fn(...rest) {console.log(rest);};
3. function after(fn, time = 1) {
4. let params = [];
5. return function(...rest) {
6. params = [...params, ...rest];
7. if (--time === 0) {
8. fn.apply(this, params);
9. }
10. }
11. }
12. let newFn = after(fn, 3); // 执行3次 内部fn才会执行
13. newFn(2);
14. newFn(3);
15. newFn(4);
16. 复制代码

函数节流

throttle 策略的电梯。保证如果电梯第一个人进来后，50毫秒后准时运送一次，不等待。如果没有人，则待机。

1. let throttle = (fn, delay = 50) => { // 节流 控制执行间隔时间 防止频繁触发 scroll resize mousemove
2. let stattime = 0;
3. return function (...args) {
4. let curTime = new Date();
5. if (curTime - stattime >= delay) {
6. fn.apply(this, args);
7. stattime = curTime;
8. }
9. }
10. }
11. 复制代码

函数节流完全版

1. /**
2. * @desc 函数防抖
3. * @param func 函数
4. * @param wait 延迟执行毫秒数
5. * @param immediate true 表立即执行，false 表非立即执行
6. */
7. 
8. function debounce(func,wait,immediate) {
9. var timeout;
10. 
11. return function () {
12. var context = this;
13. var args = arguments;
14. 
15. if (timeout) clearTimeout(timeout);
16. if (immediate) {
17. var callNow = !timeout;
18. timeout = setTimeout(function(){
19. timeout = null;
20. }, wait)
21. if (callNow) func.apply(context, args)
22. }
23. else {
24. timeout = setTimeout(function(){
25. func.apply(context, args)
26. }, wait);
27. }
28. }
29. }
30. 
31. 复制代码

防抖动

debounce 策略的电梯。如果电梯里有人进来，等待50毫秒。如果又人进来，50毫秒等待重新计时，直到50毫秒超时，开始运送。

1. let debounce = (fn, time = 50) => { // 防抖动 控制空闲时间 用户输入频繁
2. let timer;
3. return function (...args) {
4. let that = this;
5. clearTimeout(timer);
6. timer = setTimeout(fn.bind(that, ...args), time);
7. }
8. }
9. 复制代码

深度拷贝兼容写法（不包括原型属性）

1. function deepCopy(obj) {
2. if (typeof obj !== 'object') return obj;
3. if (typeof window !== 'undefined' && window.JSON) { // 浏览器环境下 并支持window.JSON 则使用 JSON
4. return JSON.parse(JSON.stringify(obj));
5. } else {
6. let newObj = obj.constructor === Array ? [] : {};
7. for(let key in obj) {
8. newObj[key] = typeof obj[key] === 'object' ? deepCopy(obj[key]) : obj[key];
9. }
10. return newObj;
11. }
12. }
13. 
14. let obj = {a: 1, b: [12]};
15. let newObj = deepCopy(obj);
16. newObj.b[1] = 100;
17. console.log(obj);
18. console.log(newObj);
19. 复制代码

深度克隆加强版

1. function cloneDeep(obj) {
2. let type = isType(obj)
3. if (type === 'Array' || type === 'Object') {
4. return cloneObj(obj)
5. } else if (type === 'Date') {
6. return obj.constructor(obj)
7. } else {
8. return obj
9. }
10. }
11. 
12. function cloneObj(obj) {
13. let newObj = obj instanceof Array ? [] : {};
14. for (let key in obj) {
15. newObj[key] = typeof obj[key] === 'object' ? cloneObj(obj[key]) : obj[key]
16. }
17. return newObj;
18. }
19. 
20. function isType(o) {
21. return /\[object\s(.*?)\]/.exec(Object.prototype.toString.call(o))[1]
22. }
23. 
24. let fn = function () {
25. return 123
26. }
27. var a = [[1, 2, 3], [4, 5, 6, 7, fn]];
28. // let c = new Date();
29. // var b = cloneDeep(c);
30. var b = cloneDeep(a);
31. console.log(b[0], a[0]);
32. console.log(b[0] === a[0]);
33. 
34. 复制代码

原生数据类型检测简易封装

1. Object.prototype.isType = function (type) {
2. return function (params) {
3. return Object.prototype.toString.call(params) === `[object ${type}]`
4. }
5. }
6. 
7. let isString = Object.isType('String')
8. let isArray = Object.isType('Array')
9. 
10. console.log(isString(1)) // false
11. console.log(isString('hello')) // true
12. 
13. console.log(isArray(2)) // false
14. console.log(isArray(['hello'])) // true
15. 复制代码

Array的reduce实现

1. Array.prototype._reduce = function (callback, initVal) {
2. let i = 0
3. let result = initVal
4. if (typeof initVal === 'undefined') {
5. result = this[0]
6. i++
7. }
8. 
9. for (i; i < this.length; i++) {
10. result = callback(result, this[i])
11. }
12. return result
13. }
14. 
15. const arr = [1, 2, 3]
16. let result = arr._reduce((a, b) => {
17. return a + b
18. }, 0)
19. console.log(result) // 6
20. 复制代码

Function的bind实现

1. 1.es5
2. Function.prototype._bind = function(context) {
3. let func = this;
4. let params = [].slice.call(arguments, 1);
5. let Fnop = function() {};
6. let fbound = function() {
7. params = params.concat([].slice.call(arguments, 0));
8. return func.apply(this instanceof Fnop ?
9. this : context, params);
10. }
11. Fnop.prototype = this.prototype;
12. fbound.prototype = new Fnop();
13. return fbound;
14. }
15. 
16. function foo() {
17. this.b = 100;
18. return this.a;
19. }
20. let fe = foo._bind({ a: 1 });
21. console.log(fe()); // 1
22. console.log(new fe()); // 实例 {b: 100}
23. 
24. 2.es6
25. Function.prototype.mybind = function(context, ...rest) {
26. return (...params) => this.call(context, ...rest, ...params);
27. }
28. 复制代码

函数组合串联compose（reduce中间件）

1. // 组合串联
2. let fn1 = (a) => a + 1;
3. let fn2 = (b) => b + 2;
4. let fn3 = (c) => c + 3;
5. 
6. let funs = [fn1, fn2, fn3];
7. 
8. let compose = (func) => {
9. return arg => func.reduceRight((composed, fn) => fn(composed), arg);
10. }
11. console.log(compose(funs)(100)); // 相当于fn1(fn2(fn3(100)))
12. 复制代码

redux 源码中compose实现(github.com/reduxjs/red…)

1. export default function compose(...funcs) {
2. if (funcs.length === 0) {
3. return arg => arg
4. }
5. 
6. if (funcs.length === 1) {
7. return funcs[0]
8. }
9. 
10. return funcs.reduce((a, b) => (...args) => a(b(...args)))
11. }
12. 复制代码

koa-compose 实现

1. function compose(middleware) {
2. return function(ctx, next) {
3. let index = -1;
4. return dispatch(0)
5. function dispatch(i) {
6. if(i <= index) return Promise.reject(new Error('next() called multiple times'));
7. index = i;
8. let fn = middleware[i]
9. if (i === middleware.length) fn = next
10. if (!fn) return Promise.resolve()
11. try {
12. return Promise.resolve(fn(ctx, dispatch.bind(null, i + 1)))
13. } catch(e) {
14. return Promise.reject(e)
15. }
16. }
17. }
18. }
19. 
20. let mid1 = (ctx, next) => {
21. console.log('ctx1', ctx);
22. next()
23. }
24. 
25. let mid2 = (ctx, next) => {
26. console.log('ctx2', ctx);
27. next()
28. }
29. 
30. let mid3 = (ctx, next) => {
31. console.log('ctx3', ctx);
32. }
33. 
34. let co = compose([mid1, mid2, mid3])
35. co('ctx')
36. 
37. 复制代码

co函数

1. function* fn(a = 0) {
2. a = yield a;
3. let b = yield 2;
4. let c = yield 3;
5. return a + b + c;
6. }
7. 
8. function co(fn, ...args) {
9. let g = fn(...args);
10. return new Promise((resolve, reject) => {
11. function next(lastValue) {
12. let { value, done } = g.next(lastValue);
13. if (done) {
14. resolve(value);
15. } else {
16. if (value instanceof Promise) {
17. value.then(next, (val) => reject(val));
18. } else {
19. next(value)
20. }
21. }
22. }
23. next();
24. });
25. }
26. co(fn, 100).then(value => {
27. console.log(value); // 105
28. });
29. 复制代码

es6简版 promise

1. class Promise {
2. constructor(fn) {
3. this.status = 'Pending'
4. setTimeout(() => {
5. fn((data) => {
6. this.resolve(data)
7. }, (error) => {
8. this.reject(error)
9. })
10. })
11. }
12. 
13. resolve(data) {
14. if (this.status === 'Pending') {
15. this.success(data)
16. this.status = 'Fulfilled'
17. }
18. }
19. 
20. reject(error) {
21. if (this.status === 'Pending') {
22. this.error(error)
23. this.status = 'Rejected'
24. }
25. }
26. 
27. then(success, error) {
28. this.success = success
29. this.error = error
30. }
31. }
32. 
33. let p1 = new Promise((resolve, reject) => {
34. // reject('hello error');
35. setTimeout(() => {
36. resolve('hello promise')
37. }, 1000)
38. })
39. 
40. p1.then((data) => console.log(data), (err) => console.log(err))
41. 
42. 复制代码

如何主动中止Promise调用链

1. const p1 = new Promise((resolve, reject) => {
2. setTimeout(() => { // 异步操作
3. resolve('start')
4. }, 1000);
5. });
6. 
7. p1.then((result) => {
8. console.log('a', result);
9. return Promise.reject('中断后续调用'); // 此时rejected的状态将直接跳到catch里，剩下的调用不会再继续
10. }).then(result => {
11. console.log('b', result);
12. }).then(result => {
13. console.log('c', result);
14. }).catch(err => {
15. console.log(err);
16. });
17. 
18. // a start
19. // 中断后续调用
20. 复制代码

bluebird.promisify实现（将异步回调函数api 转换为promise形式）

1. // promisify.js
2. module.exports = {
3. promisify(fn){
4. return function () {
5. var args = Array.from(arguments);
6. return new Promise(function (resolve, reject) {
7. fn.apply(null, args.concat(function (err) {
8. if (err) {
9. reject(err);
10. } else {
11. resolve(arguments[1])
12. }
13. }));
14. })
15. }
16. }
17. }
18. 
19. // main.js
20. const fs = require('fs');
21. const {promisify} = require('./promisify.js');
22. 
23. const readFile = promisify('fs.readFile'); // 转换异步读取
24. 
25. // 异步文件 由回调函数形式变成promise形式
26. readFile('./1.txt', 'utf8').then(data => {
27. console.log(data);
28. }).catch(err => {
29. console.log(err);
30. });
31. 复制代码

window.requestAnimationFrame兼容性处理

1. window._requestAnimationFrame = (function(){
2. return  window.requestAnimationFrame       ||
3. window.webkitRequestAnimationFrame ||
4. window.mozRequestAnimationFrame    ||
5. function(callback){
6. window.setTimeout(callback, 1000 / 60);
7. };
8. })();
9. 复制代码

字符串是否符合回文规则

1. let str = 'My age is 0, 0 si ega ym.';
2. 
3. 方法一
4. function palindrome(params) {
5. params = params.replace(/[\W\s_]/ig, '');
6. return params.toLowerCase()  === params.split('').reverse().join('').toLowerCase();
7. }
8. console.log(palindrome(str));
9. 
10. 方法二
11. function palindrome(params) {
12. params = params.replace(/[\W\s_]/ig, '').toLowerCase();
13. for (var i = 0, j = params.length-1; i<j; i++, j--) {
14. if (params[i] !== params[j]) {
15. return false;
16. }
17. }
18. return true;
19. }
20. 复制代码

解构

1. // 将 destructuringArray([1, [2, 3], 4], "[a, [b], c]") => {a: 1, b: 2, c: 4}
2. const targetArray = [1, [2, 3], 4];
3. const formater = "[a, [b], c]";
4. 
5. const destructuringArray = (values, keys) => {
6. try {
7. const obj = {};
8. if (typeof keys === 'string') {
9. keys = JSON.parse(keys.replace(/\w+/g, '"$&"'));
10. }
11. 
12. const iterate = (values, keys) =>
13. keys.forEach((key, i) => {
14. if(Array.isArray(key)) iterate(values[i], key)
15. else obj[key] = values[i]
16. })
17. 
18. iterate(values, keys)
19. 
20. return obj;
21. } catch (e) {
22. console.error(e.message);
23. }
24. }
25. 复制代码

数组展平

将[[1, 2], 3, [[[4], 5]]] 展平为 [1, 2, 3, 4, 5]

1. let arr = [[1, 2], 3, [[[4], 5]]]; // 数组展平
2. function flatten(arr) {
3. return [].concat(
4. ...arr.map(x => Array.isArray(x) ? flatten(x) : x)
5. )
6. }
7. 复制代码

二分查找

1. const arr = [1, 2, 3, 4, 5, 6, 7, 8];
2. // 二分查找 递归 由中间开始往两边查找 前提是有序的数组 返回对应的索引位置
3. function binarySearch1(arr, dest, start = 0, end = data.length) {
4.     if (start > end) {
5.         return -1
6.     }
7.     let midIndex = Math.floor((start + end) / 2); // 中间位置索引
8.     let mid = arr[midIndex]; // 中间值
9. 
10.     if (mid == dest) {
11.         return midIndex;
12.     }
13.     if (dest < mid) { // 要找的比中间值小 就从中间往开头找 一直到0
14.         return binarySearch1(arr, dest, 0, midIndex - 1);
15.     }
16.     if (dest > mid) { // 要找的比中间值大 就从中间往后找 一直到end结束
17.         return binarySearch1(arr, dest, midIndex + 1, end);
18.     }
19.     return -1; // 找不到返回-1
20. }
21. console.log(binarySearch1(arr, 7, 3, 6)); // 6
22. 
23. // 非递归 arr前提有序数组 （从小到大）返回对应的索引位置
24. function binarySearch2(arr, dest) {
25.     let max = arr.length - 1;
26.     let min = 0;
27.     while (min <= max) {
28.         let mid = Math.floor((max + min) / 2); // mid中间位置索引
29.         if (dest < arr[mid]) { // 如果要找的这项比中间项还要小 说明应该在mid中间位置前面 修改最大边界值max=mid-1
30.             max = mid - 1;
31.         } else if (dest > arr[mid]) { // 如果要找的这项比中间项还要大 说明应该在mid中间位置的后面 修改最小边界值min=mid+1
32.             min = mid + 1;
33.         } else {
34.             return mid;
35.         }
36.     }
37.     return -1; // 找不到返回-1
38. }
39. console.log(binarySearch2(arr, 3)); // 2
40. 复制代码