数组的冒泡、选择和插入排序法
冒泡排序法(从小到大)
function bubble(arr){
for(let i = 0 ;i<arr.length-1;i++){
for(let j = i+1;j<arr.length;j++){
if(arr[j]<arr[i]){
let temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
return arr;
}
选择排序法(从小到大)
function select(arr){
for(let i = 0 ;i<arr.length-1;i++){
let index = i;
for(let j = i+1;j<arr.length;j++){
if(arr[j]<arr[index]){
index = j;
}
}
if(index !== i){
let temp = arr[index];
arr[index] = arr[i];
arr[i] = temp;
}
}
return arr;
}
插入排序法(从小到大)
function insert(arr){
for(let i = 1;i<arr.length;i++){
let temp = arr[i];
for(var j = i-1;j>=0;j--){ //注意这里必须是var声明
if(arr[j]>temp){
arr[j+1] = arr[j];
}else{
break;
}
}
arr[j+1] = temp;
}
return arr;
}
ES6函数参数的默认值
- 设定默认值的参数应该是函数的尾参数，只有在该值为undefined的情况下才会取得默认值
function f(x = 1, y) {
return [x, y];
}
f() // [1, undefined]
f(2) // [2, undefined])
f(, 1) // 报错
f(undefined, 1) // [1, 1]
- 指定默认值后，函数的length属性会失真，将返回没有指定默认值的形参个数。
- 一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域。等到初始化结束，这个作用域就会消失。这种语法行为，在不设置参数默认值时，是不会出现的。（参数是由let声明的）
var x = 1;
function f(x, y = x) { //调用函数时，参数形参单独作用域，这里默认值x指向了第一个参数x
console.log(y);
}
f(2); // 2 x接收实参2，所以y=x=2
f(); //undefined x没有接收到实参，为undefined，所以y=x=undefined
let x = 1;
function f(y = x) { //函数调用时，参数y = x形成一个单独的作用域。这个作用域里面，变量x本身没有定义，所以指向外层的全局变量x
let x = 2;
console.log(y);
}
f() // 1
var x = 1;
function foo(x = x) {
// ...
}
foo() // ReferenceError: x is not defined
//参数x = x形成一个单独作用域。实际执行的是let x = x，由于暂时性死区的原因，这行代码会报错”x 未定义“
var x = 1;
function foo(x, y = function() { x = 2; }) { //这里匿名函数的x指向第一个参数x
var x = 3;
y();
console.log(x);
}
foo()//3
x//1
var x = 1;
function foo(x, y = function() { x = 2; }) {
x = 3; //如果把var去掉，那么这里的x就指向了第一个参数x
y();
console.log(x);
}
foo() // 2
x // 1
ES6对数组的一些拓展
Array.from(arg1,arg2,arg3)
arg1为类数组对象（Nodelist/arguments），arg2为类似map方法接受一个函数对每一个元素进行处理，将返回值放入数值中，arg3指定函数的this指向
Array.of()
主要目的，是弥补数组构造函数Array()的不足。因为参数个数的不同，会导致Array()的行为有差异。
//Array
Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]
Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1
实例方法copyWithin(target, start, end)
在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组
- target（必需）：从该位置开始替换数据。
- start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。
- end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。
数组实例的 find() 和 findIndex()
类似filter方法，第一个参数为回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员/下标。如果没有符合条件的成员，则返回undefined/-1 。 第二个参数指定this对象。
数组实例的 entries()，keys() 和 values()
entries()，keys()和values()——用于遍历数组。它们都返回一个遍历器对象，可以用for...of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。
for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1
for (let elem of ['a', 'b'].values()) {
console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 "b"
数组实例的 includes()
方法返回一个布尔值，表示某个数组是否包含给定的值。该方法的第二个参数表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置。
[1, 2, 3].includes(2) // true
[1, 2, 3].includes(4) // false
[1, 2, NaN].includes(NaN) // true
因它能正确判断NaN，因此可以用来弥补indexOf方法的不足。
ES6对对象的一些拓展
Object.is()
ES5 比较两个值是否相等，只有两个运算符：相等运算符（）和严格相等运算符（=）。它们都有缺点，前者会自动转换数据类型，后者的NaN不等于自身，以及+0等于-0。
相对于运算符，此方法不同之处只有两个：一是+0不等于-0，二是NaN等于自身。
+0 === -0 //true
NaN === NaN // false
Object.is(+0, -0) // false
Object.is(NaN, NaN) // true
Object.assign()
Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）
Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。
注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性
let target = { a: 1 };
let source1 = { b: 2 };
let source2 = { c: 3 };
Object.assign(target, source1, source2);
console.log(target) // {a:1, b:2, c:3}
Object.assign(obj) === obj // true assign自身则返回自身
Object.keys()，Object.values()，Object.entries()
Object.keys方法，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键名。
Object.values方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值（字符串形式）。
Object.entries方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组。