Принцип синтаксиса коротких функций обратного вызова

Question

Какой принцип стоит за этим? newArr.some(Array.isArray) === newArr.some(elem => Array.isArray(elem))

Как возможно, чтобы они были проанализированы как равные? Я думал, что newArr.some(Array.isArray) === newArr.some(Array.isArray()) (при условии, что some - это все oop, а JS принимает каждый val как неявный аргумент веселья c), но это не так. Итак, я в замешательстве. Пожалуйста, помогите мне.

Здесь есть 2 применения описанных выше случаев:

function flatMultiArr(arr) {
let newArr = [].concat(...arr);
return newArr.some(Array.isArray)
? flatMultiArr(newArr)
: newArr
}

console.log();//[ 1, {}, 3, 4 ]

function flatMultiArr(arr) {
let newArr = [].concat(...arr);
return newArr.some(elem => Array.isArray(elem))
? flatMultiArr(newArr)
: newArr
}

console.log();//[ 1, {}, 3, 4 ]

Обратите внимание, что этот вопрос не о том, как сгладить многомерные массивы.

Answer 1

Этот принцип известен как эта конверсия . Нет, они не "анализируются как равные", это разные функции, но они ведут себя одинаково , и поэтому могут быть рассуждены примерно одинаково. Для упрощения:

const f = Array.isArray

и

function f(x) { return Array.isArray(x); }

будут иметь одинаковые результаты при вызове ¹ , то есть f([]) или f(5).

_{1: Как правило, существуют незначительные различия в привязке this в методе и количестве аргументов, но работает для Array.isArray}.

Answer 2

Обратите внимание, что обратные вызовы - это просто функции. Это называется eta-абстракция и делает вашу функцию немного более ленивой:

const fix  = f =>      f(fix( f));
const fix_ = f => x => f(fix_(f)) (x);
//                ^^^^            ^^^ eta abstraction

try {
const map = fix(go => f => ([x, ...xs]) =>
    x == undefined
      ? []
      : go(f) (xs).concat(f(x)));
}

catch (e) {
  console.log(e.message);
}

const map_ = fix_(go => f => ([x, ...xs]) =>
    x === undefined
      ? []
      : [f(x)].concat(go(f) (xs)));

console.log(
  map_(x => x * x) ([1,2,3]));