Existential Operator / Null Propagation Operator (Laurentiu Macovei)

Ron Waldon jokeyrhyme at gmail.com
Thu Oct 29 19:30:09 UTC 2015

Has anyone considering just making dot-property access return intermediate
undefined or null values by default?

Not having to introduce new syntax would be a bonus. I'm trying to think of
existing code that this would break and can't think of any good examples.

The only compatibility issue I have thought of so far is code that relies
on an Error being thrown but also does not check the value:

let value;
try { value = deep.deep.deep.prop; } catch (err) { /* ... */ }
// use value without even a basic truthy test

On Fri, 30 Oct 2015, 06:07  <es-discuss-request at mozilla.org> wrote:

---------- Forwarded message ----------
From: Laurentiu Macovei <laurentiu.macovei at gmail.com>
To: Sander Deryckere <sanderd17 at gmail.com>
Cc: "es-discuss@ <es-discuss at mozilla.org>mozilla.org
<es-discuss at mozilla.org> list" <es-discuss at mozilla.org>
Date: Thu, 29 Oct 2015 19:52:37 +0100
Subject: Re: Re: Existential Operator / Null Propagation Operator

Yes! I have updated my answer using markdown and also posted on the
original issue of TypeScript. https

Is there a better place to propose it for `ES6`/`ES7` ?

This would be amazing operator!! Especially for `ES6`/`ES7`/`TypeScript`


var error = a.b.c.d; //this would fail with error if a, b or c are null or

var current = a && a.b && a.b.c && a.b.c.d; // the current messy way to
handle this

var currentBrackets = a && a['b'] && a['b']['c'] && a['b']['c']['d']; //the
current messy way to handle this

var typeScript = a?.b?.c?.d; // The typescript way of handling the above
mess with no errors

var typeScriptBrackets = a?['b']?['c']?['d']; //The typescript of handling
the above mess with no errors


However I propose a more clear one - as not to confuse ? from the a ? b : c
statements with a?.b statements:


var doubleDots = a..b..c..d; //this would be ideal to understand that you
assume that if any of a, b, c is null or undefined the result will be null
or undefined.

var doubleDotsWithBrackets = a..['b']..['c']..['d'];


For the bracket notation, I recommend two dots instead of a single one as
it's consistent with the others when non brackets are used. Hence only the
property name is static or dynamic via brackets.

Two dots, means if its null or undefined stop processing further and assume
the result of expression is null or undefined. (as d would be null or

Two dots make it more clear, more visible and more space-wise so you
understand what's going on.

This is not messing with numbers too - as is not the same case e.g.


1..toString(); // works returning '1'

var x = {};

x.1 = {y: 'test' }; //fails currently

x[1] = {y: 'test' }; //works currently

var current = x[1].y; //works

var missing= x[2].y; //throws exception

var assume= x && x[2] && x[2].y; // works but very messy


About numbers two options: Your call which one can be adopted, but I
recommend first one for compatibility with existing rules!

1. Should fail as it does now (`x.1.y` == `runtime error`)


var err = x..1..y; // should fail as well, since 1 is not a good property
name, nor a number to call a method, since it's after x object.


2. Should work since it understands that is not a number calling a property
from `Number.prototype`


var err = x..1..y; // should work as well, resulting 'test' in this case

var err = x..2..y; // should work as well, resulting undefined in this case


With dynamic names:


var correct1 = x..[1]..y; //would work returning 'test'

var correct2 = x..[2]..y; //would work returning undefined;


What do you think folks?

Best Regards,

Laurenţiu Macovei
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20151029/1a1457d3/attachment.html>

More information about the es-discuss mailing list