/**
 * @param push 將一個或多個元素添加到數(shù)組的末尾，返回該數(shù)組的新長度
 *
 * 集合apply和call合并數(shù)組
 *
 */
let user = ["zhangsan", "lisi"];
console.log(user.push("xiaoming")); //	3
console.log(user); // ["zhangsan", "lisi", "xiaoming"]
let user1 = ["xiaowang", "xiaoming"];
let user2 = ["zhangsan", "lisi"];
console.log(Array.prototype.push.apply(user1, user2)); // 	4
console.log(user1); // ["xiaowang", "xiaoming", "zhangsan", "lisi"]

/**
 *
 * @param pop 方法從數(shù)組中刪除最后一個元素，返回值是該元素。
 *
 * 如果數(shù)組是空數(shù)組，那么返回的是undefined
 *
 */
let user = ["zhangsan", "lisi"];
console.log(user.pop()); //	lisi
console.log(user); //	["zhangsan"]
let empArray = [];
console.log(empArray.pop()); //	undefined

/**
 *
 * @param sort
 *
 * 使用原地算法對數(shù)組的元素進行排序，并返回數(shù)組。
 * 默認排序順序是在將元素轉(zhuǎn)換為字符串，然后比較它們的UTF-16代碼單元值序列時構建的
 * 由于它取決于具體實現(xiàn)，因此無法保證排序的時間和空間復雜性。
 *
 * arr.sort([compareFunction])
 *
 * @param compareFunction
 *
 * 用來指定按某種順序進行排列的函數(shù)。
 * 如果省略，元素按照轉(zhuǎn)換為的字符串的各個字符的Unicode位點進行排序。
 *
 * 如果沒有指明 compareFunction ，那么元素會按照轉(zhuǎn)換為的字符串的諸個字符的Unicode位點進行排序。
 * 例如 "Banana" 會被排列到 "cherry" 之前。
 * 當數(shù)字按由小到大排序時，9 出	* 現(xiàn)在 80 之前，但因為（沒有指明 compareFunction），比較的數(shù)字會先被轉(zhuǎn)換為字符串，所以在Unicode順序上 "80" 要比 "9" 要靠前。
 * 如果指明了 compareFunction ，那么數(shù)組會按照調(diào)用該函數(shù)的返回值排序。即 a 和 b 是兩個將要被比較的元素：
 * 如果 compareFunction(a, b) 小于 0 ，那么 a 會被排列到 b 之前；
 * 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相對位置不變。
 * 備注： ECMAScript 標準并不保證這一行為，而且也不是所有瀏覽器都會遵守（例如 Mozilla 在 2003 年之前的版本）；
 * 如果 compareFunction(a, b) 大于 0 ， b 會被排列到 a 之前。
 * compareFunction(a, b) 必須總是對相同的輸入返回相同的比較結果，否則排序的結果將是不確定的。
 *
 * firstEl
 * 第一個用于比較的元素。
 * secondEl
 * 第二個用于比較的元素
 *
 */
/**
 *
 * 基本用法
 *
 * */

const user = ["zhangsan", "lisi", "xiaoming", "xiaowang"];
user.sort();
console.log(user); // ["lisi", "xiaoming", "xiaowang", "zhangsan"]
const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1); // [1, 100000, 21, 30, 4]

/**
 *
 * 自定義排序方法
 *
 * */
var numbers = [4, 2, 5, 1, 3];
let sortFun = function (a, b) {
  return a - b;
};
numbers.sort(sortFun);
console.log(numbers); // [1, 2, 3, 4, 5]

/**
 *
 * @param shift
 * 從數(shù)組中刪除第一個元素，并返回該元素的值,如果刪除空數(shù)組，返回值是undefined
 *
 * @param unshift
 * 方法將一個或多個元素添加到數(shù)組的開頭，并返回該數(shù)組的新長度
 *
 * */
let user = ["zhangsan", "lisi"];
console.log(user.shift()); //	zhangsan
console.log(user); //	["lisi"]
let empArray = [];
console.log(empArray.shift()); //	undefined
let user1 = ["xiaoming", "xiaowang"];
console.log(user1.unshift("xiaoming1", "xiaowang1")); //	4
console.log(user1); //	["xiaoming1", "xiaowang1", "xiaoming", "xiaowang"]

/**
 *
 * @param concat
 *
 * 方法用于合并兩個或多個數(shù)組。返回值是新數(shù)組，原數(shù)組不會發(fā)生更改
 *
 * 注：數(shù)組合并是淺拷貝
 *
 */
let user = ["zhangsan", "lisi"];
let user1 = [["xiaowang"], { name: "xiaoming" }];
console.log(user.concat(user1)); // ["zhangsan","lisi",["xiaowang"],{name: "xiaoming"}]
console.log(user); // ["zhangsan", "lisi"]

/**
 *
 * @param indexOf
 *
 * 返回在數(shù)組中可以找到一個給定元素的第一個索引，如果不存在，則返回-1，
 * 常用于判斷數(shù)組是否存在某個元素
 *
 * @param includes
 *
 * 判斷一個數(shù)組是否包含一個指定的值，返回值是布爾值 true 或者 false
 *
 */
