看题目手写

请实现如下函数

var addSix = createBase(6);
addSix(10); // returns 16
addSix(21); // returns 27
// addSix是一个函数，也就是说 createBase 函数的返回是一个函数
//---
function createBase(baseNumber) {
    return function(N) {
        // we are referencing baseNumber here even though it was declared
        // outside of this function. Closures allow us to do this in JavaScript
        return baseNumber + N;
    };
}
var addSix = createBase(6);
addSix(10);
addSix(21);

// 1. 实现⼀个带并发限制的异步调度器Scheduler，
// 保证同时运⾏的任务最多有两个。完善代码中 Scheduler类，使得以下程序能正确输出
// output: 2 3 1 4 
// ⼀开始，1、2两个任务进⼊队列 
// 500ms时，2完成，输出2，任务3进队 
// 800ms时，3完成，输出3，任务4进队 
// 1000ms时，1完成，输出1 
// 1200ms时，4完成，输出4
class Scheduler {
  constructor() {
    this.stack = [];
    this.queue = [];
  }
  add(promiseCreater) {
    const p = function(resolve){
      const handle = () => {
        this.stack.filter(f => f !== p);
        const target = this.queue.shift();
        if(target) {
          this.stack.push(target);
          target();
        }
        resolve();
      }
      promiseCreater().then(handle);
    }.bind(this);
    return new Promise((resolve) => {
      const exe = () => {p(resolve)}
      if(this.stack.length === 2) {
        this.queue.push(exe);
      }else {
        exe();
        this.stack.push(exe);
      }
    });
  }
}
const timeout = time => new Promise((resolve) => {
  setTimeout(resolve, time);
})
const scheduler = new Scheduler();
const addTask = (time, order) => {
  scheduler.add(() => {
    return timeout(time);
  }).then(() => {
    console.log(order);
  })
}
addTask(1000, '1');
addTask(500, '2');
addTask(300, '3');
addTask(400, '4');

// 给定⻓度为n的整形数组，给定⼩于n的数k，找到数组中出现次数⼤于等于 n 的数字
function find(arr: number[], k: number): number[] { 
  //TODO
  const map = {};
  const result = [];
  arr.forEach(i => {
    if(map[i]) {
        map[i] += 1;
    }else {
        map[i] = 1;
    }
    if(map[i] >= k ) {
      result.push(i);
    }
  });
  return [...new Set(result)];
}
//example const arr = [1, 2, 3, 4, 2, 1]; find(arr, 3); 
  // [1,2]

实现一个 Symbol，满足以下条件：
● 返回的值不能相同
● 如果我们希望使⽤同⼀个 Symbol 值，可以使⽤ Symbol.for。它接受⼀个字符串作为参数，然后搜索 
有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则返回⼀个新的 Symbol 
值
● Symbol 无法作为构造函数使用，即 new Symbol 会报异常
const MySymbol = (() => {
  const map = {};
  return (keyword) => {
    const value = Math.random() * Date.now();
    if(map[keyword]) {
      return map[keyword];
    }else {
      map[keyword] = value;
    }
    const obj = {
      value,
      for: () => {
        return value;
      }
    }
    return obj;
  }
})()

请实现如下的函数，可以批量请求数据，所有的URL地址在 urls 参数中，同时可以通过 max 参数控制 
请求的并发数，当所有的请求结束之后，需要执⾏ callback 回调函数。发请求的函数可以直接使⽤ 
fetch 即可。
const batchFetch = (urls, max, callback) => {
    const stack = [];
  const result = [];
  let nextIdx = 0;
  let finishNum = 0;
  const next = () => {
    const idx = nextIdx;
    const url = urls[idx];
    const setData = (data) => {
        finishNum += 1;
      result[idx] = data;
      stack.filter(u => u !== url);
      if(finishNum === urls.length) {
        callback(result);
      } else if(stack.length < max) {
        next();
      }
    }
    if(url) {
      nextIdx++;
      stack.push(url);
      fetch(url).then(data => {
        setData(data)
      }).ctach(err => {
          setData(err)
      });
    }
  }
  while(stack.length < max || nextIdx <= urls.length) {
      next();
  }
}

给定单项链表，求距离终点 k 的节点，要求空间复杂度为 O(1)
// 假设链表长度为10， k = 4;
// 那么就是从头开始数第 6（10 - 4）个
const getNode = (head, k) => {
    const next = head;
  const kNode = head;
  let step = 0;
  while(next) {
      next = next.next;
    if(step < k) {
        step++;
    }else {
        kNode = head.next;
    }
  }
  return step === k ? kNode : null;
}

