<font id="zqva1"></font>
<rt id="zqva1"></rt>
  • <tt id="zqva1"></tt>
    <cite id="zqva1"></cite>

    <cite id="zqva1"><noscript id="zqva1"></noscript></cite>
      <rp id="zqva1"><meter id="zqva1"></meter></rp>

        <cite id="zqva1"></cite>
          <b id="zqva1"></b>
          <rp id="zqva1"></rp>
          <cite id="zqva1"></cite>

          <rt id="zqva1"></rt>

        1. <rp id="zqva1"></rp>

          js中數組創建的多種方式,數組中常用方法總匯

          時間:?2018-01-02閱讀:?857標簽:?Array

          javascript創建數組的幾種方式

          1、字面量形式直接創建數組:

          var arr = [];//創建一個空數組
          var arr2 = [1,2];//創建一個有2個元素的數組


          2、Array構造函數創建數組:

          var arr1 = new Array();//創建空數組
          var arr2 = new Array(5);//創建一個長度為5的數組
          var arr3 =  new Array(1,2,3,4,5);//創建數組并初始化


          js數組常用的方法有哪些? 

          toString():把數組轉換成一個字符串
          toLocaleString():把數組轉換成一個字符串
          join():把數組轉換成一個用符號連接的字符串
          shift():從數組頭部刪除一個元素
          unshift():在數組的頭部添加若干元素 
          pop():從數組尾部刪除一個元素
          push():把一個元素添加到數組的尾部 
          concat():給數組添加元素
          slice():返回數組的部分
          reverse():將數組反向排序
          sort():對數組進行排序操作
          splice():插入、刪除或者替換一個數組元素  

          下面詳細介紹一下各個方法的基本功能。


          1、join()

          join(separator): 將數組的元素組起一個字符串,以separator為分隔符,省略的話則用默認用逗號為分隔符,該方法只接收一個參數:即分隔符。

          var arr = [1,2,3];
          console.log(arr.join()); // 1,2,3
          console.log(arr.join("-")); // 1-2-3
          console.log(arr); // [1, 2, 3](原數組不變)

          通過join()方法可以實現重復字符串,只需傳入字符串以及重復的次數,就能返回重復后的字符串,函數如下:

          function repeatString(str, n) {
          return new Array(n + 1).join(str);
          }
          console.log(repeatString("abc", 3)); // abcabcabc
          console.log(repeatString("Hi", 5)); // HiHiHiHiHi


          2、push()和pop()

          push(): 可以接收任意數量的參數,把它們逐個添加到數組末尾,并返回修改后數組的長度。 
          pop():數組末尾移除最后一項,減少數組的 length 值,然后返回移除的項。

          var arr = ["Lily","lucy","Tom"];
          var count = arr.push("Jack","Sean");
          console.log(count); // 5
          console.log(arr); // ["Lily", "lucy", "Tom", "Jack", "Sean"]
          var item = arr.pop();
          console.log(item); // Sean
          console.log(arr); // ["Lily", "lucy", "Tom", "Jack"]


          3、shift() 和 unshift()

          shift():刪除原數組第一項,并返回刪除元素的值;如果數組為空則返回undefined 。 
          unshift:將參數添加到原數組開頭,并返回數組的長度 。

          這組方法和上面的push()和pop()方法正好對應,一個是操作數組的開頭,一個是操作數組的結尾。

          var arr = ["Lily","lucy","Tom"];
          var count = arr.unshift("Jack","Sean");
          console.log(count); // 5
          console.log(arr); //["Jack", "Sean", "Lily", "lucy", "Tom"]
          var item = arr.shift();
          console.log(item); // Jack
          console.log(arr); // ["Sean", "Lily", "lucy", "Tom"]


          4、sort()

          sort():按升序排列數組項——即最小的值位于最前面,最大的值排在最后面。

          在排序時,sort()方法會調用每個數組項的 toString()轉型方法,然后比較得到的字符串,以確定如何排序。即使數組中的每一項都是數值, sort()方法比較的也是字符串,因此會出現以下的這種情況:

          var arr1 = ["a", "d", "c", "b"];
          console.log(arr1.sort()); // ["a", "b", "c", "d"]
          arr2 = [13, 24, 51, 3];
          console.log(arr2.sort()); // [13, 24, 3, 51]
          console.log(arr2); // [13, 24, 3, 51](元數組被改變)

          為了解決上述問題,sort()方法可以接收一個比較函數作為參數,以便我們指定哪個值位于哪個值的前面。比較函數接收兩個參數,如果第一個參數應該位于第二個之前則返回一個負數,如果兩個參數相等則返回 0,如果第一個參數應該位于第二個之后則返回一個正數。以下就是一個簡單的比較函數:

          function compare(value1, value2) {
          if (value1 < value2) {
          return -1;
          } else if (value1 > value2) {
          return 1;
          } else {
          return 0;
          }
          }
          arr2 = [13, 24, 51, 3];
          console.log(arr2.sort(compare)); // [3, 13, 24, 51]

          如果需要通過比較函數產生降序排序的結果,只要交換比較函數返回的值即可:

          function compare(value1, value2) {
          if (value1 < value2) {
          return 1;
          } else if (value1 > value2) {
          return -1;
          } else {
          return 0;
          }
          }
          arr2 = [13, 24, 51, 3];
          console.log(arr2.sort(compare)); // [51, 24, 13, 3]


          5、reverse()

          reverse():反轉數組項的順序。

          var arr = [13, 24, 51, 3];
          console.log(arr.reverse()); //[3, 51, 24, 13]
          console.log(arr); //[3, 51, 24, 13](原數組改變)


          6、concat()

          concat() :將參數添加到原數組中。這個方法會先創建當前數組一個副本,然后將接收到的參數添加到這個副本的末尾,最后返回新構建的數組。在沒有給 concat()方法傳遞參數的情況下,它只是復制當前數組并返回副本。

          var arr = [1,3,5,7];
          var arrCopy = arr.concat(9,[11,13]);
          console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
          console.log(arr); // [1, 3, 5, 7](原數組未被修改)

          從上面測試結果可以發現:傳入的不是數組,則直接把參數添加到數組后面,如果傳入的是數組,則將數組中的各個項添加到數組中。但是如果傳入的是一個二維數組呢?

          var arrCopy2 = arr.concat([9,[11,13]]);
          console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]
          console.log(arrCopy2[5]); //[11, 13]

          上述代碼中,arrCopy2數組的第五項是一個包含兩項的數組,也就是說concat方法只能將傳入數組中的每一項添加到數組中,如果傳入數組中有些項是數組,那么也會把這一數組項當作一項添加到arrCopy2中。


          7、slice()

          slice():返回從原數組中指定開始下標到結束下標之間的項組成的新數組。slice()方法可以接受一或兩個參數,即要返回項的起始和結束位置。在只有一個參數的情況下, slice()方法返回從該參數指定位置開始到當前數組末尾的所有項。如果有兩個參數,該方法返回起始和結束位置之間的項——但不包括結束位置的項。

          var arr = [1,3,5,7,9,11];
          var arrCopy = arr.slice(1);
          var arrCopy2 = arr.slice(1,4);
          var arrCopy3 = arr.slice(1,-2);
          var arrCopy4 = arr.slice(-4,-1);
          console.log(arr); //[1, 3, 5, 7, 9, 11](原數組沒變)
          console.log(arrCopy); //[3, 5, 7, 9, 11]
          console.log(arrCopy2); //[3, 5, 7]
          console.log(arrCopy3); //[3, 5, 7]
          console.log(arrCopy4); //[5, 7, 9]

          arrCopy只設置了一個參數,也就是起始下標為1,所以返回的數組為下標1(包括下標1)開始到數組最后。 
          arrCopy2設置了兩個參數,返回起始下標(包括1)開始到終止下標(不包括4)的子數組。 
          arrCopy3設置了兩個參數,終止下標為負數,當出現負數時,將負數加上數組長度的值(6)來替換該位置的數,因此就是從1開始到4(不包括)的子數組。 
          arrCopy4中兩個參數都是負數,所以都加上數組長度6轉換成正數,因此相當于slice(2,5)。


          8、splice()

          splice():很強大的數組方法,它有很多種用法,可以實現刪除、插入和替換。

          刪除:可以刪除任意數量的項,只需指定 2 個參數:要刪除的第一項的位置和要刪除的項數。例如, splice(0,2)會刪除數組中的前兩項。

          插入:可以向指定位置插入任意數量的項,只需提供 3 個參數:起始位置、 0(要刪除的項數)和要插入的項。例如,splice(2,0,4,6)會從當前數組的位置 2 開始插入4和6。
          替換:可以向指定位置插入任意數量的項,且同時刪除任意數量的項,只需指定 3 個參數:起始位置、要刪除的項數和要插入的任意數量的項。插入的項數不必與刪除的項數相等。例如,splice (2,1,4,6)會刪除當前數組位置 2 的項,然后再從位置 2 開始插入4和6。

          splice()方法始終都會返回一個數組,該數組中包含從原始數組中刪除的項,如果沒有刪除任何項,則返回一個空數組。

          var arr = [1,3,5,7,9,11];
          var arrRemoved = arr.splice(0,2);
          console.log(arr); //[5, 7, 9, 11]
          console.log(arrRemoved); //[1, 3]
          var arrRemoved2 = arr.splice(2,0,4,6);
          console.log(arr); // [5, 7, 4, 6, 9, 11]
          console.log(arrRemoved2); // []
          var arrRemoved3 = arr.splice(1,1,2,4);
          console.log(arr); // [5, 2, 4, 4, 6, 9, 11]
          console.log(arrRemoved3); //[7]


          9、indexOf()和 lastIndexOf()

          indexOf():接收兩個參數:要查找的項和(可選的)表示查找起點位置的索引。其中, 從數組的開頭(位置 0)開始向后查找。 
          lastIndexOf:接收兩個參數:要查找的項和(可選的)表示查找起點位置的索引。其中, 從數組的末尾開始向前查找。

          這兩個方法都返回要查找的項在數組中的位置,或者在沒找到的情況下返回?1。在比較第一個參數與數組中的每一項時,會使用全等操作符。

          var arr = [1,3,5,7,7,5,3,1];
          console.log(arr.indexOf(5)); //2
          console.log(arr.lastIndexOf(5)); //5
          console.log(arr.indexOf(5,2)); //2
          console.log(arr.lastIndexOf(5,4)); //2
          console.log(arr.indexOf("5")); //-1


          10、forEach()

          forEach():對數組進行遍歷循環,對數組中的每一項運行給定函數。這個方法沒有返回值。參數都是function類型,默認有傳參,參數分別為:遍歷的數組內容;第對應的數組索引,數組本身。

          var arr = [1, 2, 3, 4, 5];
          arr.forEach(function(x, index, a){
          console.log(x + '|' + index + '|' + (a === arr));
          });
          // 輸出為:
          // 1|0|true
          // 2|1|true
          // 3|2|true
          // 4|3|true
          // 5|4|true


          11、map()

          map():指“映射”,對數組中的每一項運行給定函數,返回每次函數調用的結果組成的數組。

          下面代碼利用map方法實現數組中每個數求平方。

          var arr = [1, 2, 3, 4, 5];
          var arr2 = arr.map(function(item){
          return item*item;
          });
          console.log(arr2); //[1, 4, 9, 16, 25]


          12、filter()

          filter():“過濾”功能,數組中的每一項運行給定函數,返回滿足過濾條件組成的數組。

          var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
          var arr2 = arr.filter(function(x, index) {
          return index % 3 === 0 || x >= 8;
          });
          console.log(arr2); //[1, 4, 7, 8, 9, 10]


          13、every()

          every():判斷數組中每一項都是否滿足條件,只有所有項都滿足條件,才會返回true。

          var arr = [1, 2, 3, 4, 5];
          var arr2 = arr.every(function(x) {
          return x < 10;
          });
          console.log(arr2); //true
          var arr3 = arr.every(function(x) {
          return x < 3;
          });
          console.log(arr3); // false


          14、some()

          some():判斷數組中是否存在滿足條件的項,只要有一項滿足條件,就會返回true。

          var arr = [1, 2, 3, 4, 5];
          var arr2 = arr.some(function(x) {
          return x < 3;
          });
          console.log(arr2); //true
          var arr3 = arr.some(function(x) {
          return x < 1;
          });
          console.log(arr3); // false


          15、reduce()和 reduceRight()

          這兩個方法都會實現迭代數組的所有項,然后構建一個最終返回的值。reduce()方法從數組的第一項開始,逐個遍歷到最后。而 reduceRight()則從數組的最后一項開始,向前遍歷到第一項。

          這兩個方法都接收兩個參數:一個在每一項上調用的函數和(可選的)作為歸并基礎的初始值。

          傳給 reduce()和 reduceRight()的函數接收 4 個參數:前一個值、當前值、項的索引和數組對象。這個函數返回的任何值都會作為第一個參數自動傳給下一項。第一次迭代發生在數組的第二項上,因此第一個參數是數組的第一項,第二個參數就是數組的第二項。

          下面代碼用reduce()實現數組求和,數組一開始加了一個初始值10。

          var values = [1,2,3,4,5];
          var sum = values.reduceRight(function(prev, cur, index, array){
          return prev + cur;
          },10);
          console.log(sum); //25


          站長推薦

          1.阿里云: 本站目前使用的是阿里云主機,安全/可靠/穩定。點擊領取2000元代金券、了解最新阿里云產品的各種優惠活動點擊進入

          2.騰訊云: 提供云服務器、云數據庫、云存儲、視頻與CDN、域名等服務。騰訊云各類產品的最新活動,優惠券領取點擊進入

          3.廣告聯盟: 整理了目前主流的廣告聯盟平臺,如果你有流量,可以作為參考選擇適合你的平臺點擊進入

          鏈接: http://www.modern-decoration.com.cn/article/detial/302

          arguments轉化成Array數組的方法

          簡單說一下arguments,arguments 就是函數內一個內建對象,它包含函數接收到的所有變量;所以,在實際開發中,我們使用arguments可以很方便的獲取到所有的實參,并且也需要對其使用是寫數組的方法

          Array.prototype.slice.call()

          MDN中對于Array.prototype.slice.()的介紹中,提到了類數組對象。以下是原文:slice 方法可以用來將一個類數組(Array-like)對象/集合轉換成一個新數組。你只需將該方法綁定到這個對象上。 一個函數中的 arguments 就是一個類數組對象的例子。

          使用 Array.fill( ) 填充對象的問題

          當你想使用 Array.fill( ) 來填充一個全是空白對象的數組時需要特別注意。Array(length).fill({ }) 這樣填充創建的數組,里面每一項{ }都完全相同

          Array.from() 五個超好用的用途

          任何一種編程語言都具有超出基本用法的功能,它得益于成功的設計和試圖去解決廣泛問題。JavaScript 中有一個這樣的函數: Array.from:允許在 JavaScript 集合(如: 數組、類數組對象、或者是字符串

          es6之Array.from()方法

          Array.from()方法就是將一個類數組對象或者可遍歷對象轉換成一個真正的數組。==只要是部署了Iterator接口==的數據結構,Array.from都能將其轉為數組。

          Js Array對象常用方法

          不改變原數組:concat();join();slice();toString(),改變原數組:pop();push();reverse();shift();unshift();sort();splice(),array.concat(array)連接兩個或多個數組,返回被連接數組的一個副本

          Array.slice 8種不同用法

          在深入研究一些更高級的用法之前,讓我們看一下slice方法的基礎知識。如MDN文檔,slice 是數組上的一個方法,它最多有兩個參數,從該索引處開始提取原數組中的元素,如果該參數為負數,則表示從原數組中的倒數第幾個元素開始提取

          Array數組相關方法

          push向數組末尾添加元素;unshift向數組開頭增加元素;pop刪除數組末尾一項;shift刪除數組的第一項;join為數組添加指定的分隔符;slice找某一區域內的項,返回成新數組形式

          js數組的迭代

          js數組的迭代:forEach() 方法對數組的每個元素執行一次提供的函數。map() 方法創建一個新數組,其結果是該數組中的每個元素都調用一個提供的函數后返回的結果。filter() 方法創建一個新數組, 其包含通過所提供函數實現的測試的所有元素。

          es6之Array.of()和Array.from()

          es6新增了二種方法:Array.of()和Array.from(),它們有什么用途呢?在平時的開發中能給我們帶來什么方便呢?本篇將從一個創建數組的小問題開始,逐步揭開它們的面紗。

          內容以共享、參考、研究為目的,不存在任何商業目的。其版權屬原作者所有,如有侵權或違規,請與小編聯系!情況屬實本人將予以刪除!

          文章投稿關于web前端網站點搜索站長推薦網站地圖站長QQ:522607023

          小程序專欄: 土味情話心理測試腦筋急轉彎幽默笑話段子句子語錄成語大全運營推廣

          国产精品高清视频免费 - 视频 - 在线观看 - 影视资讯 - 唯爱网