JavaScript 數組的知識點講解

數組的基本方法以下

1. concat()

該方法用於鏈接2個或者多個數組。該方法不會改變現有的數組，而僅僅會返回被鏈接數組的一個副本。

語法：arrayObject.concat(array1,array2,….arrayx);

鏈接多個數組，使用逗號隔開；

好比以下代碼演示：

var arr1 = [1,2,3],

arr2 = [4,5,6],

arr3 = [7,8,9,1,2,3];

console.log(arr1.concat(arr2,arr3)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3]

console.log(arr1); // [1,2,3]

console.log(arr2); // [4,5,6]

console.log(arr3); // [7,8,9,1,2,3]

2.join()

該方法是把數組中的全部元素放入一個字符串中，元素經過指定的分隔符進行分割的。

語法以下：arrayObject.join(separator);

separator: 指定分隔符對數組中的元素進行分割，若是省略該參數，則會使用逗號做爲分隔符。以下代碼演示：

var arrs = [];

arrs[0] = "aa";

arrs[1] = "bb";

arrs[2] = "cc";

console.log(arrs.join()); // aa,bb,cc

console.log(arrs.join("/")); // aa/bb/cc

console.log(arrs.join("-")); // aa-bb-cc

3.pop()

該方法刪除數組的最後一個元素，把數組的長度減1，而且返回它被刪除元素的值，若是數組變爲空，則該方法不改變數組，返回undefine值。以下代碼演示：

var arrs = [1,2,3,4];

console.log(arrs.pop()); // 4

console.log(arrs); // [1,2,3]

4.push()

該方法是向數組末尾添加一個或者多個元素，並返回新的長度。

基本語法：arrayObject.push(newElem1,newElem2,…..newElemX); 演示代碼以下：

var arrs = [1,2,3];

arrs.push(4);

console.log(arrs); // [1,2,3,4]

arrs.push(5,6);

console.log(arrs); // [1,2,3,4,5,6]

5.reverse()

該方法用於顛倒數組中元素的順序；

語法以下：arrayObject.reverse();

以下代碼演示：

var arrs = [1,2,3,4];

console.log(arrs.reverse()); //[4,3,2,1]

6.shift()

該方法用於把數組的第一個元素從其中刪除，並返回被刪除的值。若是數組是空的，shift方法將不進行任何操做，返回undefined的值。

以下代碼演示：

var arrs = [1,2,3,4];

console.log(arrs.shift());// 1

console.log(arrs); // [2,3,4]

var arrs2 = [];

console.log(arrs2.shift()); // undefined

console.log(arrs2); // []

7.sort()

1. 該方法是對數組的元素進行排序；sortby參數規定排序順序，且必須是函數。

若是該方法沒有使用參數，則是按字母的字符編碼的順序進行排序。

2. 若是想按其餘標準進行排序，就須要提供比較函數，該函數比較2個值，而後返回一個用於說明這2個值的相對順序的數字，好比比較a與b，返回值以下：

若a小於b，在排序後的數組中a應該出如今b以前，則返回一個小於0的值。

若a等於b，在排序後的數組中 a等於b 則返回0；

若a大於b，則返回一個大於0的值；

好比以下代碼演示：

var arrs = ["tugenhua","longen","alibaba"];

console.log(arrs.sort()); // ["alibaba", "longen", "tugenhua"]

var arrs2 = ["15","5","8","12"];

console.log(arrs2.sort(function(a,b){

return a - b; // ["5", "8", "12", "15"]

}));

8.splice()

該方法用於插入，刪除和替換數組的元素；

基本語法以下：

Array.splice(index,howmany,element1,…..elementX);

Index參數：【必填】是從何處添加/刪除元素，該參數是開始插入或刪除數組元素的下標，必須是數字；

Howmany: 【必須】應該刪除多少個元素，必須是數字，也能夠是0，若是未設定該參數，則刪除從index開始到原數組結尾的全部元素；

Element1: 【可選】規定要添加到數組的新元素，從index所指的下標處開始插入；

ElementX: 【可選】 可向數組中添加若干個元素；

以下代碼演示：

// 假如原數組以下

var arrs = [1,2,3,4,5,6];

// 先向數組的第二個位置中添加一個元素8；

arrs.splice(1,0,8);

console.log(arrs); // [1, 8, 2, 3, 4, 5, 6]

