let string = "123456";
 　　let s1 = "123";
        let s2 = "011";
        string.includes(s1); //true
        string.includes(s2); //false

1、
　　let array = [1, 1, 1, 2, 3, 4, 4, 5, 3,6];
　　let arr = new Set(array);
 　　console.log(arr);[1, 2, 3, 4, 5]
　2、
　　let array = Array.from(new Set([1, 1, 1, 2,2, 3, 2, 4])); [1, 2, 3, 4]
 3、
　　let arr = [1，2，3，4，5,6]
　　let ids = [1，3，4,6]
　　const arr2 = new Set(ids)
   var res = arr.filter(item => !arr2.has(item))；  [2,5]

includes()：   返回布尔值，表示是否找到了参数字符串
startsWith()：返回布尔值 ，表示字符串是否在源字符串的头部
endsWith()：返回布尔值 ，表示字符串是否在源字符串的头部

var s = ‘Hello world‘;
s.startsWith(‘world‘, 6) // true 第二个参数表示开始搜索的位置
s.endsWith(‘Hello‘, 5) // true  第二个参数代表截取到前5 个
s.includes(‘Hello‘, 6) // false  第二个参数表示开始搜索的位置

var obj1 = { a: 1, b: 2 }; 
var obj2 = { c: 3, d: 4 }; 
var obj3 = { e: 5};
// ES6
Object.assign(obj1, obj2, obj3)
// result
obj1 = { a: 1, b: 2, c: 3, d: 4, e: 5}

var obj1 = { a: 1, b: 2 }; 
var obj2 = { b: 3, d: 4 };
// ES6
Object.assign(obj1, obj2)
// result
obj1 = {a: 1, b: 3, d: 4}
相同的属性的话后边的会把前面的属性覆盖掉

let { foo, bar } = { foo: ‘123‘, bar: ‘456‘ };
foo // "123"
bar // "456"

var { a, b = 3 } = { a: 1 };
// a = 1
// b = 3

var str = ‘aaa ‘
var repeat = str.repeat(3)
// aaa aaa aaa 

let obj = {x: 1, y: 2};
`${obj.x + obj.y}`
// 3
模板字符串之中还能调用函数
function fn() {
    return "你好";
}
`${fn()} 模板字符串`
// 你好 模板字符串

function add(x, y) {
  return x + y;
}

const numbers = [4, 38];
add(...numbers) // 42

onst arr1 = [‘a‘, ‘b‘];
const arr2 = [‘c‘];

// ES6 的合并数组
[...arr1, ...arr2]
// [ ‘a‘, ‘b‘, ‘c‘]

与解构赋值结合

const [first, ...rest] = [1, 2, 3, 4, 5];
first // 1
rest  // [2, 3, 4, 5]

const [first, ...rest] = [];
first // undefined
rest  // []

扩展运算符还可以将字符串转为真正的数组。

[...‘hello‘]
// [ "h", "e", "l", "l", "o" ]