Арифметические операции — JavaScript

Что это и зачем?

Представь, что ты — кассир в магазине сладостей. К тебе подходит покупатель и говорит: «Дайте мне 3 шоколадки по 50 рублей и 2 лимонада по 70 рублей». Чтобы посчитать сумму, тебе нужно умножить (3 × 50 и 2 × 70), потом сложить результаты. А если покупатель даёт 500 рублей, нужно вычесть сумму покупки, чтобы сдать сдачу. Если же конфеты продаются по 4 штуки в упаковке, а нужно 10 конфет — придётся делить и узнавать, сколько упаковок брать.

В JavaScript арифметические операции работают точно так же, как на уроках математики. Только вместо того чтобы писать на бумаге, ты даёшь команды компьютеру. Компьютер считает мгновенно и никогда не ошибается (если ты не ошибёшься в команде).

Зачем это нужно программисту? Представь, что ты пишешь игру, где персонаж собирает монетки. Каждая монетка добавляет 10 очков. Тебе нужно уметь прибавлять 10 к текущему счёту. Или, например, ты делаешь калькулятор для уроков физики — там нужны все операции сразу.

В JavaScript есть 5 основных арифметических действий:

• + — сложение (как в школе)
• - — вычитание
• * — умножение (звёздочка, потому что на клавиатуре нет знака ×)
• / — деление (слеш, потому что нет знака ÷)
• % — остаток от деления (это новое! Показывает, сколько останется, если поделить нацело)

В отличие от Python, где деление всегда даёт дробное число (например, 10 / 3 = 3.333...), в JavaScript тоже есть дробные числа, но есть одна хитрость: целые числа в JS могут вести себя неожиданно, если их много. Но об этом позже.

Главное правило: компьютер выполняет действия в том же порядке, что и в математике: сначала умножение и деление, потом сложение и вычитание. Скобки меняют порядок. Запомни: сначала скобки, потом умножение/деление, потом сложение/вычитание.

Примеры кода с объяснением

Давай сразу перейдём к примерам. Открывай консоль браузера (F12 → вкладка Console) или любой онлайн-редактор и пробуй вводить код. Все примеры можно копировать и запускать.

Пример 1: Сложение и вычитание — как в магазине

// У тебя было 150 рублей. Ты купил пирожок за 45 рублей.
// Сколько денег осталось?
let bylo = 150;
let potratil = 45;
let ostalos = bylo - potratil;
console.log("Осталось рублей:", ostalos); // Выведет: Осталось рублей: 105

// А теперь представь, что мама дала ещё 50 рублей на мороженое.
let dobavka = 50;
let vsego = ostalos + dobavka;
console.log("Теперь всего денег:", vsego); // Выведет: Теперь всего денег: 155

// Кстати, можно сразу писать числа, без переменных:
console.log(100 + 200); // 300
console.log(500 - 250); // 250

Объяснение: Переменные — это как коробочки с наклейками. В коробку bylo мы положили число 150. Когда мы пишем bylo - potratil, компьютер достаёт из коробок числа и вычитает. Результат кладём в новую коробку ostalos. console.log — это команда «покажи результат в консоли».

В Python то же самое выглядело бы почти так же, только let не нужен (в Python просто bylo = 150). JavaScript требует let (или const, или var), чтобы объявить переменную.

Пример 2: Умножение — считаем стоимость покупки

// Ты покупаешь 4 тетради по 25 рублей каждая.
// Сколько нужно заплатить?
let cenaTetradi = 25;
let kolichestvo = 4;
let stoimost = cenaTetradi * kolichestvo;
console.log("Стоимость тетрадей:", stoimost); // 100

// А если нужно купить 3 пачки печенья по 89 рублей и 2 сока по 55 рублей?
let pechenie = 89 * 3; // 267
let sok = 55 * 2;      // 110
let itog = pechenie + sok;
console.log("Итого к оплате:", itog); // 377