// 接着從arrs數組中刪除一個元素2

arrs.splice(2,1);

console.log(arrs); // [1, 8, 3, 4, 5, 6]

// 再接着從arrs數組中替換一個元素8 使他變爲10;以下代碼：

arrs.splice(1,1,10);

console.log(arrs); // [1, 10, 3, 4, 5, 6]

9.toString()

將數組轉換爲一個字符串，而且返回這個字符串；以下代碼演示：

var arrs = [1,2];

console.log(arrs.toString()); // 1,2

10.unshift()

該方法是向數組的開頭添加一個或者更多元素，並返回新的長度。

以下代碼演示：

var arrs = [1,2];

arrs.unshift(3);

console.log(arrs); //[3, 1, 2]

11.slice()

該方法是從已有的數組中返回指定的元素。

基本語法：arrs.slice(start,end);

start參數【必須】從何處開始選取(包括start)，若是是負數，那麼會從尾部選取，好比-1表明最後一個元素，-2表明倒數第二個元素，以此類推。

End參數【可選】規定是從何處結束選取(不包括end)，若是沒有指定該參數，那麼數組會包含從start開始到數組結束的全部元素，若是該參數是負數的話，那麼它規定的是從數組尾部開始算起的元素。

以下演示：

var arrs2 = [1,2,3];

console.log(arrs2.slice(1)); // [2,3]

console.log(arrs2.slice(0,1));// [1]

console.log(arrs2.slice(1,-1)); // [2]

console.log(arrs2.slice(2,-1)); // []

console.log(arrs2.slice(0)); // [1,2,3]

判斷一個數組中是否有相同的元素

/*

* 判斷數組中是否有相同的元素的代碼

*/

// 方案一

function isRepeat1(arrs) {

if (arrs.length > 0) {

var s = arrs.join(",");

for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {

if (s.replace(arrs[i], "").indexOf(arrs[i]) > -1) {

return true;

}

}

}

return false;

}

// 方案二

function isRepeat2(arrs) {

var hash = {};

if (arrs.length > 0) {

for (var i = 0, ilen = arrs.length; i < ilen; i += 1) {

if (hash[arrs[i]]) {

return true;

}

hash[arrs[i]] = true;

}

}

return false;

}

var arrs = [1, 4, 3, 2, 5];

console.log(isRepeat1(arrs)); // false

var arrs2 = [1, 2, 3, 1];

console.log(isRepeat1(arrs2)); // true

var arrs = [1, 4, 3, 2, 5];

console.log(isRepeat2(arrs)); // false

var arrs2 = [1, 2, 3, 1];

console.log(isRepeat2(arrs2)); // true

計算一個數組中每一個元素在數組中出現的次數；

代碼以下：

/*

* 計算數組中每一個元素在數組中出現的個數

* @param {arrs} 數組

* @method 定義一個新數組，循環當前的數組，使用一個臨時的變量temp保存當前的值，外層for循環定義一次變量count=0，當作計數器，內部再一次循環數組判斷當前的數組與外層的數組某一項是否相等，如是count++; 而後把當前的一項值置爲-1，下一次就不會再繼續循環了

* @return {newArrs} 返回一個新數組

*/

function arrayElemCount(arrs){

var newArrs = [];

if(arrs.length > 0) {

for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {

var temp = arrs[i];

var count = 0;

for(var j = 0,jlen = arrs.length; j < jlen; j+=1) {

if(arrs[j] == temp) {

count++;

arrs[j] = -1;

}

}

newArrs.push(temp + ":" +count);

}

}

return newArrs;

}

var arrs = [1,2,1,2,3,4,5,6,7,1,2,3];

console.log(arrayElemCount(arrs));

// 打印以下：["1:3", "2:3", "-1:6", "-1:6", "3:2", "4:1", "5:1", "6:1", "7:1", "-1:12", "-1:12", "-1:12"]

// 鍵值爲-1的，均可以去掉

Javascript刪除數組重複元素的操做

1. 方案一遍歷數組使用indexOf方法，代碼以下：

/*

* javascript數組去重方案一

* @param {arrs} 原數組

* @method 新建一個新數組，遍歷原數組，在新數組內使用indexOf查找原數組內的每一項，若是沒有找到，就把當前的項存入新數組裏面去，這樣就過濾掉

* 重複項 indexOf方法在IE8及IE8如下不支持，所以有必要封裝一個

* @return {newArrays} 返回新數組

*/

