Логика в JS, не понимаю
 

Я вот не могу понять эту логику.
Сразу скажу код работает как должен но я просто не могу понять как.

const a = [1, 2, 3]
const b = [1, 2, 3]
const c = [2, 1, 3]

const areArraysEqual = (firstArray, secondArray) => {

    if(firstArray.every((el, ind) => el === secondArray[ind])
    ){
        return true
    }

    return false
}

console.log(areArraysEqual(a, b)) // true
console.log(areArraysEqual(a, c)) // false

Есть два массива я хочу проверить совпадают ли там элементы.
И для этого создаю проверку с помощью метода every где есть два параметра элемента и индекса. Происходит следующее что берется элемент первого массива и сравнивается с элементом второго массива исходя из номера его индекса. И все работает.

Но в моей логике что я взял первый элемент он 1 а индекс второго массива 0 То есть почему идет сравнение элементов если я написал элемент у первого массива а у второго написал индекс, там же разные значения.

alert(1 === 1)

что не так?

рони,
тут просто тип данных сравнен

а в моем примере сравниваются два массива
const a = [1, 2, 3]
где 1, 2, 3 это элементы у которых индекс 0 1 2

я вижу это сравнение так 1 !== 0 true

Сергей Ракипов,
вы когда обратились к массиву по индексу, то получили элемент.
(el, ind) => el === secondArray[ind])
el это firstArray[ind] или
(a[0], 0) => a[0] === b[0] или
(1, 0) => 1 === 1

рони,
вот это что вы написали (a[0], 0) как я понял а это массив [0] это индекс массив а через запятую 0 это что?

Сергей Ракипов,
(элемент_массива_под_индекс ом_таким-то, индекс_такой_то)

Сергей Ракипов,
есть два дома , есть номера квартир, есть жильцы этих квартир, никто жильца не сравнивает с номером его квартиры, сравнивают жильцов по номеру.
в первом доме, в нулевой комнате живёт единица и во втором доме, в нулевой комнате тоже живёт единица.

Сергей Ракипов,
(el, ind) => el === secondArray[ind])
(firstArray[ind] , ind) => firstArray[ind] === secondArray[ind])
(a[0], 0) => a[0] === b[0]
(1, 0) => 1 === 1
все эти строки это одно и тоже для первого шага перебора элементов массива

Я вот сколько лет возвращаясь вновь и вновь освоить JS иногда думаю это не моё.

Я вот так думаю
дом это массив a[1, 2, 3]
номера квартир это а[0 1 2] (то есть индекс для меня номер квартир) (далее я назову это ind)
а жильцы это a[1, 2, 3] (элементы этого массива, то есть они могут быть числа, строки, переменные и т.д.) (далее я назову это el)

И когда мне говорят сравни жильцов двух домов и если они одинаковые выведи тру

a[1, 2, 3]
в[1, 2, 3]

я беру метод every который мне скажет номера домов и кто в них живет (это в параметрах el жилец и ind квартира), то есть индекс 0 1 3 это квартиры и в них живут жильцы 1,2,3 соответственно



И вот из первого дома я имею жильца 1 А из второго дома я беру номер квартиры
И мне говорят это одинаково или тру
А у меня не доумение ну как же так это же вообще нельзя сравнивать.

и берёте жильца по номеру квартиры
читать тут

Разве в документации что-то непонятно написано? - https://developer.mozilla.org/ru/doc...ts/Array/every

["a", "b", "c", "d"].every(
 (el, ind, arr) => {
    console.log("el=" + el, "ind=" + ind, "arr=" + arr);
    return true;
 }
);

про как указать номер массива я знаю

К описанию у меня нет вопросов, я уже сдался это не так важно, просто я по другому не могу объяснить как я воспринимаю логику этого кода. Мне проще запомнить что это работает так и все.

Если только JS думает так есть массив иду по индексам, смотрю что находится в этом индексе, "запомнил" беру следующий массив иди по индексам и уже после этого сравниваю что находится в этом индексе.

В коде то просто написано 1 как значение сравни с 0 как с положением массива.

В коде написано
el - значение из первого массива, secondArray[ind] - значение по индексу ind из второго массива
ind - индекс
secondArray[ind] - значение по этому индексу

Спасибо что помогаете разобраться.

По индексам массива идёт только функция every:
И только по индексам одного массива - того, который указан перед ней через точку. Т.е. в данном случае она идёт по индексам массива firstArray.

И когда она проходит по индексам этого массива, она запускает для каждого его элемента функцию, которую ей передали в качестве параметра. В вашем случае это стрелочная функция:
где (el, ind) - это параметры данной функции. Значения в эти параметры передаёт every (при каждом запуске этой стрелочной функции значения будут разными).

Вот и вся логика. По индексам второго массива никто не проходит.

