Spreading nullish values

To throw or not to throw?

// Array spread�const mergedArray = [...array1, ...array2];�// → throws if e.g. `array2` is `null` or `undefined`��// Object spread�const mergedObject = { ...object1, ...object2 };�// → ignores e.g. `object2` if it’s `null` or `undefined`

​

• Leave things as they are and live with the inconsistency

​

Option 1

• Tighten up object spread to match array spread
• Throw when spreading null or undefined
• Pro:
• Is explicit rather than implicit
• Makes bugs (e.g. accidental undefined) more detectable
• Con:
• Inconsistent with Object.assign and similar userland utilities

​

Option 2

• Relax array spread to match object spread
• null and undefined spread to nothing
• Pro:
• Seems like the smallest possible non-breaking change
• Consistent with object spread
• Con:
• Potentially hides bugs
• Still not consistent with iteration: null & undefined still not iterable

​

Option 3

• Make null and undefined iterable (producing no values)
• Pro:
• Would fix this behavior in general, not just for array spread specifically
• Con:
• Potentially hides bugs (e.g. accidental undefined)

​

​

Option 4

1. leave things as-is
2. tighten up object spread, disallow spreading nullish values
3. relax array spread; allow spreading nullish values
4. make null and undefined iterable

Options: recap

Object spread rationale

null | undefined | Point3D

Not very common type:

{} | Point3D

?Point3D

Not very common type:

{} | Point3D

{ ...obj || {} }

We don’t recommend obj || {} as a pattern elsewhere.

obj ? { foo: obj.foo, bar: obj.bar, baz: value } : { baz: value }

​

​

​

{ ...obj, baz: someValue }

​

​

​

{ ...(obj || {}), baz: someValue }

​

​

arr ? [arr[0], arr[1], arr[2], value] : []

​

​

​

[ ...arr, value ]

​

​

​

[ ...(arr || []), value ]

​

​

{ ...obj, foo: {...obj?.foo, bar: 1 }}

{ ...obj || {}, foo: {...obj?.foo || {}, bar: 1 }}