Js代码题

function Bar() {
  return;
  {
    a: 1;
  }
}
const f = Bar();
console.log(f.a);

输出 error，因为return后没有值，即使格式化也没有用，因此下方的Object和return没有关联

js 将多层嵌套的数组转换为一层数组

let list = [1, [2, [3, [4]], 5]];

Array.prototype.transfer = function (level) {
  let list = this;
  const flat = (list) => {
    return list.reduce((prev, next) => {
      next = Array.isArray(next) ? next : [next];
      return [...prev, ...next];
    }, []);
  };
  while (level > 0) {
    list = flat(list);
    level--;
  }
  return list;
};

let list = this调用时候的数组，在原型链上的东西，使用时即调用本身。

手写防抖节流

//防抖
let btn = document.querySelcetor('button');
let timer = null;
btn.onclick = function () {
  clearTimeout(timer);
  timer = setTimeout(() => {
    console.log('触发请求');
  }, 1000);
};
//节流
let btn = document.querySelcetor('button');
let flag = true;
btn.onclick = function () {
  if (flag) {
    flag = false;
    console.log('触发请求');
    setTimeout(() => {
      flag = true;
    }, 1000);
  }
};

一道经典面试题—setTimeout(function(){},0)

for (var i = 0; i < 3; i++) {
  setTimeout(function () {
    console.log(i);
  }, 0);
  console.log(i);
}
//结果为0 1 2 3 3 3

该题考了三个知识点：作用域，闭包，异步

先简化此题

setTimeout(function () {
  console.log(1);
}, 0);
console.log(2);
//先打印2，再打印1

因为使用 var，是 es5 里面的内容，所以没有块级作用域

for (var i = 0; i < 3; i++) {}
console.log(i);
//输出3

怎么保证能弹出 0,1,2

for (var i = 0; i < 3; i++) {
  setTimeout(
    (function (i) {
      return function () {
        console.log(i);
      };
    })(i),
    0
  ); //改为立即执行的函数
  console.log(i);
}
//输出为0,1,2,0,1,2

实现一个简单的数组去重

let arr =[1,2,3,2,4,2,1,3]
arr.reduce((accumulator, currentValue) => {
    if (!accumulator.includes(currentValue)) {
      return  [ ...accumulator, currentValue ]
    }
    return accumulator
}, [])

对范围内的所有数字求和

我们将传递给您一个包含两个数字的数组。返回这两个数字的总和加上它们之间所有数字的总和。最低的数字并不总是最先出现的。
例如，sumAll([4,1])应该返回，10因为 1 到 4（包括 1 和 4）之间的所有数字的总和是10。

function sumAll(arr) {
  let sumBetween = 0;
  for (let i = Math.min(...arr); i <= Math.max(...arr); i++) {
    sumBetween += i;
  }
  return sumBetween;
}

sumAll([1, 4]);

function sumAll(arr) {
  const [first, last] = [...arr].sort((a, b) => a - b);
  return first !== last
    ? first + sumAll([first + 1, last])
    : first;
}

sumAll([1, 4]);

function sumAll(arr) {
  let max = Math.max(arr[0], arr[1]);
  let min = Math.min(arr[0], arr[1]);
  let sumBetween = 0;
  for (let i = min; i <= max; i++) {
    sumBetween += i;
  }
  return sumBetween;
}

sumAll([1, 4]);

找出字符串中最长的单词

// 解法一
// 使用reduce进行遍历，将单词长度存到longest里面，最后返回longest
function findLongestWordLength(str) {
  let arr = str.split(' ')
  return arr.reduce((longest, word) => {
    return Math.max(longest, word.length)
  }, 0)
}
// 解法二
// 使用map进行遍历
function findLongestWordLength(str) {
  return Math.max(...str.split(' ').map(word=>word.length))
}

findLongestWordLength("The quick brown fox jumped over the lazy dog");

求每个数组中最大的值并将这些值重新放入一个新数组中

//解法一
function largestOfFour(arr) {
  return arr.map((group) => {
    return group.reduce((prev, current) => {
      return current > prev ? current : prev;
    });
  });
} 
//解法2
function largestOfFour(arr) {
  return arr.reduce((newArr, arr) => {
    let max = Math.max(...arr)
    return [...newArr, max];
  }, []);
}

largestOfFour([[4, 5, 1, 3],[13, 27, 18, 26],[32, 35, 37, 39],[1000, 1001, 857, 1]])

返回提供的字符串，每个单词的第一个字母大写。确保单词的其余部分是小写的。

// 解法一：我们正在使整个字符串小写，然后将其转换为数组。然后我们使用 map 函数将小写字符替换为大写。最后，我们使用join方法返回字符串。
function titleCase(str) {
  var convertToArray = str.toLowerCase().split(" ");
  var result = convertToArray.map(function(val) {
    return val.replace(val.charAt(0), val.charAt(0).toUpperCase());
  });
  return result.join(" ");
}

titleCase("I'm a little tea pot");

// 解法二：使用正则表达式
function titleCase(str) {
  return str.toLowerCase().replace(/(^|\s)\S/g, L => L.toUpperCase());
}

titleCase("I'm a little tea pot")

确认字符串的结尾

检查字符串（第一个参数，str）是否以给定的目标字符串（第二个参数，target）结尾。

// 解法一
function confirmEnding(str, target) {

  return str.slice(-target.length) === target ? true : false
}

// 解法二
function confirmEnding(str, target) {
  // "Never give up and good luck will find you."
  // -- Falcor

  let re = new RegExp(target + "$", "i");

  return re.test(str);
}

confirmEnding("Bastian", "n");

解法一：str.slice(-target.length)切割str中target.length的长度，加负号标识从结尾开始，判断是否等于target，等于则返回true否则返回false。

解法二：使用正则表达式，new RegExp(target + "$", "i")指判断是否是target字符串结尾，且忽略大小写。

Return true if the string in the first element of the array contains all of the letters of the string in the second element of the array.

function mutation(arr) {
  return arr[1].toLowerCase().split('').every(letter => {
    return arr[0].toLowerCase().indexOf(letter) != -1;
  })
}

mutation(["hello", "hey"]);

区分两个数组

比较两个数组并返回一个新数组，其中包含仅在两个给定数组之一中找到的任何项目，但不能同时在这两个数组中找到。换句话说，返回两个数组的对称差。

// 方法一
function diffArray(arr1, arr2) {
  let newArr = [...arr1, ...arr2]
  return newArr.filter(item => !arr1.includes(item) || !arr2.includes(item))
}
// 方法二
function diffArray(arr1, arr2) {
  return [...diff(arr1, arr2), ...diff(arr2, arr1)];

  function diff(a, b) {
    return a.filter(item => b.indexOf(item) === -1);
  }
}
diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]);