Теперь, когда мы умеем писать и выполнять JavaScript, давайте перейдем к самым фундаментальным строительным блокам языка: переменным, типам данных и операторам.
Переменная – это именованная область в памяти, где мы можем хранить информацию (данные). Представьте ее как контейнер с ярлычком (именем).
Исторически в JavaScript использовалось ключевое слово var. Однако с появлением современных стандартов ECMAScript 2015 (ES6) появились let и const, которые предлагают более предсказуемое и безопасное поведение.
let: Объявляет переменную, которая может быть изменена. Это наш основной инструмент для переменных, чьи значения будут меняться в процессе выполнения программы.javascriptlet message = "Привет"; // Объявили переменную message и присвоили ей значение "Привет"
console.log(message); // Выведет: Привет
message = "Привет, мир!"; // Теперь мы можем изменить значение переменной
console.log(message); // Выведет: Привет, мир!
Область видимости let: Переменные, объявленные с помощью let, имеют блочную область видимости. Это означает, что они существуют только внутри того блока кода (например, внутри фигурных скобок {} для циклов или условий), где были объявлены.javascriptif (true) {
let blockVar = "Я внутри блока";
console.log(blockVar); // Работает
}
// console.log(blockVar); // Ошибка! blockVar не существует вне блока if
const: Объявляет переменную, значение которой не может быть изменено после первого присваивания. Используйте const для значений, которые должны оставаться постоянными. Это помогает избежать случайных изменений и делает код более читаемым.javascriptconst PI = 3.14159;
console.log(PI); // Выведет: 3.14159
// PI = 3.14; // Ошибка! Нельзя переприсвоить значение константе.
Важно: const означает, что переменной нельзя присвоить новое значение. Если переменная хранит объект или массив, сами объекты/массивы можно изменять (например, добавлять элементы в массив), но нельзя присвоить этой переменной другой массив или объект.javascriptconst person = { name: "Алиса" };
person.name = "Боб"; // Можно изменять свойства объекта
console.log(person.name); // Выведет: Боб
// person = { name: "Чарли" }; // Ошибка! Нельзя переприсвоить новый объект.
var: Объявляет переменную, которая имеет функциональную область видимости (а не блочную, как let). В современном JavaScript let и const предпочтительнее из-за более предсказуемого поведения. Тем не менее, вы можете встретить var в старом коде.javascript// Пример с var, чтобы показать разницу
if (true) {
var oldVar = "Я существую везде";
console.log(oldVar); // Работает
}
console.log(oldVar); // Работает! oldVar видна вне блока if.
Из-за такого поведения var может приводить к трудноуловимым ошибкам, поэтому старайтесь использовать let и const.
Правило: Всегда старайтесь использовать const по умолчанию. Если вам нужно изменить значение переменной, тогда используйте let. Избегайте var.
JavaScript – это язык с динамической типизацией. Это значит, что тип переменной определяется в момент присваивания значения, и вы можете менять его позже.
Существуют примитивные типы данных (неизменяемые) и объекты (изменяемые).
Примитивные типы:
String (Строка): Последовательность символов. Используется для представления текста.
Примеры: "Привет", 'JavaScript', `Шаблонная строка`
Заметьте, что строки могут заключаться в одинарные ('), двойные (") или обратные (`) кавычки. Обратные кавычки (шаблонные строки) позволяют встраивать выражения с помощью ${выражение}.javascriptlet firstName = "Алексей";
let lastName = 'Петров';
let greeting = `Привет, ${firstName} ${lastName}!`; // Шаблонная строка
console.log(greeting); // Выведет: Привет, Алексей Петров!
Number (Число): Используется для целых и дробных чисел.Примеры: 10, 3.14, -5, 1000
JavaScript также имеет специальные числовые значения:Infinity: Бесконечность (например, 1 / 0).
–Infinity: Отрицательная бесконечность.
NaN (Not a Number): Результат некорректных числовых операций (например, 'abc' / 2).
Boolean (Булево значение): Имеет только два возможных значения: true (истина) или false (ложь). Часто используется в условиях.Примеры: true, false
Undefined (Неопределенное): Переменная, которая была объявлена, но ей не было присвоено никакого значения.Пример: let someVariable; console.log(someVariable); // Выведет: undefined
Null (Пустое значение): Явно указывает на отсутствие какого-либо объекта или значения. В отличие от undefined, null присваивается намеренно.Пример: let emptyValue = null;
Symbol (Символ): Уникальное и неизменяемое примитивное значение, часто используется как ключ свойства объекта, чтобы избежать конфликтов имен. (Более продвинутая тема, для начала можно не углубляться).
BigInt (Большое целое число): Для работы с целыми числами, которые превышают максимальное безопасное целочисленное значение для типа Number.
Объекты (Object):
Это более сложный тип данных, который может содержать коллекции данных (свойства) и функции (методы). Объекты не являются примитивными.
Примеры: { name: "Алиса", age: 30 }, [1, 2, 3] (массивы – это тоже объекты).
Как узнать тип переменной:
Используйте оператор typeof.
javascript
let str = "Текст";
console.log(typeof str); // Выведет: string
let num = 100;
console.log(typeof num); // Выведет: number
let isTrue = true;
console.log(typeof isTrue); // Выведет: boolean
let emptyVar;
console.log(typeof emptyVar); // Выведет: undefined
let nullValue = null;
console.log(typeof nullValue); // Внимание! Выведет: object (это историческая особенность JavaScript)
let person = { name: "Иван" };
console.log(typeof person); // Выведет: object
let arr = [1, 2, 3];
console.log(typeof arr); // Выведет: object (массивы – это объекты)
Операторы – это символы, которые выполняют операции над значениями (операндами).
Арифметические операторы:
+ : Сложение (также конкатенация строк)javascriptlet sum = 10 + 5; // 15
let greeting = "Привет" + " " + "мир!"; // "Привет мир!"
– : Вычитаниеjavascriptlet difference = 10 – 5; // 5
* : Умножениеjavascriptlet product = 10 * 5; // 50
/ : Делениеjavascriptlet quotient = 10 / 5; // 2
% : Остаток от деления (оператор модуля)javascriptlet remainder = 10 % 3; // 1 (10 = 3*3 + 1)
let evenOrOdd = 7 % 2; // 1 (нечетное), 6 % 2 // 0 (четное)
++ : Инкремент (увеличение на 1)javascriptlet counter = 5;
counter++; // counter теперь 6
console.log(counter); // 6
Важно: ++ и – могут использоваться как перед переменной (префиксная форма), так и после (постфиксная). Их поведение немного отличается, когда они используются внутри выражения (об этом позже).– : Декремент (уменьшение на 1)javascriptlet counter = 5;
counter–; // counter теперь 4
console.log(counter); // 4
Операторы присваивания:
= : Простое присваивание (мы уже видели его)javascriptlet a = 10;
+=, -=, *=, /=, %= : Сокращенные операторы.javascriptlet x = 10;
x += 5; // То же, что x = x + 5; x теперь 15
x -= 2; // То же, что x = x – 2; x теперь 13
x *= 3; // То же, что x = x * 3; x теперь 39
Операторы сравнения: Возвращают true или false.
== : Равенство (с учетом преобразования типов)javascriptconsole.log(5 == "5"); // true (строка "5" преобразуется в число 5)
console.log(0 == false); // true (false преобразуется в 0)
=== : Строгое равенство (без преобразования типов) – предпочтительный вариант!javascriptconsole.log(5 === "5"); // false (тип Number не равен типу String)
console.log(0 === false); // false
console.log(5 === 5); // true
!= : Неравенство (с учетом преобразования типов)javascriptconsole.log(5 != "5"); // false
!== : Строгое неравенство (без преобразования типов) – предпочтительный вариант!javascriptconsole.log(5 !== "5"); // true
> : Больше
< : Меньше
>= : Больше или равно
<= : Меньше или равно
Логические операторы: Используются для объединения или инвертирования булевых значений.
&& (Логическое И): Возвращает true, если оба операнда true.javascriptlet isLogged = true;
let isAdmin = true;
console.log(isLogged && isAdmin); // true
let isUser = true;
let isGuest = false;
console.log(isUser && isGuest); // false
|| (Логическое ИЛИ): Возвращает true, если хотя бы один из операндов true.javascriptlet hasPermission = true;
let hasAccess = false;
console.log(hasPermission || hasAccess); // true
let isWeekend = false;
let isHoliday = false;
console.log(isWeekend || isHoliday); // false
! (Логическое НЕ): Инвертирует булево значение.javascriptlet isOnline = false;
console.log(!isOnline); // true
let isEmpty = true;
console.log(!isEmpty); // false
JavaScript часто пытается автоматически преобразовать типы данных, чтобы выполнить операцию. Это называется неявным преобразованием. Хотя иногда это удобно, оно может приводить к неожиданным результатам. Гораздо безопаснее и понятнее использовать явное преобразование.
Неявное преобразование (когда JavaScript делает сам):
При использовании + со строкой: Любое число или булево значение будет преобразовано в строку.javascriptconsole.log("Значение: " + 5); // "Значение: 5"
console.log("Статус: " + true); // "Статус: true"
При сравнении с ==: Один операнд может быть преобразован к типу другого.javascriptconsole.log(5 == "5"); // true (строка "5" стала числом 5)
console.log(true == 1); // true (true стало числом 1)
console.log(null == undefined); // true (особый случай)
Явное преобразование (когда мы говорим JavaScript, что делать):
В строку:
String(value): Преобразует любое значение в строку.javascriptconsole.log(String(123)); // "123"
console.log(String(true)); // "true"
console.log(String(null)); // "null"
console.log(String(undefined)); // "undefined"
value.toString(): Метод объектов (включая числа, но не null и undefined).javascriptconsole.log((123).toString()); // "123"
console.log(true.toString()); // "true"
// console.log(null.toString()); // Ошибка!
В число:
Number(value): Преобразует любое значение в число.javascriptconsole.log(Number("123")); // 123
console.log(Number("Привет")); // NaN (не число)
console.log(Number(true)); // 1
console.log(Number(false)); // 0
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN
parseInt(string, radix): Парсит строку и возвращает целое число. radix – основание системы счисления (обычно 10).javascriptconsole.log(parseInt("123px", 10)); // 123 (игнорирует "px")
console.log(parseInt("0xFF", 16)); // 255 (шестнадцатеричная система)
console.log(parseInt("abc", 10)); // NaN
parseFloat(string): Парсит строку и возвращает число с плавающей точкой.javascriptconsole.log(parseFloat("3.14м")); // 3.14
Унарный плюс (+): Быстрый способ преобразовать в число.javascriptconsole.log(+"123"); // 123
console.log(+"Привет"); // NaN
console.log(+true); // 1
В булево значение:Boolean(value): Преобразует любое значение в true или false.
“Falsy” значения (преобразуются в false):false
0 (ноль)
"" (пустая строка)
null
undefined
NaN
Все остальные значения преобразуются в true (их называют “Truthy” значениями).
javascriptconsole.log(Boolean("Привет")); // true
console.log(Boolean("")); // false
console.log(Boolean(100)); // true
console.log(Boolean(0)); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean({})); // true (пустой объект – Truthy!)
console.log(Boolean([])); // true (пустой массив – Truthy!)
Задание 1: Система учета товаров
javascript
// 1. Создайте константы для базовой информации о магазине:
// – Название магазина (строка)
// – Курс валюты (число)
// – Признак активности (булево значение)
// 2. Создайте переменные для:
// – Количества товара на складе
// – Цены товара
// – Названия товара
// 3. Проверьте типы всех созданных переменных
// 4. Попробуйте изменить константу с названием магазина
// и обработайте ошибку с помощью try/catch
Задание 2: Калькулятор скидок
javascript
// 1. Создайте переменные для:
// – Исходной цены товара
// – Процента скидки
// – Порога для дополнительной скидки
// 2. Рассчитайте:
// – Цену со скидкой
// – Разницу между исходной и конечной ценой
// – Итоговый процент скидки с точностью до 2 знаков
// 3. Используйте операторы сравнения для проверки:
// – Превышает ли скидка пороговое значение
// – Является ли цена положительным числом
Задание 3: Валидация данных формы
javascript
// Напишите функцию validateForm(data), которая принимает объект с полями:
// – name (строка)
// – age (число)
// – email (строка)
// – subscription (булево значение)
// Функция должна проверять типы данных и возвращать объект с результатами:
// – isValid (булево значение)
// – errors (массив строк с описанием ошибок)
Решение задания 1:
javascript
// 1. Создаем константы
const STORE_NAME = "TechMarket";
const CURRENCY_RATE = 97.5;
const IS_ACTIVE = true;
// 2. Создаем переменные
let stockQuantity = 150;
let itemPrice = 2990;
let itemName = "Смартфон";
// 3. Проверяем типы
console.log(typeof STORE_NAME); // "string"
console.log(typeof CURRENCY_RATE); // "number"
console.log(typeof IS_ACTIVE); // "boolean"
console.log(typeof stockQuantity); // "number"
// 4. Пытаемся изменить константу
try {
STORE_NAME = "NewMarket"; // Вызовет ошибку
} catch (error) {
console.log("Ошибка:", error.message);
// "Assignment to constant variable"
}
Решение задания 2:
javascript
// 1. Исходные данные
let originalPrice = 5000;
let discountPercent = 15;
let threshold = 10;
// 2. Расчеты
let discountAmount = originalPrice * (discountPercent / 100);
let finalPrice = originalPrice – discountAmount;
let priceDifference = originalPrice – finalPrice;
let actualDiscountPercent = (priceDifference / originalPrice) * 100;
// Округляем до 2 знаков
actualDiscountPercent = Number(actualDiscountPercent.toFixed(2));
// 3. Проверки
let isAboveThreshold = discountPercent > threshold;
let isPriceValid = originalPrice > 0;
console.log("Цена со скидкой:", finalPrice);
console.log("Реальная скидка:", actualDiscountPercent + "%");
console.log("Скидка выше порога:", isAboveThreshold);
console.log("Цена валидна:", isPriceValid);
Решение задания 3:
javascript
function validateForm(data) {
let errors = [];
// Проверка имени
if (typeof data.name !== 'string' || data.name.trim().length === 0) {
errors.push("Имя должно быть непустой строкой");
}
// Проверка возраста
if (typeof data.age !== 'number' || data.age < 0 || data.age > 150) {
errors.push("Возраст должен быть числом от 0 до 150");
}
// Проверка email
if (typeof data.email !== 'string' || !data.email.includes('@')) {
errors.push("Email должен быть строкой с символом @");
}
// Проверка подписки
if (typeof data.subscription !== 'boolean') {
errors.push("Подписка должна быть булевым значением");
}
return {
isValid: errors.length === 0,
errors: errors
};
}
// Пример использования:
const userData = {
name: "Иван Иванов",
age: 25,
email: "ivan@example.com",
subscription: true
};
console.log(validateForm(userData));
// { isValid: true, errors: [] }
Мы начали с самых азов: как работает веб, как открыть инструменты разработчика, как написать первую строку кода, как объявлять переменные и какие типы данных существуют. Это основа, на которой будет строиться все остальное.
О проекте
О подписке
Другие проекты