// Можно считать прямо в console.log:
console.log("Проверка:", 89 * 3 + 55 * 2); // Тоже 377

// Умножение в программировании — это звёздочка *.
// В математике пишут ×, на клавиатуре его нет, поэтому используют *.
console.log(10 * 10); // 100
console.log(7 * 8);   // 56

Объяснение: Обрати внимание: мы не написали (89 * 3) + (55 * 2), хотя так тоже можно. Компьютер сам знает, что умножение выполняется раньше сложения. Но если хочешь быть уверенным — ставь скобки. Они не мешают, а делают код понятнее.

Совет: всегда ставь скобки в сложных выражениях, как в математике. (a + b) * c — это не то же самое, что a + b * c.

Пример 3: Деление — делим пиццу

// У тебя пицца на 8 кусков. Вас 3 друга (и ты — четвёртый).
// Сколько кусков достанется каждому, если делить поровну?
let kuskov = 8;
let druzei = 4; // ты + 3 друга
let kazhdomu = kuskov / druzei;
console.log("Каждому по кусков:", kazhdomu); // 2

// А если пицца на 10 кусков, а вас 4?
console.log(10 / 4); // 2.5 — каждому по 2 с половиной куска

// Деление может давать дробные числа. В JavaScript они называются "числа с плавающей точкой".
console.log(7 / 2); // 3.5
console.log(1 / 3); // 0.3333333333333333 (много цифр после запятой)

// Важно: если разделить 0 на любое число, получится 0:
console.log(0 / 5); // 0

// А если число разделить на 0? Получится Infinity (бесконечность):
console.log(10 / 0); // Infinity — это специальное значение в JS

Объяснение: В Python деление / тоже даёт дробное число. Но в Python есть ещё // — целочисленное деление (сколько целых кусков). В JavaScript такого оператора нет (но есть способы получить целое число — через Math.floor или Math.trunc, об этом позже).

Запомни: делить на ноль в математике нельзя, но компьютер не зависает — он выдаёт Infinity (бесконечность). Это полезно знать, чтобы не пугаться.

Пример 4: Остаток от деления — секретный оператор %

// Вернёмся к пицце. 10 кусков, 4 человека.
// Каждому по 2 целых куска, но останется 2 куска (10 - 4*2 = 2).
// Вот этот остаток и показывает оператор % (проценты, но не проценты!).
let ostatok = 10 % 4;
console.log("Останется кусков:", ostatok); // 2

// Ещё пример: 15 конфет, 4 друга.
console.log(15 % 4); // 3 (каждому по 3, останется 3)

// Где это пригодится? Например, нужно узнать, чётное число или нет.
let chislo = 42;
if (chislo % 2 === 0) {
    console.log("Число чётное"); // Это выполнится, потому что 42 % 2 = 0
} else {
    console.log("Число нечётное");
}

// Или проверить, делится ли число на 5:
console.log(25 % 5); // 0 — делится нацело
console.log(27 % 5); // 2 — не делится, остаток 2

// Внимание: оператор % работает и с отрицательными числами, но там есть нюансы.
console.log(-7 % 3); // -1 (в JavaScript остаток может быть отрицательным, в Python — всегда положительный)
// В Python: -7 % 3 = 2. Это важно помнить, если переходишь с Python на JS!

Объяснение: Оператор % (называется «процент», но на самом деле «остаток от деления») — одна из самых полезных вещей в программировании. С его помощью можно:

• Проверять чётность чисел
• Узнавать, делится ли одно число на другое без остатка
• Создавать циклические эффекты (например, в играх: если остаток от деления на 10 равен 0 — выдавать бонус)

Разница с Python: в Python -7 % 3 даёт 2, а в JavaScript — -1. Почему? Потому что в Python остаток всегда неотрицательный, а в JavaScript он может быть отрицательным, если делимое отрицательное. Запомни: если работаешь с отрицательными числами, лучше использовать Math.abs или проверять знак.

Пример 5: Комбинируем всё вместе — задача про поездку

