Как сложить числа в js

Сложение (+)

Оператор сложения (+) создаёт сумму числовых операндов или конкатенацию строк.

Интерактивный пример

Синтаксис

Примеры

Сложение чисел

// Number + Number -> addition 1 + 2; // 3 // Boolean + Number -> addition true + 1; // 2 // Boolean + Boolean -> addition false + false; // 0 

Сложение строк

// String + String -> concatenation "foo" + "bar"; // "foobar" // Number + String -> concatenation 5 + "foo"; // "5foo" // String + Boolean -> concatenation "foo" + false; // "foofalse" 

Спецификации

Specification
ECMAScript Language Specification # sec-addition-operator-plus

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

• Subtraction operator (en-US)
• Division operator (en-US)
• Multiplication operator (en-US)
• Remainder operator (en-US)
• Exponentiation operator (en-US)
• Increment operator (en-US)
• Decrement operator
• Unary negation operator (en-US)
• Unary plus operator (en-US)

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 7 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.

Как сложить числа в js

Мы хотим сделать этот проект с открытым исходным кодом доступным для людей во всем мире. Пожалуйста, помогите нам перевести это руководство на другие языки.

Светлая тема Тёмная тема
Поделиться

• Учебник
• Язык JavaScript
• Продвинутая работа с функциями
• Рекурсия и стек

Вычислить сумму чисел до данного

важность: 5

Напишите функцию sumTo(n) , которая вычисляет сумму чисел 1 + 2 + . + n .

sumTo(1) = 1 sumTo(2) = 2 + 1 = 3 sumTo(3) = 3 + 2 + 1 = 6 sumTo(4) = 4 + 3 + 2 + 1 = 10 . sumTo(100) = 100 + 99 + . + 2 + 1 = 5050

Сделайте три варианта решения:

1. С использованием цикла.
2. Через рекурсию, т.к. sumTo(n) = n + sumTo(n-1) for n > 1 .
3. С использованием формулы арифметической прогрессии.

Пример работы вашей функции:

function sumTo(n) < /*. ваш код . */ >alert( sumTo(100) ); // 5050

P.S. Какой вариант решения самый быстрый? Самый медленный? Почему?

P.P.S. Можно ли при помощи рекурсии посчитать sumTo(100000) ?

Решение с помощью цикла:

function sumTo(n) < let sum = 0; for (let i = 1; i return sum; > alert( sumTo(100) );

Решение через рекурсию:

function sumTo(n) < if (n == 1) return 1; return n + sumTo(n - 1); >alert( sumTo(100) );

Решение по формуле: sumTo(n) = n*(n+1)/2 :

function sumTo(n) < return n * (n + 1) / 2; >alert( sumTo(100) );

P.S. Надо ли говорить, что решение по формуле работает быстрее всех? Это очевидно. Оно использует всего три операции для любого n, а цикл и рекурсия требуют как минимум n операций сложения.

Вариант с циклом – второй по скорости. Он быстрее рекурсии, так как операций сложения столько же, но нет дополнительных вычислительных затрат на организацию вложенных вызовов. Поэтому рекурсия в данном случае работает медленнее всех.

P.P.S. Некоторые движки поддерживают оптимизацию «хвостового вызова»: если рекурсивный вызов является самым последним в функции, без каких-либо других вычислений, то внешней функции не нужно будет возобновлять выполнение и не нужно запоминать контекст его выполнения. В итоге требования к памяти снижаются. Но если JavaScript-движок не поддерживает это (большинство не поддерживают), будет ошибка: максимальный размер стека превышен, так как обычно существует ограничение на максимальный размер стека.

• © 2007—2024 Илья Кантор
• о проекте
• связаться с нами
• пользовательское соглашение
• политика конфиденциальности

Числа (объект 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).

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.