Usuń właściwość dla wszystkich obiektów w tablicy

Chcę usunąć badwłaściwość z każdego obiektu w tablicy. Czy jest na to lepszy sposób niż użycie forpętli i usunięcie jej z każdego obiektu?

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

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

Wygląda na to, że powinien być sposób użycia prototype, czy coś. Nie wiem Pomysły?

Jedyne inne sposoby są kosmetyczne i są faktycznie pętlami.

Na przykład :

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

Uwagi:

• jeśli chcesz być kompatybilny z IE8, potrzebujesz podkładki forEach . Jak wspomniałeś o prototypie, prototype.js również ma podkładkę .
• deletejest jednym z najgorszych „zabójców optymalizacji” . Używanie go często obniża wydajność aplikacji. Nie możesz tego uniknąć, jeśli naprawdę chcesz usunąć właściwość, ale często możesz ustawić właściwość na undefinedlub po prostu zbudować nowe obiekty bez właściwości.

W ES6 możesz zdekonstruować każdy obiekt, aby utworzyć nowy bez nazwanych atrybutów:

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

Wolę używać map, aby usunąć właściwość, a następnie zwrócić nowy element tablicy.

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

Jeśli używasz underscore.js :

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

Rozwiązanie wykorzystujące prototypy jest możliwe tylko wtedy, gdy Twoje obiekty są podobne:

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

Ale potem jest to proste (i O(1)):

delete Cons.prototype.bad;

Moim zdaniem to najprostszy wariant

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

Możesz śledzić to, bardziej czytelne, a nie oczekiwane zwiększenie z powodu nieznalezionego klucza:

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

Zasugeruję użycie Object.assignw forEach()pętli, aby obiekty były kopiowane i nie wpływały na oryginalną tablicę obiektów

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

To pytanie jest teraz trochę stare, ale chciałbym zaoferować alternatywne rozwiązanie, które nie powoduje mutacji danych źródłowych i wymaga minimalnego wysiłku ręcznego:

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", ]));

Nadal jest trochę mniej niż doskonały, ale zachowuje pewien poziom niezmienności i ma elastyczność umożliwiającą nazwanie wielu właściwości, które chcesz usunąć. (Mile widziane sugestie)

próbowałem z craetingiem nowego obiektu bez usuwania coulmns w Vue.js.

let data =this.selectedContactsDto[];

// selectedContactsDto [] = obiekt z listą obiektów tablicy utworzonych w moim projekcie

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

Aby usunąć parę klucz-wartość z tablicy obiektów, użyj Postgres SQL jako bazy danych, jak w tym przykładzie:

To jest obiekt szczegółów użytkownika zwracający funkcję użytkownika, musimy usunąć klucz "api_secret" z wierszy:

    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);
    }); 
}

Powyższa funkcja zwraca poniżej obiekt jako odpowiedź JSON wcześniej

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

Po dodaniu tej linii responseObject._embedded[0].api_secret = undefineddaje poniższy wynik jako odpowiedź JSON:

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

Najkrótsza droga w ES6:

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

Istnieje wiele bibliotek. Wszystko zależy od tego, jak skomplikowana jest struktura danych (np. Rozważ głęboko zagnieżdżone klucze)

Lubimy pola obiektowe, ponieważ działa również z głęboko zagnieżdżonymi hierarchiami (parametr budowania dla pól API). Oto prosty przykład kodu

// const objectFields = require('object-fields');

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

const retain = objectFields.Retainer(['good']);
retain(array);
console.log(array);
// => [ { good: 'something' }, { good: 'something' } ]

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

<script src="https://bundle.run/object-fields@2.0.19"></script>

Zastrzeżenie : jestem autorem pól obiektowych

ES6:

const newArray = array.map(({keepAttr1, keepAttr2}) => ({keepAttr1, newPropName: keepAttr2}))