логотип PurpleSchool
Иконка входа
Вход
  • Обучение
  • Войти
логотип PurpleSchool

Основы JavaScript для начинающих

06 января 2024 г.
3 103 просмотра
фото команды
Автор

Вячеслав

Введение

JavaScript – это ключ к волнующему миру веб-разработки, в котором он играет важную роль и на стороне клиента (в браузере пользователя), и на стороне сервера. Начать изучение JavaScript – значит взглянуть на мир программирования с широкой перспективы. Почему этот язык так важен?

Зачем изучать JavaScript?

JavaScript является универсальным языком программирования, который дает вам возможность придавать жизнь вашим идеям. Создание динамичных интерфейсов, обработка событий, взаимодействие с пользователями – все это делает JavaScript неотъемлемой частью как клиентской, так и серверной веб-разработки.

Роль JavaScript в веб-разработке

JavaScript на стороне клиента используется для создания интерактивных пользовательских интерфейсов, в то время как на стороне сервера он используется для обработки запросов, управления базами данных и бизнес-логикой. Этот язык становится ключевым элементом технологического стека веб-разработчика.

Краткий обзор структуры статьи

Статья представляет собой полное руководство по основам JavaScript, охватывая ключевые концепции, необходимые для старта вашего пути в программировании. Мы начнем с базового синтаксиса и постепенно перейдем к более сложным темам, таким как функции и объекты. Каждая часть статьи подкреплена примерами кода и практическими заданиями, чтобы обеспечить легкость усвоения материала. Независимо от вашего уровня подготовки, это руководство призвано убедить вас: программирование – это увлекательное и доступное искусство, которое можно освоить сегодня.

Основы синтаксиса JavaScript

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

Переменные

Переменные – это контейнеры для хранения данных. В JavaScript есть три ключевых слова для создания переменных: letconst, и var.

let:  переменные, объявленные с использованием let, могут изменяться после их создания.

let name = 'John'; name = 'Max'; // Допустимо, можно изменять

const:  переменные, объявленные с использованием const, являются константами и не могут изменяться после их присвоения.

const PI = 3.14;
PI = 8; // Недопустимо, приведет к ошибке

var: Ранее использовавшееся ключевое слово для объявления переменных. В отличие от let и constvar имеет различное поведение в некоторых случаях, и его использование старается избегаться в современном коде. 

var x = 5;

Комментарии в коде

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

