一邊學習前端，一邊通過部落格的形式自己總結一些東西，當然也希望幫助一些和我一樣開始學前端的小夥伴。
如果出現錯誤，請在評論中指出，我也好自己糾正自己的錯誤
此文是連線我之前的一篇總結文章，可以去我主頁搜尋
author： thomaszhou
- 7. 一維、二維、多維陣列的最值求解
- 8. 陣列內部元素隨機排列
- 9.陣列求和、平均值、陣列中指定值的出現次數
- 10. 找出陣列間不同項-相同項
- 11. 過濾陣列中的非唯一值
- 12陣列合並
- 13. flatten深度展開陣列-降為
- 14. 獲得第n個斐波那契數字
- 15. 一些簡單的應用（簡單的內建函式用法）
一到多維陣列的最值求解
-
1.6.1 一維陣列的最值
-
for迴圈或者foreach（比for快點）
- 不討論for放啊
-
forEach方法
<script>
//forEach比普通迴圈效率高點
var arr = [1,23,45,66,75,111,4];
Array.prototype.max = function () {
var max = this[0];
this.forEach (function (eval) {
if (eval > max) {
max = eval;
}
});
return max;
}
console.log(arr.max());//111
</script>
複製程式碼- reduce方法來求解
<script>
//reduce()方法
Array.prototype.max = function () {
var max = this[0];
return this.reduce(function (preValue, curValue) {
// prevalue是每次迭代的結果
return preValue > curValue ? preValue : curValue;
})
}
console.log(arr.max());
複製程式碼- 用內建函式Math.max()和Math.min()
- 該方法預設不能直接傳一個陣列物件作為引數
var arr = [1,23,45,66,75,111,4];
// 內建函式Math.max()和Math.min()的括號裡面不能放陣列物件，而是必須放具體的值，如下：
console.log(Math.max(arr));//NaN
console.log(Math.max(1,2,43,5,6,777));//77
console.log(Math.min(1,2,43,5,6,777));//1
console.log(Math.max());//沒有引數的時候，-Infinity
複製程式碼以下方法使用來解決不能傳遞物件引數的問題！
如何解決？？？
// 需要利用別的方法來引用陣列物件
//法一：Function.prototype.apply()
console.log(Math.max.apply(Math, arr));//111
法二：
Array.prototype.max = function () {
return Math.max.apply(Math, arr)
//return Math.max.apply({}, arr)這個同上條語句
//不明白為什麼是{}??
}
console.log(arr.max());//111
複製程式碼法三：ES6方法
// es6的方法-----...展開運算子
//使陣列中的值在函式呼叫的位置展開
const arrayMax = arr => Math.max(...arr);//最大值
const arrayMin = arr => Math.min(...arr);//最小值
console.log(arrMax(arr));//111
</script>
複製程式碼-
1.6.2二維陣列的最值
雙層for迴圈是最簡單的方法，
- 比較好的思路是
- step1:先得出每個子陣列的最大值
- step2:然後找出這些數的最大值
- 方法一(map,reduce,Math.max())：
var arr2 = [[1,20,5],[3,45,564],[34,12]];
var newMap1 = arr2.map(function (item) {
//map是遍歷最外層，item就是每個子陣列
return item.reduce(function (preVal, curVal) {
//對每個子陣列item進行求出最值的操作，並返回
return preVal > curVal ? preVal: curVal;
})
});
console.log(newMap1);//[20,564,34]
//Math.max求出最值
console.log(Math.max(...newMap1));//564
複製程式碼-
step1: 在外層陣列中使用Array.prototype.map()方法遍歷陣列。
-
step2: 使用map()方法遍歷陣列，會呼叫一個回撥函式，在這個回撥函式中， 使用reduce()方法對每個子陣列group進行合併,將值返回到一個新陣列中。
-
step3: 而在使用reduce()方法時，同樣會呼叫一個回撥函式，這個回撥函式只做了一件事情， 就是子陣列中的元素做為比較，如果curVal大於preVal，將會返回current， 否則返回prev，最終得到每個子陣列中最大值
-
方法二（最佳）---目前沒看懂
var arr2 = [[1,20,5],[3,45,564],[34,12]];
function largestOfFour (arr) {
return arr.map(Function.apply.bind(Math.max, null));
}
console.log(largestOfFour(arr2)); //[20, 564, 34]
複製程式碼這個方案，使用Function.bind方法建立一個特殊的回撥函式，就類似於Math.max方法一樣，但其有一個Function.prototype.apply功能，將陣列作為它的引數。
-
先對主陣列中的每個元素做遍歷，也就是陣列內部的每個子陣列
-
使用map()方法需要一個回撥函式，用來找出內部每個陣列中的最大值。需要建立一個函式，讓Math.max能接受輸入的陣列工作。換句話說，這是非常簡單而且這樣工作也非常的好，如Math.max([9,43,20,6]);將會返回最大值43
-
Function.prototype.apply方法工作可以接受陣列做為引數，但函式通過呼叫上下文，這事情就有點複雜。例如Math.max.apply(null,[9,43,20,6])將呼叫一個Max.max方法，但這樣的方法找起來不容易。
-
這裡給Function.prototype.apply方法傳遞了一個null引數，告訴Math.max不需要任何上下文。
-
因為arr.map()需要一個回撥函式，而不只是一個表示式，我們在Function.bind方法中提供了一個函式
-
因為Function.prototype.apply是一個靜態方法，類似一個函式物件，我們可以稱之為Function.prototype.apply上繫結了一個Function.prototype.bind。例如: Function.apply.bind
-
現在可以通過Function.prototype.apply.bind回撥函式指定其上下文，比如在這個示例中的Math.max方法
-
由於是嵌入到Function.prototype.apply方法，需要一個上下文作為第一個引數，而且這個上下文還是一個虛假的。
-
所以我們將null作為第二個引數傳遞給Function.prototype.apply.bind，並且繫結一個上下文，這個上下文就是Math.max方法
-
由於Math.max是獨立於任何上下文的，所以它會忽略Function.prototype.apply方法呼叫的虛假上下文
-
我們使用Function.prototype.apply.bind(Math.max,null)讓一個新函式接受arr.map值，比如陣列中的子陣列
-
很巧妙的方法！！！！！！！！也是多位陣列的方法
var arr2 = [[1,20,5],[3,45,564],[34,12]];
var new1 = function (arr) {
// 通過join先把陣列裡面的值用，拼接成字串
// 用split將字串拼接為陣列
return arr.join(',').split(',');
}(arr2)
// console.log(largestOfFour(arr2));
console.log(Math.max(...new1));//564
複製程式碼-
1.3.3 多維陣列最值
上文使用不同的方法實現了從二維陣列中取出子陣列中最大值，並且將這些最大值重新組成一個新陣列，如果延伸一下，取出裡面的最大值時，還需要使用Array.prototype.max函式，函式中通過Math.max.apply({},this)取得最大值。不過如果不是二維陣列，那上述方法將無法取出陣列中最大的值。
- 而在多維陣列中取最大值，可以通過join()和split()方法組合在一起：
var arr2 = [333,[3,45,564],[34,12,[1,4000]]];
var new1 = function (arr) {
// 通過join先把陣列裡面的值用，拼接成字串
// 用split將字串拼接為陣列
return arr.join(',').split(',');
}(arr2)
// console.log(largestOfFour(arr2));
console.log(Math.max(...new1));//4000
複製程式碼
陣列內部元素隨機排列
var arr = [1,2,3,4,5,7,8,9]
arr.sort(function () {
return Math.random() - 0.5
})
複製程式碼
計數陣列中值的出現次數
陣列平均數（其實就是陣列求和）
使用reduce（）將每個值新增到累加器，初始值為0，總和除以陣列長度。
const average = arr => arr.reduce((pre, cur) => pre + cur, 0) / arr.length;
// 箭頭函式，如果函式只有一條語句，不要加"{}"和 ";"
// average([1,2,3]) -> 2
複製程式碼計數陣列中值的出現次數
每次遇到陣列中的特定值時，使用reduce（）來遞增計數器。
const arrayCount = (arr, value) => {
let count = 0;
arr.forEach(val => {
val === value? count += 1: count += 0;
});
return count;
}
console.log(arrayCount([1,1,2,3,4], 1)); // 2
複製程式碼或者reduce方法
const countOccurrences = (arr, value) => arr.reduce((a, v) => v === value ? a + 1 : a + 0, 0);
// countOccurrences([1,1,2,1,2,3], 1) -> 3
複製程式碼
找出陣列間不同項-相同項
找出陣列a中除陣列b以外的值
從b建立一個Set，然後在a上使用Array.filter（），只保留b中不包含的值。
es6: Set結構的has方法，是用來查詢值的
const difference = (a, b) => {
let s = new Set(b);
return a.filter(x => !s.has(x));
}
console.log(difference([1,2,3], [1,2]));//[3]
複製程式碼找出陣列間不同項-相同項（或者說交集）
上面是 !s.has(x))，如果改成s.has(x))，那就是求陣列a中和陣列b的交集
const difference = (a, b) => {
let s = new Set(b);
return a.filter(x => s.has(x));//將！去掉了
}
console.log(difference([1,2,3,2], [1,2,4,2]));//[1, 2, 2]
複製程式碼
過濾陣列中的非唯一值
- 將Array.filter（）用於僅包含唯一值的陣列。
- 思路：indexOf和lastIndexOf找的位置相同，那就是唯一的值
const arrayIntersection = arr => arr.filter(i => arr.indexOf(i) === arr.lastIndexOf(i));
// console.log(arrayIntersection([1,2,2,3,4,4,5])); // [1,3,5]
複製程式碼
陣列合並
const arrayConcat = (arr, ...args) => {
let array = arr.concat(...args);
return array;
};
console.log(arrayConcat([1], [2,6], 5, [[2],10])); // [1, 2, 6, 5, [2], 10]
複製程式碼缺點：只能將二維陣列降成一維，如上面[2]就是二維陣列
這就聯絡到深度展開陣列的操作，看下面的flatten深度展開陣列
flatten深度展開陣列
其實就是陣列降維：將巢狀多層的陣列(巢狀可以是任何層數)轉換為只有一層的陣列
-
方法一:
let arr = [1,[2],[[[3,[10]],4],5]];
let newArr = [];
function changeArr(arr){
for(var i=0;i<arr.length;i++){
//遍歷arr陣列得每一個元素,這裡也可以用forEach
if(arr[i] instanceof Array){
//判斷元素是否為陣列
changeArr(arr[i])
//元素為陣列則繼續呼叫changeArr方法遍歷
}else{
newArr.push(arr[i])
//元素不是陣列則可以直接push進新陣列
}
}
//此上的判斷也可以直接用三元表示式
}
changeArr(arr);
console.log(newArr); // [1, 2, 3, 10, 4, 5]
複製程式碼-
方法2（可多維）：指定降維層數
使用遞迴去遞減深度。使用 Array.reduce() 和 Array.concat() 來合併元素或陣列。基本情況下，當深度為 1 時停止遞迴。省略第二個引數，展開深度為 1。
const flattenDepth = (arr, depth = 1) =>
depth != 1 ? arr.reduce((a, v) => a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v), [])
: arr.reduce((a, v) => a.concat(v), []);
// 降2維
console.log(flattenDepth([1,[2],[[[3],4],5]], 2)); // [1,2,[3],4,5]
// 降3維
console.log(flattenDepth([1,[2],[[[3],4],5]], 3)); // [1, 2, 3, 4, 5]
複製程式碼-
方法3（可高維）:缺點是得到的值變成了字元形式
陣列中元素僅基本型別的元素或陣列，可以轉換為字串，不存在迴圈引用的情況。
function flatten(arr) { return arr.toString().split(',')}
// arr.toString() 結果是字串形式的1，2，3，4
<!--// 變成字元形式的陣列-->
console.log(flatten([1,[2],[[3]], [[[4]]]])) //["1", "2", "3", "4"]
複製程式碼解決辦法：最後再遍歷一遍陣列，用Number轉化為數字！
獲得第n個斐波那契數字
斐波那契數列是0、1、1、2、3、5、8、13、21、34...
- 思路：構建一個長度為n的斐波那契數列，然後將最後一個值返回
這個是迭代方式，遞迴方法太耗時
function fibonacci(n) {
let fibo = [0, 1];
if (n < 2) {
return n;
}
for (let i = 2; i <= n; i++) {
fibo.push(fibo[i-1] + fibo[i-2]);
}
return fibo[n];
}
console.log(fibonacci(0)); // 0
console.log(fibonacci(1)); // 1
console.log(fibonacci(6)); // 8
複製程式碼
一些簡單的應用
陣列去掉最後n個值
其實就是去掉最後n個值，利用arr.slice(0，-1)。以0為起點，去一個是-1，去兩個是-2，以此類推，
const initial = arr => arr.slice(0, -1);
// initial([1,2,3]) -> [1,2]
複製程式碼用值初始化陣列
使用Array（n）建立所需長度的陣列，fill(v)以填充所需的值，可以忽略value使用預設值0。
const initializeArray = (n, value = 0) => Array(n).fill(value);
// initializeArray(5, 2) -> [2,2,2,2,2]
複製程式碼Initialize array with range (使用指定範圍來定義陣列)
使用 Array(end-start) 建立一個所需長度的陣列，使用 Array.map() 來填充範圍中的所需值。 你可以省略start，預設值為 0。
const initializeArrayRange = (end, start = 0) =>
Array.apply(null, Array(end - start)).map((v, i) => i + start);
// initializeArrayRange(5) -> [0,1,2,3,4]
複製程式碼陣列的最後
返回arr.slice（-1）[0]
const last = arr => arr.slice(-1)[0];
//arr.slice(-1)得到的是陣列[3]
console.log(last([1,2,3])); // 3
複製程式碼獲取陣列的第 N 個元素
使用 Array.slice() 得到一個包含第一個元素的陣列。 如果索引超出範圍，則返回 []。（譯者注：超過索引返回 undefind） 省略第二個引數 n 來獲取陣列的第一個元素。
const nth = (arr, n=0) => (n>0? arr.slice(n,n+1) : arr.slice(n))[0];
// nth(['a','b','c'],1) -> 'b'
// nth(['a','b','b']-2) -> 'a'
複製程式碼