9
votes

Array.Map Vous voulez mapper une valeur pour rien

J'ai le tableau: [1,2,3,4,5,6,7] code>

Je veux atteindre: [[1,2], [3 , 4], [5,6], [7]] code> P>

Je pense que je pense que cela ne semble pas ne pas être capable de ne rien planer pour un élément? P>

J'ai (Utilisation de sous-traitants): P>

arr.map(function(el, idx, arr) {
  if (idx%2 != 0) return null;
  if (idx == arr.length-1) return [el];
  return [el, arr[idx+1]]
}).compact();

javascript functional-programming map-function

1 commentaires

Pouvez-vous partager ce que vous avez essayé jusqu'à présent? Aussi, vous ne pouvez pas éviter les boucles. array.map créera également une boucle. Sa juste approche plus propre.



                                    
                    6 Réponses :
                    
                                            
                            
                                
                                    6
 votes
                                
                            
                            
                                
                                     the   mappe  code> fonction  peut ' T Faites cela, c'est une transformation de conservation de la structure. 
 Vous pouvez écrire ce "chunking" en tant que  Réduire  code>, une boucle simple, ou quelque chose d'étrange comme  p>  xxx  Pré> 
 ou  p> 
return arr.map(function(_, i) {
    return arr.slice(i, 2);
}).filter(function(_, i) {
    return i%2==0;
})

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                     Essayez une combinaison de carte et filtre 
var output = [1,2,3,4,5,6,7].map(function(value,index,arr){
   if(index%2==0)
   {
     //return [value, arr[index+1]];
     return index + 1 < arr.length ? [value, arr[index+1] ] : [ value ];
   }
   else
   { 
     return false;
   }
}).filter(function(value){return value});
console.log(output);

                                

                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Donne l'index hors de la liaison :)                                                
                                                
                                                                                            
                                                    @Charlesw. Essayez maintenant                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    6
 votes
                                
                            
                            
                                
                                      Réduire  code> Le tableau à l'aide de l'opérateur MODULO: 
function chunk(arr, n) {
  return arr.reduce(function (p, c, i) {
    if (i % n === 0) p.push([]);
    p[p.length - 1].push(c);
    return p;
  }, []);
}

chunk(arr, 2); // [[1,2],[3,4],[5,6],[7]]

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    C'est un peu ce que je cherche. Merci                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                     Tu ne peux pas juste faire quelque chose comme ça? 
 édité pour empêcher la modification d'origine, selon la suggestion de Andy  P> 
var temp = original.slice();
var newList = [];
while(temp.length)
{
    newList.push(temp.splice(0,2));
}

                                

                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Cela pourrait être mieux qu'il n'a pas détruit le tableau d'origine. Peut-être cloner d'abord avec  var caray2 = array.slice (0); .                                                

                                                
                                                                                            
                                                    1) Je ne t'ai pas répondu. 2) Je faisais juste une suggestion.                                                
                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    4
 votes
                                
                            
                            
                                
                                     Une solution de plus filaire en une boucle. 
  p> 


function due(array) {
    return array.length && [array.splice(0, 2)].concat(due(array)) || [];
}

var array = [1, 2, 3, 4, 5, 6, 7],
    result = due(array.slice());

document.write('<pre>' + JSON.stringify(result, 0, 4) + '</pre>');

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Superbe réponse spécialement  dû () , mais il changera la matrice d'origine. Je suggérerais d'utiliser  array.slice ()  à la place, mais je suppose que la récursion ne fonctionnera pas.                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Vous pouvez essayer  array.slice ()  code> et tout en boucle pour cela. 
 Aussi à l'aide de la fonction comme  mappe  code>,  filtre  code> va-t-on tous les éléments.  p> 
  p> 


function splitArrayInLength(arr, len) {
  var returnArr = [];
  var index = 0;
  while(index < arr.length){
    returnArr.push(arr.slice(index, index + len));
    index += len;
  }
  return returnArr;
}

function main() {
  var arr = [1, 2, 3, 4, 5, 6, 7];
  print(splitArrayInLength(arr, 2));
  print(splitArrayInLength(arr, 4));
}

function print(obj){
  document.write("<pre>" + JSON.stringify(obj, 0, 4) + "</pre><br/>");
}

main();

                                

                                                                    
                                    
                                    
                                        0 commentaires