int a[]={21,11,45,56,9,66,77,89,78,68,100,120,111} 请查询数组中有没有比它前面元素都大,比它后面的元素都小的数,没有打印-1,有显示其索引。要求时间复杂度和空间复杂度最大都是O(N)。
function cal(arr) {
  let leftMax = arr[0];
    let val = leftMax;
  let valIdx = 0;
  arr.forEach((n, idx) => {
      if(n > leftMax) {
      leftMax = n;
      if(val === null) {
          valIdx = idx;
        val = n;
      }
    }else {
      if(n < val) {
        valIdx = -1;
        val = null;
      }
    }
  });
  return valIdx;
}

// 实现一个fibonacci函数，输入数字n，
// 输出fibonacci数列的第n项数字，并给该函数加入缓存功能。
function a() {
    const map = {
      0: 1, 
    1: 1,
  };
  return function(n) {
      if(map[n - 1]) {
        return map[n - 1];
    }else {
        const dp = [1,1];
      for(let i = 2; i < n; i++) {
          dp[i] = dp[i - 2] + dp[i - 1];
        map[i] = dp[i];
      }
      return dp[n - 1];
    }
  }
}

function myNew(f, ...args) {
    const o = Object.create({});
  o.__proto__ = f.prototype;
  const result = f.call(o, args);
  return result instanceof f ? result : o;
}

// 给定一个字符串里面只有"R" "G" "B" 三个字符，请排序，最终结果的顺序是R在前 G中 B在后。
// 要求：空间复杂度是O(1)，且只能遍历一次字符串。
function f(str) {
  let lastR = 0;
  let lastG = -1;
  const arr = str.split('');
    arr.forEach((s, idx) => {
    arr.splice(idx,1);
      if(s === 'R') {
        arr.splice(lastR,0,'R');
      lastR += 1;
      lastG += 1;
    }else if(s === 'G') {
      if(lastG === - 1) {
        arr.splice(lastR,0,'G');
        lastG = lastR + 1
      }else {
          arr.splice(lastG,0,'G');
        lastG += 1;
      }
    }else {
        arr.splice(lastG, 0, 'B');
    }
  });
  return arr.join('');
}
// 方法二：不用遍历，直接 sort 然后反转数组
function f2(str) {
    return str.split('').sort().reverse().join('');
}

实现sleep
某个时间后就去执行某个函数，使用Promise封装
function sleep(fn, time) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(fn);
        }, time);
    });
}
let saySomething = (name) => console.log(`hello,${name}`)
async function autoPlay() {
    let demo = await sleep(saySomething('111'),1000)
    let demo2 = await sleep(saySomething('222'),1000)
    let demo3 = await sleep(saySomething('333'),1000)
}
autoPlay()

模板引擎实现
let template = '我是{{name}}，年龄{{age}}，性别{{sex}}';
let data = {
  name: '姓名',
  age: 18
}
render(template, data); // 我是姓名，年龄18，性别undefined
function render(template, data) {
  const reg = /\{\{(\w+)\}\}/; // 模板字符串正则
  if (reg.test(template)) { // 判断模板里是否有模板字符串
    const name = reg.exec(template)[1]; // 查找当前模板里第一个模板字符串的字段
    template = template.replace(reg, data[name]); // 将第一个模板字符串渲染
    return render(template, data); // 递归的渲染并返回渲染后的结构
  }
  return template; // 如果模板没有模板字符串直接返回
}

## 下面代码中 a 在什么情况下会打印 1？
```js
var a = ?;
if(a == 1 && a == 2 && a == 3){
     console.log(1);
}

code

var a = {
  i: 1,
  toString() {
    return a.i++;
  }
}
if( a == 1 && a == 2 && a == 3 ) {
  console.log(1);
}
let a = [1,2,3];
a.toString = a.shift;
if( a == 1 && a == 2 && a == 3 ) {
  console.log(1);
}

<a name="t8jz1"></a>
#### 实现 (5).add(3).minus(2) 功能。
```markdown
例： 5 + 3 - 2，结果为 6
Number.prototype.add = function(n) {
  return this.valueOf() + n;
};
Number.prototype.minus = function(n) {
  return this.valueOf() - n;
};

冒泡排序如何实现，时间复杂度是多少， 还可以如何改进？

