Типы данных: целые и дробные числа

1. Целые числа (Integers)

Представьте, что вы создаете свой первый мини-сайт или игру. Вам наверняка понадобится:

• Считать очки игрока.
• Отображать количество товаров в корзине.
• Вычислять общую стоимость покупки.
• Таймер обратного отсчета до конца акции.
• И даже просто посчитать, сколько дней до вашей следующей зарплаты! (Кстати, это самая популярная операция для программистов).

Для всего этого нам нужны числа. В JavaScript, как и в жизни, числа бывают разные: целые и дробные. Давайте разберемся, что это за "звери" и как с ними работать.

Целые числа — это те, у которых нет дробной части. Все просто, как 1, 2, 3, -10 или 1000000. Это ваши любимые "счетные" числа.

В JavaScript нет отдельного типа для целых чисел, как в некоторых других языках (например, в C# или Java, которые мы видели в примерах). Здесь все числа хранятся как "числа с плавающей точкой двойной точности" (да, звучит страшно, но на практике обычно не беспокоит). Однако для простоты мы будем делить их на "целые" и "дробные" по их значению.

Как объявить целое число?
Точно так же, как мы объявляли другие переменные, используя let или const, и просто присваиваем числовое значение без кавычек.

// Объявляем количество золотых монет у нашего героя
let goldCoins = 100;
console.log("У героя сейчас", goldCoins, "золотых монет."); 
// Вывод: У героя сейчас 100 золотых монет.

Как видите, все числа пишутся без кавычек. Если вы случайно поставите кавычки, JavaScript подумает, что это текст (строка), а не число, и тогда с ним нельзя будет выполнять математические операции! Это как если бы вы пытались посчитать, сколько у вас "яблок" + "груш". Получится "яблокигруши", а не количество фруктов.

2. Дробные числа (Floating-point numbers)

Дробные числа, или числа с плавающей точкой, — это те, у которых есть дробная часть, отделенная точкой (не запятой, это важно!). Например, 3.14, 0.5, 99.99. Эти числа очень важны, когда речь идет о чем-то, что нельзя посчитать поштучно: деньги, измерения, проценты.

// Цена одного драгоценного камня
const gemPrice = 15.5; 
console.log("Цена одного камня:", gemPrice, "монет.");
// Вывод: Цена одного камня: 15.5 монет.

Вроде все просто. Но есть подвох:

// Точность дробных чисел: когда математика шутит
let result = 0.1 + 0.2;
console.log("0.1 + 0.2 =", result); // Вывод: 0.1 + 0.2 = 0.30000000000000004

Вы не ошиблись, и ваш калькулятор на телефоне тоже не сошёл с ума. В мире JavaScript (да и вообще в большинстве языков программирования) есть небольшой подвох с дробными числами. Из-за того, как компьютеры хранят дробные числа (в двоичной системе), некоторые обычные для нас десятичные дроби (вроде 0.1) не могут быть представлены абсолютно точно. Это как пытаться записать 1/3 в десятичной системе: 0.333333... и так до бесконечности. Компьютер "отрезает" эти хвосты, что приводит к крошечным неточностям.

3. Математические операции

Итак, у нас есть числа. Теперь давайте заставим их выполнять полезную работу. JavaScript поддерживает все стандартные арифметические операции, которые вы знаете со школьной скамьи:

Сложение (+)

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

let currentGold = 100;
let questReward = 50;

// Герой выполнил квест и получил золото
currentGold = currentGold + questReward; 
console.log("Новое количество золота после квеста:", currentGold);
// Вывод: Новое количество золота после квеста: 150

Вычитание (-)

Используется для вычитания одного числа из другого.

let playerHealth = 100;
let damageTaken = 25;

// Игрок получил урон от монстра
playerHealth = playerHealth - damageTaken; 
console.log("Здоровье игрока после удара:", playerHealth);
// Вывод: Здоровье игрока после удара: 75

Умножение (*)

Используется для умножения чисел. Звездочка (*) — это наш знак умножения.

let potionPrice = 5;
let numberOfPotions = 3;

// Сколько золота нужно за 3 зелья?
let totalPotionCost = potionPrice * numberOfPotions;
console.log("Стоимость 3 зелий:", totalPotionCost);
// Вывод: Стоимость 3 зелий: 15

Деление (/)

Используется для деления чисел. Слэш (/) — это наш знак деления.

let totalXP = 1000;
let playersInParty = 4;

// Сколько опыта получит каждый игрок, если поделить поровну?
let xpPerPlayer = totalXP / playersInParty;
console.log("Опыт на игрока:", xpPerPlayer);
// Вывод: Опыт на игрока: 250

Важный момент: деление на ноль в JavaScript не вызывает ошибку, как в некоторых других языках. Оно просто возвращает Infinity (бесконечность) или NaN (Not a Number — не число), если это 0/0.

console.log("10 / 0 =", 10 / 0); // Вывод: 10 / 0 = Infinity
console.log("0 / 0 =", 0 / 0);   // Вывод: 0 / 0 = NaN

Запомните это, чтобы не удивляться, если вдруг увидите Infinity или NaN в результате своих расчетов!

Остаток от деления (%)

Этот оператор (%) возвращает остаток от деления. Он очень полезен, когда нужно проверить число на четность, или определить, сколько "осталось" после того, как вы что-то поделили на равные части. Представьте, что у вас 10 печенек, и вы хотите поделить их по 3 штуки. Сколько полных порций получится? Три. А сколько печенек останется? Одна. Вот эта "одна" и есть остаток.

let totalCookies = 10;
let cookiesPerPack = 3;

// Сколько печенек останется после формирования полных упаковок?
let remainingCookies = totalCookies % cookiesPerPack;
console.log("Остаток печенек:", remainingCookies);
// Вывод: Остаток печенек: 1

Оператор % — это просто суперзвезда, когда дело доходит до циклических задач, например, чтобы что-то происходило каждый N-й раз, или чтобы элемент из списка повторялся после достижения конца.

4. Приоритет операций

Помните школьное правило "сначала умножение и деление, потом сложение и вычитание"? В JavaScript это работает точно так же! Операции выполняются в определенном порядке, который называется приоритетом.

1. Скобки (): Всё, что внутри скобок, выполняется в первую очередь. Это как в математике — скобки меняют порядок действий.
2. Умножение (*), Деление (/), Остаток от деления (%): Эти операции имеют одинаковый приоритет и выполняются слева направо.
3. Сложение (+), Вычитание (-): Эти операции имеют самый низкий приоритет среди арифметических и тоже выполняются слева направо.

Примеры:

// Без скобок
let result1 = 5 + 2 * 3; 
// Сначала 2 * 3 = 6, потом 5 + 6 = 11
console.log("5 + 2 * 3 =", result1); // Вывод: 5 + 2 * 3 = 11

// Со скобками
let result2 = (5 + 2) * 3; 
// Сначала (5 + 2) = 7, потом 7 * 3 = 21
console.log("(5 + 2) * 3 =", result2); // Вывод: (5 + 2) * 3 = 21

Когда сомневаетесь, или если выражение выглядит слишком сложно, всегда используйте скобки! Они не только гарантируют правильный порядок вычислений, но и делают ваш код намного понятнее для вас самих (спустя месяц, когда вы забудете, что там намудрили) и для других программистов. Чистый код — счастливый код!

5. Сокращенные операции и инкремент/декремент

Программисты — существа ленивые. В хорошем смысле! Мы всегда ищем способы писать меньше кода, чтобы делать больше. И JavaScript нам в этом очень помогает, предлагая сокращенные операторы.

Инкремент (++) и Декремент (--)

Эти операторы используются, чтобы увеличить или уменьшить числовую переменную на единицу. Они очень часто встречаются, когда нужно посчитать количество чего-либо (например, очков, жизней, пройденных шагов).

• ++ (инкремент): увеличивает значение переменной на 1.
• -- (декремент): уменьшает значение переменной на 1.

Есть два варианта: префиксный (оператор перед переменной) и постфиксный (оператор после переменной). Разница проявляется, когда вы используете эту операцию внутри другого выражения.

Постфиксный инкремент/декремент (variable++ / variable--):
Сначала используется текущее значение переменной в выражении, а потом значение переменной увеличивается/уменьшается.

let playerLives = 3;
let score = 0;
console.log("Начальные жизни:", playerLives); // Вывод: 3

// Игрок использовал жизнь. Сначала добавляем текущие жизни к счету, потом уменьшаем их.
score = playerLives-- * 10; // score = 3 * 10 = 30. А playerLives после этой строки станет 2.
console.log("Очки (постфиксный декремент):", score);       // Вывод: 30
console.log("Жизни после декремента:", playerLives); // Вывод: 2

В этом примере playerLives-- сначала "отдал" своё значение (3) для умножения, и только потом уменьшился до 2.

Сокращенная запись присваивания (+=, -=, *=, /=, %= )

Эти операторы позволяют объединить арифметическую операцию и присваивание. Вместо того чтобы писать a = a + 5;, мы можем написать a += 5;. Это не только короче, но и часто читается интуитивнее, когда вы привыкнете.

x += 5;

x = x + 5;

y -= 2;

y = y - 2;

z *= 3;

z = z * 3;

a /= 4;

a = a / 4;

b %= 2;

b = b % 2;

Примеры использования:

let currentScore = 100;

// Игрок получил бонусные очки
currentScore += 50; // currentScore = 100 + 50 = 150
console.log("Счет после бонуса:", currentScore); 
// Вывод: Счет после бонуса: 150

Эти сокращенные операторы сильно упрощают код и делают его более читаемым, особенно когда нужно выполнить множество операций над одной и той же переменной.

6. Типичные ошибки при работе с числами и операциями

Работая с числами в JavaScript, новички (да и опытные программисты иногда!) могут столкнуться с несколькими распространенными "граблями". Вот на что стоит обратить внимание:

Ошибка №1: Сложение числа со строкой.
Это, пожалуй, самый частый сюрприз для начинающих. Если вы попытаетесь сложить число со строкой (let result = 10 + "5";), JavaScript не выдаст ошибку, но и не посчитает 15. Вместо этого он "склеит" их, превратив число в строку. В итоге result станет строкой "105". Это происходит из-за того, что оператор + в JavaScript используется как для сложения чисел, так и для конкатенации (склейки) строк. Если хотя бы один из операндов — строка, + ведет себя как оператор конкатенации. Будьте внимательны! Чтобы этого избежать, убедитесь, что обе части сложения — числа, используя функции преобразования типов, о которых мы поговорим в будущих лекциях.

Ошибка №2: Непонимание точности дробных чисел.
Мы уже упоминали, что 0.1 + 0.2 в JavaScript дает 0.30000000000000004. Эта "погрешность" может быть проблемой в очень точных расчетах, например, в финансовых приложениях. Для большинства задач это не критично, но если вам нужна абсолютная точность с десятичными дробями, придется либо округлять результат ((0.1 + 0.2).toFixed(2)), либо использовать специальные библиотеки для работы с большими числами (BigDecimal в других языках, или аналогичные в JS).

Ошибка №3: Путаница префиксного и постфиксного инкремента/декремента.
Как мы видели, a++ и ++a ведут себя по-разному, если используются внутри выражений. Если вы просто увеличиваете или уменьшаете значение переменной, не используя ее в той же строке для другой операции, то нет разницы, какой вариант использовать. Но если вы пишете что-то вроде let y = x++; или let y = ++x;, помните, что порядок получения значения и изменения переменной отличается. Всегда проверяйте, когда именно вам нужно, чтобы переменная изменилась.

Ошибка №4: Забытый приоритет операций.
Иногда по невнимательности забывают про правила математического приоритета, что приводит к неверным результатам. Например, ожидают, что 10 - 2 * 3 будет равен 24 (если бы сначала было 10 - 2), но на самом деле он равен 4 (потому что сначала 2 * 3 = 6, а потом 10 - 6 = 4). Всегда используйте скобки () для ясности и для принудительного изменения порядка операций, если стандартный приоритет вас не устраивает. Это сделает ваш код более надежным и понятным.

1

Задача

Модуль 1: Web Core, 20 уровень, 3 лекция

Недоступна

Переопределение методов

Переопределение методов

Открыть

1

Задача

Модуль 1: Web Core, 20 уровень, 3 лекция

Недоступна

Метод sum в Array

Метод sum в Array

Открыть