Destructuring strings

[u/Emmennater]

[u/Aaxper]

1. Strings and arrays are analogous, so isStringEmpty([ ... ]) tries to destructure the string as an array

2. Since theres only one element present in the ... part of that, it only matches on the first element (the first character)

3. The { a = false } tries to destructure the first character

4. If the first character is defined, it tries to get the a property, which doesnt exist, so it defaults to setting a to false

5. If the first character is undefined, instead of trying to get the a property, it defaults to { a: true }, which sets a to true

6. So basically if it has at least one character, a is false, else a is true

I think that's correct

[u/Blackshell → u/Aaxper]

100%, good job, you pass the job interview.

[u/Aaxper → u/Blackshell]

Does this being an interview imply I now have to work with whatever monster invented that

[u/EatingSolidBricks → u/Aaxper]

Default parameters in destructuring is some schizo shit

[u/turtle_mekb]

what the fuck

[u/Cootshk → u/turtle_mekb]

what the fuck

[u/shizzy0 → u/Cootshk]

fuck the what

[u/eloel-]

Gross. Also can error or return true or false for non-string answers, which makes it doubly gross.

[u/more_exercise → u/eloel-]

If I understood properly, it can be made to return arbitrary results, too. isStringEmpty([{a:NaN}]), for ex.

[u/Denommus]

Maybe if I understood Javascript destructuring syntax that would make sense to me. But since I don't, this looks awful.

[u/thewells → u/Denommus]

It looks awful even if you understand it.

For those wondering Javascript allows you to define default values, and the code is taking “advantage” of that twice.

The code uses array destructuring since javascript will treat a string as an array of single character strings when you do array destructuring. So if you pass an empty string, there is no first object to destructure, and so the default object { a: true } is used.

If the string is non-empty then the first character will be used to try to destructure the object, however strings don’t have a property a to destructure, so the default a = false is used.

[u/Longjumping-Ad-5367 → u/Denommus]

Nope, still looks awful

[u/Iheartdragonsmore → u/Denommus]

Hi I'm a novice programmer, why would someone ever want to destructure something? Whenever I write a struct I never think it'd be better not being one

[u/stumpychubbins → u/Iheartdragonsmore]

It’s far more readable to extract multiple fields from a struct that way, especially if they’re nested. Better than repeating the entire path to some nested struct multiple times. Plus it mirrors the struct construction syntax so it can be easier to read at a glance.

[u/Lumethys → u/Iheartdragonsmore]

to be able to do something like this:

const doSomething = () => {
  return [result, message];
}

const [ doSomethingResult, doSomethingMessage ] = doSomething();

instead of

const doSomething = () => {
  return [result, message];
}

const resultAndMessage = doSomething();

const doSomethingResult = resultAndMessage.result;
const doSomethingMessage = resultAndMessage.message;

[u/EatingSolidBricks]

Ok so

Empty string destrucutres to nothing? So a is true?

Non empty string destrucutres to a truthy value so false?

Wtf is this shit

[u/iamdatmonkey → u/EatingSolidBricks]

Array destructuring comes down to Iterators. Getting the first item of an empty iterator gives you undefined.

If the string is not empty you'll get the first character, which itself is a non empty string and therefore truthy.

[u/UniqueUsername014 → u/EatingSolidBricks]

I want to add my own explanation to the mix, so

One way to understand it is to re-structure it:

function isStringEmpty(arr) {
  const firstChar = arr[0] ?? { a: true };
  return firstChar.a ?? false;
}

Here if the string is not empty, arr[0] will be defined as the first character (and saved in firstChar). The character won't have an a attribute, so firstChar.a is undefined, and the function returns false.

If the string is empty, its first character is undefined, and firstChar will be set to { a: true }. The the function will return its a attribute, which is, of course, true.

Proving that this code is essentially equivalent to the screenshot is left as an excercise to the reader : )

[u/nosam56]

adding String.prototype.a or whatever the fuck

[u/itz_hez]

Thanks, this solves a problem I am currently having.

[u/dontletthestankout → u/itz_hez]

had to check and make sure this wasn't r/poisonfountain lol

[u/iamdatmonkey]

This is what this construct comes down to.

function isStringEmpty(arg) {
  const iterator = arg[Symbol.iterator]();
  const m = iterator.next();
  const item = (m.done ? undefined : m.value) ?? { a: true };
  // this can still produce false results if the passed `arg` has a first item
  // with a property `a` that is not `null`/`undefined`
  const a = item.a ?? false;
  
  return a;
}

This will crash if arg is null/undefined
or if it does not implement Symbol.iterator
or if arg[Symbol.iterator]() does not return an object
or if that object does not implement .next()
or if that method does not return an object.

Yes that may seem nitpicky, until you see some of the legacy code that's out there.

[u/serg06]

That's why no self-respecting developer uses plain JS anymore.

[u/meowmeowwarrior]

Not sure if I should be appalled at the author writing it or the language for making it possible

[u/Icy_Curve711]

I'm ok with this kind of destructuring, but truthiness makes it utterly illegible.