JS中數組那些事~

阿新 • • 發佈：2017-12-06

man ice 數組求和尾刪 log var lte 數組 style

　　今天閑的沒事，看了一些關於數組的操作，好久木有用過，很多都已經忘記的差不多了，所以今天花了一個小時寫了一些demo，準備備份一下方便以後使用~~~

　　下面是一些工作當中，經常用到的數組的方法，小夥伴可以自行選擇自己的喜好~~~

<!DOCTYPE html>
<html>
<head>
    <title>array</title>
</head>
<body>
    
</body>
<script type="text/javascript">
    
    var 
            arr   
= [1,2,3,4,5],
            arr1 = [10,4,5,2,8,99];
            
            /*
                A instanceof B
                A是不是B造出來的
             */
            console.log(arr instanceof Array)  //true

            /*
                Array.isArray(a)
                變量a是否是數組
             */
            console.log(Array.isArray(arr))     
//true
            console.log(Array.isArray(2))      //false

            /*
                toString()
                數組轉為字符串，用“ ， ”鏈接;
                join也能達到這種效果
             */
            console.log(arr.toString())

            /*
                數組.join(‘符號‘)
                將數組以符號鏈接形成字符串
              
*/
             console.log(arr.join(‘$‘))
             console.log(arr.join(‘ ‘))


            /* push  在數組末尾添加
               pop   在數組末尾刪除
            */
            arr.push(‘paoAfter‘)
            console.log(arr);
            arr.pop()
            console.log(arr);

            /* unshift  在數組最前面添加
               shift   在數組最前面刪除
            */
          arr.unshift(‘paoUnshift‘)
          console.log(arr)
          arr.shift()
          console.log(arr)


          /* 數組的排序 */
          /*
              reverse
              數組翻轉
           */
          console.log(arr.reverse())

          /*
              sort()  ????
              數組排序，從小到大
           */
           console.log(arr.sort())

           //利用回調函數對數組大小進行排序
           arr1.sort(function (a,b) {
                   return a - b;
           })
           console.log(arr1)


           /* 數組元素的操作 */
           /*
                   數組1.concat(數組2)
                   拼接兩個數組
            */
           console.log(arr.concat(arr1))
           //數組去重1：
           Array.prototype.arrUnique = function () {
               // 先排序
               this.sort();
               // 定義一個新數組從排序後的數組的第一個開始接收值
               var arr = [this[0]];
               // 從第二個數值開始比較
               for (var i = 1; i < this.length; i++) {
                   //比較相鄰的值不一樣時，新數組接收值，達到去重效果
                   //原數組的第一個與新數組的最後一個相比較
                   if( this[i] !== arr[arr.length - 1]) {
                       arr.push(this[i])
                   }
               }
               return arr;
           }

           var arrnew = arr.concat(arr1).arrUnique()
           console.log(arrnew)


           // 數組去重2
           var r=[],
                    arr = [‘apple‘, ‘strawberry‘, ‘banana‘, ‘pear‘, ‘apple‘, ‘orange‘, ‘orange‘, ‘strawberry‘];
                for(var i=0,len=arr.length;i<len;i++){
                    //如果新的數組中找不到arr數組中的元素，將數組元素存放在新數組中
                    if(r.indexOf(arr[i])===-1){
                        r.push(arr[i]);
                    }
                }

           /*
               slice 數組的截取
               數組.slice(開始的索引，結束的索引)
            */
           console.log(arr.slice(3))     //從索引值為3截取到最後
           console.log(arr.slice(0,3))   //從索引值為1到3截取
           console.log(arr.slice(-2))   //負數後幾個

           /*
               數組.splice (開始索引值，刪除幾個，替換內容1，替換內容2，....)
               同slice有點雷同
            */
           console.log(arr.splice(3))     //從索引值為3截取到最後
           console.log(arr)

           console.log(arr.splice(0,3))   //從索引為0開始刪除3個
           console.log(arr)

           console.log(arr1)
           console.log(arr1.splice(1,2,‘a‘,‘b‘)) //從索引為1開始刪除2個，並用‘a’，‘b’替換刪除的內容
           console.log(arr1)

           /*
               數組.indexOf(元素)   （從左往右）
                數組中是否包含元素，如果包含，返回對應的索引；如果不包含，返回-1

                數組.lastIndexOf(元素)   （從右往左）
            */
               console.log(arr1.indexOf(2))   //index：0
            console.log(arr1.indexOf(990))   //-1；查不到


            console.log(arr1.lastIndexOf(2))   //index：0
            console.log(arr1.lastIndexOf(990))   //-1；查不到



            /*  數組叠代 */
            /*
                數組.map(function (item,index,array) { return newArr})
             */
                    var sporter =[{
                                                    name:‘aa‘,
                                                    isHell:null
                                                    },{
                                                    name:‘bb‘,
                                                    isHell:null
                                                    },{
                                                    name:‘cc‘,
                                                    isHell:true
                                                }];
                    var arr2 = [];
                    sporter.map(function (item,index,array) {
                        if ( item.isHell ) {
                            arr2.push(item.name);
                        }
                    })
                console.log(arr2)
                // es6寫法
                sporter.map( item => { 
                    if ( item.isHell ) {
                            arr2.push(item.name);
                        }
                })
                console.log(arr2)

                /*
                數組.filter(function (item,index,array) { return newArr})
                返回符合條件的元素為true的數組
             */
            var arr = sporter.filter( item => {return item.isHell});
            console.log(arr)

            var arr = sporter.filter( item =>  item.isHell);
            console.log(arr)

            console.log(‘-1‘ == false)  //false

            // 數組去重3
            var 
                    arr3 = [1,2,3,2,3,5,6,6];

            var arr  =    arr3.filter(function(item,index,self) {
                    console.log(item+‘----------------‘+self)
                        return self.indexOf(item) == index;
                    });
            console.log(arr)

            /*
                every()
                    數組中的每一項運行給定函數，如果該函數對每一項都返回true，則返回true ;

                some()
                對數組中的每一項運行給定函數，如果該函數對任一項返回true，則返回true;
             */
            var arr = sporter.every(function (item) {
                return item.isHell;
            })
            console.log(arr)

            var arr = sporter.some(function (item) {
                return item.isHell;
            })
            console.log(arr)

            /*
                forEach()
                和for循環一樣，沒有返回值
             */
            var arr = sporter.forEach(function(item) {
                item.sex = ‘man‘
            })
            console.log(arr)   //因為forEach沒有返回值，所以是undefined

            /*
                數組.redval(a,b)
                這個方法一般用在累計累加上，實用技巧暫時還沒發現。比如，數字數組求和，字符串數組連接上
             */
            // 數組求和，數組的拼接
            var sum=0,arr=[1,2,3,4,5,6];
            sum = arr.reduce(function (a,b) {
                return a + b;
            })

            /*
                數組.find(val)
                方法返回傳入一個測試條件（函數）符合條件的數組第一個元素。
             */
            var 
                    arr4 = [1,2,3,4];
            var a    = arr4.find(function(val){
                        return val > 2;
                    })
                    console.log(a)

           /*
            
                   數組.findIndex(val)
                    findIndex：方法返回傳入一個測試條件（函數）符合條件的數組第一個元素位置。
                    如果不存在，則返回-1；如果存在滿足條件的，返回符合條件的第一個索引；
            */
           var a = arr4.findIndex(function(val) {
                   return val > 4;
           })
           console.log(a) //-1



           /* 數組的清空 */
           var arr5 = [‘a‘,‘b‘,‘c‘,1];
           arr5.length = 0;  //偽數組無法清空
           console.log(arr5)

           arr5.splice(0);  //從索引為0開始截取到最後一個，偽數組無法清空
           console.log(arr5);

           arr5 = [];   //推薦使用，偽數組可用

           // 偽數組：就是長的像數組，不過沒有數組的方法，不能添加刪除元素
           fn(111,222,333);
           function fn() {
               arguments.length = 0; //無法清空
               console.log(arguments);

               arguments.splice(0)
               console.log(arguments);  //報錯

               arguments = []
               console.log(arguments)
           }

