<progress id="zl1bp"></progress>
<menuitem id="zl1bp"><i id="zl1bp"><video id="zl1bp"></video></i></menuitem><cite id="zl1bp"></cite>
<var id="zl1bp"><strike id="zl1bp"><listing id="zl1bp"></listing></strike></var>
<menuitem id="zl1bp"></menuitem>
<var id="zl1bp"></var>
<var id="zl1bp"><strike id="zl1bp"></strike></var>
<var id="zl1bp"><video id="zl1bp"></video></var><cite id="zl1bp"><video id="zl1bp"><listing id="zl1bp"></listing></video></cite>
<var id="zl1bp"></var><var id="zl1bp"><strike id="zl1bp"></strike></var>
<var id="zl1bp"><strike id="zl1bp"><listing id="zl1bp"></listing></strike></var><var id="zl1bp"></var><cite id="zl1bp"><video id="zl1bp"><listing id="zl1bp"></listing></video></cite>
2HZZ國外網址導航喜歡加入收藏
當前位置:國外網 » 站長資訊 » 編程 » 文章詳細
JavaScript Array slice() 方法

發布時間:2021-10-23,來源:2HZZ外國網址導航

JavaScript Array slice() 方法shift()some() JavaScript Array 參考手冊實例從數組中選擇元素:


var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1, 3);
親自試一試
頁面下方有更多 TIY 實例。


定義和用法
slice() 方法以新的數組對象,返回數組中被選中的元素。


slice() 方法選擇從給定的 start 參數開始的元素,并在給定的 end 參數處結束,但不包括。


注釋:slice() 方法不會改變原始數組。


瀏覽器支持
所有瀏覽器都完全支持 slice() 方法:


Chrome IE Edge Firefox Safari Opera
Chrome IE Edge Firefox Safari Opera
Yes Yes Yes Yes Yes Yes
語法
array.slice(start, end)
參數值
參數 描述
start
可選。整數,指定從哪里開始選擇(第一個元素的索引為 0)。


使用負數從數組的末尾進行選擇。如果省略,則類似于 "0"。


end
可選。整數,指定結束選擇的位置。


如果省略,將選擇從開始位置到數組末尾的所有元素。使用負數從數組末尾進行選擇。


技術細節
返回值: 新的數組,包含選定的元素。
JavaScript 版本: ECMAScript 1
更多實例
使用負值選擇元素:


var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var myBest = fruits.slice(-3, -1);
親自試一試
相關頁面
教程:JavaScript 數組


教程:JavaScript 數組 Const


教程:JavaScript 數組方法


教程:JavaScript 排序數組


教程:JavaScript 數組迭代


JavaScript 數組
JS 數字方法
JS 數組方法
JavaScript 數組用于在單一變量中存儲多個值。


實例
var cars = ["Saab", "Volvo", "BMW"];
親自試一試
什么是數組?
數組是一種特殊的變量,它能夠一次存放一個以上的值。


如果您有一個項目清單(例如,汽車品牌列表),在單個變量中存儲汽車品牌應該是這樣的:


var car1 = "Saab";
var car2 = "Volvo";
var car3 = "BMW"; 
不過,假如您希望遍歷所有汽車并找到一個特定的值?假如不是三個汽車品牌而是三百個呢?


解決方法就是數組!


數組可以用一個單一的名稱存放很多值,并且還可以通過引用索引號來訪問這些值。


創建數組
使用數組文本是創建 JavaScript 數組最簡單的方法。


語法:
var array-name = [item1, item2, ...];
實例
var cars = ["Saab", "Volvo", "BMW"];
親自試一試
空格和折行并不重要。聲明可橫跨多行:


實例
var cars = [
    "Saab",
    "Volvo",
    "BMW"
];
親自試一試
請不要最后一個元素之后寫逗號(比如 "BMW",)。


可能存在跨瀏覽器兼容性問題。


使用 JavaScript 關鍵詞 new
下面的例子也會創建數組,并為其賦值:


實例
var cars = new Array("Saab", "Volvo", "BMW");
親自試一試
以上兩個例子效果完全一樣。無需使用 new Array()。


出于簡潔、可讀性和執行速度的考慮,請使用第一種方法(數組文本方法)。