冒泡算法的原理：
升序冒泡： 两次循环，相邻元素两两比较，如果前面的大于后面的就交换位置
降序冒泡： 两次循环，相邻元素两两比较，如果前面的小于后面的就交换位置
```js
// 升序冒泡
function maopao(arr){
  const array = [...arr]
  for(let i = 0, len = array.length; i < len - 1; i++){
    for(let j = i + 1; j < len; j++) {
      if (array[i] > array[j]) {
        let temp = array[i]
        array[i] = array[j]
        array[j] = temp
      }
    }
  }
  return array
}

看起来没问题，不过一般生产环境都不用这个，原因是效率低下，冒泡排序在平均和最坏情况下的时间复杂度都是 O(n^2)，最好情况下都是 O(n)，空间复杂度是 O(1)。因为就算你给一个已经排好序的数组，如[1,2,3,4,5,6] 它也会走一遍流程，白白浪费资源。所以有没有什么好的解决方法呢？ 答案是肯定有的：加个标识，如果已经排好序了就直接跳出循环。

function maopao(arr){
  const array = [...arr]
  let isOk = true
  for(let i = 0, len = array.length; i < len - 1; i++){
    for(let j = i + 1; j < len; j++) {
      if (array[i] > array[j]) {
        let temp = array[i]
        array[i] = array[j]
        array[j] = temp
        isOk = false
      }
    }
    if(isOk){
      break
    }
  }
  return array
}

<a name="bi9iZ"></a>
#### 要求设计 LazyMan 类，实现以下功能。
```markdown
```js
LazyMan('Tony');
// Hi I am Tony
LazyMan('Tony').sleep(10).eat('lunch');
// Hi I am Tony
// 等待了10秒...
// I am eating lunch
LazyMan('Tony').eat('lunch').sleep(10).eat('dinner');
// Hi I am Tony
// I am eating lunch
// 等待了10秒...
// I am eating diner
LazyMan('Tony').eat('lunch').eat('dinner').sleepFirst(5).sleep(10).eat('junk food');
// Hi I am Tony
// 等待了5秒...
// I am eating lunch
// I am eating dinner
// 等待了10秒...
// I am eating junk food

class LazyManClass {
  constructor(name) {
    this.name = name
    this.queue = []
    console.log(`Hi I am ${name}`)
    setTimeout(() => {
      this.next()
    },0)
  }
  sleepFirst(time) {
    const fn = () => {
      setTimeout(() => {
        console.log(`等待了${time}秒...`)
        this.next()
      }, time)
    }
    this.queue.unshift(fn)
    return this
  }
  sleep(time) {
    const fn = () => {
      setTimeout(() => {
        console.log(`等待了${time}秒...`)
        this.next()
      },time)
    }
    this.queue.push(fn)
    return this
  }
  eat(food) {
    const fn = () => {
      console.log(`I am eating ${food}`)
      this.next()
    }
    this.queue.push(fn)
    return this
  }
  next() {
    const fn = this.queue.shift()
    fn && fn()
  }
}
function LazyMan(name) {
  return new LazyManClass(name)
}

<a name="jH9H0"></a>
#### 已知如下代码，如何修改才能让图片宽度为 300px ？注意下面代码不可修改。
```markdown
<img src="1.jpg" style="width:480px!important;”>
## code
```css
max-width: 300px
transform: scale(0.625,0.625)

<a name="xPsIO"></a>
#### 编程算法题
```javascript
用 JavaScript 写一个函数，输入 int 型，返回整数逆序后的字符串。如：输入整型 1234，返回字符串“4321”。要求必须使用递归函数调用，不能用全局变量，输入函数必须只有一个参数传入，必须返回字符串。
function fun(num) {
  let num1 = num / 10;
  let num2 = num % 10;
  if (num1 < 1) {
    return num;
  } else {
    num1 = Math.floor(num1);
    return `${num2}${fun(num1)}`;
  }
}
var a = fun(12345);
console.log(a);
console.log(typeof a);

循环打印红黄绿

下面来看一道比较典型的问题，通过这个问题来对比几种异步编程方法：红灯 3s 亮一次，绿灯 1s 亮一次，黄灯 2s 亮一次；如何让三个灯不断交替重复亮灯？
三个亮灯函数：

function red() {
    console.log('red');
}
function green() {
    console.log('green');
}
function yellow() {
    console.log('yellow');
}

这道题复杂的地方在于需要“交替重复”亮灯，而不是“亮完一次”就结束了。

（1）用 callback 实现

const task = (timer, light, callback) => {
    setTimeout(() => {
        if (light === 'red') {
            red()
        }
        else if (light === 'green') {
            green()
        }
        else if (light === 'yellow') {
            yellow()
        }
        callback()
    }, timer)
}
task(3000, 'red', () => {
    task(2000, 'green', () => {
        task(1000, 'yellow', Function.prototype)
    })
})

这里存在一个 bug：代码只是完成了一次流程，执行后红黄绿灯分别只亮一次。该如何让它交替重复进行呢？

上面提到过递归，可以递归亮灯的一个周期：

const step = () => {
    task(3000, 'red', () => {
        task(2000, 'green', () => {
            task(1000, 'yellow', step)
        })
    })
}
step()

注意看黄灯亮的回调里又再次调用了 step 方法 以完成循环亮灯。

（2）用 promise 实现

const task = (timer, light) => 
    new Promise((resolve, reject) => {
        setTimeout(() => {
            if (light === 'red') {
                red()
            }
            else if (light === 'green') {
                green()
            }
            else if (light === 'yellow') {
                yellow()
            }
            resolve()
        }, timer)
    })
const step = () => {
    task(3000, 'red')
        .then(() => task(2000, 'green'))
        .then(() => task(2100, 'yellow'))
        .then(step)
}
step()

