J'ai deux tableaux d'objets avec name value et id

Tableau A

ArrayA:  [{
    name: ,
    value: ,
    key: 
},
];

J'ai un autre tableau d'objets mais avec des noms de propriétés différents

ArrayB:  [{
    user: “userA” ,
    email: “emailA”,
    key:1: 
},
{
    user: “userB” ,
    email: “emailB”,
    key: 
},
];

Maintenant, je veux que ArrayA aura les valeurs de ArrayB. Je veux dire utilisateur => nom et e-mail => valeur

ArrayA doit avoir les entrées suivantes

  ArrayA:  [{
        name: “userA” ,
        value: “emailA”,
        key: 1
    },
        name: “userB” ,
        value: “emailB”,
        key: 1
    ]

J'ai essayé d'utiliser map mais sans succès, une idée de ce qui me manque ici?

ArrayA = ArrayB.map(((item: { name: string; value: string }) => (item.user, item.email))

Je peux utiliser une boucle, y a-t-il une meilleure façon d'y parvenir?

Dois-je utiliser du lodash?

0
Beno Odr 14 juin 2020 à 14:15

5 réponses

Meilleure réponse

Je pense que ArrayA est inutile ici, Vous pouvez simplement utiliser map() sur ArrayB et renvoyer le tableau avec les propriétés dont vous avez besoin.

const ArrayB = [
  {
    user: "dani" ,
    email: "dani@gmail.com",
    key:1 
  },
  {
    user: "john" ,
    email: "john@gmail.com",
    key:2
  }
]

const res = ArrayB.map(({ user, email, key }) => ({
  name: user,
  value: email,
  key 
}));

console.log(res);
3
zb22 14 juin 2020 à 12:08

Vous devez utiliser la Array concat () Méthode.

let ArrayA = [
    {
        name: 'name1',
        value: '22',
        key: 5,
    },
];

let ArrayB = [
    {
        name: 'name2',
        value: '33',
        key: 6,
    },
];

let ArrayC = ArrayA.concat(ArrayB);

let ArrayD = ArrayA.concat([{ name: 'name2' }, { value: '33' }, { key: 6 }]);


console.log(ArrayC);
console.log(ArrayA);
console.log(ArrayD); //ref sreenshot

Array

Vous ne pouvez pas avoir d'éléments dans le tableau directement comme ce que vous avez spécifié, ils ont besoin d'un objet pour avoir une relation clé-valeur

1
tHeSiD 14 juin 2020 à 11:29

Vous pouvez renommer la clé en maintenant un object. Quelque chose comme ça:

var obj={ user:'name', email:'value', key:'key' };
var arrayA=[{name:'somevalue', value:'somevalue', key:''}];
var arrayB= [{ user: 'userA' , email: 'emailA', key:'1' }, { user: 'userB' , email: 'emailB', key:'' }];

arrayA = [...arrayA, ...arrayB.map(k=>Object.fromEntries(Object.entries(k).map(([key,v])=>[obj[key],v])))];

console.log(arrayA)
1
gorak 14 juin 2020 à 11:33

Il est préférable d'utiliser l'opérateur de propagation et la carte:

const result = [...ArrayA, ...ArrayB.map(({ key, user, email }) => ({ key, name: user, value: email }))]
1
Yuriy Naydenov 14 juin 2020 à 11:29

En fonction de la taille de ces objets avoir un moyen de traduction pourrait être agréable.

Le vieux JavaScript simple avec Object.fromEntries a une solution. https://developer.mozilla.org/ fr-FR / docs / Web / JavaScript / Reference / Global_Objects / Object / fromEntries

objA = {
    name: 'user',
    value: 'email',
    key: 1
};

objB = {
    user: 'user',
    email: 'email',
    key: 1
};

function translate(object) {
    return Object.fromEntries(
        Object.entries(objB)
            .map(([key, value]) => {
                let newKey;
                switch(key) {
                    case 'user':
                        newKey = 'name';
                        break;
                    case 'value':
                        newKey = 'email';
                        break;
                    default:
                        newKey = key;
                }
                return [newKey, value];
            })
    );
}

const originalObject = Object.fromEntries(Object.entries(objB));
const newObject = translate(originalObject);

console.log(originalObject);
console.log(newObject);

Avec une sortie de:

{ user: 'user', email: 'email', key: 1 }
{ name: 'user', email: 'email', key: 1 }

Vous pouvez mapper les tableaux avec la fonction comme vous l'avez fait dans votre solution.

1
Seth 14 juin 2020 à 11:52