</script>
</html>

好啦，有需要了解的

JS中數組那些事~

man ice 數組求和尾刪 log var lte 數組 style 　　今天閑的沒事，看了一些關於數組的操作，好久木有用過，很多都已經忘記的差不多了，所以今天花了一個小時寫了一些demo，準備備份一下方便以後使用~~~ 　　下面是一些工作當中，經常用到的數組的方法，小

JS中數組和對象的區別

src 區別 nbsp log 對象 img images image ima JS中數組和對象的區別

關於JS中數組的分析操作

cti 3.5 ++ index 方法基礎 javascrip als length 　JS數組的基礎操作代碼：　 <script type="text/javascript"> 數組的三種定義 var arr1 = new Array()

js中數組對象字符串的相互轉換

獲取 login 字符接收當前 gif lar value 數組 js中數組對象字符串的相互轉換對象-數組-字符串：　　　　例如：　　var data = { user:”userName”, 　　pass:”12121” 　

JS中數組的叠代方法和歸並方法

*** 數組a 昨天二次 ever 所有 href clas item 昨天總結的JavaScript中的數組Array方法數組的叠代方法 ES5中為數組定義了5個叠代方法。每個方法都要接收兩個參數：要在每一項上面運行的函數和（可選的）運行該函數的作用域對象---影響t

關於js中數組方法總結

filter foreach 默認 tin ffffff 關於調用 index reducer 數組在筆試中經常會出現的面試題，javascript中的數組與其他語言中的數組有些不同，為了方便之後數組的方法學習，整理了關於數組的操作方法數組創建 JavaScript中創

js中數組的增刪改查

tro ear get slice tel tle 歷史 click demo 1 slice選取數組的的一部分，並返回一個新數組 <!DOCTYPE html> <html> <head> <meta charset="

js中數組常用方法總結

dds 設置布爾 nsh border 方式 cal AR 操作數前言從事前端到現在也有快兩年了，平時也會收集整理一些筆記放在印象筆記，不過收集過之後就在沒有看過，經大佬指點，真正掌握一個知識點，最好的方式就是用自己的話把內容講明白，就開始將以前零散的東西整合一下，和

JS 中數組字符串索引和數值索引研究

組成 ava RF 分享 style spa 這樣的使用字符串 alt 　　先來看一個問題： var array = []; array["a"] = "hello"; array["b"] = "world"; array["c"] = "yes"; console.

js中數組相關的Api

lte 圖片技術 api 多說怎麽 TE In 分享圖片話不多說，直接上圖，一眼便知道怎麽回事！！！ forEach every some sort map filter js中數組相關的Api

js中數組和對象的遍歷的簡單總結(ES6)

遍歷數組 key watermark fff trie sha tex mar title 在ES6中，對於數組的遍歷提供了3個方法keys() values() entries() 用於遍歷數組的key value 例如:對於對象的遍歷js中數組和對象的遍歷的簡單總結(E

JS中數組方法的封裝之slice

n) 功能 urn new ice this 三目運算符 fun 負數 slice方法的功能 // 1) : 數組的截取 // 2) :slice(m,n): 從數組索引m開始，截取到索引n，但是不包含n;[前包後不包] // slice(m) : 從索引m開始，截取到末尾

JS中數組去重的五種方法

func 大量環比 -- war 重新 pan 選擇 nbsp 數組去重方法方法一:運用splice()方法和雙層for循環（有點類似選擇排序） function norepeat(arr){

js中數組API以及ES6總結

es6 換行箭頭 isa new 下標 array 不改變當前 1. 數組API2. ES6: 1. 數組API: 遍歷: 對數組中每個元素執行相同的操作 arr.forEach(): 對原數組中每個元素執行相同的操作 arr.forEach(function

JS中數組的一些筆記

原來就是 pre 一次一個浪費個數 array push 今天工作時碰到一個需求，有兩個數組arrayChild, arrayFather, 要求： 1、往數組arrayChild中放入一個元素； 2、將當前的數組arrayChild放入arrayFather中；

js 中數組和字符串之間的轉換

array nbsp arr 數組 clas pan -c spa var var abc = new Array(a,b,c,d,e); abc.join(‘-‘) // 結果 : a-b-c-d-e-f var obk = ‘a-b-c-d-e‘; obk.

js中數組的操作方法

構造函數方法刪除數組元素 shift nsh 接受 ons 更新 strong 今天給大家帶來一篇有關數組操作方法的文章。新建數組方法一：通過new運算符創建一個數組構造函數。 var arr = new Array(); 方法二：通過方括號直接創建直接量

JS中數組的去重

元素 put 自己 js數組 ica get rom 一個數方法記一道JS數組去重題前言，有一次去面試，面試官問我一個數組去重題。有哪些方法可以實現。當時第一反應是hash去重，第一個想法是自己去實現去重算法，（太弱了）。 ES6中的Set類不過在ES6中新加的S

js從數組中隨機獲取n個不重復的數據

課堂 || 不重復 function return func () 思路 != 做雲課堂的作業時遇到一要求，實現刷新頁面時顯示不同數據，（數組中20個據，頁面加載10個）。思路就是從0-19中隨機生成10個不同的數，讓數組取下標輸出數據。下面是在num的範圍內生成n個不重

js 刪除數組中多個元素

true arr return contain index var nbsp log dex js中如果使用forEach的話 , splice刪除的時候會導致js的數組的length發生改變 , 因此會出現本應該刪除的元素沒有被刪除 . 因此 , 我的想法是 : 使用i

JS中數組那些事~

相關推薦