function arrayUnique(arrs) {

var newArrays = [];

for(var i = 0,ilen = arrs.length; i < ilen; i++) {

if(newArrays.indexOf) {

if(newArrays.indexOf(arrs[i]) == -1) {

newArrays.push(arrs[i]);

}

}else {

if(indexOf(arrs[i],newArrays) == -1) {

newArrays.push(arrs[i]);

}

}

}

return newArrays;

}

/*

* 爲了支持IE8及如下瀏覽器須要封裝一個indexOf方法

* @param {arr,arrs} 某一項 原數組

* @return 返回數組某一項

*/

function indexOf(arr,arrs){

if(arrs.length > 0) {

for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {

if(arrs[i] == arr) {

return i;

}

}

}

return -1;

}

var arrs = [1,2,3,1,2,3];

console.log(arrayUnique(arrs)); // [1,2,3]

2. 方案二：數組下標判斷法；

/*

* 數組下標判斷法

* 思路：先定義一個新數組，循環當前數組，使用indexOf方法，若是在當前的數組的第i項在當前數組中的位置是i項的話，說明該項在數組中並未出現過，存入新數組，不然的話，在原數組中出現過，所以須要過濾掉。性能和第一種方案差很少。

* @return {newArrars} 返回新數組

*/

function arrayUnique(arrs) {

var newArrays = [];

if(arrs.length > 0) {

for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {

if(arrs.indexOf) {

if(arrs.indexOf(arrs[i]) == i) {

newArrays.push(arrs[i]);

}

}else {

if(indexOf(arrs[i],arrs) == i) {

newArrays.push(arrs[i]);

}

}

}

}

return newArrays;

}

/*

* 爲了支持IE8及如下瀏覽器須要封裝一個indexOf方法

* @param {arr,arrs} 某一項 原數組

* @return 返回數組某一項

*/

function indexOf(arr,arrs){

if(arrs.length > 0) {

for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {

if(arrs[i] == arr) {

return i;

}

}

}

return -1;

}

var arrs = [1,2,1,3,1];

console.log(arrayUnique(arrs)); // [1,2,3]

3. 方案三：排序後相鄰去除法

/*

* 排序後相鄰去除法

* @method 新建一個新數組，遍歷當前的數組，若是當前的數組某一項不等於新數組的最後一項的話，就把當前的項存入新數組中，最後返回新數組

*/

function arrayUnique(arrs) {

var newArrays = [];

if(arrs.length > 0) {

arrs.sort();

for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {

if(arrs[i] !== newArrays[newArrays.length - 1]) {

newArrays.push(arrs[i]);

}

}

}

return newArrays;

}

var arrs = [1,2,1,3,1];

console.log(arrayUnique(arrs)); // [1,2,3]

4. 方案四：對象鍵值對法

代碼以下：

/*

* 對象鍵值法(該方法性能最優)

* @method 定義一個空對象和空新數組，遍歷當前的數組，判斷該對象是否存在數組的某一項，若是不存在

* 就當當前的某一項存入新數組去，且當前的項置爲-1 目的過濾掉重複的項

*/

function arrayUnique(arrs) {

var newArrays = [];

var hash = {};

if(arrs.length > 0) {

for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {

if(!hash[arrs[i]]) {

hash[arrs[i]] = 1;

newArrays.push(arrs[i]);

}

}

}

return newArrays;

}

var arrs = [4,5,2,1,2,1,3,1];

console.log(arrayUnique(arrs)); // [4,5,2,1,3]

Javascript刪除數組裏面的某個元素。

方案一：使用indexOf和splice()方法刪除某個元素；

代碼以下：

/*

* 爲了支持IE8及如下瀏覽器須要封裝一個indexOf方法

* @param {arr,arrs} 某一項 原數組

* @return 返回數組某一項

*/

function indexOf(arr,arrs){

if(arrs.length > 0) {

for(var i = 0,ilen = arrs.length; i < ilen; i+=1) {

if(arrs[i] == arr) {

return i;

}

}

}

return -1;

}