这里将回调移除，在一次亮灯结束后，resolve 当前 promise，并依然使用递归进行。

（3）用 async/await 实现

const taskRunner =  async () => {
    await task(3000, 'red')
    await task(2000, 'green')
    await task(2100, 'yellow')
    taskRunner()
}
taskRunner()

2. 实现每隔一秒打印 1,2,3,4

// 使用闭包实现
for (var i = 0; i < 5; i++) {
  (function(i) {
    setTimeout(function() {
      console.log(i);
    }, i * 1000);
  })(i);
}
// 使用 let 块级作用域
for (let i = 0; i < 5; i++) {
  setTimeout(function() {
    console.log(i);
  }, i * 1000);
}

3. 小孩报数问题

有30个小孩儿，编号从1-30，围成一圈依此报数，1、2、3 数到 3 的小孩儿退出这个圈， 然后下一个小孩 重新报数 1、2、3，问最后剩下的那个小孩儿的编号是多少?

function childNum(num, count){
    let allplayer = [];    
    for(let i = 0; i < num; i++){
        allplayer[i] = i + 1;
    }
    let exitCount = 0;    // 离开人数
    let counter = 0;      // 记录报数
    let curIndex = 0;     // 当前下标
    while(exitCount < num - 1){
        if(allplayer[curIndex] !== 0) counter++;    
        if(counter == count){
            allplayer[curIndex] = 0;                 
            counter = 0;
            exitCount++;  
        }
        curIndex++;
        if(curIndex == num){
            curIndex = 0               
        };           
    }    
    for(i = 0; i < num; i++){
        if(allplayer[i] !== 0){
            return allplayer[i]
        }      
    }
}
childNum(30, 3)

有这样一个函数 A,要求在不改变原有函数 A 功能以及调用方式的情况下，使得每次调用该函数都能在控制台打印出“HelloWorld”

function A() { console.log(“调用了函数A”); }

## 1
```js
~(function(){
  Function.prototype.before = function(beforeFn){
    return (...args) => {
      // 先执行传入的beforeFn的函数
      beforeFn.apply(this, args);
      // 再执行调用beforeFn的函数
      const res = this.apply(this, args);
      return res;
    }
  }
  Function.prototype.after = function(afterFn){
    return (...args) => {
      // 先执行调用的after的函数
      const res = this.apply(this, args);
      // 再执行传入的afterFn函数
      afterFn.apply(this, args);
      return res;
    }
  }
  function A() {
    console.log("调用了函数A");
  }
  const fn = A.before(() => {
    console.log('before');
  }).after(() => {
    console.log('after');
  });
  fn();
})();

2

function A() {
  console.log("调用了函数A");
}
const B = A;
A = () => {
  console.log('HelloWorld');
  B()
}
A()

<a name="a3J6A"></a>
#### 请你完成一个 safeGet 函数，可以安全的获取无限多层次的数据
> // 请你完成一个safeGet函数，可以安全的获取无限多层次的数据，一旦数据不存在不会报错，会返回 undefined，例如
> var data = { a: { b: { c: "yideng" } } };
> safeGet(data, "a.b.c"); // => yideng
> safeGet(data, "a.b.c.d"); // => undefined
> safeGet(data, "a.b.c.d.e.f.g"); // => undefined
```javascript
// 普通方式遍历
function safeGet(obj,str){
    let arr = str.split('.');
    let temp = obj;
    for(let i = 0;i<arr.length;i++){
        let target = temp[arr[i]];
        if(!target) return undefined;
        if(i === arr.length-1){
            return target;
        }
        temp = target;
    }
}
// reduce 方式
const safeGet = (o,path) =>{
    try{
        return path.split('.').reduce((pre,cur)=>pre[cur],o);
    }catch(e){
        return undefined;
    }
}

写一个 isPrime()函数

写一个isPrime()函数，当其为质数时返回true，否则返回false。 提示：质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

function isPrime(number) {
   // If your browser doesn't support the method Number.isInteger of ECMAScript 6,
   // you can implement your own pretty easily
   if (typeof number !== 'number' || !Number.isInteger(number)) {
      // Alternatively you can throw an error.
      return false;
   }
   if (number < 2) {
      return false;
   }
   if (number === 2) {
      return true;
   } else if (number % 2 === 0) {
      return false;
   }
   var squareRoot = Math.sqrt(number);
   for(var i = 3; i <= squareRoot; i += 2) {
      if (number % i === 0) {
         return false;
      }
   }
   return true;
}

请实现一个 flattenDeep 函数，把嵌套的数组扁平化~~

flattenDeep([1, [2, [3, [4]], 5]]); //[1, 2, 3, 4, 5] // 请实现一个flattenDeep函数，把嵌套的数组扁平化

