proposal-top-level-await VS proposal-nullish-coalescing

For more info about this feature, you can refer to the official proposal repo.

This one is Stage 4 (complete)

But browsers don't support top-level await yet. So we need to put it all inside as async function.

Note that ESM is not “backwards” compatible with CJS: a CJS module cannot require() an ES Module; it is possible to use a dynamic import (await import()), but this is likely not what consumers expect (and, unlike ESM, CJS does not support Top-Level Await).

top-level await feature for ES modules

That said, ES2022 does introduce a top-level await that works in the top level scope, but only in modules, not global scope. So if in a module this could work:

With the latest node version(s) (v14.8+), we should be able to rewrite the above code to something like this. proposal-top-level-await

Now a days, you'll likely mostly use async/await. The few cases where you'll need the Promise API (then()'s etc.) is when you're outside of an async function. With the new top-level await feature coming to modules, you wouldn't even need it outside of async functions in module code which will make its usage even less common.

The await is in top level. The top level await proposal is in stage 3. Currently, the browser support is also not good enough but should work in latest version of the google chrome browser.

There is a proposal for top-level await in JS. I'm guessing this would effectively kinda do the same thing? Or am I wrong there?

For more info about this feature, you can refer to the original proposal.

Propuesta

For comparison, here are the Javascript RFCs for the equivalent operators:

https://github.com/TC39/proposal-optional-chaining

https://github.com/tc39/proposal-nullish-coalescing

IMO optional chaining is a lifesaver when dealing with deeply nested JSON, and it's become indispensable in our Typescript code. But we also deal with JSON from various third-party endpoints in Python, and far too often we resort to an inefficient deep_get utility to make our code sensical.

> if json?.get("foo")?.get("bar")?[0]?.get("baz")

may seem messy but would be infinitely better than the fragile (note the nested list-of-a-single-dict, and how bugs can appear if it's not there):

> if json.get("foo", {}).get("bar", [{}])[0].get("baz")

or the inefficient

> if deep_get(json, "foo.bar.0.baz")

It's not nearly as good as the Typescript json.foo?.bar?.[0]?.baz - but it's good enough!

The nullish coalescing proposal provides a way to handle undefined or null values and provide default values for the expression. You can use the “??” operator to provide a default value for an expression.