JS面试手写代码

阳光穿透心脏的1/2处 2022-01-19 00:07 235阅读 0赞

转自： [https://blog.csdn.net/qq\_34629352/article/details/89838760][https_blog.csdn.net_qq_34629352_article_details_89838760]

https://blog.csdn.net/qq\_34629352/article/details/89838760  
https://blog.csdn.net/weixin\_34062469/article/details/88020033  
Github 代码实现案例  
二叉搜索树 中序、先序、后序遍历 搜索树中的值  
vue设计原理简单实现:数据劫持、依赖收集、模板编译、双向绑定、计算属性  
spa单页路由设计简单实现  
浏览器缓存交互实现  
npm发布li-server静态服务器编写  
node events模块实现 发布订阅  
JavaScript数据结构与算法pdf资源  
百度网盘 密码:ll8d

如果不喜欢看pdf可以看下面在网上发现一个博客讲解

数据结构与算法讲解

高阶函数实现AOP（面向切面编程）  
什么是面向切面编程?

Function.prototype.before = function (beforefn) \{  
        let \_self = this; // 缓存原函数的引用  
        returnfunction () \{ // 代理函数  
            beforefn.apply(this, arguments); // 执行前置函数  
            return \_self.apply(this, arguments); // 执行原函数  
        \}  
    \}  
   
    Function.prototype.after = function (afterfn) \{  
        let \_self = this;  
        returnfunction () \{  
            letset = \_self.apply(this, arguments);  
            afterfn.apply(this, arguments);  
            returnset;  
        \}  
    \}  
   
    let func = () => console.log('func');  
    func = func.before(() => \{  
        console.log('===before===');  
    \}).after(() => \{  
        console.log('===after===');  
    \});  
   
    func();  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
输出结果：

=before=  
func  
=after=

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

let obj2 = Object.\_create(obj1);  
    console.log(obj2.\_\_proto\_\_ === obj1); // true  
    console.log(obj2.id); // 1

// 原生的Object.create  
    let obj3 = Object.create(obj1);  
    console.log(obj3.\_\_proto\_\_ === obj1); // true  
    console.log(obj3.id); // 1  
1  
2  
3  
4  
5  
6  
7  
8  
一道面试题  
!\[\](data:image/svg+xml;utf8,<?xml version="1.0"?><svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="720" height="1280"></svg>)

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

Function.prototype.sleep = function (delay) \{  
    this()  
    this.await(delay);  
    return this;  
\}

Function.prototype.sleepFirst = function (delay) \{  
    this.await(delay);  
    this();  
    return this;  
\}

Function.prototype.eat = function (dinner) \{  
    setTimeout(() => \{  
        console.log(\`Eat $\{dinner\}~\`);  
    \});  
    return this;  
\};

Function.prototype.await = function (delay) \{  
    delay = isNaN(delay) ? 0 : delay;  
    let startTime = new Date();  
    let delayTime = delay \* 1000;  
    while (new Date() - startTime <= delayTime) \{  
    \}  
    console.log(\`Wake up after $\{delayTime\}ms\`);  
\}  
 // CodingMan('peter')  
 // CodingMan('peter').sleep(2).eat('hanbao');  
 // CodingMan('peter').sleepFirst(2).eat('hanbao');  
 CodingMan('peter').eat('haha').eat('hanbao');  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
currying 函数柯理化  
curry 柯理化的实现（递归调用 + valueOf）  
知识点：valueOf 浏览器环境下 当我们以log(fn)这种形式取值时，会隐式调用fn自身的valueOf 所以得到的是valueOf的返回值

functionfn() \{\};  
fn.valueOf = () => console.log('valueof');  
console.log(fn); // valueof  
   
   
const mul = x => \{  
    const result = y => mul(x \* y); // 递归调用mul  
    result.valueOf = () => x;  
    return result;  
\}  
console.log(mul(2)(3)); // 6  
   
// 在上面mul每执行一次,就会返回一个valueOf被改写后的新函数result 并且result执行会在里面调用mul(x \* y)  
// 在result函数的valueOf里保存着 由上一次x \* y 传进来的结果x, 也就是上一次x\*y 会作为这一次的输出 依然叫x  
   
// 第一次mul(2) 此时 x为2  return result  
result 为 result = y => mul(2 \* y);   
// 第二次 mul(2)(3) 等价于 第一个mul返回的result(3), result执行 => mul(2 \* 3) 再次调用mul 将2\*3 = 6 的结果作为mul参数  
// 最后mul(6) x = 6 在返回一个新函数result 此时result的valueOf = () => 6  
   
// log(mul(2)(3)) 相当于log的最后返回的result 隐式调用valueOf 返回 6  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
curry 将多参数函数转换为接收单一参数的函数  
function fe(a, b, c) \{  
return a + b + c;  
\}

console.log(curry(fe)(1)(2)(3)); // 6

currying 部分求值  
    // currying 函数柯理化  
    let currying = function(fn) \{  
        let args = \[\];  
        returnfunctionfe() \{  
            if (arguments.length === 0) \{  
                return fn.apply(this, args);  
            \}  
            \[\].push.apply(args, arguments);  
            return fe;  
        \}  
    \}  
    let count = currying(function (...rest) \{  
        return rest.reduce((prev, cur) => prev + cur, 0);  
    \});  
   
    console.log(count(100)(200)(10)()); // 310  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
收集参数 延迟执行 到达指定次数才执行  
// 参数收集 指定次数后执行  
function fn(…rest) \{console.log(rest);\};  
function after(fn, time = 1) \{  
let params = \[\];  
returnfunction(…rest) \{  
params = \[…params, …rest\];  
if (–time === 0) \{  
fn.apply(this, params);  
\}  
\}  
\}  
let newFn = after(fn, 3); // 执行3次 内部fn才会执行  
newFn(2);  
newFn(3);  
newFn(4);

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

let debounce = (fn, time = 50) => \{ // 防抖动 控制空闲时间 用户输入频繁  
let timer;  
returnfunction (…args) \{  
let that = this;  
clearTimeout(timer);  
timer = setTimeout(fn.bind(that, …args), time);  
\}  
\}

深度拷贝兼容写法（不包括原型属性）  
function deepCopy(obj) \{  
    if (typeof obj !== 'object') return obj;  
    if (typeof window !== 'undefined' && window.JSON) \{ // 浏览器环境下 并支持window.JSON 则使用 JSON  
        return JSON.parse(JSON.stringify(obj));  
    \} else \{  
        let newObj = obj.constructor === Array ? \[\] : \{\};  
        for(let key in obj) \{  
            newObj\[key\] = typeof obj\[key\] === 'object' ? deepCopy(obj\[key\]) : obj\[key\];  
        \}  
        return newObj;  
    \}  
\}  
   
let obj = \{a: 1, b: \[12\]\};  
let newObj = deepCopy(obj);  
newObj.b\[1\] = 100;  
console.log(obj);  
console.log(newObj);  
\`\`\`Function的bind实现  
Function.prototype.\_bind = function(context) \{  
    let func = this;  
    let params = \[\].slice.call(arguments, 1);  
    returnfunction() \{  
        params = params.concat(\[\].slice.call(arguments, 0));  
        func.apply(context, params);  
    \}  
\}  
   
let obj = \{id: 24\}  
   
function fn1(a) \{  
    console.log(this, arguments);  
\}  
let foo = fn1.\_bind(obj, obj.id);  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
函数组合串联compose（koa reduce中间件）  
// 组合串联  
let fn1 = (a) => a + 1;  
let fn2 = (b) => b + 2;  
let fn3 = © => c + 3;

let funs = \[fn1, fn2, fn3\];

let compose = (func) => \{  
return arg => func.reduceRight((composed, fn) => fn(composed), arg);  
\}  
console.log(compose(funs)(100)); // 相当于fn1(fn2(fn3(100)))

co函数  
function\* fn(a) \{  
  a = yield a;  
  let b = yield 2;  
  let c = yield 3;  
  return a + b + c;  
\}  
   
function co(fn, ...args) \{  
  let g = fn(...args);  
  return new Promise((resolve, reject) => \{  
    function next(lastValue) \{  
        let \{ value, done \} = g.next(lastValue);  
        if (done) \{  
          resolve(value);  
        \} else \{  
         if (value instanceof Promise) \{  
           value.then(next, (val) => reject(val));  
         \} else \{  
           next(value)  
         \}  
        \}  
    \}  
    next();  
  \});  
\}  
co(fn, 100).then(value => \{  
    console.log(value); // 105  
\});  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
如何主动中止Promise调用链  
const p1 = new Promise((resolve, reject) => \{  
setTimeout(() => \{ // 异步操作  
resolve(‘start’)  
\}, 1000);  
\});

p1.then((result) => \{  
console.log(‘a’, result);  
return Promise.reject(‘中断后续调用’); // 此时rejected的状态将直接跳到catch里，剩下的调用不会再继续  
\}).then(result => \{  
console.log(‘b’, result);  
\}).then(result => \{  
console.log(‘c’, result);  
\}).catch(err => \{  
console.log(err);  
\});

// a start  
// 中断后续调用

bluebird.promisify实现（将异步回调函数api 转换为promise形式）  
// promisify.js  
module.exports = \{  
   promisify(fn)\{  
       returnfunction () \{  
           var args = Array.from(arguments);  
           return new Promise(function (resolve, reject) \{  
               fn.apply(null, args.concat(function (err) \{  
                   if (err) \{  
                       reject(err);  
                   \} else \{  
                       resolve(arguments\[1\])  
                   \}  
               \}));  
           \})  
       \}  
   \}  
\}  
   
// main.js  
const fs = require('fs');  
const \{promisify\} = require('./promisify.js');  
   
const readFile = promisify('fs.readFile'); // 转换异步读取  
   
// 异步文件 由回调函数形式变成promise形式  
readFile('./1.txt', 'utf8').then(data => \{   
   console.log(data);  
\}).catch(err => \{  
   console.log(err);  
\});  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
window.requestAnimationFrame兼容性处理  
window.\_requestAnimationFrame = (function()\{  
return window.requestAnimationFrame ||  
window.webkitRequestAnimationFrame ||  
window.mozRequestAnimationFrame ||  
function(callback)\{  
window.setTimeout(callback, 1000 / 60);  
\};  
\})();

字符串是否符合回文规则  
let str = 'My age is 0, 0 si ega ym.';  
   
方法一  
function palindrome(params) \{  
  params = params.replace(/\[\\W\\s\_\]/ig, '');  
 return params.toLowerCase()  === params.split('').reverse().join('').toLowerCase();  
\}  
console.log(palindrome(str));  
   
方法二  
function palindrome(params) \{  
  params = params.replace(/\[\\W\\s\_\]/ig, '').toLowerCase();  
  for (var i = 0, j = params.length-1; i<j; i++, j--) \{  
    if (params\[i\] !== params\[j\]) \{  
      returnfalse;  
    \}  
  \}  
  returntrue;  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
解构  
// 将 destructuringArray(\[1, \[2, 3\], 4\], “\[a, \[b\], c\]”) => \{a: 1, b: 2, c: 4\}  
const targetArray = \[1, \[2, 3\], 4\];  
const formater = “\[a, \[b\], c\]”;

const destructuringArray = (values, keys) => \{  
try \{  
const obj = \{\};  
if (typeof keys === ‘string’) \{  
keys = JSON.parse(keys.replace(/\\w+/g, ‘"$&"’));  
\}

const iterate = (values, keys) =>  
  keys.forEach((key, i) => \{  
    if(Array.isArray(key)) iterate(values\[i\], key)  
    else obj\[key\] = values\[i\]  
  \})  
    
iterate(values, keys)

return obj;  
1  
2  
3  
4  
5  
6  
7  
8  
9  
\} catch (e) \{  
console.error(e.message);  
\}  
\}

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

let arr = \[\[1, 2\], 3, \[\[\[4\], 5\]\]\]; // 数组展平  
function flatten(arr) \{  
    return \[\].concat(  
        ...arr.map(x => Array.isArray(x) ? flatten(x) : x)  
    )  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
二分查找  
const arr = \[1, 2, 3, 4, 5, 6, 7, 8\];  
// 二分查找 递归 由中间开始往两边查找 前提是有序的数组 返回对应的索引位置  
function binarySearch1(arr, dest, start = 0, end = data.length) \{  
if (start > end) \{  
return -1  
\}  
let midIndex = Math.floor((start + end) / 2); // 中间位置索引  
let mid = arr\[midIndex\]; // 中间值

if (mid == dest) \{  
    return midIndex;  
\}  
if (dest < mid) \{ // 要找的比中间值小 就从中间往开头找 一直到0  
    return binarySearch1(arr, dest, 0, midIndex - 1);  
\}  
if (dest > mid) \{ // 要找的比中间值大 就从中间往后找 一直到end结束  
    return binarySearch1(arr, dest, midIndex + 1, end);  
\}  
return -1; // 找不到返回-1  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
\}  
console.log(binarySearch1(arr, 7, 3, 6)); // 6

// 非递归 arr前提有序数组 （从小到大）返回对应的索引位置  
function binarySearch2(arr, dest) \{  
let max = arr.length - 1;  
let min = 0;  
while (min <= max) \{  
let mid = Math.floor((max + min) / 2); // mid中间位置索引  
if (dest < arr\[mid\]) \{ // 如果要找的这项比中间项还要小 说明应该在mid中间位置前面 修改最大边界值max=mid-1  
max = mid - 1;  
\} elseif (dest > arr\[mid\]) \{ // 如果要找的这项比中间项还要大 说明应该在mid中间位置的后面 修改最小边界值min=mid+1  
min = mid + 1;  
\} else \{  
return mid;  
\}  
\}  
return -1; // 找不到返回-1  
\}  
console.log(binarySearch2(arr, 3)); // 2

找出数组中重复出现过的元素  
// 例如：\[1，2，4，4，3，3，1，5，3\]  
// 输出：\[1，3，4\]  
let arr = \[1, 2, 4, 4, 3, 3, 1, 5, 3\];  
   
// 方法一  
function repeat1(arr)\{  
    var result = \[\], map = \{\};  
    arr.map(function(num)\{  
    if(map\[num\] === 1) result.push(num); // 等于1说明之前出现过一次 这次重复出现了  
        map\[num\] = (map\[num\] || 0) + 1; // 微妙之处 开始第一次出现无值 记为 0 + 1 = 1 下一次从1开始累加  
    \});  
    return result;  
\}  
console.log(repeat1(arr));  
   
// 方法二  
   
function repeat(arr) \{  
    let result = arr.filter((x, i, self) => \{  
        return self.indexOf(x) === i && self.lastIndexOf(x) !== i  
    \}); //   
    return result;  
\}  
console.log(repeat(arr));  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
数组中按照数字重复出现的次数进行排序  
// 如果次数相同 则按照值排序 比如 2, 2, 2和 1, 1, 1 应排序为 \[1, 1, 1, 2, 2, 2\]  
// 比如 \[1,2,1,2,1,3,4,5,4,5,5,2,2\] => \[3, 4, 4, 1, 1, 1, 5, 5, 5, 2, 2, 2, 2\]

不用循环，创建一个长度为 100 的数组，并且每个元素的值等于它的下标。  
// 方法一 递归写法  
function createArray(len, arr = \[\]) \{  
   
    if (len > 0) \{  
        arr\[--len\] = len;  
        createArray(len, arr);  
    \}  
    return arr;  
\}  
console.log(createArray(100));   
   
// 方法二  
   
// 下面评论中@MaDivH 提供的实现方法 长度为 100 的数组   
Array(100).fill().map((\_,i)=>i+1);  
   
// 方法三  
\[...Array(100).keys()\]  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
根据关键词找出 所在对象id  
var docs = \[  
\{  
id: 1,  
words: \[‘hello’, “world”\]  
\}, \{  
id: 2,  
words: \[‘hello’, “hihi”\]  
\}, \{  
id: 3,  
words: \[‘haha’, “hello”\]  
\}, \{  
id: 4,  
words: \[‘world’, “nihao”\]  
\}  
\];  
findDocList(docs, \[‘hello’\]) // 文档id1，文档id2，文档id3  
findDocList(docs, \[‘hello’, ‘world’\]) // 文档id1  
function findDocList(docs, word = \[\]) \{  
if (word.constructor !== Array) return;  
let ids = \[\];  
for (let i = 0; i < docs.length; i++) \{  
let \{id, words\} = docs\[i\];  
let flag = word.every((item) => \{  
return words.indexOf(item) > -1;  
\});  
flag && ids.push(id);  
\}  
return ids;  
\}  
findDocList(docs, \[‘hello’, ‘world’\]);

getElementsByClassName 兼容写法  
function getByClass(cName) \{  
      if ('getElementsByClassName'in this) \{  
          return this.getElementsByClassName(cName);  
      \}  
      cName = cName.replace(/(^\\s+|\\s+$)/g, '').split(/\\s+/g);  
      let eles = this.getElementsByTagName('\*');  
     for (let i = 0; i < cName.length; i++) \{  
        let reg = new RegExp(\`(^| )$\{cName\[i\]\}( |$)\`);  
        let temp = \[\];  
        for (let j = 0; j < eles.length; j++) \{  
            let cur = eles\[j\];  
            let \{className\} = cur;  
            if (reg.test(className)) \{  
                temp.push(cur);  
            \}  
        \}  
        eles = temp;  
     \}  
     return eles;  
  \}  
  console.log(content.getByClass('c1 c2 '));  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
插入排序  
插入排序 从后往前比较 直到碰到比当前项 还要小的前一项时 将这一项插入到前一项的后面

选择排序  
选择排序 每次拿当前项与后面其他项进行比较 得到最小值的索引位置 然后把最小值和当前项交换位置

快速排序（递归）  
function quickSort(arr) \{  
    if (arr.length <= 1) return arr;  
    let midIndex = Math.floor(arr.length / 2);  
    let midNum = arr.splice(midIndex, 1)\[0\];  
    let left = \[\];  
    let right = \[\];  
    for(let i = 0; i < arr.length; i++) \{  
        let cur = arr\[i\];  
        if (cur <= midNum) \{  
            left.push(cur);  
        \} else \{  
            right.push(cur);  
        \}  
    \}  
    return quickSort(left).concat(midNum, quickSort(right));  
\}  
   
let arr = \[2, 4, 12, 9, 22, 10, 18, 6\];  
quickSort(arr);  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
数组去重几种方法  
const arr = \[1, 2, 1, 2, 3, 4, 2, 1, 3\];

// 1 ES6  
let newArr = \[…new Set(arr)\];

// 2  
const arr = \[1, 2, 1, 2, 3, 4, ‘l’, 2, 1, 3, ‘l’\];  
const newArr = arr.filter(function(ele, index, array) \{  
return index === array.indexOf(ele)  
\});  
console.log(newArr); // \[ 1, 2, 3, 4, ‘l’ \]

// 3  
Array.prototype.unique2 = function() \{  
let newArr = \[\];  
let len = this.length;  
for(let i = 0; i < len; i++) \{  
let cur = this\[i\];  
if(newArr.indexOf(cur) === -1) \{  
newArr\[newArr.length\] = cur;  
\}  
\}  
return newArr;  
\}  
console.log(arr.unique1());

// 4  
Array.prototype.unique3 = function() \{  
let newArr = this.slice(0);  
let len = this.length;  
let obj = \{\};  
for(let i = 0; i < len; i++) \{  
let cur = newArr\[i\];  
if(obj\[cur\]) \{  
newArr\[i\] = newArr\[newArr.length - 1\];  
newArr.length–;  
i–;  
continue;  
\}  
obj\[cur\] = cur;  
\}  
return newArr;  
\}  
console.log(arr.unique3());

// 5  
Array.prototype.unique4 = function() \{  
let json = \{\}, newArr = \[\], len = this.length;  
for(var i = 0; i < len; i++) \{  
let cur = this\[i\];  
if (typeof json\[cur\] == “undefined”) \{  
json\[cur\] = true;  
newArr.push(cur)  
\}  
\}  
return newArr;  
\}  
console.log(arr.unique4());

千分符  
方法一  
// 处理数字  
let str1 = 2123456789;  
let str2 = 2123456789.12;  
console.log(str1.toLocaleString()); // 2,123,456,789  
console.log(str2.toLocaleString()); // 2,123,456,789.12  
1  
2  
3  
4  
5  
6  
7  
方法二  
// 处理字符串  
let str1 = ‘2123456789’;  
let str2 = ‘2123456789.12’;

// 利用正向预查 匹配 开头一个数字\\d 后面匹配这个数字后面必须是三个数字为一组为结尾或小数为结尾  
function thousandth(str) \{   
    let reg = /\\d(?=(?:\\d\{3\})+(?:\\.\\d+|$))/g;   
    return str.replace(reg, '$&,');  
\}  
console.log(thousandth(str1)); // 2,123,456,789  
console.log(thousandth(str2)); // 2,123,456,789.12  
1  
2  
3  
4  
5  
6  
7  
在一个数组中 如a、b两项, 要保证a和b两项的差 与 a和b两项索引的差 的相加后的结果max 是数组中其他两项max 中的最大值 找出符合条件两项a, b的值 (不可以排序 或改变数组位置) 如：  
let max = (a - b) + (a的索引- b的索引); 求a b

答案：  
1  
2  
3  
4  
// 思路：其实也就是找出数组中当前的每一项与自身索引相加后的和的最大值以及与索引相加后的最小值的和 找出符合条件的两项即可 如 let result = (maxItem-minItem) + (maxIndex-minIndex) 等价于 (maxItem+maxIndex) - (minItem+minIndex)

// let arr = \[1, 2, 3, 4, 5, 6\]; // 最简单的测试数组 最小项1 最大项6  
// 很显然这个数组中最大值6与索引相加(6+5)是当中最大值11 1与索引相加(1+0)为当中的最小值1（6 + 5）-（1+0）= 10

// 假设法  
let arr = \[2, 10, 9, 1, 8, 3, 4\];  
let minItem = arr\[0\]; // 假设第一项与自身索引的和是最小值 索引为0因此省略  
let maxItem = arr\[0\]; // 假设第一项与自身索引的和是最大值 索引为0因此省略  
let min = minItem; // 最小项  
let max = maxItem; // 最大项  
let minIndex = 0; // 最小项索引  
let maxIndex = 0; // 最大项索引  
for(let i = 1; i < arr.length; i++) \{  
let cur = arr\[i\] + i; // 当前项和自身索引的和  
cur < minItem ? (minItem = cur, min = arr\[i\], minIndex = i) : null;  
cur > maxItem ? (maxItem = cur, max = arr\[i\], maxIndex = i) : null;  
\}  
console.log(maxItem, minItem); // 最大项与索引的和 最小项与索引的和  
console.log(max, min); // 最大项 最小项  
console.log(maxIndex, minIndex); // 最大项的索引 最小项的索引

检测 字符串中括号表达式是否平衡  
// 如 balance('\[()') = false; balance('\[()()()\]') = true  
// 一  
function match(a, b) \{  
    return (a === '(' && b === ')') || (a === ')' && b === '(') || (a === '\[' && b === '\]') || (a === '\]' && b === '\[');  
\}  
   
function balance(str) \{  
    if (str.length % 2 === 0) \{  
        let len = str.length;  
        for (let i = 0, j = len - 1; i < len / 2; i++, j--) \{  
            if (!match(str\[i\], str\[j\])) \{  
                returnfalse;  
            \}  
        \}  
        returntrue;  
    \}  
    returnfalse;  
\}  
console.log(balance('\[()()()\]')); // true  
console.log(balance('\[()')); // false  
console.log(balance('\[\]()')); // false  
// 二  
function is\_balance(str) \{  
    return \[...str\].reduce((stack, c) => \{  
        match(stack\[stack.length - 1\], c) ?  
            stack.pop() : stack.push(c);  
        return stack;  
    \}, \[\]).length === 0;  
\}  
console.log(is\_balance('\[()()()\]')); // true  
console.log(is\_balance('\[()')); // false  
console.log(is\_balance('\[\]()')); // false  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
求相邻两项最大和  
// 一  
let arr1 = \[-1, 3, 1, -5, 2\]; // 如 \[2, 4, -4, -3\] => 4  
function sum(arr) \{  
let prev = arr\[0\];  
let sumArr = \[\];  
let len = arr.length;  
for(let i = 1; i < len; i++) \{  
let cur = arr\[i\];  
sumArr.push(cur + prev);  
prev = cur;  
\}  
return Math.max(…sumArr);  
\}  
console.log(sum(arr1));

// 二  
function maxsum(arr) \{  
const M = \[arr\[0\]\];  
let max = M\[0\];

for(let i = 1; i < arr.length; i++) \{  
    M\[i\] = Math.max(arr\[i\], M\[i - 1\] + arr\[i\]);  
    max = Math.max(M\[i\], max);  
\}  
return max;  
1  
2  
3  
4  
5  
\}

字符串去除相邻的重复项 如：‘aabbccddeexxxxaa’ => ‘abcdexa’  
// 正则表达式  
let str = ‘aabbccddeexxxxaa’;  
function uniq1(str) \{  
// return str.replace(/(\[a-z\])(\\1)\{1,\}/g, ‘$1’);  
return str.replace(/(.)(?=\\1)/g, ‘’);  
\}  
console.log(uniq1(str));

// 数组方式  
function uniq2(str) \{  
let arr = str.split(’’);  
let newArr = \[arr\[0\]\];  
for(let i = 1; i < arr.length; i++) \{  
let cur = arr\[i\];  
if (cur !== newArr\[newArr.length - 1\]) \{  
newArr.push(cur);  
\}  
\}  
return newArr.join(’’);  
\}  
console.log(uniq2(str));

害怕手写代码 ? 只能硬着头皮  
欢迎大家和我一起来补充 上面很多也都是可以优化的 我还是一个成长中的小白，只是分享和记录下自己碰到的问题 后续会持续更新...  
\---------------------   
作者：Vincent8080   
来源：CSDN   
原文：https://blog.csdn.net/weixin\_34062469/article/details/88020033   
版权声明：本文为博主原创文章，转载请附上博文链接！  
\---------------------   
作者：baoleilei6   
来源：CSDN   
原文：https://blog.csdn.net/qq\_34629352/article/details/89838760   
版权声明：本文为博主原创文章，转载请附上博文链接！

[https_blog.csdn.net_qq_34629352_article_details_89838760]: https://blog.csdn.net/qq_34629352/article/details/89838760