訪問數組元素
我們通過引用索引號(下標號)來引用某個數組元素。


這條語句訪問 cars 中的首個元素的值:


var name = cars[0];
這條語句修改 cars 中的首個元素:


cars[0] = "Opel";
實例
var cars = ["Saab", "Volvo", "BMW"];
document.getElementById("demo").innerHTML = cars[0]; 
親自試一試
[0] 是數組中的第一個元素。[1] 是第二個。數組索引從 0 開始。


改變數組元素
這條語句修改了 cars 中第一個元素的值:


cars[0] = "Opel";
實例
var cars = ["Saab", "Volvo", "BMW"];
cars[0] = "Opel";
document.getElementById("demo").innerHTML = cars[0];
親自試一試
訪問完整數組
通過 JavaScript,可通過引用數組名來訪問完整數組:


實例
var cars = ["Saab", "Volvo", "BMW"];
document.getElementById("demo").innerHTML = cars; 
親自試一試
數組是對象
數組是一種特殊類型的對象。在 JavaScript 中對數組使用 typeof 運算符會返回 "object"。


但是,JavaScript 數組最好以數組來描述。


數組使用數字來訪問其“元素”。在本例中,person[0] 返回 Bill:


數組:
var person = ["Bill", "Gates", 62];
親自試一試
對象使用名稱來訪問其“成員”。在本例中,person.firstName 返回 Bill:


對象:
var person = {firstName:"John", lastName:"Doe", age:46};
親自試一試
數組元素可以是對象
JavaScript 變量可以是對象。數組是特殊類型的對象。


正因如此,您可以在相同數組中存放不同類型的變量。


您可以在數組保存對象。您可以在數組中保存函數。你甚至可以在數組中保存數組:


myArray[0] = Date.now;
myArray[1] = myFunction;
myArray[2] = myCars;
數組屬性和方法
JavaScript 數組的真實力量隱藏在數組的屬性和方法中:


實例
var x = cars.length;   // length 屬性返回元素的數量
var y = cars.sort();   // sort() 方法對數組進行排序
我們將在下一章學習數組方法。


length 屬性
length 屬性返回數組的長度(數組元素的數目)。


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.length;                       // fruits 的長度是 4
親自試一試
length 屬性始終大于最高數組索引(下標)。


訪問第一個數組元素
實例
fruits = ["Banana", "Orange", "Apple", "Mango"];
var first = fruits[0];
親自試一試
訪問最后一個數組元素
實例
fruits = ["Banana", "Orange", "Apple", "Mango"];
var last = fruits[fruits.length - 1];
親自試一試
遍歷數組元素
遍歷數組的最安全方法是使用 "for" 循環:


實例
var fruits, text, fLen, i;


