数组中改变/不改变原始数组的方法

不会改变原来数组【concat()、every()、some()、filter()、map()、slice()】

• concat()

// concat()用于连接两个或多个字符串
// 该方法没有改变原有字符串，但是会返回连接两个或多个字符串的新字符串
let s1 = 'name:';
let s2 = 'zs';
console.log(s1);//name:
console.log(s1.concat(s2));//name:zs

• every()

// every()方法用于检测数组所有元素是否都符合指定条件(通过函数提供)
// every()方法使用指定函数检测数组中的所有元素：
//    1.如果数组中检测到有一个元素不满足，则整个表达式放回false，且剩余的元素不会在进行检测
//    2.如果所有元素都满足条件，则返回true
 
//下面的例子检测在数组中是否有元素大于 10。
[12, 5, 8, 130, 44].every(x => x >= 10); // false
[12, 54, 18, 130, 44].every(x => x >= 10); // true

• some()

// some()方法测试数组中是不是至少有 1 个元素通过了被提供的函数测试
// some()方法回依次执行数组的每个元素：
//    1.如果有一个元素满足条件，则表达式返回true，剩余的元素不会再执行检测。
//    2.如果没有满足条件的元素，则返回false。
// 注意：如果用一个空数组进行测试，在任何情况下它返回的都是false
// 注意：some()不会改变原始数组
 
//下面的例子检测在数组中是否有元素大于 10。
[2, 5, 8, 1, 4].some(x => x > 10);  // false
[12, 5, 8, 1, 4].some(x => x > 10); // true

• filter()

// filter()方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素
// filter()方法创建给定数组一部分的浅拷贝
// 注意：filter()不会对空数组进行检测
// 注意：filter()不会改变原始数组
 
// 下例使用 filter() 创建了一个新数组，该数组的元素由原数组中值大于 10 的元素组成。
function isBigEnough(value) {
  return value >= 10;
}
 
const filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

• map()

// map()方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值
// map()方法按照原始数组元素顺序依次处理元素
// 注意：map()不会对空数组进行检测
// 注意：map()不会改变原始数组
 
// 下面的代码创建了一个新数组，值为原数组中对应数字的平方根。
const numbers = [1, 4, 9];
const roots = numbers.map((num) => Math.sqrt(num));
// roots 现在是     [1, 2, 3]
// numbers 依旧是   [1, 4, 9]

• slice()

// slice() 方法可从已有的数组中返回选定的元素
// slice() 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分
// slice(begin,end) 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。
// 注意：slice() 方法不会改变原始数组
 
// 返回现有数组的一部分
var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
var citrus = fruits.slice(1, 3);
 
// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
// citrus contains ['Orange','Lemon']

会改变原来数组的有【pop()、push()、shift()、unshift()、reverse()、sort()、splice()】

• pop()

// pop()方法用于删除数组的最后一个元素并返回删除的元素
// 注意：此方法会改变数组的长度
// 提示：移除数组第一个元素，请使用shift()方法
 
const myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
const popped = myFish.pop();
console.log(myFish); // ['angel', 'clown', 'mandarin']
console.log(popped); // 'sturgeon'

• push()

// push()方法可向数组的末尾添加一个或多个元素，并返回该数组的新长度
// 注意：新元素将添加在数组的末尾
// 此方法会改变数组的长度
// 提示：在数组起始位置添加元素请使用unshift() 方法
 
var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");
console.log(sports); // ["soccer", "baseball", "football", "swimming"]
console.log(total); // 4

• shift()

// shift() 方法从数组中删除第一个元素，并返回该元素的值。
// 注意：此方法改变原数组的长度
// 提示：移除数组末尾的元素可以使用 pop() 方法
 
let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];
console.log('调用 shift 之前：' + myFish);
// "调用 shift 之前：angel,clown,mandarin,surgeon"
 
var shifted = myFish.shift();
console.log('调用 shift 之后：' + myFish);
// "调用 shift 之后：clown,mandarin,surgeon"
 
console.log('被删除的元素：' + shifted);
// "被删除的元素：angel"

• unshift()

// unshift() 方法可向数组的开头添加一个或更多元素，并返回该数组的新长度
// 注意：该方法将改变数组的数目
// 提示：将新项添加到数组末尾，请使用push()方法
 
const arr = [1, 2];
 
arr.unshift(0);               // 调用的结果是 3，这是新的数组长度
// arr is [0, 1, 2]
 
arr.unshift(-2, -1);          // 新的数组长度为 5
// arr is [-2, -1, 0, 1, 2]
 
arr.unshift([-4, -3]);        // 新的数组长度为 6
// arr is [[-4, -3], -2, -1, 0, 1, 2]
 
arr.unshift([-7, -6], [-5]);  // 新的数组长度为 8
// arr is [ [-7, -6], [-5], [-4, -3], -2, -1, 0, 1, 2 ]

• reverse()

// reverse() 方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。
 
const a = [1, 2, 3];
console.log(a); // [1, 2, 3]
 
a.reverse();
console.log(a); // [3, 2, 1]

• sort()

// sort() 方法用于对数组元素进行排序。排序的顺序可以是字母或数字，并按升序或降序。默认排序顺序为按字母升序
// 注意：当数字是按字母顺序排列时“40”将排在“5”前面。使用数字排序，则必须通过一个函数作为参数来调用。函数指定数字是按照升序还是降序排列。
// 注意：此方法改会改变原始数组
 
var stringArray = ["Blue", "Humpback", "Beluga"];
var numericStringArray = ["80", "9", "700"];
var numberArray = [40, 1, 5, 200];
var mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];
 
function compareNumbers(a, b)
{
  return a - b;
}
 
console.log('stringArray:' + stringArray.join()); 
// stringArray: Blue,Humpback,Beluga
console.log('Sorted:' + stringArray.sort()); 
// Sorted: Beluga,Blue,Humpback
 
console.log('numberArray:' + numberArray.join()); 
// numberArray: 40,1,5,200
console.log('Sorted without a compare function:'+ numberArray.sort()); 
// Sorted without a compare function: 1,200,40,5
console.log('Sorted with compareNumbers:'+ numberArray.sort(compareNumbers)); 
// Sorted with compareNumbers: 1,5,40,200
 
console.log('numericStringArray:'+ numericStringArray.join()); 
// numericStringArray: 80,9,700
console.log('Sorted without a compare function:'+ numericStringArray.sort()); 
// Sorted without a compare function: 700,80,9
console.log('Sorted with compareNumbers:'+ numericStringArray.sort(compareNumbers)); 
// Sorted with compareNumbers: 9,80,700
 
console.log('mixedNumericArray:'+ mixedNumericArray.join()); 
// mixedNumericArray: 80,9,700,40,1,5,200
console.log('Sorted without a compare function:'+ mixedNumericArray.sort()); 
// Sorted without a compare function: 1,200,40,5,700,80,9
console.log('Sorted with compareNumbers:'+ mixedNumericArray.sort(compareNumbers)); 
// Sorted with compareNumbers: 1,5,9,40,80,200,700

• splice()

// splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组，并以数组形式返回被修改的内容。
// 注意：此方法会改变原数组
 
// 从索引 2 的位置开始删除 0 个元素，插入“drum”
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2, 0, "drum");
// 运算后的 myFish: ["angel", "clown", "drum", "mandarin", "sturgeon"]
// 被删除的元素：[], 没有元素被删除
 
// 从索引 3 的位置开始删除 1 个元素
var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
var removed = myFish.splice(3, 1);
// 运算后的 myFish: ["angel", "clown", "drum", "sturgeon"]
// 被删除的元素：["mandarin"]