/*

* 刪除數組裏面的某個元素

* @param {elem,arrs} 要刪除的元素 原數組

* 思路：先使用indexOf方法在數組裏面找到該元素的位置，而後使用splice()方法刪除一個元素

* @return {elem,arrs} 返回一個對象，對象有2個元素，第一個是被刪除的元素elem鍵，另外一個是被刪除元素

後的數組，也就是新數組 [2,3]

*/

function removeAttrsElem(elem,arrs){

var newElem;

if(arrs.length > 0) {

var index = indexOf(elem,arrs);

if(index > -1) {

newElem = arrs.splice(index,1);

}

}

return {

elem: newElem,

arrs: arrs

}

}

var arrs = [1,2,3];

var elem = 1;

console.log(removeAttrsElem(elem,arrs));

// 返回一個對象 {elem:1,arrs:[2,3]}

方案二：直接遍歷數組 取其中某一項 若是某一項與該元素相同的話，直接截取，和第一種方案相似，比第一種方案簡單

/*

* 刪除數組裏面的某個元素

* @param {elem,arrs} 要刪除的元素 原數組

* 思路：直接遍歷數組 取其中某一項 若是某一項與該元素相同的話，直接截取，和第一種方案相似，比第一種方案簡單

* @return {elem,arrs} 返回一個對象，對象有2個元素，第一個是被刪除的元素elem鍵，另外一個是被刪除元素

後的數組，也就是新數組 [2,3]

*/

function removeAttrsElem(elem,arrs){

var newElem;

if(arrs.length > 0) {

for(var i =0,ilen = arrs.length; i < ilen; i+=1) {

if(arrs[i] == elem) {

newElem = arrs.splice(i,1);

}

}

}

return {

elem: newElem,

arrs: arrs

}

}

var arrs = [1,2,3];

var elem = 1;

console.log(removeAttrsElem(elem,arrs));

// 返回一個對象 {elem:1,arrs:[2,3]}

在javascript中求出2個數組的相同的元素及不一樣的元素

思路：先定義一個對象，把A數組轉換成對象，而後遍歷B數組，判斷B數組中某一項是否在A數組那個對象裏面 若是在的話，說明B數組與A數組有相同的元素，不然B數組和A數組有不一樣的元素有哪些；

代碼以下：

/*

* 求出2個數組的相同的元素和不一樣的元素

* 思路：先定義一個對象，把A數組轉換成對象，而後遍歷B數組，判斷B數組中某一項是否在

* A數組那個對象裏面 若是在的話，說明有相同的元素，不然爲不一樣的元素

*/

function getArrsSameAndDiffElem(arrs1,arrs2){

var hash = {},

sameElemArrs = [],

diffElemArrs = [];

if(arrs1.length > 0) {

for(var i = 0,ilen = arrs1.length; i < ilen;i+=1) {

hash[arrs1[i]] = 1;

}

}

if(arrs2.length > 0) {

for(var j = 0,jlen = arrs2.length; j < jlen; j+=1) {

if(hash[arrs2[j]]) {

// 說明有相同的元素，把相同的元素存入sameElemArrs數組裏面去

sameElemArrs.push(arrs2[j]);

}else {

// 說明是不一樣的元素，把不一樣的元素存入diffElemArrs數組裏面去

diffElemArrs.push(arrs2[j]);

}

}

}

return {

sameElemArrs: sameElemArrs,

diffElemArrs: diffElemArrs

}

}

var arrs1 = ["aac","aab","cfg",'longen','tugenhua','single'];

var arrs2 = ["aac","mnc","nba","cba","anta",'tugenhua','single'];

console.log(getArrsSameAndDiffElem(arrs1,arrs2));

// 打印出 diffElemArrs = ["mnc","nba","cba","anta"]

// 相同的元素 sameElemArrs = ["aac",'tugenhua','single']

如上能夠看到 arrs2中與arr1中數組有相同的元素如上，不一樣的元素也如上；

若是須要判斷arr1中與arr2中數組相同元素及不一樣的元素，傳遞參數調換位置便可！

Javascript檢測2個數組是否類似

判斷2個數組是否類似的條件：

1. 先判斷這兩個對象是否爲Array的實例。

2. 接着判斷該數組的長度是否一致。

3. 判斷該2個對象的類型是否同樣，先對這2個數組先轉換爲字符串後，再進行排序比較，若是該2個對象類型的個數一致，長度一致，且都是數組，說明該2個數組是類似的；好比以下：

var arr11 = [11,true];