// Задача: ты едешь на море. Расстояние — 600 км.
// Твоя машина проезжает 100 км на 8 литрах бензина.
// Бензин стоит 55 рублей за литр.
// Сколько денег нужно на бензин в одну сторону?

let rasstoyanie = 600; // км
let rashodNa100km = 8; // литров
let cenaBenzina = 55; // рублей за литр

// Сначала узнаем, сколько литров нужно на всю дорогу.
let litrovVsego = (rasstoyanie / 100) * rashodNa100km;
// 600 / 100 = 6 (сотен км), умножаем на 8 = 48 литров.
console.log("Нужно литров:", litrovVsego); // 48

// Теперь считаем стоимость:
let stoimostBenzina = litrovVsego * cenaBenzina;
console.log("Стоимость бензина в рублях:", stoimostBenzina); // 2640

// А если туда и обратно? (1200 км)
let vsegoKm = rasstoyanie * 2;
let litrovTudaObratno = (vsegoKm / 100) * rashodNa100km;
let itogovayaSumma = litrovTudaObratno * cenaBenzina;
console.log("Туда и обратно:", itogovayaSumma); // 5280

// Можно было посчитать проще: умножить результат на 2.
console.log("Проверка:", stoimostBenzina * 2); // 5280

// Или сразу одной строкой:
console.log("Одной строкой:", ((600 * 2) / 100) * 8 * 55); // 5280

Объяснение: Обрати внимание на скобки. Мы написали (rasstoyanie / 100) * rashodNa100km. Если бы мы написали rasstoyanie / 100 * rashodNa100km, результат был бы тем же, потому что деление и умножение имеют одинаковый приоритет и выполняются слева направо. Но скобки делают код понятнее для тебя и других программистов.

В этом примере мы использовали сразу 4 операции: деление, умножение, сложение (хотя его не видно — мы просто умножили расстояние на 2) и присваивание. Компьютер выполнил всё за долю секунды.

Типичные ошибки

Даже опытные программисты иногда ошибаются в арифметике. Вот самые частые ошибки новичков:

Ошибка 1: Забываешь, что умножение и деление выполняются раньше сложения

// Хочешь посчитать среднее арифметическое трёх чисел: 5, 10, 15.
// Правильно: (5 + 10 + 15) / 3 = 10
// А если забыть скобки:
console.log(5 + 10 + 15 / 3); // 5 + 10 + 5 = 20 (неправильно!)
// Компьютер сначала разделил 15 на 3, а потом сложил.

Решение: Всегда ставь скобки вокруг суммы, если ты делишь сумму на что-то: (a + b + c) / 3.

Ошибка 2: Путаешь оператор присваивания = и сравнения ===

let x = 10;
// Хочешь проверить, равно ли x 10?
if (x = 10) { // Ошибка! Здесь не сравнение, а присваивание!
    console.log("Равно");
}
// В результате x станет 10 (если был другим), и условие сработает, но не так, как ты думал.
// Правильно: if (x === 10)

Решение: Запомни: = — это «положить в коробку», а === — «проверить, одинаковое ли содержимое». В Python используют == для сравнения, а в JavaScript — === (строгое сравнение). Никогда не путай!

Ошибка 3: Деление на ноль (случайно)

let a = 10;
let b = 0;
console.log(a / b); // Infinity — не ошибка, но может испортить дальнейшие расчёты
// Если потом умножить Infinity на что-то, получится Infinity.
// Если разделить Infinity на Infinity, получится NaN (Not a Number — не число).

Решение: Всегда проверяй, не равен ли делитель нулю, особенно если число вводит пользователь. Например:

let delitel = 0;
if (delitel !== 0) {
    console.log(10 / delitel);
} else {
    console.log("На ноль делить нельзя!");
}

Ошибка 4: Не учитываешь, что числа могут быть дробными

console.log(0.1 + 0.2); // 0.30000000000000004 (не 0.3!)
// Это особенность компьютеров: они не