JavaScriptの行列でよく使われる反復方法

7790 ワード

1.forEach():各配列の要素に一回のコールバック関数を実行させる
2.map():コールバック関数の戻り値からなる新しい配列を返します.
3.filter():配列中のフィルタ条件に適合する要素からなる新しい配列を返します.
4.find():最初の配列内のフィルタ条件に合致する要素を返し、undefinedに戻ることができません.
5.findIndex():最初の配列でフィルタ条件に一致する要素のインデックス値を返し、戻り値が見つからない-1
6.every():配列の各要素が条件に合っているかどうかを確認すると、trueに戻ります.逆にfalseを返します
7.some():配列が少なくとも一つの要素で条件に合っているかどうかを確認すると、trueに戻ります.すべての要素が条件に合わない場合、falseを返します.
8.reduce():行列に戻る前項と後件がある計算をした後、累計した値
1.forEach():各配列の要素に一回のコールバック関数を実行させる
    /**
    *  :forEach
    *  :                 
    *  :arr.forEach(callback(currentValue[, index[,array]])[, thisArg])
    *  :
    *     callback           ,      
    *     currentValue                
    *     index                  
    *     array    forEach()         
    *     thisA             callback ,  this  
    *   :undefined
    *  :forEach         ,          
    *     
    */ 

    const arr = ['a', 'b', 'c'];
    arr.forEach(function(e){
      console.log(e)
    })
    // "a"
    // "b"
    // "c"

    const arr = [1,3,7]
    let numAll = 0;
    arr.forEach(function(e){
      numAll += e 
    })
    console.log(numAll)
    // 11
2.map():コールバック関数の戻り値からなる新しい配列を返します.
    /**
    *  :map
    *  :                   
    *  :var new_array = arr.map(function callback(currentValue[, index[, array]]) {
    *             // Return element for new_array 
    *     }[, thisArg])
    *  :
    *     callback             
    *     currentValue             
    *     index                  
    *     array    map          
    *     thisA        callback   ,  this
    *   :                         
    *  :map       
    *              
    */ 

    //         2,      
    const arr =[1,4,9,16]
    const arr1 = arr.map(x => x *2)
    console.log(arr1)
    // [2, 8, 18, 32]

    //            
    var numbers = [1,4,9]
    var roots = numbers.map(Math.sqrt) 
    console.log(roots)
    // [1,2,3]
3.filter():配列中のフィルタ条件に適合する要素からなる新しい配列を返します.

    /**
    *  :filter
    *  :                       
    *  :var newArray = arr.filter(callback(currentValue[, index[, array]])[, thisArg])
    *  :
    *     callback             
    *     currentValue             
    *     index                  
    *     array    filter          
    *     thisArg        callback   ,  this
    *   :                       ,        ,      
    *  :filter       
    *                  
    */ 

    //          6          
    const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present']
    const result = words .filter(word => word.length > 6)

    console.log(result)
    // ["exuberant", "destruction", "present"]
    
    var fruits =  ['apple', 'banana', 'grapes', 'mango', 'orange'];
    function filterItems(query){
      return fruits.filter(function(e){
        //                  (  )              
        //    indexOf    -1
        return e.toLowerCase().indexOf(query.toLowerCase()) > -1;
      })
    }

    console.log(filterItems('AP'))
    console.log(filterItems('aN'))
    // ["apple", "grapes"]
    // ["banana", "mango", "orange"]
4.find():最初の配列内のフィルタ条件に合致する要素を返し、undefinedに戻ることができません.
    /**
    *  :find
    *  :                     ,     undefined
    *  :arr.find(callback(currentValue[, index[, array]])[, thisArg])
    *  :
    *     callback             
    *     currentValue             
    *     index                  
    *     array    find          
    *     thisArg        callback   ,  this
    *   :                     ,     undefined
    *  :find       
    *                  
    */ 

    const arr =  [5, 12, 8, 130, 44];
    const arr1 = arr.find(element => element > 10)
    const arr2 = arr.find(element => element > 500)
    console.log(arr)
    console.log(arr1)
    console.log(arr2)
    // [5, 12, 8, 130, 44];
    // 12
    // undefined

    var inventory =  [
      {name: 'apples', quantity: 2},
      {name: 'bananas', quantity: 0},
      {name: 'cherries', quantity: 5}
    ];

    function findItem(query){
      return query.name = 'apples'
    }

    console.log(inventory.find(findItem))
    console.log(inventory.find(e => e.name = 'apples'))
    // {name: "apples", quantity: 2}
    // {name: "apples", quantity: 2}
5.findIndex():最初の配列でフィルタ条件に一致する要素のインデックス値を返し、戻り値が見つからない-1
    /**
    *  :findIndex
    *  :                         ,     -1
    *  :arr.findIndex(callback(currentValue[, index[, array]])[, thisArg])
    *  :
    *     callback             
    *     currentValue             
    *     index                  
    *     array    findIndex          
    *     thisArg        callback   ,  this
    *   :                     ,     undefined
    *  :findIndex       
    *                    
    */ 

    const arr =  [5, 12, 8, 130, 44];
    const arr1 = arr.findIndex(element => element > 10)
    const arr2 = arr.findIndex(element => element > 500)
    console.log(arr)
    console.log(arr1)
    console.log(arr2)
    // [5, 12, 8, 130, 44];
    // 1
    // -1
6.every():配列の各要素が条件に合っているかどうかを確認すると、trueに戻ります.逆にfalseを返します
    /**
    *  :every
    *  :                ,   true。    false
    *  :arr.every(callback(currentValue[, index[, array]])[, thisArg])
    *  :
    *     callback             
    *     currentValue             
    *     index                  
    *     array    every          
    *     thisArg        callback   ,  this
    *   :                     ,     undefined
    *  :every       
    *                
    */ 

    const arr =  [1, 30, 39, 29, 10, 13];
    const arr1 = arr.every(element => element > 0)
    const arr2 = arr.every(element => element > 10)
    console.log(arr)
    console.log(arr1)
    console.log(arr2)
    // [5, 12, 8, 130, 44];
    // true
    // false
7.some():配列が少なくとも一つの要素で条件に合っているかどうかを確認すると、trueに戻ります.すべての要素が条件に合わない場合、falseを返します.

    /**
    *  :some
    *  :                 ,   true。           ,   false
    *  :arr.every(callback(currentValue[, index[, array]])[, thisArg])
    *  :
    *     callback             
    *     currentValue             
    *     index                  
    *     array    some          
    *     thisArg        callback   ,  this
    *   :                     ,     undefined
    *  :some       
    *                
    */ 

    const arr =  [1, 30, 39, 29, 10, 13];
    const arr1 = arr.some(element => element > 0)
    const arr2 = arr.some(element => element > 10)
    console.log(arr)
    console.log(arr1)
    console.log(arr2)
    // [5, 12, 8, 130, 44];
    // true
    // true
8.reduce():行列に戻る前項と後件がある計算をした後、累計した値
    /**
    *  :reduce
    *  :                     
    *  :arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
    *  :
    *     callback             
    *     accumulator            
    *     currentValue             
    *     index                  
    *     array    reduce          
    *     initialValue         callback           。 
    *                           ,             。 
    *                                reduce    。
    *   :         
    *  :reduce       
    *                
    */ 

    const arr = [1,2,3,4]
    const arr1 = arr.reduce((el1,el2) => el1 + el2)
    const arr2 = arr.reduce((el1,el2) => el1 * el2)
    console.log(arr)
    console.log(arr2)
    // [1,2,3,4]
    // 10
    // 24