fruits = ["Banana", "Orange", "Apple", "Mango"];
fLen = fruits.length;
text = "<ul>";
for (i = 0; i < fLen; i++) {
     text += "<li>" + fruits[i] + "</li>";

親自試一試
您也可以使用 Array.foreach() 函數:


實例
var fruits, text;
fruits = ["Banana", "Orange", "Apple", "Mango"];


text = "<ul>";
fruits.forEach(myFunction);
text += "</ul>";


function myFunction(value) {
  text += "<li>" + value + "</li>";
}
親自試一試
添加數組元素
向數組添加新元素的最佳方法是使用 push() 方法:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Lemon");                // 向 fruits 添加一個新元素 (Lemon)
親自試一試
也可以使用 length 屬性向數組添加新元素:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[fruits.length] = "Lemon";     // 向 fruits 添加一個新元素 (Lemon)
親自試一試
警告!
添加最高索引的元素可在數組中創建未定義的“洞”:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[6] = "Lemon";                 // 向 fruits 添加一個新元素 (Lemon)
親自試一試
關聯數組
很多編程元素支持命名索引的數組。


具有命名索引的數組被稱為關聯數組(或散列)。


JavaScript 不支持命名索引的數組。


在 JavaScript 中,數組只能使用數字索引。


實例
var person = [];
person[0] = "Bill";
person[1] = "Gates";
person[2] = 62;
var x = person.length;          // person.length 返回 3
var y = person[0];              // person[0] 返回 "Bill"
親自試一試 警告!
假如您使用命名索引,JavaScript 會把數組重定義為標準對象。


之后,所有數組的方法和屬性將產生非正確結果。


實例:
var person = [];
person["firstName"] = "Bill";
person["lastName"] = "Gates";
person["age"] = 62;
var x = person.length;         // person.length 將返回 0
var y = person[0];              // person[0] 將返回 undefined
親自試一試
數組和對象的區別
在 JavaScript 中,數組使用數字索引。


在 JavaScript 中,對象使用命名索引。


數組是特殊類型的對象,具有數字索引。


何時使用數組,何時使用對象?
JavaScript 不支持關聯數組
如果希望元素名為字符串(文本)則應該使用對象。
如果希望元素名為數字則應該使用數組。
避免 new Array()
沒有必要使用 JavaScript 的內建數組構造器 new Array()。


請使用 [] 取而代之!


下面兩條不同的語句創建了名為 points 的新的空數組:


var points = new Array();         // 差
var points = [];                  // 優
下面兩條不同的語句創建包含六個數字的新數組:


var points = new Array(40, 100, 1, 5, 25, 10); // 差
var points = [40, 100, 1, 5, 25, 10];          // 優
親自試一試
new 關鍵詞只會使代碼復雜化。它還會產生某些不可預期的結果:


var points = new Array(40, 100);  // 創建包含兩個元素的數組(40 和 100)
假如刪除其中一個元素會怎么樣?


var points = new Array(40);       // 創建包含 40 個未定義元素的數組?。?!
親自試一試
如何識別數組
常見的問題是:我如何知曉某個變量是否是數組?


問題在于 JavaScript 運算符 typeof 返回 "object":


var fruits = ["Banana", "Orange", "Apple", "Mango"];


typeof fruits;             // 返回 object
親自試一試
typeof 運算符返回 "object",因為 JavaScript 數組屬于對象。


解決方案 1:
為了解決這個問題,ECMAScript 5 定義了新方法 Array.isArray():


Array.isArray(fruits);     // 返回 true
親自試一試
此方案的問題在于 ECMAScript 5 不支持老的瀏覽器。


解決方案 2:
創建您自己的 isArray() 函數以解決此問題:


function isArray(x) {
    return x.constructor.toString().indexOf("Array") > -1;
}
親自試一試
假如參數為數組,則上面的函數始終返回 true。


或者更準確的解釋是:假如對象原型包含單詞 "Array" 則返回 true。


解決方案 3:
假如對象由給定的構造器創建,則 instanceof 運算符返回 true:


var fruits = ["Banana", "Orange", "Apple", "Mango"];
 
fruits instanceof Array     // 返回 true
親自試一試


JavaScript 數組 Const
JS 數組迭代
JS 日期
ECMAScript 2015 (ES6)
2015 年,JavaScript 引入了一個重要的新關鍵字:const。


使用 const 聲明數組已成為一種常見做法:


實例
const cars = ["Saab", "Volvo", "BMW"];
親自試一試
無法重新賦值
用 const 聲明的數組不能重新賦值:


實例
const cars = ["Saab", "Volvo", "BMW"];
cars = ["Toyota", "Volvo", "Audi"];    // ERROR
親自試一試
數組不是常量
關鍵字 const 有一定誤導性。


它不定義常量數組。它定義的是對數組的常量引用。


因此,我們仍然可以更改常量數組的元素。


/
元素可以重新賦值
您可以更改常量數組的元素:


實例
// 您可以創建常量數組:
const cars = ["Saab", "Volvo", "BMW"];


// 您可以更改元素:
cars[0] = "Toyota";


// 您可以添加元素:
cars.push("Audi");
親自試一試
瀏覽器支持
Internet Explorer 10 或更早的版本不支持 const 關鍵字。


下表注明了完全支持 const 關鍵字的首個瀏覽器版本:


Chrome IE Firefox Safari Opera
Chrome 49 IE 11 / Edge Firefox 36 Safari 10 Opera 36
2016 年 3 月 2013 年 10 月 2015 年 2 月 2016 年 9 月 2016 年 3 月
聲明時賦值
JavaScript const 變量在聲明時必須賦值:


意思是:用 const 聲明的數組必須在聲明時進行初始化。


使用 const 而不初始化數組是一個語法錯誤:


實例
不起作用:


const cars;
cars = ["Saab", "Volvo", "BMW"];
用 var 聲明的數組可以隨時初始化。


您甚至可以在聲明之前使用該數組:


實例
沒問題:


cars = ["Saab", "Volvo", "BMW"];
var cars;
親自試一試
const 塊作用域
用 const 聲明的數組具有塊作用域。


在塊中聲明的數組與在塊外聲明的數組不同:


實例
const cars = ["Saab", "Volvo", "BMW"];
// 此處 cars[0] 為 "Saab"
{
  const cars = ["Toyota", "Volvo", "BMW"];
  // 此處 cars[0] 為 "Toyota"
}
// 此處 cars[0] 為 "Saab"
親自試一試
用 var 聲明的數組沒有塊作用域:


實例
var cars = ["Saab", "Volvo", "BMW"];
// 此處 cars[0] 為 "Saab"
{
  var cars = ["Toyota", "Volvo", "BMW"];
  // 此處 cars[0] 為 "Toyota"
}
// 此處 cars[0] 為 "Toyota"
親自試一試
您可以在以下章節中學習更多關于塊作用域的內容:JavaScript 作用域。


重新聲明數組
在程序中的任何位置都允許用 var 重新聲明數組:


實例
var cars = ["Volvo", "BMW"];   // 允許
var cars = ["Toyota", "BMW"];  // 允許
cars = ["Volvo", "Saab"];      // 允許
不允許在同一作用域或同一塊中將數組重新聲明或重新賦值給 const:


實例
var cars = ["Volvo", "BMW"];         // 允許
const cars = ["Volvo", "BMW"];       // 不允許
{
  var cars = ["Volvo", "BMW"];         // 允許
  const cars = ["Volvo", "BMW"];       // 不允許
}
不允許在同一作用域或同一塊中重新聲明或重新賦值現有的 const 數組:


實例
const cars = ["Volvo", "BMW"];       // 允許
const cars = ["Volvo", "BMW"];       // 不允許
var cars = ["Volvo", "BMW"];         // 不允許
cars = ["Volvo", "BMW"];             // 不允許


{
  const cars = ["Volvo", "BMW"];     // 允許
  const cars = ["Volvo", "BMW"];     // 不允許
  var cars = ["Volvo", "BMW"];       // 不允許
  cars = ["Volvo", "BMW"];           // 不允許
}
允許在另一個作用域或另一個塊中使用 const 重新聲明數組:


實例
const cars = ["Volvo", "BMW"];       // 允許
{
  const cars = ["Volvo", "BMW"];     // 允許
}
{
  const cars = ["Volvo", "BMW"];     // 允許
}
完整的數組參考手冊
如需完整參考,請訪問我們的完整 JavaScript 數組參考手冊。


該手冊包含所有數組屬性和方法的描述和實例。


JavaScript 數組方法
JS 數組
JS 數組排序
JavaScript 數組的力量隱藏在數組方法中。


把數組轉換為字符串
JavaScript 方法 toString() 把數組轉換為數組值(逗號分隔)的字符串。


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.toString(); 
結果


Banana,Orange,Apple,Mango
親自試一試
join() 方法也可將所有數組元素結合為一個字符串。


它的行為類似 toString(),但是您還可以規定分隔符:


實例
var fruits = ["Banana", "Orange","Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.join(" * "); 
結果


Banana * Orange * Apple * Mango
親自試一試
Popping 和 Pushing
在處理數組時,刪除元素和添加新元素是很簡單的。


Popping 和 Pushing 指的是:


從數組彈出項目,或向數組推入項目。


Popping
pop() 方法從數組中刪除最后一個元素:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();              // 從 fruits 刪除最后一個元素("Mango")
親自試一試
pop() 方法返回“被彈出”的值:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x = fruits.pop();      // x 的值是 "Mango"
親自試一試
Pushing
push() 方法(在數組結尾處)向數組添加一個新的元素:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi");       //  向 fruits 添加一個新元素
親自試一試
push() 方法返回新數組的長度:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x =  fruits.push("Kiwi");   //  x 的值是 5
親自試一試
位移元素
位移與彈出等同,但處理首個元素而不是最后一個。


shift() 方法會刪除首個數組元素,并把所有其他元素“位移”到更低的索引。


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift();            // 從 fruits 刪除第一個元素 "Banana"
親自試一試
shift() 方法返回被“位移出”的字符串:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift();             // 返回 "Banana"
親自試一試
unshift() 方法(在開頭)向數組添加新元素,并“反向位移”舊元素:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");    // 向 fruits 添加新元素 "Lemon"
親自試一試
unshift() 方法返回新數組的長度。


實例


var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");    // 返回 5
親自試一試
更改元素
通過使用它們的索引號來訪問數組元素:


數組索引(下標)以 0 開始。[0] 是第一個數組元素,[1] 是第二個,[2] 是第三個 ...


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[0] = "Kiwi";        // 把 fruits 的第一個元素改為 "Kiwi"
親自試一試
length 屬性提供了向數組追加新元素的簡易方法:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[fruits.length] = "Kiwi";          // 向 fruits 追加 "Kiwi"
親自試一試
刪除元素
既然 JavaScript 數組屬于對象,其中的元素就可以使用 JavaScript delete 運算符來刪除:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
delete fruits[0];           // 把 fruits 中的首個元素改為 undefined
親自試一試
使用 delete 會在數組留下未定義的空洞。請使用 pop() 或 shift() 取而代之。


拼接數組
splice() 方法可用于向數組添加新項:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 0, "Lemon", "Kiwi");
親自試一試
第一個參數(2)定義了應添加新元素的位置(拼接)。


第二個參數(0)定義應刪除多少元素。


其余參數(“Lemon”,“Kiwi”)定義要添加的新元素。


splice() 方法返回一個包含已刪除項的數組:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 2, "Lemon", "Kiwi");
親自試一試
使用 splice() 來刪除元素
通過聰明的參數設定,您能夠使用 splice() 在數組中不留“空洞”的情況下移除元素:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(0, 1);        // 刪除 fruits 中的第一個元素
親自試一試
第一個參數(0)定義新元素應該被添加(接入)的位置。


