Why use prefer-destructuring on arrays?

Hello 😃

Take this example

const test = {};
const something = [1, 2, 3];

test.value = something[0]; // triggers error

I guess

[test.value] = something;

fixes it, but it is just unreadable.

I am curious why forcing this rule on arrays?

[micchickenburger]

Here’s an example why forcing destructuring on arrays of n length is quite silly:

const match = url.match(/^(.+):\/\/(.+):(\d+)\/?/);
// match[0]: result
// match[1]: protocol
// match[2]: hostname
// match[3]: port

// Get port
const port = match[3];

// with destructuring
const [, , , port] = match;  // wth

Of course, this example is quite trivial. Why would I use capturing parenthesis if I wasn’t going to use that value? I could just do this: const [, protocol, hostname, port] = match;

But sometimes you receive an array you didn’t create, and you only need item at index 7, for example. The syntax starts to look a bit ludicrous. I support requiring destructuring arrays of length one, but not more than that.

[ericblade]

Arrow function syntax and object destructuring are also “unreadable” until you get used to them 😃

I believe ljharb would say that accessing a specific element inside an array is a sign of “code smell”. In general, most of the time you are going to need to do array operations, you are going to be performing them on the entire contents of an array. If you’re using an array that you need to access by individual element, you might be using the wrong data structure.