// 直接利用 ES6 新增数组方法 flat
function flattenDeep(arr){
     return arr.flat(Infinity)
}
// 可以利用 reduce 和 concat
function flattenDeep(arr){
    arr.reduce((prev,cur)=>{
        return prev.concat(Array.isArray(cur) ?
        flattenDeep(cur) :
        cur)},[])
}
// 使用 stack 无限反嵌套多层嵌套数组
function flattenDeep(input){
    const stack = [...input];
    const res = [];
    while(stack.length){
        //使用 pop 从stack 取出并移除值
        const next = stack.pop();
        if(Array.isArray(next)){
            //使用 push 送回内层数组中的元素，不会改变原始输入 origin input
            stack.push(next);
        }else{
            res.push(next);
        }
    }
    //使用 reverse 恢复原数组的顺序
    return res.reverse();
}
// 利用数组的 toString 方法返回 以 ，分割的字符串形式但是这个方法会有一个问题，就是如果你的数组中不仅有字符串还有数字，那么经过 split 后都会是 字符串形式的数据，map 之后又会都转为数字，所以和原数组可能有差别。
function flattenDeep(arr){
    return arr.toString().split(',').map(item=>+item);
}

请实现一个 uniq 函数，实现数组去重

uniq([1, 2, 3, 5, 3, 2]); //[1, 2, 3, 5] // 请实现一个 uniq 函数，实现数组去重

// 利用ES6新增数据类型Set
// 1、
function uniq(arry){
  return [...new Set(arry)]
}
// 2、
function unique10(arr) {
  //Set数据结构，它类似于数组，其成员的值都是唯一的
  return Array.from(new Set(arr)); // 利用Array.from将Set结构转换成数组
}
// 利用数组的indexOf下标属性来查询
function uniq(arry){
    var result = [];
    for(var i = 0; i < arry.length; i++){
        if(result.indexOf(arry[i]) === -1){
            //如果result中没有arry[i],则添加到数组中
            result.push(arry[i])
        }
    }
    return result
}
// 利用数组原型对象上的includes方法
function uniq(arry){
    var result = [];
    for(var i = 0; i < arry.length; i++){
        if(!result.includes(arry[i]) === -1){
            //如果result中没有arry[i],则添加到数组中
            result.push(arry[i])
        }
    }
    return result
}
// 利用reduce
function uniq(arry){
    return arry.reduce((prev,cur)=>prev.includes(cur) ? prev : [..prev,cur],[])
}
// 利用Map
function uniq(arry){
    let map = new Map();
    let result = new Array();
    for(let i = 0; i < arry.length; i++){
        if(map.has(arry[i])){
            map.set(arry[i],true)
        }else{
            map.set(arry[i],false)
            result.push(arry[i])
        }
    }
    return result
}
// 利用数组原型对象上的 filter 和 includes方法组合
function unique(arr) {
  var newArr = []
  newArr = arr.filter(function (item) {
    return newArr.includes(item) ? '' : newArr.push(item)
  })
  return newArr
}
// 利用数组原型对象上的 forEach 和 includes方法组合
function unique(arr) {
  let newArr = []
  arr.forEach(item => {
      return newArr.includes(item) ? '' : newArr.push(item)
  })
  return newArr
}

实现 (5).add(3).minus(2) 功能

// 实现 (5).add(3).minus(2) 功能 console.log((5).add(3).minus(2)); // 6

Number.prototype.add = function(number){
    if(typeof number !== 'number'){
        throw TypeError('the add function need a number');
    }
    return this + number;
}
Number.prototype.ninus = function(number){
    if(typeof number !== 'number'){
        throw TypeError('the ninus function need a number');
    }
    return this - number;
}

如何在不使用%摸运算符的情况下检查一个数字是否是偶数

// 位运算 & 运算符将两个数字都转化为二进制，它使用按位与运算符比较每个位
function isEven(num){
    if(num & 1){
        return false;
    }else{
        return true;
    }
}
// 递归方式
function isEven(num){
    if(num<0 || num ===1){
        return false;
    }
    if(num === 0){
        return true;
    }
    return isEven(num-2);
}

完成 plus 函数，通过全部的测试用例

“use strict”; function plus(n) {} module.exports = plus; // 测试用例如下 (“use strict”); var assert = require(“assert”); var plus = require(“../lib/assign-4”); describe(“测试用例”, function () { it(“plus(0) === 0”, function () { assert.equal(0, plus(0).toString()); }); it(“plus(1)(1)(2)(3)(5) === 12”, function () { assert.equal(12, plus(1)(1)(2)(3)(5).toString()); }); it(“plus(1)(4)(2)(3) === 10”, function () { assert.equal(10, plus(1)(4)(2)(3).toString()); }); it(“plus(1,1)(2,2)(3)(4) === 13”, function () { assert.equal(13, plus(1, 1)(2, 2)(3)(4).toString()); }); });