第二個參數(1)定義應該刪除多個元素。


其余參數被省略。沒有新元素將被添加。


合并(連接)數組
concat() 方法通過合并(連接)現有數組來創建一個新數組:


實例(合并兩個數組)
var myGirls = ["Cecilie", "Lone"];
var myBoys = ["Emil", "Tobias", "Linus"];
var myChildren = myGirls.concat(myBoys);   // 連接 myGirls 和 myBoys
親自試一試
concat() 方法不會更改現有數組。它總是返回一個新數組。


concat() 方法可以使用任意數量的數組參數:


實例(合并三個數組)
var arr1 = ["Cecilie", "Lone"];
var arr2 = ["Emil", "Tobias", "Linus"];
var arr3 = ["Robin", "Morgan"];
var myChildren = arr1.concat(arr2, arr3);   // 將arr1、arr2 與 arr3 連接在一起
親自試一試
concat() 方法也可以將值作為參數:


實例(將數組與值合并)
var arr1 = ["Cecilie", "Lone"];
var myChildren = arr1.concat(["Emil", "Tobias", "Linus"]); 
親自試一試
裁剪數組
slice() 方法用數組的某個片段切出新數組。


本例從數組元素 1 ("Orange")開始切出一段數組:


實例
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1); 
親自試一試
slice() 方法創建新數組。它不會從源數組中刪除任何元素。