let user = ["zhangsan", "lisi"];
console.log(user.indexOf("lisi")); // 1
console.log(user.indexOf("xiaoming")); // -1
let user1 = ["zhangsan", ["xiaowang"], { name: "xiaoming" }];
console.log(user1.includes("zhangsan")); // true
console.log(user1.includes(["xiaowang"])); // false
console.log(user1.includes({ name: "xiaoming" })); // false

/**
 *
 * @param reverse
 *
 * 反轉(zhuǎn)數(shù)組元素，將原有數(shù)組倒敘顯示，會改變元素的元素位置
 *
 */
let user = ["zhangsan", "lisi", "xiaoming"];
console.log(user.reverse()); // ["xiaoming", "lisi", "zhangsan"]
console.log(user); // ["xiaoming", "lisi", "zhangsan"]
let user1 = ["zhangsan", ["xiaowang", "lisi"], { name: "xiaoming" }];
console.log(user1.reverse()); // [{name: "xiaoming"},["xiaowang", "lisi"],"zhangsan"]

/**
 *
 * @param join
 *
 * 根據(jù)傳入的參數(shù)字符串，對數(shù)組進行切割，返回值是使用參數(shù)拼接元素的字符串
 * 如果數(shù)組只有一個元素，則不使用分割符號
 *
 */
let user = ["zhangsan", "lisi", "xiaoming"];
console.log(user.join(" ")); // zhangsan lisi xiaoming
console.log(user.join("")); // zhangsanlisixiaoming
console.log(user.join(",")); // zhangsan,lisi,xiaoming
console.log(user.join({ a: 1 })); // zhangsan[object Object]lisi[object Object]xiaoming
console.log(user); // ["zhangsan", "lisi", "xiaoming"]

/**
 *
 * @param slice
 *
 * 返回一個新的數(shù)組對象，
 * 這一對象是一個由 begin 和 end 決定的原數(shù)組的淺拷貝（包括 begin，不包括end）。原始數(shù)組不會被改變。
 *
 * @param begin
 * 提取起始處的索引（從 0 開始），從該索引開始提取原數(shù)組元素。
 * 如果該參數(shù)為負數(shù)，則表示從原數(shù)組中的倒數(shù)第幾個元素開始提取，slice(-2) 表示提取原數(shù)組中的倒數(shù)第二個元素到最后一個元素（包含最后一個元素）。
 * 如果省略 begin，則 slice 從索引 0 開始。
 * 如果 begin 超出原數(shù)組的索引范圍，則會返回空數(shù)組
 *
 * @param end
 *
 * 提取終止處的索引（從 0 開始），在該索引處結束提取原數(shù)組元素。
 * slice 會提取原數(shù)組中索引從 begin 到 end 的所有元素（包含 begin，但不包含 end）。
 * slice(1,4) 會提取原數(shù)組中從第二個元素開始一直到第四個元素的所有元素 （索引為 1, 2, 3的元素）。
 * 如果該參數(shù)為負數(shù)， 則它表示在原數(shù)組中的倒數(shù)第幾個元素結束抽取。
 * slice(-2,-1) 表示抽取了原數(shù)組中的倒數(shù)第二個元素到最后一個元素（不包含最后一個元素，也就是只有倒數(shù)第二個元素）。
 * 如果 end 被省略，則 slice 會一直提取到原數(shù)組末尾。如果 end 大于數(shù)組的長度，slice 也會一直提取到原數(shù)組末尾。
 *
 */
const animals = ["ant", "bison", "camel", "duck", "elephant"];
console.log(animals.slice(2)); // Array ["camel", "duck", "elephant"]
console.log(animals.slice(2, 4)); // Array ["camel", "duck"]
console.log(animals.slice(1, 5)); // Array ["bison", "camel", "duck", "elephant"]
console.log(animals.slice(-2)); // Array ["duck", "elephant"]
console.log(animals.slice(2, -1)); // Array ["camel", "duck"]
console.log(animals.slice()); // Array ["ant", "bison", "camel", "duck", "elephant"]
/**
 *
 * @param splice(start[, deleteCount[, item1[, item2[, ...]]]])
 *
 * 通過刪除或替換現(xiàn)有元素或者原地添加新的元素來修改數(shù)組,并以數(shù)組形式返回被修改的內(nèi)容。此方法會改變原數(shù)組
 *
 * 由被刪除的元素組成的一個數(shù)組。如果只刪除了一個元素，則返回只包含一個元素的數(shù)組。如果沒有刪除元素，則返回空數(shù)組。
 *
 * @param start
 *
 * 指定修改的開始位置,默認從下標0開始。
 * 如果超出了數(shù)組的長度，則從數(shù)組末尾開始添加元素；
 * 如果是負值，則表示從數(shù)組末位開始的第幾位（從-1計數(shù)，這意味著-n是倒數(shù)第n個元素并且等價于array.length-n）；
 * 如果負數(shù)的絕對值大于數(shù)組的長度，則表示開始位置為第0位。
 *
 * @param deleteCount
 *
 * 整數(shù)，表示要移除的數(shù)組元素的個數(shù)。
 * 如果 deleteCount 大于 start 之后的元素的總數(shù)，則從 start 后面的元素都將被刪除（含第 start 位）。
 * 如果 deleteCount 被省略了，
 * 或者它的值大于等于array.length - start(也就是說，如果它大于或者等于start之后的所有元素的數(shù)量)，
 * 那么start之后數(shù)組的所有元素都會被刪除。
 *
 * 如果 deleteCount 是 0 或者負數(shù)，則不移除元素。這種情況下，至少應添加一個新元素。
 * @param item1, item2, ...
 *
 * 要添加進數(shù)組的元素,從start 位置開始。如果不指定，則 splice() 將只刪除數(shù)組元素
 *
 */
