Rule proposal: prefer-array-some

[fisker]

Fail

if (array.find(element => element === '🦄')) {
}

const foo = array.find(element => element === '🦄') ? bar : baz;

Pass

if (array.some(element => element === '🦄')) {
}

const foo = array.some(element => element === '🦄') ? bar : baz;

Just experienced one few days ago, and kind of follow up for #730

[fisker]

One note, we should definitely filter the first argument which is Literal like #704 (comment) and #697, because there is widely used jQuery.find().

Update: on second thought, jQuery.find() seems can't use in a if or ternary.

[silverwind]

I wouldn't specifically suggest some but warn on the wrongly used array#find return value in the boolean context.

BTW, I did a rule to eslint proposal regarding a general unused return values rule a while ago, maybe it is worth exploring here, #741.

[papb]

I wouldn't specifically suggest some but warn on the wrongly used array#find return value in the boolean context.

I like the idea of suggesting some. Might help users who don't know any better.

BTW, I did a rule to eslint proposal regarding a general unused return values rule a while ago, maybe it is worth exploring here, #741.

@silverwind What is the connection? In this case, the return value is being used, so what exactly do you mean?

[silverwind]

There's no real connection, my mistake. Return value is used here (thought wrongly).

[silverwind]

My issue with array#some and array#every is that I think it's hard to read/understand. I prefer for-of with a break statement because I don't have to think about whether the iterator needs to return true or false to break the loop.

[fisker]

Why are you thinking about breaking loop? When use some and every you should think is this element/result I'm searching? One important thing you should think about is, if it's empty, what the result will be.

[silverwind]

Yeah it might just be me and some/every are fine. As an example, I'd prefer the second variant here because it just seems easier to read to me:

function hasBiggerThan10(array) {
  return array.some(element => element > 10);
}

function hasBiggerThan10(array) {
  for (const element of array) {
    if (element > 10) return true;
  }
  return false;
}

[fisker]

const isBiggerThan10 = element => element > 10;

function hasBiggerThan10(array) {
  return array.some(isBiggerThan10);
}

function allBiggerThan10(array) {
  return array.every(isBiggerThan10);
}

Readable to me , and I don't see why should think about breaking loop.

[silverwind]

Maybe I've expressed myself badly but the "hard" part is remembering to return a truthy value in the callback.

One distinct advantage for-of has over array methods is that it works on all iterables (NodeList, Set, Map), so it's a win-win to use it over array methods.

[fisker]

Yes, I agree in some case loop better, some also useful to avoid use let/break in simple tests. I use both.

[riophae]

Although this could be a taste issue, Array#some can easily run on all iterables too. Just FYI.

Array.from(new Set([ 1, 2, 3, 2 ])).some(...)
Array.from('abc').some(...)
Array.from(document.querySelectorAll('div')).some(...)

[sindresorhus]

This is accepted.

[fisker]

WIP