Переменные - это фундаментальные строительные блоки программы JavaScript. Это имена, которые представляют сущности, хранящиеся в памяти. В JavaScript переменные могут содержать практически все, что угодно. Они могут содержать числа, объекты, логические значения, строки, функции, массивы, разновидности и комбинации этих вещей. Когда вы объявляете переменную, это имя, которое ссылается на эти объекты в памяти. Другими словами, вы получаете объект и управляете им с помощью переменных.

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

Переменные имеют типы данных в JavaScript. Числа, объекты, логические значения и строки - все типы. Существует также тип undefined, который является уникальным в JavaScript и представляет собой переменные, для которых не задано значение или которые еще не были определены. Поскольку переменные могут иметь разные типы, при необходимости они могут быть преобразованы в разные типы данных. Например, строки, содержащие только числовое содержание, могут быть преобразованы в числа и наоборот. Мы можем сделать это с помощью различных операторов и функций, таких как + для преобразования строк в числа и toString функция преобразования числа в строки.

Объявление переменных

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

let a = 1;

Знак равенства - это оператор присваивания. Значение справа устанавливается равным переменной слева. Итак, в этом случае переменная a имеет значение 1. Это объявляет примитивные типы, но мы также можем присвоить объект переменной, например:

let a = { num: 1 };

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

Мы также можем присвоить одну переменную другой переменной. Например, мы можем написать:

let a = 1
let b = a // 1

В приведенном выше примере a установлено в 1, тогда b назначается a, которому присвоено значение 1. b получит значение 1 из a.

const - ключевое слово, с помощью которого мы объявляем константы. Константам JavaScript нельзя присвоить новое значение после их установки. Однако мы можем изменить значения внутри объекта, установленного с помощью const. Итак, мы не можем писать:

const a = { num: 1};
a = 2; // error

но мы можем написать:

const a = { num: 1 };
a.num = 2;

Тогда значение a будет {num: 2}. const очень полезен, поскольку в этом случае очень сложно случайно перезаписать значение вашего объекта.

Мы также можем объявить глобальные переменные, если 'use strict' не добавлен поверх нашего кода. Мы объявляем глобальные переменные, записывая a = 1;, который объявляет a в глобальной области видимости. Это означает, что код, написанный где угодно, может его модифицировать. Это то же самое, что и присоединение a к объекту window, поэтому a = 1 совпадает с window.a = 1. Случайно перезаписать значение a слишком легко, поэтому мы никогда не должны объявлять глобальные переменные, если вы не используете что-то в объекте window.

Именование переменных

Переменным можно давать разные имена. Есть несколько правил, которые применяются при именовании переменных. Они могут начинаться с заглавной или строчной буквы, символа подчеркивания или знака доллара. Переменные в JavaScript чувствительны к регистру, поэтому a не то же самое, что A. Кроме того, они не могут содержать пробелов. Вы можете именовать переменные сколь угодно долго, но если вы сделаете их слишком длинными, это, вероятно, запутает других разработчиков, читающих ваш код.

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

  • Аннотация
  • еще
  • экземпляр
  • выключатель
  • логический
  • перечислить
  • int
  • синхронизированный
  • перерыв
  • экспорт
  • интерфейс
  • это
  • байт
  • расширяет
  • длинный
  • бросать
  • кейс
  • ложный
  • родные
  • бросает
  • ловить
  • окончательный
  • новый
  • преходящий
  • символ
  • наконец
  • нулевой
  • правда
  • класс
  • плавать
  • упаковка
  • пытаться
  • const
  • для
  • частный
  • тип
  • Продолжить
  • функция
  • защищенный
  • вар
  • отладчик
  • перейти к
  • общественный
  • пустота
  • дефолт
  • if
  • возвращение
  • летучий
  • удалять
  • орудия
  • короткая
  • в то время как
  • do
  • Импортировать
  • статический
  • с участием
  • двойной
  • in
  • супер

Типы данных

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

JavaScript предоставляет основные типы данных. Он имеет числовой, строковый, логический, NaN и неопределенный типы.

Тип номера

В переменной типа number хранятся числа, как следует из названия. Числа JavaScript могут варьироваться от 5e-324 (-5 с последующими 324 нулями) до 1.7976931348623157e + 308 (то же, что и 1797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) на�,

Вы можете объявить числовые переменные, написав:

let x = 1;

Мы можем преобразовать переменные любого типа в числа. Если вы конвертируете число в число, вы все равно получите число. Функция Number позволяет преобразовывать переменные любого типа в числа, возможно. Если нет, возвращается NaN, что означает, что преобразовываемая переменная не является числом.

Строки с числовым содержанием можно преобразовать в число.

Number(“1”) // returns number 1

Текстовые строки, которые нельзя преобразовать в числа, возвращают значение NaN:

Number(“duck”) // returns NaN

Логическое значение true возвращает число 1:

Number(true) // returns 1

Логическое значение false возвращает число 0:

Number(false) // returns 0

Другие ложные значения, что означает, что если они преобразованы в логическое значение, они вернут false, также преобразованные в 0. Ложные значения в JavaScript включают пустую строку (“”), 0, false, null и undefined.

Например,

Number(‘’) // returns 0
Number(null) // returns 0
Number(undefined) // returns 0
Number(0) // returns 0

Знак + перед переменной выполняет то же самое, что и функция Number, поэтому мы можем написать:

+“1” // returns number 1
+“duck” // returns NaN
+‘’ // returns 0
+null // returns 0
+undefined // returns 0
+0 // returns 0

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

'2'*'2' // 4
'2'/2 // 1

Но, конечно, это не сработает, если в одной или обеих строках нет только числового содержания. Например: 'duck'*'goose' вернет NaN, поскольку оба они не являются числами.

Тип строки

Строковые типы - это переменные, которые могут хранить любые символы. Он может хранить буквы, цифры, знаки препинания и специальные escape-символы для представления определенных символов. К escape-символам относятся:

  • \ ’- одинарная кавычка
  • \ ”- двойная кавычка
  • \\ - обратная косая черта
  • \ n - новая строка
  • \ r - возврат каретки
  • \ t - вкладка
  • \ b - возврат
  • \ f - подача формы

Мы можем объявить строки, написав:

let a  = 'string';

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

let a = "\"This is a string in quotes\"";

or

let a = "'This is a string in quotes'";

Строки шаблона

В современном JavaScript также есть строки шаблонов, начиная с 2015 года. Это очень удобно, поскольку мы можем помещать переменные внутри строк, чтобы наши строки могли иметь переменные без необходимости их объединения. Мы объявляем строки шаблона с помощью обратного апострофа, который является символом на клавиатуре под клавишей Escape. Мы помещаем переменные внутрь нашей строки, записывая ${a}, где a - переменная.

Например, мы можем написать:

let a = 1;
let b = `There is ${a} chicken.` // There is 1 chicken.

Логический тип

Переменные логического типа могут содержать только значения true или false. Мы заявляем об этом так:

let a = true;

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

  • NaN
  • undefined
  • 0 (числовое значение ноль)
  • -0
  • “” (пустая строка)
  • false

NaN Тип

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

Неопределенный тип

Переменная с типом undefined означает, что для переменной не задано значение или она еще не определена.

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