var arr22 = [false,22];

如上2個數組是類似的，可是若是2個數組以下這樣的話

var arr11 = [11,true];

var arr22 = [false,true];

說明2個數組不類似了~ 代碼以下：

function arraysSimilar(arr1,arr2) {

if(!(arr1 instanceof Array) || !(arr2 instanceof Array)) {

return false;

}

if(arr1.length !== arr2.length) {

return false;

}

var arrsLen = arr1.length;

var tempArrs1 = [],

tempArrs2 = [];

for(var i = 0; i < arrsLen; i+=1) {

var t1 = Object.prototype.toString.apply(arr1[i]);

tempArrs1.push(t1);

var t2 = Object.prototype.toString.apply(arr2[i]);

tempArrs2.push(t2);

}

return tempArrs1.sort().join() === tempArrs2.sort().join() ? true : false;

}

var arr1 = ["aa","cc",false,"bb"];

var arr2 = ["11","cc","11",false];

console.log(arraysSimilar(arr1,arr2)); // true

var arr11 = [11,true];

var arr22 = [false,22];

console.log(arraysSimilar(arr11,arr22)); // true

如何判斷該對象是否爲數組。

1. typeof

首先咱們會想到的是使用typeof來檢測數據類型，可是對於Function, String, Number, Undefined等這幾種基本類型來講，使用typeof來檢測均可以檢測到，好比代碼以下：

function test(){}

console.log(typeof 1); // number

console.log(typeof test); // function

console.log(typeof "yunxi"); // string

console.log(typeof undefined); // undefined

可是對於數組或者正則來講，使用typeof來檢測的話，那就知足不了，由於當咱們檢測數組或者正則的話，那麼返回的類型將會是一個對象object，以下代碼所示：

console.log(typeof []); // object

console.log(typeof /\d+/g); // object

2. Instanceof

由此咱們很容易會想到使用instanceof來檢測某個對象是不是數組的實例，該檢測會返回一個布爾型(boolean),若是是數組的話，返回true，不然的話返回false；咱們再來看下上面的檢測是否爲數組的代碼以下：

console.log([] instanceof Array); // true

console.log(/\d+/g instanceof Array); // false

如上能夠看到使用instanceof確實能夠判斷是否爲數組的列子;

3. constructor屬性

在javascript中，每一個對象都有一個constructor屬性，它引用了初始化該對象的構造函數，好比判斷未知對象的類型，所以咱們能夠以下寫一個方法：代碼以下：

function isArray(obj) {

return typeof obj == 'object' && obj.constructor == Array

}

// 測試demo

console.log(isArray([])); // true

var a = {"a":1};

console.log(isArray(a)); // false

var b = [1,2,3];

console.log(isArray(b)); // true

console.log(isArray(/\d+/g));// false

如上能夠看到，經過調用isArray 方法也能夠判斷是否爲數組的列子。

咱們如今能夠看到，對於第二點和第三點分別使用instanceof方法和constructor屬性貌似均可以來判斷是否爲數組了，可是也有列外狀況，好比在跨框架iframe的時候使用頁面中的數組時，會失敗，由於在不一樣的框架iframe中，建立的數組是不會相互共享其prototype屬性的；以下代碼測試便可獲得驗證~

var iframe = document.createElement('iframe');

document.body.appendChild(iframe);

xArray = window.frames[window.frames.length-1].Array;

var arr = new xArray("1","2","3","4","5");

//這個寫法IE下是不支持的，標準瀏覽器firefox，chrome下有

console.log(arr); // 打印出 ["1", "2", "3", "4", "5"]

console.log(arr instanceof Array); // false

console.log(arr.constructor === Array); // false

如上的方法咱們都不能來判斷一個對象是否爲數組的方式; 可是咱們在看ECMA262中能夠看到，可使用 Object.prototype.toString.call()方法來判斷一個對象是否爲數組；以下代碼：

function isArray(obj) {

return Object.prototype.toString.call(obj) == '[object Array]';

}

// 代碼調用

console.log(isArray([])); // true

console.log(isArray([1,2,3])); // true

var iframe = document.createElement('iframe');

document.body.appendChild(iframe);

xArray = window.frames[window.frames.length-1].Array;

var arr = new xArray("1","2","3","4","5");

console.log(arr); // ["1","2","3","4","5"]

console.log(isArray(arr)); // true

