I know how to do it, also, what about nested objects. It is not about serialization, and falsy values should be explicitly compared to their own empty value.

```js
const propertyDict = {
  aa ?: null,
  bb ?: undefined,
  cc ?:  couldBeZero !== 0 ? couldBeZero : null,
  dd ?: couldBeFalse !== False ? couldBeFalse : null,
  ee ?: couldBeEmptyString !== "" ? couldBeEmptyString : null,
}
```

of course you could use the falsy values with `or`

```js
const propertyDict = {
  aa ?: null,
  bb ?: undefined,
  cc ?:  couldBeZero  || null, //doesn't added if couldBeZero is null or falsy(0, "", [])
  dd ?: couldBeFalse || null,
  ee ?: couldBeEmptyString || null,
}
```

if you don't intend to remove falsy values from the object but still don't want null properties

```js
const propertyDict= {
  aa ?: null,
  bb ?: undefined,
  cc ?: couldBeZeroOrNull,
  dd ?: couldBeFalseOrNull,
  ee ?: couldBeEmptyStringOrNull,
}
```

why is for me a concern currently(I always had this need, but I will show a current use case).

Suppose you want to filter from a collection in mongodb you will use Collection#find method, you pass an object as your first parameters to filter out the collection.

```js
function filterPosts({ categoryId, postType }){
  // if non of them is present(==null) I want to get all the Posts
  // if either of them is present I want to use them as the filter
  // currently I have to go like this
  const query = {
    ...(categoryId? {categoryId} : {}),
    ...(postType? {postType} : {})
  }
  /* but normally I could forget and just do this
  const query = {
    categoryId,
    postType,
  }

  If you pass null in one of the properties, the database will perform an equality
  comparison to null and will return nothing if both are null. That's why I need to
  remove properties with null values before sending the query.
  */
  return db.collection('Posts').find(query)
}
```

is better to have a null check there

```js
function filterPosts({categoryId, postType}){
  return db.collection('Posts').find({ categoryId?, postType? })
}
```







________________________________
De: kai zhu <kaizhu256 at gmail.com>
Enviado: martes, 28 de noviembre de 2017 11:43 p.m.
Para: Rodrigo Carranza
Cc: J Decker; Michał Wadas; es-discuss at mozilla.org
Asunto: Re: A way to prevent properties to be added to an object if they are null or undefined.

@rodrigo, you can achieve most of what you want with a simple helper
function. my suspicion is there are too many variations for this to be
practical as a language proposal (e.g. you often want the empty string
"" to be considered nullish as well for the special nodejs object
process.env, which silently converts all set items to string).



```js
/*jslint node: true*/
'use strict';
var obj, objectSetNonNullishProperty, propertyDict;



objectSetNonNullishProperty = function (obj, propertyDict) {
/*
 * this function will assign all non-nullish items in propertyDict to obj
 * edit it to suit your needs and variations
 */
    var value;
    Object.keys(propertyDict).forEach(function (key) {
        value = propertyDict[key];
        if (value !== null && value !== undefined) {
            obj[key] = value;
        }
    });
    return obj;
};



// test assigning non-nullish properties to empty obj
obj = {};
propertyDict = {
    aa: null,
    bb: undefined,
    cc: 0,
    dd: false,
    ee: ''
};
console.assert(JSON.stringify(
    objectSetNonNullishProperty(obj, propertyDict)
) === JSON.stringify({
    cc: 0,
    dd: false,
    ee: ''
}));



// test overriding obj with non-nullish properties
obj = {
    aa: 1,
    bb: 2,
    cc: 3,
    dd: 4,
    ee: 5
};
propertyDict = {
    aa: null,
    bb: undefined,
    cc: 0,
    dd: false,
    ee: ''
};
console.assert(JSON.stringify(
    objectSetNonNullishProperty(obj, propertyDict)
) === JSON.stringify({
    aa: 1,
    bb: 2,
    cc: 0,
    dd: false,
    ee: ''
}));
```