本例從數組元素 3 ("Apple")開始切出一段數組:


實例
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(3); 
親自試一試
slice() 可接受兩個參數,比如 (1, 3)。


該方法會從開始參數選取元素,直到結束參數(不包括)為止。


實例
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1, 3); 
親自試一試
如果結束參數被省略,比如第一個例子,則 slice() 會切出數組的剩余部分。


實例
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(2); 
親自試一試
自動 toString()
如果需要原始值,則 JavaScript 會自動把數組轉換為字符串。下面兩個例子將產生相同的結果:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.toString(); 
親自試一試
實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits; 
親自試一試
所有 JavaScript 對象都擁有 toString() 方法。


數組排序
我們將在下一章學習到數組排序的知識~。


查找數組中的最大和最小值
沒有在 JavaScript 數組中查找最高和最低值的內建函數。


您將在本教程的下一章學習如何解決這個問題。


完整的數組參考手冊
如需完整的參考手冊,請訪問我們完整的 JavaScript 數組參考手冊。


該參考手冊包含所有數組屬性和方法的描述和實例。


JavaScript 數組排序
JS 數組方法
JS 數組迭代
sort() 方法是最強大的數組方法之一。


數組排序
sort() 方法以字母順序對數組進行排序:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();            // 對 fruits 中的元素進行排序
親自試一試
反轉數組
reverse() 方法反轉數組中的元素。


