Mam obiekt z kilkoma właściwościami. Chciałbym usunąć wszystkie właściwości, które mają fałszywe wartości.

Można to osiągnąć za compactpomocą tablic, ale co z obiektami?

Możesz stworzyć własną wtyczkę podkreślenia (mixin):

_.mixin({
  compactObject: function(o) {
    _.each(o, function(v, k) {
      if(!v) {
        delete o[k];
      }
    });
    return o;
  }
});

A potem użyj go jako natywnej metody podkreślenia:

var o = _.compactObject({
  foo: 'bar',
  a: 0,
  b: false,
  c: '',
  d: null,
  e: undefined
});

Aktualizacja

Jak zauważył @AndreiNeculau , ta mieszanka wpływa na oryginalny obiekt, podczas gdy oryginalna metoda podkreślenia zwraca kopię tablicy . Aby rozwiązać ten problem i sprawić, by nasz zachowywał się bardziej jak kuzyn , oto drobna aktualizacja:compact
compactObject

_.mixin({
  compactObject : function(o) {
     var clone = _.clone(o);
     _.each(clone, function(v, k) {
       if(!v) {
         delete clone[k];
       }
     });
     return clone;
  }
});

Od wersji Underscore 1.7.0 możesz używać _.pick:

_.pick(sourceObj, _.identity)

Wyjaśnienie

Drugi parametr _.pickmoże być funkcją predykatu do wybierania wartości. Wartości, dla których predykat zwraca prawdę, są wybierane, a wartości, dla których predykat zwraca fałsz, są ignorowane.

pick _.pick (obiekt, * klucze)

Zwróć kopię obiektu , przefiltrowaną, aby zawierała tylko wartości dla kluczy z białej listy (lub tablicy prawidłowych kluczy). Alternatywnie akceptuje predykat wskazujący, które klucze wybrać.

_.identityjest funkcją pomocniczą, która zwraca swój pierwszy argument, co oznacza, że ​​działa również jako funkcja predykatu, która wybiera prawdziwe wartości i odrzuca fałszywe. Biblioteka Underscore zawiera również kilka innych predykatów, na przykład _.pick(sourceObj, _.isBoolean)zachowuje tylko właściwości logiczne.

Jeśli często używasz tej techniki, możesz uczynić ją nieco bardziej wyrazistą:

var pickNonfalsy = _.partial(_.pick, _, _.identity); // Place this in a library module or something
pickNonfalsy(sourceObj);

Podkreślona wersja 1.6.0 również została udostępniona _.pick, ale nie akceptowała funkcji predykatu zamiast białej listy.

Szybkie i jasne: _.omitBy( source, i => !i );

Stwierdzono to w sposób odwrotny do odpowiedzi Emila. W ten sposób imho czyta jaśniej; jest to bardziej oczywiste.

Nieco mniej czyste, jeśli nie masz luksusu ES6: _.omitBy( source, function(i){return !i;});

Alternatywny: _.omitBy( source, _.isEmpty)

Używanie _.isEmptyzamiast _.identityprawdziwości w wygodny sposób usunie również puste tablice i obiekty z kolekcji i być może niewygodnie usunie liczby i daty . Tak więc wynik NIE jest dokładną odpowiedzią na pytanie PO, jednak może być przydatny przy próbie usunięcia pustych kolekcji.

Z transformacją lodash ,

_.transform(obj, function(res, v, k) {
  if (v) res[k] = v;
});

Object.keys(o).forEach(function(k) {
    if (!o[k]) {
        delete o[k];
    }
});

Możesz stworzyć płytki klon:

_(obj).reduce(function(a,v,k){ 
     if(v){ a[k]=v; } 
     return a; 
},{});

do użytku obiektu usuń.

for(var k in obj){

  if(obj.hasOwnProperty(k) && !obj[k]){
    delete obj[k];
  }
}

Nagle potrzebowałem stworzyć funkcję usuwającą rekurencyjne falsyfikaty. Mam nadzieję, że to pomoże. Używam Lodash.

var removeFalsies = function (obj) {
    return _.transform(obj, function (o, v, k) {
        if (v && typeof v === 'object') {
            o[k] = _.removeFalsies(v);
        } else if (v) {
            o[k] = v;
        }
    });
};

_.mixin({ 'removeFalsies': removeFalsies });

Następnie możesz go użyć:

var o = _.removeFalsies({
  foo: 'bar',
  a: 0,
  b: false,
  c: '',
  d: null,
  e: undefined,
  obj: {
    foo: 'bar',
    a: 0,
    b: false,
    c: '',
    d: null,
    e: undefined
  }
});

// {
//   foo: 'bar',
//   obj: {
//     foo: 'bar'
//   }
// }

Aby dodać do odpowiedzi gion_13:

_.mixin({
  compactObject : function(o) {
     var newObject = {};
     _.each(o, function(v, k) {
       if(v !== null && v !== undefined) {
         newObject[k] = v
       }
     });
     return newObject;
  }
});

Ten tworzy nowy obiekt i dodaje klucze i wartości zamiast klonować wszystko i usuwać pary klucz-wartość. Niewielka różnica.

Ale co ważniejsze, sprawdza jawnie pod kątem wartości null i undefined zamiast falsey, co spowoduje usunięcie par klucz-wartość, które mają wartość false.

w lodash robisz to tak:

_.pickBy(object, _.identity);

Chociaż _.compactjest udokumentowane do użycia w tablicach. Wydaje się, że działa również w przypadku obiektów. Właśnie uruchomiłem na konsolach Chrome, Opera i Firefox:

var obj = {first: 1, second: null, third: 3, fourth: function(){return 5}}
undefined
_.compact(obj)

[1, 3, function()]

UPDATE: Jak wskazuje przykład, wywołanie _.compactobiektu spowoduje porzucenie kluczy i zwrócenie skompaktowanej tablicy.