JS ES5或者ES6简便方法

1.一组数据取最小值

// 查找数组里面最小的元素值

const arrs = [1, 2, 3, 4];
// ES6 的语法如下
const min = Reflect.apply(Math.min, arrs, arrs);

console.log(min); // 1

// ES5的语法如下：

const min2 = Math.min.apply(arrs, arrs);
console.log(min2); // 1

// 或者我们使用 Finction.prototype 代码如下演示

const min3 = Function.prototype.apply.call(Math.min, arrs, arrs);
console.log(min3); // 1

// 下面是截取字符串的方法演示下 

const strs = 'kongzhi';

// 使用ES6的语法 代码演示如下：

const str1 = Reflect.apply(String.prototype.slice, strs, [0, 3]);
console.log(str1); // 打印 kon

// 使用 ES5的语法 
const str2 = strs.slice(0, 3);
console.log(str2); // 打印 kon

// 或者我们使用 String.prototype 代码如下演示
const str3 = String.prototype.slice.apply(strs, [0, 3]);
console.log(str3); // kon

2 ，Set的基本用法

        Set类似于数组，但是成员的值都是唯一的，没有重复的值。

const s = new Set();
 
[2,3,5,4,5,2,2].forEach(x => s.add(x));
// Set结构不会添加重复的值
 
for(let i of s) {
  console.log(i);
}

const items = new Set([1,2,3,4,5,5,5,5,]);
console.log(items.size);//size表示set后的数组有多少条目

let set = new Set(['red', 'green', 'blue']);
 
// 返回键名
for(let item of set.keys()) {
  console.log(item);
}

const s = new Set();
s.add(1).add(2).add(2);
console.log(s);//{1,2}


// 返回键值
for(let item of set.values()) {
  console.log(item);
}
// set 键名=键值
 
// 返回键值对
for(let item of set.entries()){
  console.log(item);
}


// 实现并集、交集、差集
let a = new Set([1,2,3]);
let b = new Set([4,3,2]);
 
let union = new Set([...a, ...b]);
console.log(union);//并集
 
let intersect = new Set([...a].filter(x => b.has(x)));
console.log(intersect);//交集
 
let difference = new Set([...a].filter(x => !b.has(x)));
console.log(difference);//差集


// filter返回过滤后的新数组
s = new Set([...s].filter(x => (x % 3) ==0));
console.log(s);

3. Array.reduce()的使用

        从表面上看，它似乎是一个简单无趣的方法，并没有太大作用。 但是在不起眼的外表之下，Array.reduce()实际上是对开发人员工具包的强大而灵活的补充。

大部分现代的数组方法都返回一个新的数组，而 Array.reduce() 更加灵活。它可以返回任意值，它的功能就是将一个数组的内容聚合成单个值。这个值可以是数字、字符串，甚至可以是对象或新数组。

用法：

Array.reduce()接受两个参数：一个是对数组每个元素执行的回调方法，一个是初始值。

这个回调接收4个参数，前两个参数是：sum是当前聚合值，current是数组循环时的当前元素。无论你返回什么值，都将作为累加器提供给循环中的下一个元素。初始值将作为第一次循环的累加器。

var myNewArray = [].reduce(function (sum, current) {
  return sum;
}, starting);

（1）数组求和

        

var total = [1, 2, 3].reduce(function (sum, current) {
  return sum + current;
}, 0);

（2）组合多个数组方法

假设有一个wizards 数组：

var wizards = [
  {
    name: 'Harry Potter',
    house: 'Gryfindor'
  },
  {
    name: 'Cedric Diggory',
    house: 'Hufflepuff'
  },
  {
    name: 'Tonks',
    house: 'Hufflepuff'
  },
  {
    name: 'Ronald Weasley',
    house: 'Gryfindor'
  },
  {
    name: 'Hermione Granger',
    house: 'Gryfindor'
  }
];
复制代码

你想创建一个仅包含住在 Hufflepuff 的巫师名字的新数组。一个可行的方法是使用Array.filter() 方法获取 house 属性为Hufflepuff的 wizards 。然后用Array.map() 方法创建一个只包含过滤后对象的name 属性的新数组。

var hufflepuff = wizards.filter(function (wizard) {
  return wizard.house === 'Hufflepuff';
}).map(function (wizard) {
  return wizard.name;
});
复制代码

使用Array.reduce() 方法，我们可以用一步得到同样的结果，提高了性能。传递一个空数组[]作为初始值。每次循环时判断wizard.house 是否为Hufflepuff。如果是，就加入到newArr 中（即accumulator），否则啥也不做。

无论判断条件是否成立，最后都返回 newArr 作为下一次循环的accumulator 。

var hufflepuff = wizards.reduce(function (newArr, wizard) {
  if (wizard.house === 'Hufflepuff') {
    newArr.push(wizard.name);
  }
  return newArr;
}, []);

（3）从数组生成html标签

那么，如果想创建一个由住在 Hufflepuff 的巫师组成的无序列表要怎么做呢？这次不是给Array.reduce()传一个空数组作为初始值了，而是一个名为 html的空字符串''。

如果wizard.house 等于 Hufflepuff，我们就将wizard.name 用列表项li包裹起来，再拼接到html 字符串里。然后返回html 作为下一次循环的accumulator 。

var hufflepuffList = wizards.reduce(function (html, wizard) {
  if (wizard.house === 'Hufflepuff') {
    html += '<li>' + wizard.name + '</li>';
  }
  return html;
}, '');
复制代码

在Array.reduce()前后添加无序列表的开始和结束标记，就可以把它插入到 DOM 中了。

var hufflepuffList = '<ul>' + wizards.reduce(function (html, wizard) {
  if (wizard.house === 'Hufflepuff') {
    html += '<li>' + wizard.name + '</li>';
  }
  return html;
}, '') + '</ul>';

等等。