// 答案&解析
参考答案：答案不唯一
"use strict";
function plus(n) {
// 第一次执行时，定义一个数组专门用来存储所有的参数
var _args = [].slice.call(arguments);
// 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
var _adder = function () {
_args.push(...arguments);
return _adder;
};
// 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
_adder.toString = function () {
return _args.reduce(function (a, b) {
return a + b;
});
};
return _adder;
}
module.exports = plus;

写出执行结果,并解释原因

var yideng_a = Function.length; var yideng_b = new Function().length; console.log(yideng_a === yideng_b);

// Function本身期望有一个参数的情况
const a = Function('console.log("aaa")')// 如果报错把它保存成文件再打开
a();// "aaa"
console.log(Function.length)// 1
// 这里创建的函数并不包含期望值
console.dir(a);// length 0
// 同样这样设置不期望有参数
console.dir(new Function())// length 0
// 这么设置期望有两个参数
const add = new Function("a", "b", "return a+b");
console.log(add(1, 2))// 3
console.log(add.length)// 2
// 答案&解析
①每个 JavaScript 函数实际上都是一个 Function 对象。运行 (function(){}).constructor === Function,true 便可以得到这个结论。
②全局的 Function 对象没有自己的属性和方法，但是，因为它本身也是一个函数，所以它也会通过原型链从自己的原型链 Function.prototype 上继承一些属性和方法。
③length是函数对象的一个属性值，指该函数有多少个必须要传入的参数，即形参的个数。与之对比的是， arguments.length 是函数被调用时实际传参的个数。
④length 是函数对象的一个属性值，指该函数有多少个必须要传入的参数，即形参的个数。
形参的数量不包括剩余参数个数，仅包括第一个具有默认值之前的参数个数。
Function 构造器本身也是个Function。他的 length 属性值为 1 。该属性 Writable: false, Enumerable: false, Configurable: true.Function 原型对象的 length 属性值为 0 。

不借助中间变量交换两个变量的值

不借助中间变量交换两个变量的值 比如 let a = 1,b = 2;交换a,b的值

// 答案&解析
1）利用加法
let a = 1,b = 2;
b = a + b;
a = b - a;
b = b - a;
缺点：利用加法 a+b;有溢出风险
2）利用减法
let a = 1,b = 2;
b = a - b;
a = a - b;
b = a + b;
这样就解决了加法溢出的风险，理论上已经很完美了,继续往下看
3）es6解构赋值
let a = 1,b = 2;
[a,b]=[b,a]
4）按位异或^
这里用到了异或这个位运算的性质，即相同则为 0，不同则为 1
对于两个数字，a 和 b。则有 a ^ a ^ b 就等于 b 。我们可以利用这个性质来完成交换。
let a = 1,b = 2;
b = a ^ b;
a = a ^ b; // a = a ^ a ^ b
b = a ^ b; // b = a ^ b ^ b
过程解释：
a = 1 -> 01
b = 2 -> 10
a ^ a -> 01 ^ 01 -> 肯定是00，因为相同为0
a ^ a ^ b -> 00 ^ 10 -> 还是 10 -> b
a ^ b ^ b->
①过程：01 ^ 10 ^ 10 -> 11 ^ 10 -> 01 -> a
②其实这里涉及到离散数学的异或运算性质：交换律：a ^ b ^ c <=> a ^ c ^ b
还有其它性质：任何数于0异或为任何数 0 ^ n => n，相同的数异或为0: n ^ n => 0
5）逗号表达式
逗号表达式是将两个及其以上的式子联接起来，从左往右逐个计算表达式，整个表达式的值为最后一个表达式的值。
利用这个性质，先完成一次赋值操作，然后将赋值操作的返回值变为0. 就可以完成赋值操作
let a = 1,b = 2;
a = b + ((b=a),0);

实现一个 isNegtiveZero 函数，只检查+0 和-0，-0 则返回 true,+0 返回 false

// 实现一个isNegtiveZero函数，只检查+0和-0，-0则返回true,+0返回false function isNegtiveZero(num) { // 代码实现 }

