Как сложить все элементы массива js
Можно использовать обычный цикл, но есть более красивое решение. Метод reduce() , принимает в качестве аргумента массив и колбек функцию, которая применяется к каждому элементу массива и таким образом позволяет найти их сумму. Вот пример:
const numbers = [1, 2, 3, 4]; const sumOfNumbers = numbers.reduce((acc, number) => acc + number, 0); console.log(sumOfNumbers); // => 10 27 октября 2022
Немного улучшу reduce .
acc + number);
А за такое использование map могут и побить. Если уж и хочется из цикла что-то менять снаружи (что почти всегда плохая идея), то для этого используют forEach . Map возвращает значение, которое должно быть использовано. И map не должен менять ничего извне. Иначе код становится сложноподдерживаемым.
19 октября 2022
Помимо стандартного перебора значений и красивого метода reduce(), можно воспользоваться функцией высшего порядка map:
const numbers = [1, 2, 3]; let sum = 0; numbers.map((item) => sum += item); console.log(sum); // => 6 И для любителей библиотеки Lodash доступен метод _.sum():
const numbers = [1, 2, 3]; console.log(_.sum(numbers)); // => 6 Сложить два числа
(Number(cena1) + Number((cena1*0.1)*5))*dni+» р.» если применять ваш подход. Просто скобку сдвиньте и все. А так у вас в первом случае cena1 — строка, при суммировании она приводит и второй операнд к строке. Из-за этого вся ошибка.
21 июн 2021 в 11:07
3 ответа 3
Сортировка: Сброс на вариант по умолчанию
Метод Number() нужен лишь в том случае если операция сложения ,которая может трактоваться не однозначно, в других его можно опустить. Так же можно использовать шаблонную строку для того чтобы добавить рубли, и toFixed для предотвращения мелких дробей.
const cena1 = "42.05"; const dni = "1"; const stoimost = `$<((Number(cena1) + cena1 * 0.1 * 5) * dni ).toFixed(2)>р.`; console.log(stoimost) // 63.07р.Отслеживать
ответ дан 21 июн 2021 в 12:03
Daniil Loban Daniil Loban
11k 2 2 золотых знака 8 8 серебряных знаков 18 18 бронзовых знаков
JavaScript | Как сложить все цифры в строке?
Мы хотим сложить все цифры из этой строки. То есть мы хотим выполнить такую операцию:
1 + 6 + 7 + 5 + 9 + 2
Как это сделать?
Сперва преобразуем строку в массив элементов:
var massiv_str = Array.from(stroka)
Мы разложили каждый символ строки на отдельный элемент массива.
Теперь нам нужно преобразовать каждый элемент массива в число. Будем использовать метод map()
var massiv_num = massiv_str.map(i => Number(i))
Мы получили массив из чисел, которые мы будем складывать между собой.
Напишем свой метод для работы с объектами-прототипами Array :
Array.prototype.sum = function()< var s = 0; for (i = 0; i < this.length; i++)< s += this[i] > return s >
Теперь можем прогнать массив по новому методу sum() :
var massiv_summa = massiv_num.sum()
Результатом сложения всех значений элементов массива стало число 30.
Числа (объект Number)
В JavaScript существует только один тип числовых данных. Числа могут записываться как с десятичной точкой, так и без нее:
var x = 3.14; // С десятичной точкой var y = 3; // Без десятичной точки
Очень большие и очень малые числа могут записываться при помощи научной (экспоненциальной) нотации (имеет вид Mep, где M – число, e — означает «умножить на 10 в степени. «, p – порядок или степень, в которую возводится 10):
var x = 123e5; // 12300000 var y = 123e-5; // 0.00123
В JavaScript числа всегда 64-битные с плавающей точкой
В отличие от многих других языков программирования JavaScript не определяет множество различных числовых типов вроде целочисленные без знака, с плавающей точкой, короткие, длинные и т.п.
В JavaScript все числа всегда хранятся как числа с плавающей точкой двойной точности в соответствии с международным стандартом IEEE 754.
По данному стандарту числа хранятся в 64 битах, где показатель числа (мантисса) хранится в битах с 0 по 51, порядок в битах с 52 по 62 и показатель знака в бите 63:
| Значение (aka Мантисса) | Порядок | Знак |
|---|---|---|
| 52 бита (0 — 51) | 11 бит (52 — 62) | 1 бит (63) |
Точность
Целые числа (без периода или экспоненциальной нотации) имеют точность до 15 цифр.
var x = 999999999999999; // в x будет 999999999999999 var y = 9999999999999999; // в y будет 10000000000000000
Максимальное количество знаков после десятичной точки — 17, однако вычисления с участием чисел с плавающей точкой не всегда бывают точны на 100%:
var x = 0.2 + 0.1; // в x будет 0.30000000000000004
Решить данную проблему помогает одновременное умножение и деление:
var x = (0.2 * 10 + 0.1 * 10) / 10; // в x будет 0.3
Сложение чисел и строк
ВНИМАНИЕ!! JavaScript использует оператор + как для сложения чисел, так и для объединения строк (конкатенации). Числа складываются. Строки объединяются.
Если вы складываете два числа, результатом будет число:
var x = 10; var y = 20; var z = x + y; // в z будет 30 (число)
Если вы складываете две строки, результатом будет объединенная строка:
var x = "10"; var y = "20"; var z = x + y; // в z будет 1020 (строка)
Если вы складываете число и строку, результатом будет объединенная строка:
var x = 10; var y = "20"; var z = x + y; // в z будет 1020 (строка)
Обычной ошибкой является в следующем примере ожидать, что результатом будет 30:
var x = 10; var y = 20; var z = "Результат: " + x + y;
Обычной ошибкой является в следующем примере ожидать, что результатом будет 102030:
var x = 10; var y = 20; var z = "30"; var result = x + y + z;
Интерпретатор JavaScript обрабатывает код слева направо. Таким образом, сначала будет вычислена сумма 10 + 20, так как x и y числа. А затем будет проведена конкатенация строк 30 + «30», потому что z — строка.
Числовые строки
Строки JavaScript могут содержать числовой контент:
var x = 100; // x - число var y = "100"; // y - строка
JavaScript будет стараться конвертировать строки в числа во всех арифметических операциях.
var x = "100"; var y = "10"; var z = x / y; // в z будет 10
Это тоже сработает:
var x = "100"; var y = "10"; var z = x * y; // в z будет 1000
И это сработает:
var x = "100"; var y = "10"; var z = x - y; // в z будет 90
А вот это не сработает:
var x = "100"; var y = "10"; var z = x + y; // в z не будет 110 (там будет 10010)
В последнем примере JavaScript использует оператор + для конкатенации строк.
NaN (Не число)
NaN — зарезервированное в JavaScript слово, обозначающее, что некое числовое значение является некорректным.
Например, попытка выполнить арифметическую операцию с не числовой строкой вернет в результате NaN (Не число):
var x = 100 / "Apple"; // в x будет NaN
Тем не менее, если строка содержит числовое значение, результатом будет число:
var x = 100 / "10"; // в x будет 10
Вы можете использовать глобальную JavaScript функцию isNaN(), чтобы выяснить является ли значение числом:
var x = 100 / "Apple"; isNaN(x); // вернет true, потому что в x не число
Остерегайтесь значения NaN. Если вы используете NaN в математических операциях, результат также будет NaN:
var x = NaN; var y = 5; var z = x + y; // в z будет NaN
Или результатом может быть конкатенация:
var x = NaN; var y = "5"; var z = x + y; // в z будет NaN5
NaN имеет числовой тип: typeof NaN вернет number:
typeof NaN; // возвращает "number"
Infinity (Бесконечность)
Если при вычислении результат выходит за пределы максимально допустимого числа, то в JavaScript возвращается значение Infinity (или -Infinity).
var myNumber = 2; while (myNumber != Infinity) < // Выполнять пока не будет Infinity myNumber = myNumber * myNumber; >
Деление на 0 (ноль) также генерирует значение Infinity:
var x = 2 / 0; // в x будет Infinity var y = -2 / 0; // в y будет -Infinity
Infinity имеет числовой тип: typeof Infinity вернет number:
typeof Infinity; // возвращает "number"
Шестнадцатеричные числа
Если числовая константа начинается с символов 0x, то она интерпретируется JavaScript как шестнадцатеричное число.
var x = 0xFF; // в x будет 255
Внимание! Никогда не записывайте числа в виде значения, начинающегося с нуля (например, 07). Некоторые версии JavaScript интерпретируют такие числа, как записанные в восьмеричном формате.
По умолчанию, JavaScript отображает числа в виде десятеричных значений. Однако при необходимости вы можете вывести числа в любой из трех систем счисления: с основанием 16 (шестнадцатеричная), с основанием 8 (восьмеричная) или с основанием 2 (бинарная). Для этого нужно воспользоваться методом toString():
var myNumber = 128; myNumber.toString(16); // возвращает 80 myNumber.toString(8); // возвращает 200 myNumber.toString(2); // возвращает 10000000
Числа могут быть объектами
Обычно, числа JavaScript это примитивные значения – литералы:
var x = 123;
Однако, при помощи ключевого слова new числа также можно определить и как объекты:
var y = new Number(123);
var x = 123; var y = new Number(123); // typeof x вернет тип number // typeof y вернет тип object
Тем не менее, не определяйте числа как объекты. Это замедляет скорость выполнения скрипта. Кроме этого, ключевое слово new в данном случае усложняет код и может привести к неожиданным результатам:
При использовании оператора сравнения ==, одинаковые числа равны:
var x = 500; var y = new Number(500); // (x == y) будет истинным (true), потому что x и y имеют равные значения
Однако, при использовании оператора сравнения ===, одинаковые числа не будут равными, потому что оператор === ожидает совпадения как по значению, так и по типу.
var x = 500; var y = new Number(500); // (x === y) будет ложным (false), потому что x и y не равны по типу (number и object)
Или еще хуже. Объекты не сравниваются:
var x = new Number(500); var y = new Number(500); // (x == y) - false, потому что x и y разные объекты
Обратите внимание на разницу между (x==y) и (x===y).
Сравнение двух объектов JavaScript всегда возвращает ложь (false).