Однострочные комментарии и комментарии после кода начинаются с двойного слэша ( // ).

// Это однострочный комментарий
let name = 'John';
let age = 25; // Это комментарий к переменной "age"

Многострочные комментарии начинаются с /* и заканчиваются */. Они могут охватывать несколько строк:

/*
  Это многострочный комментарий.
  Он может охватывать несколько строк и использоваться для
  более подробных пояснений к блокам кода.
*/
let year = 2024;

Многострочные комментарии использоваться для более подробных пояснений к блокам кода.

Типы данных

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

Строки Strings используются для текстовой информации.

let greeting = 'Привет, мир!';

Числа Numbers используются для представления числовых значений.

let age = 42;

Логические значения Booleans представляют истину true или ложь false.

let isAdmin = true; let isMarried = false;

Значение null не относится ни к одному из типов, описанных выше. Оно формирует отдельный тип, который содержит только значение null:

let surname = null;

Это значение представляет собой «ничего», «пусто» или «значение неизвестно».

Значение undefined Оно означает, что значение не было присвоено

let age; 
let name = undefined;

Если переменная объявлена, но ей не присвоено никакого значения, то её значением будет undefinedМы можем сами присвоить значение undefinedлюбой переменной

Арифметические операторы

Арифметические операторы используются для выполнения математических операций. Рассмотрим примеры:

  • Сложение ( + )
  • Вычитание ( - )
  • Умножение ( * )
  • Деление ( / )
  • Остаток от деления ( % )

Давайте посмотрим как это работает в JavaScript:

let sum = 5 + 3;         // Результат: 8
let difference = 10 - 4; // Результат: 6
let product = 3 * 5;     // Результат: 15
let quotient = 20 / 4;   // Результат: 5
let remainder = 15 % 7;  // Результат: 1

Строковые операторы

Строковые операторы используются для работы с текстовой информацией.

Конкатенация ( + ):

let greeting = 'Привет' + ' ' + 'мир!'; // Результат: 'Привет мир!'

Операторы сравнения

Операторы сравнения используются для сравнения двух значений и возвращают логическое значение (true или false).

Равно ( == ) cравнивает значения с приведением типов (приводит типы, если они отличаются).

let logical_and = true && false; // Результат: false

В данном примере строка '5' приволится к числу 5 происходит сравнение числа 5 и числа 5.

Строго равно ( === ) cравнивает значения без приведения типов (сравнивает значения и типы данных).

let strictly_equal = number1 === number2; // Результат: false

В большинстве случаев рекомендуется использовать ===, чтобы избежать неожиданных результатов, связанных с приведением типов.

Преобразование типов

Мы часто сталкиваемся с разными типами данных, такими как числа, строки и булевы значения. Иногда возникает необходимость преобразовать один тип в другой. Давайте рассмотрим способы преобразования типов и приведем примеры.

Преобразование в число (Number()) используется для преобразования значения в число. Рассмотрим пример:

let num = Number('123'); 
console.log(num); // Вывод: 123

Преобразование в строку (String()) используется для преобразования значения в строку:

let str = String(456); 
console.log(str); // Вывод: '456'

Преобразование в булево (Boolean()) используется для преобразования значения в булево (логическое) значение.

let boolean_value_1 = Boolean(0); 
let boolean_value_2 = Boolean(1); 
let boolean_value_3 = Boolean(50);

console.log(boolean_value_1); // Вывод: false 
console.log(boolean_value_2); // Вывод: true 
console.log(boolean_value_3); // Вывод: true

Автоматическое преобразование типов в JavaScript происходит во время выполнения операций, когда операторы или функции ожидают определенный тип данных, отличающийся от текущего. Давайте рассмотрим различные сценарии автоматического преобразования и приведем примеры.

В данном случае, при конкатенации строки и числа, число автоматически преобразуется в строку:

let str = 'Возраст: ' + 42; 

console.log(str); // Вывод: 'Возраст: 42'

Оператор умножения * приводит строку к числу

let num = '123' * 1; 

console.log(num); // Вывод: 123

Двойное отрицание !! используется для преобразования значения в булево. Все строки, кроме пустой строки, преобразуются в true.

let boolean_value = !!'Какая-то строка'; 

console.log(boolean_value); // Вывод: true

Преобразование типов в JavaScript является важной частью работы с данными. Понимание, как происходит преобразование, поможет вам более эффективно оперировать значениями разных типов в ваших программных решениях.

Логические операторы

Логические операторы используются для комбинирования или изменения логических значений.

И (&&) возвращает true, если оба значения являются истинными, иначе возвращает false

let logical_and = true && false; // Результат: false

Часто используется в условиях, где необходимо, чтобы все условия были истинными.

Оператор ИЛИ (||): возвращает true, если хотя бы одно из значений истинно, иначе возвращает false

 let logical_or = true || false; // Результат: true

Используется, когда нужно, чтобы хотя бы одно из условий было истинным

Оператор НЕ (!): инвертирует логическое значение. Если значение было true, то оно становится false, и наоборот

let negation = !true; // Результат: false

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

Условные операторы (if, else)

Условные операторы в JavaScript позволяют вам принимать решения на основе логики ваших программ. Они позволяют выполнять определенные блоки кода только при соблюдении определенных условий.

Оператор if

Оператор if используется для выполнения кода, если заданное условие истинно.

let age = 18;

if (age >= 18) {
  console.log('Вы совершеннолетний!');
}

Если значение переменной age больше или равно 18, то код внутри блока if будет выполнен

Оператор else

Оператор else используется для выполнения кода, если условие в ifне является истинным.

let age = 16;

if (age >= 18) {
  console.log('Вы совершеннолетний');
} else {
  console.log('Вы несовершеннолетний');
}

Если значение переменной age меньше 18, то выполнится код внутри блока else.

Оператор else if

Оператор else if используется для добавления дополнительных условий, которые проверяются, если предыдущие условия были ложными.

let age = 22;

if (age < 18) {
  console.log('Вы несовершеннолетний');
} else if (age < 25) {
  console.log('Вы молодой');
} else {
  console.log('Вы взрослый');
}

Если значение age меньше 18, выполнится первый блок. Если от 18 до 24, выполнится второй блок, иначе выполнится блок else.

Условные операторы являются мощным инструментом для управления потоком выполнения программы, основываясь на условиях. Они позволяют вашему коду принимать решения и выполнять различные действия в зависимости от ситуации.

Циклы (for, while)

Циклы в JavaScript предоставляют механизм для многократного выполнения одного и того же участка кода. Давайте рассмотрим два основных типа циклов: for и while.

Цикл for

Цикл for предназначен для выполнения блока кода определенное количество раз.

for (let i = 0; i < 5; i++) {
  console.log('Это итерация номер ' + (i + 1));
}
  1. let i = 0: Начальное значение счетчика.
  2. i < 5: Условие выполнения цикла.
  3. i++: Инкремент (увеличение счетчика на 1).

Давайте рассмотрим простой пример использования цикла для подсчета суммы чисел от 1 до 10. Мы будем использовать цикл for для итерации от 1 до 10 и накапливать сумму чисел в переменной sum.

let sum = 0;

for (let i = 1; i <= 10; i++) {
  sum += i;
}

console.log('Сумма чисел от 1 до 10: ' + sum); // Вывод: 55
  1. let сумма = 0;: Мы инициализируем переменную сумма значением 0.
  2. for (let i = 1; i <= 10; i++): Цикл for начинается с 1, выполняется до 10 (включительно), и каждую итерацию увеличивает значение i на 1.
  3. сумма += i;: Мы добавляем текущее значение i к переменной sum на каждой итерации.

После завершения цикла мы выводим сумму чисел от 1 до 10, которая равна 55 в этом случае.

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

Цкил while

Цикл whileвыполняет блок кода, пока условие в скобочках истинно.

Пример:

let counter = 0;

while (counter < 3) {
  console.log('Это итерация номер ' + (counter + 1));
  counter = counter + 1;
}
  1. let counter = 0: Инициализация счетчика перед циклом.
  2. counter < 3: Условие выполнения цикла.
  3. counter = counter + 1: Инкремент счетчика внутри цикла.

Цикл while подходит для ситуаций, когда точное количество итераций заранее неизвестно, и выполнение зависит от условия. В данном примере, цикл будет выполняться, пока число меньше 3.

Массивы

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

Существует два варианта синтаксиса для создания пустого массива:

let emptyArray = [];
let emptyArray = new Array();

Создание массива с элементами:

let arrayOfNumbers = [1, 2, 3, 4, 5];
let arrayOfStrings = ['apple', 'banana', 'orange'];
let mixedArray = [1, 'two', true, [1, 2, 3]];

Элементы массива нумеруются, начиная с нуля.

Мы можем получить элемент, указав его номер в квадратных скобках:

console.log(arrayOfStrings[0]); // Вывод: 'apple'
console.log(arrayOfStrings[1]); // Вывод: 'banana'
console.log(arrayOfStrings[2]); // Вывод: 'orange'

Мы можем заменить элемент:

arrayOfStrings[2] = 'mango'; // Теперь ['apple', 'banana', 'mango']

Мы можем узнать длину массива с помощью метода length:

console.log(arrayOfStrings.length); // Вывод: 3

Мы можем добавить элемент к уже существующему массиву:

// Добавляем элемент в конец массива
arrayOfStrings.push('mango'); // Теперь ['apple', 'banana', 'orange', 'mango']

// Добавляем элемент в начало массива
arrayOfStrings.unshift('mango'); // Теперь ['mango', 'apple', 'banana', 'orange']

Мы можем удалять элементы массива:

// Удаление последнего элемента
arrayOfStrings.pop(); // ['apple', 'banana']

// Удаление первого элемента
arrayOfStrings.shift(); // ['banana', 'orange']

Мы можем использовать цикл for для перебора массива:

let arratOfNumbers = [10, 20, 30];

for (let i = 0; i < arratOfNumbers.length; i++) {
  console.log(arratOfNumbers[i]);
}

Функции

Функции - это фрагменты кода, которые могут быть именованы, сохранены и затем вызваны для выполнения определенной задачи. Функции помогают организовать код, сделать его более читаемым и уменьшить повторение блоков кода.

Объявление и вызов функций

Функции в JavaScript могут быть объявлены с использованием ключевого слова function

function sayHi() {
  console.log('Привет, мир!');
}

Вызвать функции можно по имени с использованием круглых скобок:

sayHi(); // Вывод: 'Привет, мир!'

Параметры и возвращаемые значения

Функции могут принимать параметры (значения, передаваемые при вызове) и возвращать значения с использованием ключевого слова return.

Пример с параметрами и возвращаемым значением:

function sum(a, b) {
  return a + b;
}

let result = sum(5, 3);
console.log(result); // Вывод: 8

Стрелочные функции (Arrow Functions)

Стрелочные функции представляют сокращенный синтаксис для объявления функций

Пример стрелочной функции:

let sayHi = () => {
  console.log('Привет, мир!');
};

sayHi(); // Вывод: 'Привет, мир!'

Предположим, у вас есть функция, которая возводит число x в степень n >= 1. Эта функция может быть переиспользована в различных частях вашего кода, где вам нужно произвести такое преобразование

function pow(x, n) {
  if (n < 1) {
    return false;
  }

  let result = 1;
  for (let i = 0; i < n; i++) {
    result = result * x;
  }

  return result;
}
  1. Если значение n меньше 1, функция возвращает false. Это предостережение от некорректных входных данных, так как функция предназначена для работы с положительными степенями.
  2. Переменная result инициализируется значением 1. Это начальное значение, и в нее будет поочередно умножаться число x
  3. Цикл for выполняется от 0 до n - 1. На каждом шаге цикла значение result умножается на x. Таким образом, на выходе из цикла переменная result содержит значение x в степени n.
  4. Функция возвращает значение переменной result как результат возведения в степень.

Теперь мы можем возводить число в степень с помощью этой функции

console.log(pow(5, 3)); // Вывод: 125
console.log(pow(6, 5)); // Вывод: 7776

Объекты

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

Создадим объект "Коробка для игрушек"

let toyBox = {
  color: 'красный',
  size: 'средний',
  toys: ['мяч', 'кукла', 'машина'],
  isOpen: false,
  open: function () {
    this.isOpen = true;
    console.log('Коробка открыта!');
  },
};

Наша коробка для игрушек имеет различные свойства. Мы можем обратиться к ним различными способами:

console.log(toyBox.color); // Вывод: 'красный'
console.log(toyBox['color']); // Вывод: 'красный'

Так же мы можем изменять значения объекта:

toyBox.color = 'синий';
toyBox.toys.push('кубики');
toyBox.open(); // Вывод: 'Коробка открыта!'

И теперь наша коробка с игрушками будет выглядить так:

{
  color: 'синий',
  size: 'средний',
  toys: ['мяч', 'кукла', 'машина', 'кубики'],
  isOpen: true,
  open: function() {
    this.isOpen = true;
    console.log('Коробка открыта!');
  }
}

this - это ключевое слово, которое указывает на текущий контекст выполнения кода, или, другими словами, на объект, который вызывает метод. В контексте метода openthis ссылается на объект toyBox, потому что метод вызывается на этом объекте.

Таким образом, использование this позволяет методу взаимодействовать с данными и свойствами конкретного объекта, сделав код более гибким и переиспользуемым для различных объектов.

Метод open в объекте выполняет две важные вещи:

  1. this.isOpen = true говорит о том, что мы устанавливаем состояние коробки в открытое.
  2. console.log('Коробка открыта!') просто выводит сообщение "Коробка открыта!" в консоль браузера или среды выполнения JavaScript.

Цикл for..in

Для перебора всех свойств объекта используется цикл for..in. Этот цикл отличается от изученного ранее цикла for(;;).

К примеру, выведем все свойства ранее созданного объекта toyBox2:

let toyBox2 = {
  color: 'красный',
  size: 'средний',
  toys: ['мяч', 'кукла', 'машина'],
};

for (let key in toyBox) {
  // ключи
  console.log(key); //  color, size, toys
  // значения ключей
  console.log(toyBox[key]); // красный, средний, ["мяч", "кукла", "машина"]
}

Обработка ошибок и отладка в JavaScript

JavaScript, как и любой другой язык программирования, подразумевает работу с ошибками и их отладку. Это важная часть процесса разработки, которая помогает создавать более стабильные и надежные приложения. В этом блоке статьи мы рассмотрим два основных аспекта обработки ошибок и отладки в JavaScript: использование try-catch блоков.

Использование try-catch блоков

Одним из основных методов обработки ошибок в JavaScript является использование конструкции try-catch. Этот механизм позволяет попытаться выполнить определенный блок кода, и, если в процессе возникает ошибка, перехватить её и выполнить альтернативный блок кода в блоке catch.

Пример:

try {
  // Блок кода, который может вызвать ошибку
  let result = invalidFunction(); // Функция, которая вызывает ошибку
  console.log(result); // Этот код не выполнится при ошибке в предыдущей строке
} catch (error) {
  // Блок кода для обработки ошибки
  console.error('Произошла ошибка:', error.message); // Выводит сообщение об ошибке
} finally {
  // Блок кода, который выполняется в любом случае
  console.log('Этот код выполнится всегда');
}

Заключение

В процессе изучения основ JavaScript вы освоили ключевые концепции этого мощного языка программирования. Надеемся, что статья была полезной и помогла вам сформировать прочное понимание базовых принципов JavaScript.

JavaScript открывает двери в захватывающий мир веб-разработки, создания интерактивных интерфейсов и многое другое. Независимо от того, новичок вы или опытный разработчик, JavaScript предоставляет множество возможностей для реализации ваших идей.

Не бойтесь экспериментировать, создавать и делиться своим кодом. Программирование – это искусство, и ваш вклад может внести значительный вклад в развитие этого удивительного сообщества.

Начните свое увлекательное путешествие в мир программирования с JavaScript уже сегодня!

изображение курса

Основы разработки

Антон Ларичев
иконка часов4 часа лекций
иконка звёздочки рейтинга5.0
бесплатно
Основы разработки