Introduction   JavaScript error handling is about to get a major upgrade. The new ECMAScript... Tagged with javascript, webdev, tooling, programming.

Materialize

Bobby Iliev

DevOps

Community Picks is a section on daily.dev where our community members share the most interesting and valuable content they've discovered online. From insightful articles to handy tools, every post is a gem curated by our dedicated coomunity. To contribute to Community Picks, you need to have at least 250 reputation points, ensuring that only active and trusted members can share their finds.

Community Picks

The proposed Safe Assignment Operator (`?=`) in JavaScript aims to simplify error handling by reducing the need for traditional try-catch blocks. This operator transforms function results into a tuple, improving code readability and consistency across APIs. It also automatically handles errors, enhancing security. Inspired by constructs in languages like Go, Rust, and Swift, it supports integration with Promises and async functions and offers customizable error handling via `Symbol.result`.

Bye Bye, Try-Catch Blocks: Meet JavaScript's Safe Assignment Operator Proposal😉

Current Limitations and Areas for Improvement

FYI: This is just a DRAFT PROPOSAL
Proposal: <a href="https://github.com/arthurfiorette/proposal-safe-assignment-operator" target="_blank" rel="noopener nofollow">https://github.com/arthurfiorette/proposal-safe-assignment-operator</a>

😱 is golang coming to javascript?
(it is one of my favourite features in golang btw)

<blockquote>
Consistency Across APIs
</blockquote>
while i agree that this would reduce nested try-catch in our code, this would probably just bloat the javascript syntaxes. because we could already do that with a wrapper function without having to add new syntax. we can just add an extension to the function prototype
<pre><code class="language-js">
Function.prototype.toSafe = function() {
 try {
 const result = this();
 return [null, result];
 } catch (error) {
 return [error, null]
 }
}

const hello = () =&gt; &#x27;world&#x27;;
const notSafe = () =&gt; { throw new Error(&#x27;world&#x27;) };

hello.toSafe()
notSafe.toSafe()

Promise.prototype.toSafe = function() {
 return this
 .then((result) =&gt; [null, result])
 .catch((error) =&gt; [error, null])
}

await Promise.resolve(&#x27;hello&#x27;).toSafe()
await Promise.reject(new Error(&#x27;world&#x27;)).toSafe()

const [error, data] = await fetch(&#x27;...&#x27;).toSafe()
</code></pre>
<blockquote>
Improved Security
</blockquote>
what even? this has never been an issue in the javascript programming, on what situation where the current javascript try-catch method has lead to ‘unnoticed bugs and potential security risks’?
and how does <code>const [error, ]?= ...</code> promote bugs handling if it can be ignored <code>const [, data] ?= ...</code> like how we do in the try-catch <code>try {} catch (ignored) { // }</code>

Just when I moved to Golang haha.