算法面试题

Table of Contents

• 扁平化嵌套数组 leetcode
  • 递归
  • 隐式类型转换
  • Generator
  • Symbol.iterator
  • …​扩展运算符
  • Array.prototype.flat()
• 柯里化 leetcode

扁平化嵌套数组 leetcode

将数组 [1, [2, [3, [4]], 5]] 转化为 [1, 2, 3, 4, 5]

递归

function flat (arr) {
  let result = [];
  for(let i = 0; i < arr.length; i++) {
    const item = arr[i];
    if(item instanceof Array) {
      result = result.concat(...flat(item));
    } else {
      result.push(item);
    }
  }
  return result;
}

隐式类型转换

主要考察数组`toString()`、`valueOf()`方法的使用，注意这种方式转换之后的数组元素变为字符串。

// 借用数组的toString方法
function flat (arr) {
  var str = arr.toString();
  return str.split(',');
}

// 借用数组的valueOf方法
Array.prototype.valueOf = function() {
  return this.join(',')
};

function flat2 (arr) {
  var str = arr.valueOf();
  return str.split(',');
}

Generator

考察ES6中Generator函数的使用，以及返回值作为一个遍历器对象的使用。

function *flat (arr) {
  for(let i = 0; i < arr.length; i++) {
    const item = arr[i];
    if(Array.isArray(item)) {
      yield *flat(item);
    } else {
      yield item;
    }
  }
}
const res = [...flat(arr)];

Symbol.iterator

考察ES6中 Symbol.iterator 的使用

Array.prototype[Symbol.iterator] = function () {
  let arr = [].concat(this);
  let first = function (arr) {
    return arr.shift();
  };

  return {
    next: function() {
      let item = first(arr);
      if (item) {
        return {
          value: item.toString(),
          done: false
        }
      } else {
        return {
          done: true
        }
      }
    }
  };
}

const flat = arr => {
  let res = [];
  for(let i of arr) {
    res.push(i);
  }
  return res.join(',').split(',');
};

或者通过generator函数+递归实现

Array.prototype[Symbol.iterator] = function* (array) {
 let arr = array || this;
 let sel = arguments.callee;
 
  for(let i = 0; i < arr.length; i++) {
    const item = arr[i];
    if(Array.isArray(item)) {
      yield *sel(item);
    } else {
      yield item;
    }
  }
}
// test
var arr = [1, [2, [3, [4]], '5']];
console.log([...arr]);

…​扩展运算符

function flat(arr) {
  let arr;
  while (arr.some(v => Array.isArray(v))) {
    arr = [].concat(...arr);
  }
  return arr;
}

Array.prototype.flat()

flat() 是ES6中新增的数组方法，该方法返回一个新数组，对原数据没有影响。

[1, [2, [3, [4]], 5]].flat(Infinity);

柯里化 leetcode

请你编写一个函数，它接收一个其他的函数，并返回该函数的 柯里化 后的形式

柯里化 函数的定义是接受与原函数相同数量或更少数量的参数，并返回另一个 柯里化 后的函数或与原函数相同的值。

实际上，当你调用原函数，如 sum(1,2,3) 时，它将调用 柯里化 函数的某个形式，如 csum(1)(2)(3)， csum(1)(2,3)， csum(1,2)(3)，或 csum(1,2,3) 。所有调用 柯里化 函数的方法都应该返回与原始函数相同的值。

/**
 * @param {Function} fn
 * @return {Function}
 */
function curry(fn) {
  let _args = [];
  return function curried(...args) {
    _args.push(...args);
    if(_args.length >= fn.length) {
      return fn.apply(this, _args);
    } else {
      return curried;
    }
  }
}

// function sum(a, b) { return a + b; }
// const csum = curry(sum);
// csum(1)(2) // 3