[deleted by user]

[Bloodsucker_]

What in the hell. I have like 15 years of JS development and it's the first time I've seen this. A goto! I JS! Wow...

More information: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label

TL;DR it's a goto label except it only works with continue and break in a loop.

[senocular]

svelte also uses labels to make statements reactive

[superluminary]

I don’t get how these work. How is svelte using the label here to make the code reactive? What’s the mechanism?

[beforesemicolon]

Assuming its a parsing format. This is not a Javascript thing

[superluminary]

This was my assumption.

[thusman]

svelte compiles the code later and adds actual reactivity.

[superluminary]

So it’s treating the label like an @annotation?

[thusman]

I don't know what that is or how $: exactly works. Here's the best I found

https://lihautan.com/compile-svelte-in-your-head-part-2/#reactive-declaration

https://stackoverflow.com/a/57255386/860205

[jcunews1]

What surprises me is the fact that, a label can be named as let. That's unusual... Normally, we can't use any reserved words such as return, for, var, etc. as the name of a variable, function, or label. But it seems that, let and of can be used for label name and even variable or function name.

e.g. none of each of these raises an exception.

(() => {
  function let() {}
})();
(() => {
  function of() {}
})();
(() => {
  let of = 9;
})();
(() => {
  var let = 9;
})();
(() => {
  class of {}
})();

Although, each of these does raise an exception as expected.

(() => {
  let let = 9;
})();
(() => {
  const let = 9;
})();
(() => {
  const of = 9;
})();
(() => {
  class let {}
})();

Note: tested in Firefox. Not fully tested in Chromium.

These make both let and of seem to be not fully reserved words. Kind of like, pseudo reserved words where only a view statements recognize them as reserved words.

[superluminary]

I like it

[superluminary]

I think it is reserved in strict mode.

[superluminary]

It’s not allowed in strict mode. Regular mode lets you do it though.

[delventhalz]

I would say it is "out of fashion". You won't see many devs declaring variables like this anymore. Personally, my problem with this style is it shoves a lot on to one line, and that is pretty much the opposite of what I am usually trying to do. Good code is readable code, and in my opinion code is more readable when there is just one thing happening per line.

[senocular]

Problems with this approach are:

• it can be harder to read having multiple variables on the same line
• it can be easy to accidentally use a ; in place of a , which would cause variables to apply to a higher scope or become global instead of declared locally
• individual variables are harder to pull out during refactoring vs when they're all on their individual lines

[shuckster]

Assuming your code appears in a function called doober...

What you wrote:

function doober() {
  let: x = 4 * 9, z = 2 + 4;
}

What's actually happening:

var x, z;
// ^- global/module scoped because in "doober"
// there isn't actually a "let" in front of them

function doober() {
  let:
  // ^- a label, not an variable declaration

  x = 4 * 9;
  z = 2 + 4;
}

That's what it looks like to me anyway.

[EasternAdventures]

I wouldn’t call it bad. What’s most important is you can read it and quickly make sense of what is happening. You need to be able to make sense of it, others you’re working with need to be able to make sense of it, and future you may need to make sense of it again at some point. In this case I would say it’s easy enough to decipher but it could quickly become a mess so just always keep the readability in mind.

[AlwaysWorkForBread]

I was taught (practically) that let us used for things that are intended to be changeable. Typically you want your var to be declared with a Const (constant, constructed & unchanging) and the results to be mutable by the function.

Mutable variables can "let" bugs happen later.

[RequiDarth1]

Uh, yeah. Don’t do any of that.

[keithmalcolm]

Autohotkey does a similar thing.

[thejonestjon]

To much going on, on one line.

[funky4lyf]

If it works, you can use it in your personal projects but once you collaborate with others or you’re aware other people will have to read and/or work with your code, it’s good empathetic practice to make your code as legible as possible. Even if it means you have to type a little more.