// 答案与解析
在 JavaScript 中, Number 是一种 定义为 64位双精度浮点型（double-precision 64-bit floating point format） (IEEE 754)的数字数据类型，首位是符号位，然后是52位的整数位和11位的小数位。如果符号位为1，其他各位均为0，那么这个数值会被表示成“-0”。
所以JavaScript的“0”值有两个，+0和-0。
1）解题思路
①看到+0和-0，大概想尝试把该数字通过toString()转化成字符串，在使用indexOf('-')判断是否等于0，或者charAt(0)判断是否等于-。很不幸，数值在进行toString()的时候就自动将其转为0了，所以此方法行不通。
②可以尝试另外一个思路，计算机在进行四则及与或模等数值运算时，符号本身也参与运算，JavaScript亦是如此。而使用0对一个数做加减操作对本身是无影响的，乘法虽然得到±0的结果，但是又回到了问题本身对±0的判断了，因此我们可以考虑到除法，加上数值本身有Infinity和-Infinity的区分，分别表示正无穷和负无穷。我们很容易想到使用一个数值来除以±0得到±Infinity。我们使用-1/0或1/-0都得到-Infinity的结果。
③同样的，JavaScript提供很多函数供你使用，但结果不外乎都是借助一个数值进行判断。如：Math.pow(-0, -1) === -Infinity，Math.atan2(-0, -1) === -Math.PI
2）参考答案
①实现方式一
function isNegtiveZero(num) {
if (num !== 0) {
throw new RangeError("The argument must be +0 or -0");
}
return 1 / num === -Infinity;
}
console.log(isNegtiveZero(+0));
console.log(isNegtiveZero(-0));
②实现方式2
ECMAScript2015添加了一个方法Object.is用于对两数值进行比较，可以用于比较±0
Object.is(+0, 0) === true;
Object.is(-0, 0) === false;
function isNegtiveZero(num) {
if (num !== 0) {
throw new RangeError("The argument must be +0 or -0");
}
return !Object.is(num, 0);
}
console.log(isNegtiveZero(+0));
console.log(isNegtiveZero(-0));

补全代码

/ 说明：该文件名未知，位于当前项目内的dist/scripts文件夹内 要求：一句话补全代码，获取它的完整位置:http://xx.com/dis/scripts/xx.js 注：非node环境，node可以使用__dirname / const url = ✍️代码书写处； export default url;

// 答案与解析
const url = import.meta.url
es2020新特性

一个简单的算法题目

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，这两个整数可能有多种组合，找出其中一组组合即可，并返回他们的数组下标。

示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]

// 最容易想到的就是暴力枚举，我们可以利用两层 for 循环来遍历每个元素，并查找满足条件的目标元素。不过这样时间复杂度为 O(N^2)，空间复杂度为 O(1)，时间复杂度较高，我们要想办法进行优化。我们可以增加一个 Map 记录已经遍历过的数字及其对应的索引值。这样当遍历一个新数字的时候去 Map 里查询，target 与该数的差值是否已经在前面的数字中出现过。如果出现过，那么已经得出答案，就不必再往下执行了。
/**
    @param {number[]} nums
    @param {number} target
    @return {number[]}
    */
    const twoSum = function (nums, target) {
    const map = new Map();
    for (let i = 0; i < nums.length; i++) {
    const diff = target - nums[i];
    if (map.has(diff)) {
    return [map.get(diff), i];
    }
    map.set(nums[i], i);
    }
    }

写出执行结果,并解释原因

3.toString() 3..toString() 3…toString()

// 答案与解析
报错 "3" 报错
运算符优先级问题
点运算符会被优先识别为数字常量的一部分，然后才是对象属性访问符
在JavaScript中，3.1，3.，.1都是合法的数字
3.toString() 会被JS引擎解析成 (3.)toString() 报错
3..toString() 会被JS引擎解析成 (3.).toString() "3"
3...toString() 会被JS引擎解析成 (3.)..toString() 报错

写出执行结果,并解释原因

function yideng() {} const a = {}, b = Object.prototype; console.log(a.prototype === b); console.log(Object.getPrototypeOf(a) === b); console.log(yideng.prototype === Object.getPrototypeOf(yideng));

// 答案
false true false
//知识点
proto（隐式原型）与prototype（显式原型）
1）是什么？
①显式原型 explicit prototype property：
每一个函数在创建之后都会拥有一个名为prototype的属性，这个属性指向函数的原型对象。(需要注意的是，通过Function.prototype.bind方法构造出来的函数是个例外，它没有prototype属性)
②隐式原型 implicit prototype link：
JavaScript中任意对象都有一个内置属性[[prototype]]，在ES5之前没有标准的方法访问这个内置属性，但是大多数浏览器都支持通过__proto__来访问。ES5中有了对于这个内置属性标准的Get方法Object.getPrototypeOf()。(注意：Object.prototype 这个对象是个例外，它的__proto__值为null)
③二者的关系：
隐式原型指向创建这个对象的函数(constructor)的prototype
2）作用是什么？
①显式原型的作用：用来实现基于原型的继承与属性的共享。
②隐式原型的作用：构成原型链，同样用于实现基于原型的继承。举个例子，当我们访问obj这个对象中的x属性时，如果在obj中找不到，那么就会沿着__proto__依次查找。
3）__proto__的指向：
__proto__的指向到底如何判断呢？根据ECMA定义 'to the value of its constructor’s "prototype" ' ----指向创建这个对象的函数的显式原型。
所以关键的点在于找到创建这个对象的构造函数，接下来就来看一下JS中对象被创建的方式，一眼看过去似乎有三种方式：（1）对象字面量的方式 （2）new 的方式 （3）ES5中的Object.create()。
但是本质上只有一种方式，也就是通过new来创建。为什么这么说呢，首先字面量的方式是一种为了开发人员更方便创建对象的一个语法糖，本质就是 var o = new Object(); o.xx = xx;o.yy=yy;
//解析：
1）a.prototype === b =>false
prototype属性是只有函数才特有的属性，当你创建一个函数时，js会自动为这个函数加上prototype属性，值是一个空对象。而实例对象是没有prototype属性的。所以a.prototype是undefined,第一个结果为false。
2）Object.getPrototypeOf(a) === b =>true
首先要明确对象和构造函数的关系，对象在创建的时候，其__proto__会指向其构造函数的prototype属性
Object实际上是一个构造函数（typeof Object的结果为"function"）,使用字面量创建对象和new Object创建对象是一样的，所以a.__proto__也就是Object.prototype，所以Object.getPrototypeOf(a)与a.__proto__是一样的，第二个结果为true
3）yideng.prototype === Object.getPrototypeOf(yideng) =>false
关键点：f.prototype和Object.getPrototypeOf(f)说的不是一回事
①f.prototype 是使用使用 new 创建的 f 实例的原型:
f.prototype === Object.getPrototypeOf(new f()); // true
②Object.getPrototypeOf(f)是 f 函数的原型:
Object.getPrototypeOf(f) === Function.prototype; //true
所以答案是 false