const months = ["Jan", "March", "April", "June"];
months.splice(1, 0, "Feb"); // 下表為1，插入一個元素
console.log(months); // ["Jan", "Feb", "March", "April", "June"]
months.splice(4, 1, "May"); // 替換下標為4的元素
console.log(months); // ["Jan", "Feb", "March", "April", "May"]
let del = months.splice(1, 1); // 刪除
console.log(del); // ["Feb"]
console.log(months); // ["Jan", "April", "May"]

/**
 *
 * @param every
 * 測試一個數(shù)組內(nèi)的所有元素是否都能通過某個指定函數(shù)的測試,返回值是布爾值 true or false
 * 備注：若收到一個空數(shù)組，此方法在任何情況下都會返回 true。
 *
 * arr.every(callback(element[, index[, array]])[, thisArg])
 * callback
 * 用來測試每個元素的函數(shù)，它可以接收三個參數(shù)：
 *
 * @param element 用于測試的當前值。
 * @param index可選 用于測試的當前值的索引。
 * @param array可選 調(diào)用 every 的當前數(shù)組。
 *
 * every 方法為數(shù)組中的每個元素執(zhí)行一次 callback 函數(shù)，直到它找到一個會使 callback 返回 false 的元素。
 * 如果發(fā)現(xiàn)了一個這樣的元素，every 方法將會立即返回 false。
 * 否則，callback 為每一個元素返回 true，every 就會返回 true。
 *
 * callback 只會為那些已經(jīng)被賦值的索引調(diào)用。不會為那些被刪除或從未被賦值的索引調(diào)用。
 * callback 在被調(diào)用時可傳入三個參數(shù)：元素值，元素的索引，原數(shù)組。
 * 如果為 every 提供一個 thisArg 參數(shù)，則該參數(shù)為調(diào)用 callback 時的 this 值。
 * 如果省略該參數(shù)，則 callback 被調(diào)用時的 this 值，在非嚴格模式下為全局對象，在嚴格模式下傳入 undefined。
 *
 *
 * every 不會改變原數(shù)組。
 * every 遍歷的元素范圍在第一次調(diào)用 callback 之前就已確定了。
 * 在調(diào)用 every 之后添加到數(shù)組中的元素不會被 callback 訪問到。
 * 如果數(shù)組中存在的元素被更改，則他們傳入 callback 的值是 every 訪問到他們那一刻的值。
 * 那些被刪除的元素或從來未被賦值的元素將不會被訪問到。
 *
 * */
const isBelowThreshold = (currentValue) => currentValue < 40;
const array1 = [1, 30, 39, 29, 10, 13];
console.log(array1.every(isBelowThreshold)); // true

/**
 *
 * @param some 測試數(shù)組中是不是至少有1個元素通過了被提供的函數(shù)測試。返回值是布爾值
 *
 * */
const array = [1, 2, 3, 4, 5];
const even = (element) => element % 2 === 0; //確認偶數(shù)
console.log(array.some(even)); // true;

/**
 * @param flat	按照一個可指定的深度遞歸遍歷數(shù)組，并將所有元素與遍歷到的子數(shù)組中的元素合并為一個新數(shù)組返回。
 *
 * var newArray = arr.flat([depth])
 * @depth  指定要提取嵌套數(shù)組的結構深度，默認值為 1。
 * */
let arr1 = [1, 2, [3, 4]];
console.log(arr1.flat()); // [1, 2, 3, 4]
let arr2 = [1, 2, [3, 4, [5, 6]]];
console.log(arr2.flat()); // [1, 2, 3, 4, [5, 6]]
let arr3 = [1, 2, [3, 4, [5, 6]]];
console.log(arr3.flat(2)); // [1, 2, 3, 4, 5, 6]
//使用 Infinity，可展開任意深度的嵌套數(shù)組
let arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
console.log(arr4.flat(Infinity)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let objArray = [{ name: "zhangsan", children: ["張三"] }];
console.log(objArray.flat(Infinity)); // [{ name: "zhangsan", children: ["張三"] }]

/**
 * @param map
 *
 * 創(chuàng)建一個新數(shù)組，這個新數(shù)組由原數(shù)組中的每個元素都調(diào)用一次提供的函數(shù)后的返回值組成
 *
 * */
const array1 = [1, 4, 9, 16];
const map1 = array1.map((x) => x * 2);
console.log(map1); // [2, 8, 18, 32]