В этом утверждении содержится логическая ошибка которая приводит к ошибочным выводам.
С точки зрения формальной логики это нарушение третьего закона логики "Исключенный третий" т.е. понятие "беру номер квартиры" не верно и не может использоваться в логическом рассуждении потому что фактически используется синтаксическая конструкция которая представлена выражением и уже в этом выражении используется так называемое "беру номер квартиры" как часть этого выражения возвращающего жильца.
Т.е. вместо целого используемого выражения в логике используется только его часть это и есть то самое "подмена понятия".

На самом деле это надо читать так
И вот из первого дома я имею жильца 1. А из второго дома я беру номер квартиры

спасибо почитал

Скажу сразу код работает просто не до конца понимаю.

const inputProducts = [
  {
    title: 'Phone case',
    price: 23,
    quantity: 2,
    category: 'Accessories',
  },
  {
    title: 'Android phone',
    price: 150,
    quantity: 1,
    category: 'Phones',
  },
  {
    title: 'Headphones',
    price: 78,
    quantity: 1,
    category: 'Accessories',
  },
  {
    title: 'Sport Watch',
    price: 55,
    quantity: 2,
    category: 'Watches',
  },
]

const quantitiesByCategories = (products) => {

  return products.reduce((qtyByCategories, product) => {

    const {category, quantity} = product

    qtyByCategories[product.category] =  (qtyByCategories[product.category] || 0) + product.quantity

    return qtyByCategories
    
  }, [])
}  

console.log(quantitiesByCategories(inputProducts))

1) Как вот этот параметр product понял что он будет объектом этого массива inputProducts

2) Почему [product.category] решило что она возьмет значение этого свойства category: 'Accessories' и станет ключом нового объекта

3) Как происходит суммирование quantity за счет этой записи (qtyByCategories[product.category] || 0) + product.quantity

1) Как вот этот параметр product понял что он будет объектом этого массива inputProducts

Вот это я понял
reduce взял массив products и вторым аргументом product взял элемент из этого массива

Может все таки самому почитать как следует учебник.
Тут трудно написать больше, чем там написано.
2 Ну вот так язык js устроен.
К свойству можно обратиться и product.Accessories и product['Accessories']
3 Если product.Accessories != undefined (нет такого свойства) или 0 или null, или false или '', то взять в место него 0 (|| 0). иначе взять само значение product.Accessories и прибавить к нему product.quantity
Результат запихнуть в product.Accessories (если такого свойства нет, оно будет создано).

почему вот эта часть qtyByCategories[product.category] стала значением вот этого свойства quantity:

А она не стала.
qtyByCategories - это новый объект, изначально пустой, в который запихиваются свойства с именами из product.category, а значение накапливается сумма из quantity.
Читать и учить как работает reduce.

voraa,
спасибо

Кто может объяснить почему тут два оператора return

И почему JS понимает что после оператора + он должен сложить значение rating: elem.rating + 100 есть какое то правило синтаксиса ?

const test = [
        {
            author: 'a',
            category: "nub",
            rating: 10,
        },
        {
            author: 'b',
            rating: 20,

        },
        {
            author: 'c',
            category: "nub",
            rating: 30,
        },
    ]
    const fn = (arr) => {
        return arr.map((elem) => {
            return {
                avtor: elem.author,
                category: elem.category === undefined ? "nub" : elem.category,
                rating: elem.rating + 100
            }
        })
    }
    const testCopy = fn(test)
    console.log(testCopy);

const fn = (arr) => {
        return arr.map((elem) => {
            return {
                avtor: elem.author,
                category: elem.category === undefined ? "nub" : elem.category,
                rating: elem.rating + 100
            }
        })
    }

Первый return относится к функции fn, а второй к функции, которая передается в map
Потому, что оператор + складывает значения, которые слева и справа от него.

А в каких случай нужно еще дважды написать return?
Просто как я думаю что написал функцию и сказал ее вернуть значение. И как бы достаточно. Не совсем понятно почему после того как я функции сказал врени результат своей работы нужно еще раз внутри написать верни. Может быть есть какие то правила которые просят писать возврат дважды

Вот тут JS avtor: elem.author, он понял что нужно изменить ключ.

А вот тут rating: elem.rating + 100 он понял что нужно сложить значение. Хотя визуально можно понять что оставь имя прежним просто напиши еще 100 которое переведется в строку. Хотя признаю может и звучит как то идиотский. Просто какое то правила синтаксиса что если написано так то будет делать такие действие если по другому то другие.

return можно и нужно писать столько раз, сколько нужно. Например так

function sign (x) {
   if (x<0) return -1;
   if (x>0) return 1;
   return 0;
}

Если функция должна вернуть значение, то у нее должен быть хотя бы один return. Если используются две такие функции, значит надо будет написать return 2 раза.

Есть простое правило. значение свойства при задании литерала объекта можно задавать выражением.

voraa,
спасибо

И правильно ли я понял если по простому то это означает

const test = {
value: a
}

вместо а могу написать в

const test = {
value: в
}