您可以使用它以降序對數組進行排序:


實例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();            // 對 fruits 中的元素進行排序
fruits.reverse();         // 反轉元素順序
親自試一試
數字排序
默認地,sort() 函數按照字符串順序對值進行排序。


該函數很適合字符串("Apple" 會排在 "Banana" 之前)。


不過,如果數字按照字符串來排序,則 "25" 大于 "100",因為 "2" 大于 "1"。


正因如此,sort() 方法在對數值排序時會產生不正確的結果。


我們通過一個比值函數來修正此問題:


實例
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return a - b}); 
親自試一試
使用相同的技巧對數組進行降序排序:


實例
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return b - a}); 
親自試一試
比值函數
比較函數的目的是定義另一種排序順序。


比較函數應該返回一個負,零或正值,這取決于參數:


function(a, b){return a-b}
當 sort() 函數比較兩個值時,會將值發送到比較函數,并根據所返回的值(負、零或正值)對這些值進行排序。


實例:
當比較 40 和 100 時,sort() 方法會調用比較函數 function(40,100)。


該函數計算 40-100,然后返回 -60(負值)。


排序函數將把 40 排序為比 100 更低的值。


您可以使用下面的代碼片段來測試數值和字母排序:


<button onclick="myFunction1()">以字母順序排序</button>
<button onclick="myFunction2()">以數字順序排序</button>


<p id="demo"></p>


<script>
var points = [40, 100, 1, 5, 25, 10];
document.getElementById("demo").innerHTML = points;


function myFunction1() {
points.sort();
document.getElementById("demo").innerHTML  = points;
}
function myFunction2() {
points.sort(function(a, b){return  a - b});
document.getElementById("demo").innerHTML = points;
}
</script>
親自試一試
以隨機順序排序數組
實例
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return 0.5 - Math.random()}); 
親自試一試
查找最高(或最低)的數組值
JavaScript 不提供查找數組中最大或最小數組值的內建函數。


不過,在對數組進行排序之后,您能夠使用索引來獲得最高或最低值。


升序排序:


實例
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return a - b});


// 現在 points[0] 包含最低值
// 而 points[points.length-1] 包含最高值
親自試一試
降序排序:


實例
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return b - a});


// 現在 points[0] 包含最高值
// 而 points[points.length-1] 包含最低值
親自試一試
如果您僅僅需要找到最高或最低值,對整個數組進行排序是效率極低的方法。


對數組使用 Math.max()
您可以使用 Math.max.apply 來查找數組中的最高值:


實例
function myArrayMax(arr) {
    return Math.max.apply(null, arr);
}
親自試一試
Math.max.apply([1, 2, 3]) 等于 Math.max(1, 2, 3)。


對數組使用 Math.min()
您可以使用 Math.min.apply 來查找數組中的最低值:


實例
function myArrayMin(arr) {
    return Math.min.apply(null, arr);
}
親自試一試
Math.min.apply([1, 2, 3]) 等于 Math.min(1, 2, 3)。


我的 Min / Max JavaScript 方法
最快的解決方法是使用“自制”方法。


此函數遍歷數組,用找到的最高值與每個值進行比較:


實例(查找 Max)
function myArrayMax(arr) {
    var len = arr.length
    var max = -Infinity;
    while (len--) {
        if (arr[len] > max) {
            max = arr[len];
        }
    }
    return max;
}
親自試一試
此函數遍歷數組,用找到的最低值與每個值進行比較:


