Tengo un objeto con varias propiedades. Me gustaría eliminar cualquier propiedad que tenga valores falsos.

Esto se puede lograr con compactmatrices, pero ¿qué pasa con los objetos?

Puede crear su propio complemento de subrayado (mixin):

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

Y luego úselo como un método de subrayado nativo:

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

Actualizar

Como señaló @AndreiNeculau , este mixin afecta al objeto original, mientras que el método de subrayado original devuelve una copia de la matriz . Para resolver este problema y hacer que nos comportemos más como su primo , aquí hay una actualización menor:compact
compactObject

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

Desde la versión 1.7.0 de Underscore, puede usar _.pick:

_.pick(sourceObj, _.identity)

Explicación

El segundo parámetro _.pickpuede ser una función de predicado para seleccionar valores. Se seleccionan los valores para los que el predicado devuelve veracidad y los valores para los que el predicado devuelve falsedad se ignoran.

pick _.pick (objeto, * claves)

Devuelve una copia del objeto , filtrado para tener solo valores para las claves en la lista blanca (o una matriz de claves válidas). También acepta un predicado que indica qué claves elegir.

_.identityes una función auxiliar que devuelve su primer argumento, lo que significa que también funciona como una función de predicado que selecciona valores verdaderos y rechaza los falsos. La biblioteca Underscore también viene con un montón de otros predicados, por ejemplo _.pick(sourceObj, _.isBoolean), solo retendría propiedades booleanas.

Si usa mucho esta técnica, es posible que desee hacerla un poco más expresiva:

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

_.pickTambién se proporcionó la versión 1.6.0 de subrayado , pero no aceptó una función de predicado en lugar de una lista blanca.

Rápido y claro: _.omitBy( source, i => !i );

Esto se expresa de manera inversa a la respuesta de Emil. De esta manera, en mi humilde opinión, lee más claro; se explica más por sí mismo.

Un poco menos limpio si no tiene el lujo de ES6: _.omitBy( source, function(i){return !i;});

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

El uso _.isEmpty, en lugar de la _.identityveracidad, también eliminará convenientemente matrices y objetos vacíos de la colección y quizás eliminará números y fechas de manera inconveniente . Por lo tanto, el resultado NO es una respuesta exacta a la pregunta del OP, sin embargo, podría ser útil cuando se busca eliminar colecciones vacías.

Con la transformación de Lodash ,

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

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

Puede crear un clon superficial:

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

para eliminar el uso de objetos.

for(var k in obj){

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

De repente, necesitaba crear una función para eliminar las falsificaciones de forma recursiva. Espero que esto ayude. Estoy usando 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 });

Entonces puedes usarlo:

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'
//   }
// }

Para agregar a la respuesta de gion_13:

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

Éste crea un nuevo objeto y agrega claves y valores en lugar de clonar todo y eliminar pares clave-valor. Diferencia menor.

Pero lo que es más importante, comprueba explícitamente si hay nulos e indefinidos en lugar de falsey, lo que eliminará los pares clave-valor que tengan falso como valor.

en el lodash te gusta esto:

_.pickBy(object, _.identity);

Aunque _.compactestá documentado para su uso en matrices. También parece funcionar para objetos. Acabo de ejecutar lo siguiente en las consolas Chrome, Opera y Firefox:

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

[1, 3, function()]

ACTUALIZACIÓN: como indica el ejemplo, la llamada _.compacta un objeto soltará las claves y devolverá una matriz compactada.