写出执行结果,并解释原因

const lowerCaseOnly = /^[a-z]+$/; console.log(lowerCaseOnly.test(“yideng”)); console.log(lowerCaseOnly.test(null)); console.log(lowerCaseOnly.test());

// 答案
true true true
// 解析
test方法的参数会被调用toString强制转换成字符串
此题转换的字符串是null、undefined

写出执行结果,并解释原因

function captureOne(re, str) { var match = re.exec(str); return match && match[1]; } var numRe = /num=(\d+)/gi, wordRe = /yideng=(\w+)/i, a1 = captureOne(numRe, “num=1”), a2 = captureOne(wordRe, “yideng=1”), a3 = captureOne(numRe, “NUM=2”), a4 = captureOne(wordRe, “YIDENG=2”), a5 = captureOne(numRe, “Num=3”), a6 = captureOne(wordRe, “YiDeng=3”); console.log(a1 === a2); console.log(a3 === a4); console.log(a5 === a6);

// 答案
true false true
// 解析
1）exec() 方法在一个指定字符串中执行一个搜索匹配。返回一个结果数组或 null。
2）但是在Javascript中使用exec进行正则表达式全局匹配时要注意：
①在全局模式下，当 exec() 找到了与表达式相匹配的文本时，在匹配后，它将把正则表达式对象的 ②lastIndex 属性设置为匹配文本的最后一个字符的下一个位置。
③这就是说，您可以通过反复调用 exec() 方法来遍历字符串中的所有匹配文本。
④当 exec() 再也找不到匹配的文本时，它将返回 null，并把 lastIndex 属性重置为 0。
3）所以在全局模式下，如果在一个字符串中完成了一次模式匹配之后要开始检索新的字符串，就必须手动地把 lastIndex 属性重置为 0。

[手写代码]实现 Promise.all 方法

// 核心思路
①接收一个 Promise 实例的数组或具有 Iterator 接口的对象作为参数
②这个方法返回一个新的 promise 对象，
③遍历传入的参数，用Promise.resolve()将参数"包一层"，使其变成一个promise对象
④参数所有回调成功才是成功，返回值数组与参数顺序一致
⑤参数数组其中一个失败，则触发失败状态，第一个触发失败的 Promise 错误信息作为 Promise.all 的错误信息。
// 实现代码
一般来说，Promise.all 用来处理多个并发请求，也是为了页面数据构造的方便，将一个页面所用到的在不同接口的数据一起请求过来，不过，如果其中一个接口失败了，多个请求也就失败了，页面可能啥也出不来，这就看当前页面的耦合程度了～
//代码实现
function promiseAll(promises) {
return new Promise(function(resolve, reject) {
if(!Array.isArray(promises)){
throw new TypeError(argument must be a array)
}
var resolvedCounter = 0;
var promiseNum = promises.length;
var resolvedResult = [];
for (let i = 0; i < promiseNum; i++) {
Promise.resolve(promises[i]).then(value=>{
resolvedCounter++;
resolvedResult[i] = value;
if (resolvedCounter == promiseNum) {
return resolve(resolvedResult)
}
},error=>{
return reject(error)
})
}
})
}
// test
let p1 = new Promise(function (resolve, reject) {
setTimeout(function () {
resolve(1)
}, 1000)
})
let p2 = new Promise(function (resolve, reject) {
setTimeout(function () {
resolve(2)
}, 2000)
})
let p3 = new Promise(function (resolve, reject) {
setTimeout(function () {
resolve(3)
}, 3000)
})
promiseAll([p3, p1, p2]).then(res => {
console.log(res) // [3, 1, 2]
})