0
votes

Objet concat avec de nouvelles valeurs et transformez-la en tableau

J'ai un tel cas: je pousse à l'objet de nouveaux de la valeur clé code> paires, comme: xxx pré>

et en conséquence, je reçois un nouvel objet valide : {key1: 'val1', clé2: 'val2'} code>. p>

mais il y a un troisième cas: p>

const keysToPush = Object.keys(b1);
const keysInitial = Object.keys(a1); // foreach too
if (keysInitial.includes(keysToPush)) // push as array

javascript typescript object arrays ecmascript-6

5 commentaires

La solution élégante écrit une fonction pour faire ce que vous dites est la partie laide. Ensuite, vous pouvez appeler addoObject (A1, B1);


                                        
                                                                            Et si vous avez  B1 = {Key1: 'val1'}; ? Voulez-vous toujours vouloir un tableau dans ce cas?

                                        
                                                                            @Trincot - Non, une seule clé: pièce de valeur.
                                        
                                                                            Donc, cela signifie que vous ne voulez pas un tableau avec des valeurs en double, uniquement les uniques?
                                        
                                                                            @Trincot correct.



                                    
                    4 Réponses :
                    
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Vous devez regarder chaque propriété et décider si d'affecter ou de convertir en tableau et de pousser la valeur. 
  p> 


const
    migrate = (target, source) => {
        Object.keys(source).forEach(key => {
            if ([].concat(target[key] || []).includes(source[key])) return;
            if (key in target) {
                if (!Array.isArray(target[key])) target[key] = [target[key]];
                target[key].push(source[key]);
            } else {
                target[key] = source[key];
            }
        });
        return target;
    };

var a1 = { key1: 'val1' },
    a2 = { key2: 'val2' },
    b1 = { key1: 'val1b' },
    b2 = { key1: 'val1b' },
    result = [a1, a2, b1, b2].reduce(migrate, {});

console.log(result);

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Vous pouvez créer une fonction pour fusionner des objets. Les étapes de la solution sont les suivantes: 

 Créez une fonction qui accepte un nombre quelconque d'objets à l'aide des paramètres de repos  li>
 Créez un objet vide qui sera le résultat.  Li>
 boucle en boucle en profondeur tous les objets en utilisant  foreach  code>. Intérieur  foreach  code> Créer un autre  foreach  code> pour boucler via des entrées de l'objet.  Li>
  Vérifiez si la clé existe déjà en résultat obj.  p>


  Vérifiez si ses valeurs sont une matrice, appuyez une nouvelle valeur à celle-ci.  P>  LI>
  Si son tableau n'est pas simplement la convertir en tableau de deux valeurs  p>  li>
 ul>  li>
 Si la clé n'existe pas qui l'ajoutez normalement en tant que clé de l'objet.  LI>
 ul>   p> 


function mergeObjs(...objs){
  const res = {};
  objs.forEach(x => {
    Object.entries(x).forEach(([k,v]) => {
      if(res[k]){
        if(Array.isArray(res[k])) res[k].push(v)
        else res[k] = [res[k],v]
      }
      else res[k] = v;
    })
  })
  return res;
}

let a1 = {key1: 'val1'};
let a2 = {key2: 'val2'};
let b1 = {key1: 'val1b'};

console.log(mergeObjs(a1,a2,b1))

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Vérifiez si la clé existe. Si tel est le cas, vérifiez s'il s'agit d'une matrice et gérez chaque cas en conséquence: 
  p> 


.as-console-wrapper {
  max-height: 100% !important;
  top: auto;
}

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Je suggérerais l'utilisation de  mappe  code> (pour les touches) de  définir  code> (pour les valeurs par touche), comme le verbe  code> sera Assurez-vous qu'aucune valeur en double. À la fin du processus, la carte   code> peut être convertie en un objet uni et le  définir  code> sur une seule valeur ou une matrice de valeurs: 
  p > 


// Sample input with some repetition:
const objects = [
    { key1: 'val1' },
    { key2: 'val2' },
    { key1: 'val1b' },
    { key2: 'val2' },
    { key1: 'val1b' }
];

const pairs = objects.flatMap(Object.entries);
const map = new Map(pairs.map(([k]) => [k, new Set]));
pairs.forEach(([k, v]) => map.get(k).add(v));
const result = Object.fromEntries(Array.from(map, ([k, set]) => 
   set.size < 2 ? [k, ...set] : [k, [...set]]
));

console.log(result);

                                

                                                                    
                                    
                                    
                                        0 commentaires