Rimuovi proprietà per tutti gli oggetti nell'array

Voglio rimuovere la badproprietà da ogni oggetto nell'array. C'è un modo migliore per farlo che usare un forciclo ed eliminarlo da ogni oggetto?

var array = [{"bad": "something", "good":"something"},{"bad":"something", "good":"something"},...];

for (var i = 0, len = array.length; i < len; i++) {
  delete array[i].bad;
}

Sembra che dovrebbe esserci un modo per usarlo prototype, o qualcosa del genere. Non lo so. Idee?

Gli unici altri modi sono cosmetici e sono in realtà dei loop.

Per esempio :

array.forEach(function(v){ delete v.bad });

Appunti:

• se vuoi essere compatibile con IE8, avresti bisogno di uno spessore per forEach . Mentre parli di prototype, prototype.js ha anche uno shim .
• deleteè uno dei peggiori "killer dell'ottimizzazione" . Usarlo spesso interrompe le prestazioni delle tue applicazioni. Non puoi evitarlo se vuoi davvero rimuovere una proprietà, ma spesso puoi impostare la proprietà undefinedo semplicemente creare nuovi oggetti senza la proprietà.

Con ES6, puoi decostruire ogni oggetto per crearne uno nuovo senza attributi denominati:

const newArray = array.map(({dropAttr1, dropAttr2, ...keepAttrs}) => keepAttrs)

Preferisco usare map per eliminare la proprietà e quindi restituire il nuovo elemento dell'array.

array.map(function(item) { 
    delete item.bad; 
    return item; 
});

Se utilizzi underscore.js :

var strippedRows = _.map(rows, function (row) {
    return _.omit(row, ['bad', 'anotherbad']);
});

Una soluzione che utilizza prototipi è possibile solo quando i tuoi oggetti sono simili:

function Cons(g) { this.good = g; }
Cons.prototype.bad = "something common";
var array = [new Cons("something 1"), new Cons("something 2"), …];

Ma poi è semplice (e O(1)):

delete Cons.prototype.bad;

Secondo me questa è la variante più semplice

array.map(({good}) => ({good}))

Puoi seguire questo, più leggibile, senza aumento delle aspettative a causa della chiave non trovata:

data.map((datum)=>{
                    return {
                        'id':datum.id,
                        'title':datum.login,
                    }

Suggerirò di utilizzare Object.assignall'interno di un forEach()ciclo in modo che gli oggetti vengano copiati e non influisca sulla matrice originale di oggetti

var res = [];
array.forEach(function(item) { 
    var tempItem = Object.assign({}, item);
    delete tempItem.bad; 
    res.push(tempItem);
});
console.log(res);

Questa domanda è un po 'vecchia ora, ma vorrei offrire una soluzione alternativa che non muta i dati di origine e richiede uno sforzo manuale minimo:

function mapOut(sourceObject, removeKeys = []) {
  const sourceKeys = Object.keys(sourceObject);
  const returnKeys = sourceKeys.filter(k => !removeKeys.includes(k));
  let returnObject = {};
  returnKeys.forEach(k => {
    returnObject[k] = sourceObject[k];
  });
  return returnObject;
}

const array = [
  {"bad": "something", "good":"something"},
  {"bad":"something", "good":"something"},
];

const newArray = array.map(obj => mapOut(obj, [ "bad", ]));

È ancora un po 'meno che perfetto, ma mantiene un certo livello di immutabilità e ha la flessibilità di nominare più proprietà che si desidera rimuovere. (Suggerimenti benvenuti)

Ho provato a craking un nuovo oggetto senza eliminare i coulmns in Vue.js.

let data =this.selectedContactsDto[];

// selectedContactsDto [] = oggetto con elenco di oggetti array creati nel mio progetto

console.log (dati); let newDataObj = data.map (({groupsList, customFields, firstname, ... item}) => item); console.log ("newDataObj", newDataObj);

Per rimuovere alcune coppie di valori chiave dall'array di oggetti, utilizza Postgres SQL come database come questo esempio:

Questa è la funzione utente restituisce l'oggetto dettagli utente, dobbiamo rimuovere la chiave "api_secret" dalle righe:

    function getCurrentUser(req, res, next) { // user function
    var userId = res.locals.userId;
    console.log(userId)
    db.runSQLWithParams("select * from users where id = $1", [userId], function(err, rows) {
      if(err){
        console.log(err)
      }
      var responseObject = {
        _embedded: rows,
      }
      responseObject._embedded[0].api_secret = undefined
      // console.log(api);
      // console.log(responseObject);
      res.json(responseObject);
    }); 
}

La funzione precedente restituisce l'oggetto sotto come risposta JSON prima

 {
    "_embedded": [
        {
            "id": "0123abd-345gfhgjf-dajd4456kkdj",
            "secret_key: "secret",
            "email": "abcd@email.com",
            "created": "2020-08-18T00:13:16.077Z"
        }
    ]
}

Dopo aver aggiunto questa riga, responseObject._embedded[0].api_secret = undefinedviene fornito il risultato seguente come risposta JSON:

{
        "_embedded": [
            {
                "id": "0123abd-345gfhgjf-dajd4456kkdj",
                "email": "abcd@email.com",
                "created": "2020-08-18T00:13:16.077Z"
            }
        ]
    }

La via più breve in ES6:

array.forEach(e => {delete e.someKey});