js將類數組對象轉換成數組對象

首先咱們來看一下類數組，什麼是類數組，類數組有什麼特徵呢？

具備：有指向對象的數字索引 及 length屬性值；

不具備：它不具備數組的方法，好比push，slice，pop等方法；

Javascript中常見的類數組有arguments, HTMLCollection的集合(好比document.getElementsByClassName,document.getElementsByTagName)等方法，常見的類數組對象有以下：

document.getElementsByClassName, document.getElementsByTagName,document.getElementsByName,arguments等等；好比以下測試代碼：類數組能夠有length屬性，能夠遍歷，可是它並非數組的實例，以下代碼：

function elems(){

for(var i = 0, ilen = arguments.length; i < ilen; i+=1) {

console.log(arguments[i]); // 循環2次 打印出 1,2

}

console.log(arguments instanceof Array);// false

}

elems(1,2);

咱們再來測試下arguments是否和數組同樣有push方法；測試代碼以下：

function test(){

console.log(arguments.push(1)); //arguments.push is not a function

}

test();

在控制檯中打印出 arguments.push is not a function 報錯，說明類數組並非一個真正的數組，由於它沒有數組的方法；

可是咱們能夠將類數組轉換爲數組，咱們可使用slice()方法call對象；slice()方法能夠將一個類數組對象/集合轉換成一個數組，只須要使用數組原型上的slice方法call這個對象，即Array.prototype.slice.call(arguments);便可將類數組轉換爲數組，或者咱們也可使用[].slice.call(arguments);來轉換數組；

以下代碼：

function test(){

//var args = [].slice.call(arguments);

var args = Array.prototype.slice.call(arguments);

console.log(args.push(1)); //1

}

test();

使用上面的 [].slice.call()方法和 Array.prototype.slice.call()方法均可以將類數組轉換爲數組的，好比上面的args就是轉換後的數組，其後就擁有push()方法；

固然若是咱們不嫌麻煩的話，咱們能夠先在函數內部定義一個新數組，而後使用arguments.length的屬性遍歷每一項，把每一項存入到新數組裏面去也是能夠的，可是這樣作並無上面的好；以下代碼：

function elems(){

var newArrs = [];

for(var i = 0, ilen = arguments.length; i < ilen; i+=1) {

newArrs[i] = arguments[i];

}

console.log(newArrs); // [1,2]

}

elems(1,2);

查找數組中最大值與最小值

最小值算法以下：

1. 將數組中第一個元素賦值給一個變量，把這個變量做爲最小值；

2. 開始遍歷數組，從第二個元素開始依次和第一個元素進行比較。

3. 若是當前的元素小於當前的最小值的話，就把當前的元素值賦值給最小值；

4. 移動到下一個元素，繼續對第三步操做；

5. 當數組元素遍歷結束時，這個變量存儲的就是最小值；

代碼以下：

// 查找數組中最小值

function arrayMin(arrs){

var min = arrs[0];

for(var i = 1, ilen = arrs.length; i < ilen; i+=1) {

if(arrs[i] < min) {

min = arrs[i];

}

}

return min;

}

// 代碼測試

var rets = [2,4,5,6,7,9,10,15];

console.log(arrayMin(rets));//2

上面是對數組中的數值進行比較的，若是數組中的數字是字符串的話，先要把字符串轉換成數字再進行比較便可，由於字符串比較的不是值，而是ASCII編碼，好比2的ASCLL編碼會大於15的ASCII編碼，由於15的編碼第一個數字是1,2的ASCII編碼確定大於1的；

求最大值的算法和上面相似：

1.將數組中第一個元素賦值給一個變量，把這個變量做爲最大值；

2.開始遍歷數組，從第二個元素開始依次和第一個元素進行比較。

3.若是當前的元素大於當前的最大值的話，就把當前的元素值賦值給最大值；

4移動到下一個元素，繼續對第三步操做；

5.當數組元素遍歷結束時，這個變量存儲的就是最小值；

// 在數組中查找最大值

function arrayMax(arrs) {

var max = arrs[0];

for(var i = 1,ilen = arrs.length; i < ilen; i++) {

if(arrs[i] > max) {

max = arrs[i];

}

}

return max;

}

// 代碼測試

var rets = [2,4,5,6,7,9,10,15];

console.log(arrayMax(rets));//15