On 11/29/17, Rodrigo Carranza <rodrigocarranza at outlook.com> wrote:
> ________________________________
>
> Yeah, it was wrong, I'm currently using like
>
> ```js
> let ret = { ... ( couldBeNull ? {couldBeNull} : {} ) }
> ```
>
> Yours is better and the usual idiom a bit hard to understand.
>
> What I'm proposing is something like this
>
> ```js
> let ret = { couldBeNull? }
> ```
> or if you want a different name for the property
>
> ```js
> let ret = { bar ?: couldBeNull }
> ```
>
> It is not like there is no way to do this, there are plenty. But this way
> could make code a bit easier to read.
>
> P.D: Sorry for the duplicates and that new thread, I don't understand so
> much this client and it is acting weird. Also I'm new to mailing lists.
>
> ________________________________
> De: J Decker <d3ck0r at gmail.com>
> Enviado: martes, 28 de noviembre de 2017 09:07 p.m.
> Para: Michał Wadas
> Cc: Rodrigo Carranza; es-discuss at mozilla.org
> Asunto: Re: A way to prevent properties to be added to an object if they are
> null or undefined.
>
> Or feed it through JSON.parse( JSON.strinigfy( o ) ) which will delete
> undefined things; doesn't help with null.
>
> On Tue, Nov 28, 2017 at 5:50 PM, Michał Wadas
> <michalwadas at gmail.com<mailto:michalwadas at gmail.com>> wrote:
> You can just use proxy with proper set trap.
>
> On Wed, 29 Nov 2017 at 02:30, Rodrigo Carranza
> <rodrigocarranza at outlook.com<mailto:rodrigocarranza at outlook.com>> wrote:
> A way to prevent properties to be added to an object if they are null or
> undefined.
>
> Currently this can be accomplished in many ways:
>
> With an if:
> ```js
> function foo(couldBeNull){
> let ret = {}
> if(couldBeNull){
> ret.couldBeNull = couldBeNull
> }
> return  ret
> }
> ```
>
> With ternary (kind of gross)
> ```js
> function foo(couldBeNull){
> let ret = {}
> couldBeNull ? (ret.couldBeNull = couldBeNull) : null
> return  ret
> }
> ```
>
> Also gross
> ```js
> function foo(couldBeNull){
> let ret = {}
> couldBeNull && (ret.couldBeNull = couldBeNull)
> return  ret
> }
> ```
>
> A bit hard to read:
> ```js
> function foo(couldBeNull){
> let ret = {
> ...({couldBeNull} : {})
> }
> return  ret
> }
> ```
>
> Requires importing a lib or writing the function by yourself. Also it has to
> iterate over all values
> ```js
> function foo(couldBeNull){
> let ret = {
> couldBeNull
> }
> ret = removeEmptyValues(ret) // imported from some library
> return  ret
> }
> ```
>
> Wouldn't it be better something like this?:
>
> ```js
> function foo(couldBeNull){
> let ret = {
> couldBeNull?
> }
> return  ret
> }
> ```
>
> Or if you want to set other property name
>
> ```js
> function foo(couldBeNull){
> let ret = {
> bar ?:  couldBeNull // bar is not added if couldBeNull is null or undefined
> }
> return  ret
> }
> ```
>
> [https://ipmcdn.avast.com/images/icons/icon-envelope-tick-round-orange-animated-no-repeat-v1.gif]<https://www.avast.com/sig-email?utm_medium=email&utm_source=link&utm_campaign=sig-email&utm_content=emailclient>
>      Libre de virus.
> www.avast.com<https://www.avast.com/sig-email?utm_medium=email&utm_source=link&utm_campaign=sig-email&utm_content=emailclient>
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org<mailto:es-discuss at mozilla.org>
> https://mail.mozilla.org/listinfo/es-discuss
>
> _______________________________________________
> es-discuss mailing list
> es-discuss at mozilla.org<mailto:es-discuss at mozilla.org>
> https://mail.mozilla.org/listinfo/es-discuss
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20171129/39582c5a/attachment-0001.html>

I know how to do it, also, what about nested objects. It is not about serialization, and falsy values should be explicitly compared to their own empty value.

```js
const propertyDict = {
  aa ?: null,
  bb ?: undefined,
  cc ?:  couldBeZero !== 0 ? couldBeZero : null,
  dd ?: couldBeFalse !== False ? couldBeFalse : null,
  ee ?: couldBeEmptyString !== "" ? couldBeEmptyString : null,
}
```

of course you could use the falsy values with `or`

```js
const propertyDict = {
  aa ?: null,
  bb ?: undefined,
  cc ?:  couldBeZero  || null, //doesn't added if couldBeZero is null or falsy(0, "")
  dd ?: couldBeFalse || null,
  ee ?: couldBeEmptyString || null,
}
```

if you don't intend to remove falsy values from the object but still don't want null properties

```js
const propertyDict= {
  aa ?: null,
  bb ?: undefined,
  cc ?: couldBeZeroOrNull,
  dd ?: couldBeFalseOrNull,
  ee ?: couldBeEmptyStringOrNull,
}
```

why is for me a concern currently(I always had this need, but I will show a current use case).

Suppose you want to filter from a collection in mongodb you will use Collection#find method, you pass an object as your first parameters to filter out the collection.

```js
function filterPosts({ categoryId, postType }){
  // if non of them is present(==null) I want to get all the Posts
  // if either of them is present I want to use them as the filter
  // currently I have to go like this
  const query = {
    ...(categoryId? {categoryId} : {}),
    ...(postType? {postType} : {})
  }
  /* but normally I could forget and just do this
  const query = {
    categoryId,
    postType,
  }

  If you pass null in one of the properties, the database will perform an equality
  comparison to null and will return nothing if both are null. That's why I need to
  remove properties with null values before sending the query.
  */
  return db.collection('Posts').find(query)
}
```

is better to have a null check there

```js
function filterPosts({categoryId, postType}){
  return db.collection('Posts').find({ categoryId?, postType? })
}
```