實例(查找 Min)
function myArrayMin(arr) {
    var len = arr.length
    var min = Infinity;
    while (len--) {
        if (arr[len] < min) {
            min = arr[len];
        }
    }
    return min;
}
親自試一試
排序對象數組
JavaScript 數組經常會包含對象:


實例
var cars = [
{type:"Volvo", year:2016},
{type:"Saab", year:2001},
{type:"BMW", year:2010}];
即使對象擁有不同數據類型的屬性,sort() 方法仍可用于對數組進行排序。


解決方法是通過比較函數來對比屬性值:


實例
cars.sort(function(a, b){return a.year - b.year});
親自試一試
比較字符串屬性會稍復雜:


實例
cars.sort(function(a, b){
  var x = a.type.toLowerCase();
  var y = b.type.toLowerCase();
  if (x < y) {return -1;}
  if (x > y) {return 1;}
  return 0;
});
親自試一試


JavaScript 數組迭代
JS 數組排序
JS 數組 Const
數組迭代方法對每個數組項進行操作。


Array.forEach()
forEach() 方法為每個數組元素調用一次函數(回調函數)。


實例
var txt = "";
var numbers = [45, 4, 9, 16, 25];
numbers.forEach(myFunction);


function myFunction(value, index, array) {
  txt = txt + value + "<br>"; 
}
親自試一試
注釋:該函數接受 3 個參數:


項目值
項目索引
數組本身
上面的例子只用了 value 參數。這個例子可以重新寫為:


實例
var txt = "";
var numbers = [45, 4, 9, 16, 25];
numbers.forEach(myFunction);


