数组

001 数组去重合并

例子1摘自MDN的Array.from()
文档：

function combine() {
  let arr = [].concat.apply([], arguments); // 没有去重复的新数组
  return Array.from(new Set(arr));
}
let m = [1, 2, 2, 'a', 'b'], n = [2, 3, 3, 'a'];
console.log(combine(m, n));  // [ 1, 2, 'a', 'b', 3 ]

关键点在于使用apply可以在不创建新数组的情况下将arguments合入[]和使用Set去重。Set对象允许你存储任何类型的唯一值。然后用Array.from()将其转化为数组元素。
参见：Function.prototype.apply()
Set

002 比较权重

function getItems(goal) {
  let arrItems = Array.from(goal).sort(compare('weight'));
  return arrItems;
}

function compare(property) {
  return function (a, b) {
    return a[property] - b[property];
  }
}

getItems([{ a: 4, weight: 4 }, { b: 2, weight: 2 }, { c: 3, weight: 3 }]);
// result：[{ b: 2, weight: 2 }, { c: 3, weight: 3 }, { a: 4, weight: 4 }]

003 Camel-Case

第一种是从从commander.js偷来的

function camelcase(flag) {
  return flag.split('-').reduce((str, word) => {
    return str + word[0].toUpperCase() + word.slice(1);
  });
}

其实这个准确的来说应该是Pascal(大驼峰法) 但是commander.js的对象program使用的都是小驼峰法(以下简称驼峰法)，这么看来是我还没偷对。
而在lodash中的camelCase则是这么写的：

const camelCase = (string) => (
  words(toString(string).replace(/['\u2019]/g, '')).reduce((result, word, index) => {
    word = word.toLowerCase()
    return result + (index ? upperFirst(word) : word)
  }, '')
)

这边用到了一个叫words的函数，比较复杂，下次在写吧

Symbol

Reflect

数组

Array.from和sort()方法

参见：Array.from
Array.prototype.sort()

Array.from()

此方法从一个类似数组或可迭代（iterable）对象中创建一个新的，浅拷贝的数组。

这个方法有三个参数，第一个是必须的类数组(或可迭代)对象arrayLike，剩余两个分别是mapFn(回调函数)和thisArg(执行回调mapFn时的this)

这里的第二个参数mapFn回调函数相当于Array.from(arrayLike)后在执行一次map方法，即等价于Array.from(obj).map(mapFn,thisArg)，除非创建的不是可用的中间数组。

from()的length属性为1，即Array.from.length===1。 Array.from()可以通过两种方式来创建对象：

• 伪数组对象(拥有一个length属性和若干索引属性的任意对象，如下方栗子5中第二个)
• 可迭代对象(可以获取对象中的元素，如Map和Set等) 一些栗子:

/** 1.Array from a String */
Array.from('foo') //['f','o','o']

/** 2.Array from a Set    */
Array.from(new Set(['foo',window]))    // ['foo',window]

/** 3.Array from a Map    */
Array.from(new Map([1,2],[2,4],[4,8])) // [[1, 2], [2, 4], [4, 8]]

/** 4.Array from an Array-like object (arguments)    */
function f(){return Array.from(arguments)};
f(1,2,3);   //[1,2,3]

/** 5.在Array.from中使用箭头函数 */
Array.from([1,2,3],x=>x+x)        //  Array [2, 4, 6]
Array.from({length:5},(v,i)=>i);  //[0,1,2,3,4]

这个方法的去重的例子参见常用函数中的数组函数中的例子1。

Array.prototype.sort()

sort()对数组元素进行排序，并返回数组(数组已原地排序，并且不进行复制)。默认排序是将元素转换为字符串，然后比较它们的UFT-16代码单元值序列。 这个函数接收一个可选的函数作为参数。如果省略，元素按照转换为字符串的各个字符的Unicode位点进行排序。 栗子：

//  1. 未指明compareFunction
[1,30,100000].sort();   // [1,100000,30]   由于没有指定比较函数，所以会将number转为字符串然后比较Unicode
//  2. 指明compareFunction
[1,30,100000].sort((a,b)=>a-b);  // [1,30,100000]

对于compareFunction：

• compareFunction(a,b)，小于0，排序结果：a,b
• compareFunction(a,b)，等于0，a,b位置不变
• compareFunction(a,b)，大于0，排序结果：b,a 结果是从小到大升序排序，如果想降序把a,b交换传入 这个两个函数一起的例子参见常用函数002

in

参见:in

参数可以是一个字符串或者symbol类型的属性名或者数组索引。

• 如果是数组索引index，会查找数组里是否有这个索引。感觉没有太多用处
• 如果是字符串，会查找对象或者其原型链里是否包含该字符串命名的对象，比如:

const trees=new Array('bay');
0 in trees // true
'bay' in trees //false
Symbol.iterator in trees // true 数组可迭代，是其__proto__上的一个属性

const mycar={make:'Honda'};
'make' in mycar //true
'Honda' in mycar //false

in的右边必须是一个对象。比如:

const c1=new String('green');
const c2="coral";
'length' in c1; // true
'length' in c2; // false