function myFunction(value) {
  txt = txt + value + "<br>"; 
}
親自試一試
所有瀏覽器都支持 Array.forEach(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
Array.map()
map() 方法通過對每個數組元素執行函數來創建新數組。


map() 方法不會對沒有值的數組元素執行函數。


map() 方法不會更改原始數組。


這個例子將每個數組值乘以2:


實例
var numbers1 = [45, 4, 9, 16, 25];
var numbers2 = numbers1.map(myFunction);


function myFunction(value, index, array) {
  return value * 2;
}
親自試一試
請注意,該函數有 3 個參數:


項目值
項目索引
數組本身
當回調函數僅使用 value 參數時,可以省略索引和數組參數:


實例
var numbers1 = [45, 4, 9, 16, 25];
var numbers2 = numbers1.map(myFunction);


function myFunction(value) {
  return value * 2;
}
親自試一試
所有瀏覽器都支持 Array.map(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
Array.filter()
filter() 方法創建一個包含通過測試的數組元素的新數組。


這個例子用值大于 18 的元素創建一個新數組:


實例
var numbers = [45, 4, 9, 16, 25];
var over18 = numbers.filter(myFunction);


function myFunction(value, index, array) {
  return value > 18;
}
親自試一試
請注意此函數接受 3 個參數:


項目值
項目索引
數組本身
在上面的例子中,回調函數不使用 index 和 array 參數,因此可以省略它們:


實例
var numbers = [45, 4, 9, 16, 25];
var over18 = numbers.filter(myFunction);


function myFunction(value) {
  return value > 18;
}
親自試一試
所有瀏覽器都支持 Array.filter(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
Array.reduce()
reduce() 方法在每個數組元素上運行函數,以生成(減少它)單個值。


reduce() 方法在數組中從左到右工作。另請參閱 reduceRight()。


reduce() 方法不會減少原始數組。


這個例子確定數組中所有數字的總和:


實例
var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduce(myFunction);


function myFunction(total, value, index, array) {
  return total + value;
}
親自試一試
請注意此函數接受 4 個參數:


總數(初始值/先前返回的值)
項目值
項目索引
數組本身
上例并未使用 index 和 array 參數??梢詫⑺膶憺椋?br />

實例
var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduce(myFunction);


function myFunction(total, value) {
  return total + value;
}
親自試一試
reduce() 方法能夠接受一個初始值:


實例
var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduce(myFunction, 100);


function myFunction(total, value) {
  return total + value;
}
親自試一試
所有瀏覽器都支持 Array.reduce(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
Array.reduceRight()
reduceRight() 方法在每個數組元素上運行函數,以生成(減少它)單個值。


reduceRight() 方法在數組中從右到左工作。另請參閱 reduce()。


reduceRight() 方法不會減少原始數組。


這個例子確定數組中所有數字的總和:


實例
var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduceRight(myFunction);


function myFunction(total, value, index, array) {
  return total + value;
}
親自試一試
請注意此函數接受 4 個參數:


總數(初始值/先前返回的值)
項目值
項目索引
數組本身
上例并未使用 index 和 array 參數??梢詫⑺膶憺椋?br />

實例
var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduceRight(myFunction);


function myFunction(total, value) {
  return total + value;
}
親自試一試
所有瀏覽器都支持 Array.reduceRight(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
Array.every()
every() 方法檢查所有數組值是否通過測試。


這個例子檢查所有數組值是否大于 18:


實例
var numbers = [45, 4, 9, 16, 25];
var allOver18 = numbers.every(myFunction);


function myFunction(value, index, array) {
  return value > 18;
}
親自試一試
請注意此函數接受 3 個參數:


項目值
項目索引
數組本身
如果回調函數僅使用第一個參數(值)時,可以省略其他參數:


實例
var numbers = [45, 4, 9, 16, 25];
var allOver18 = numbers.every(myFunction);


function myFunction(value) {
  return value > 18;
}
親自試一試
所有瀏覽器都支持 Array.every(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
Array.some()
some() 方法檢查某些數組值是否通過了測試。


這個例子檢查某些數組值是否大于 18:


實例
var numbers = [45, 4, 9, 16, 25];
var someOver18 = numbers.some(myFunction);


function myFunction(value, index, array) {
  return value > 18;
}
親自試一試
請注意此函數接受 3 個參數:


項目值
項目索引
數組本身
所有瀏覽器都支持 Array.some(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
Array.indexOf()
indexOf() 方法在數組中搜索元素值并返回其位置。


注釋:第一個項目的位置是 0,第二個項目的位置是 1,以此類推。


實例
檢索數組中的項目 "Apple":


var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");
親自試一試
所有瀏覽器都支持 Array.indexOf(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
語法
array.indexOf(item, start)
item 必需。要檢索的項目。
start 可選。從哪里開始搜索。負值將從結尾開始的給定位置開始,并搜索到結尾。
如果未找到項目,Array.indexOf() 返回 -1。


如果項目多次出現,則返回第一次出現的位置。


Array.lastIndexOf()
Array.lastIndexOf() 與 Array.indexOf() 類似,但是從數組結尾開始搜索。


實例
檢索數組中的項目 "Apple":


var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");
親自試一試
所有瀏覽器都支持 Array.lastIndexOf(),除了 Internet Explorer 8 或更早的版本:


Yes 9.0 Yes Yes Yes
語法
array.lastIndexOf(item, start)
item 必需。要檢索的項目。
start 可選。從哪里開始搜索。負值將從結尾開始的給定位置開始,并搜索到開頭。
Array.find()
find() 方法返回通過測試函數的第一個數組元素的值。


這個例子查找(返回)大于 18 的第一個元素的值:


實例
var numbers = [4, 9, 16, 25, 29];
var first = numbers.find(myFunction);


function myFunction(value, index, array) {
  return value > 18;
}
親自試一試
請注意此函數接受 3 個參數:


項目值
項目索引
數組本身
老舊的瀏覽器不支持 Array.find()。下面列出了完全支持此方法的首個瀏覽器版本:


45 12 25 8 32
Array.findIndex()
findIndex() 方法返回通過測試函數的第一個數組元素的索引。


這個例子查找大于 18 的第一個元素的索引:


實例
var numbers = [4, 9, 16, 25, 29];
var first = numbers.findIndex(myFunction);


function myFunction(value, index, array) {
  return value > 18;
}
親自試一試
請注意此函數接受 3 個參數:


項目值
項目索引
數組本身
老舊的瀏覽器不支持 Array.findIndex()。下面列出了完全支持此方法的首個瀏覽器版本:


45 12 25 8 32