Работа с переменными в javascript: Работа с переменными

Видео курс JavaScript Starter. Переменные и типы данных

• Главная >
• Каталог >
• JavaScript Стартовый >
• Переменные и типы данных в JavaScript

Для прохождения теста нужно авторизироваться

Войти Регистрация

×

Вы открыли доступ к тесту! Пройти тест

Войдите или зарегестрируйтесь для того чтоб продолжить просмотр бесплатного видео

Войти Регистрация

№1

Введение

0:28:13

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

№2

Структура кода

0:21:14

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

№3

Переменные и типы данных в JavaScript

0:38:50

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Строки и преобразование типов

0:28:04

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Операторы

0:39:16

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Условный оператор if

0:44:53

Материалы урокаДомашние заданияТестирование

Условные конструкции – важная часть любого алгоритма. Без условных конструкций код будет выполняться линейно и одинаково. Если вы хотите сделать так, чтобы действия пользователя могли влиять на последовательность выполнения инструкций, вам нужно научиться работать с оператором if else и узнать особенности работы с типом данных Boolean. Как раз эту задачу решает данный урок.

Читать дальше…

Switch и тернарный оператор

0:22:34

Материалы урокаДомашние заданияТестирование

Оператор if это основа ветвления в коде, но иногда для ветвлений подойдет другая условная конструкция – switch. В этом уроке будут рассмотрены способы использования оператора switch и вы узнаете, как работают такие ключевые слова как case, default и break. Также, в этом уроке будет рассмотрена третья условная конструкция – тернарный оператор. Она не очень часто используется в коде, но в определенных ситуация может сделать код более понятным и коротким.

Читать дальше…

Циклы

0:48:05

Материалы урокаДомашние заданияТестирование

В процессе создания алгоритма часто необходимо одно и то же действие выполнить много раз. Вместо того, чтобы копировать инструкции в коде, разработчик использует циклы. В этом уроке вы узнаете, как с помощью циклических конструкций while, do/while и for повторить блок кода нужное количество раз.

Читать дальше…

Массивы в JavaScript

0:36:57

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Методы массивов

0:28:25

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Функции. Часть 1

0:51:24

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Функции. Часть 2

1:00:54

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Объекты. Часть 1

0:35:20

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

Объекты. Часть 2

0:36:56

Материалы урокаДомашние заданияТестирование

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

Читать дальше…

ПОКАЗАТЬ ВСЕ

ПОДРОБНЕЕ

ПОДРОБНЕЕ

ПОДРОБНЕЕ

Регистрация через

или E-mail

Нажав на кнопку «Зарегистрироваться»,
Вы соглашаетесь с условиями использования.

Уже есть аккаунт

Получите курс бесплатно

Вы выбрали курс для изучения
«»
Чтобы получить доступ к курсу, зарегистрируйтесь на сайте.

РЕГИСТРАЦИЯ

Спасибо за регистрацию

Перейдите на почту и подтвердите Ваш аккаунт,
чтобы получить доступ ко всем
бесплатным урокам и вебинарам на сайте ITVDN.com

ПОДТВЕРДИТЬ ПОЧТУ НАЧАТЬ ОБУЧЕНИЕ

Спасибо за регистрацию

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

НАЧАТЬ ОБУЧЕНИЕ

Подтверждение аккаунта

На Ваш номер телефона было отправлено смс с кодом активации аккаунта. Пожалуйста, введите код в поле ввода.

Отправить код еще раз

Изменить номер телефона

Ошибка

Переменные JavaScript. Типизация JavaScript переменных. Объявление переменных JavaScript.

Здравствуйте, уважаемые посетители моего скромного блога для начинающих вебразработчиков и web мастеров ZametkiNaPolyah.ru. Продолжаем рубрику Заметки по JavaScript, в которой уже были следующие публикации: типы данных JavaScript, числа JavaScript, строки JavaScript, вставка JavaScript в HTML, JavaScript операторы (void JavaScript, delete JavaScript, typeof JavaScript, new JavaScript), преобразование число в строку JavaScript и строку в число JavaScript, логические значения false и true JavaScript, синтаксис JavaScript и лексическая структура JavaScript, специальные значения null JavaScript и undefined JavaScript. Сегодня речь пойдет о JavaScript переменных и работе с JavaScript переменными.

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

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

JavaScript переменные.

Содержание статьи:

• JavaScript переменные.
• Типизация переменных JavaScript. JavaScript слабо типизированный язык программирования.
• Объявление переменных JavaScript. Создание JavaScript переменных. Инициализация переменной JavaScript.

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

name=”John”;

В данном случае можно сказать, что внутри переменной name хранится JavaScript строка или значение John. Со значением, хранящимся в переменной можно произвести какую-либо операцию, например конкатенацию строк:

name=”John”; var hello=”Hello, ”+name+”!”;

В данному случае для объявления переменной hello я использовал ключевое слово JavaScript var. Также в примере используется оператор склейки строк JavaScript “+” (конкатенации строк), который нужен для того, чтобы вывести осмысленное приветствие. Собственно, на этом я бы мог остановиться и сказать: в принципе, вышесказанного достаточно для того, чтобы писать программы и использовать JavaScript переменные. Но, чтобы не появлялись вопросы: а почему у меня возникают ошибки, вроде бы все правильно сделал, нужно знать немного больше про JavaScript переменные.

Типизация переменных JavaScript. JavaScript слабо типизированный язык программирования.

Если вы пробовали писать программы на таких языках как C и Java, то знаете, что при объявление переменной указывается тип данных этой переменной и в дальнейшем никак нельзя изменить тип данных, который может храниться в этой переменной.

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

Таким образом, JavaScript переменной можно присвоить какое-либо число, а затем присвоить специальное значение, например null JavaScript:

n=16; n=null;

JavaScript переменная n будет содержать значение, которое ей присвоили последним, в нашем случае переменная n содержит значение null.

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

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

Объявление переменных JavaScript. Создание JavaScript переменных. Инициализация переменной JavaScript.

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

var new_var;

Таким образом, мы объявили JavaScript переменную, точнее мы явно объявили переменную JavaScript. Мы создали участок памяти, который назвали new_var и в последствие мы можем обращаться к этому участку памяти. Если не объявлять JavaScript переменную явно, то интерпретатор сделает это сам, в этом случае говорят, что переменная объявлена неявно.

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

var new_var = “Это JavaScript строка”;

В JavaScript можно объявлять и инициализировать переменные в одну строку:

var n=0, k=5, h=7;

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

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

Ключевое слово var можно использовать внутри JavaScript циклов, то есть можно объявлять и инициализировать переменные внутри цикла.

Теперь давайте немного поговорим о инструкции var JavaScript. Инструкция var позволяет объявить JavaScript переменную, причем объявить одну и ту же JavaScript переменную можно несколько раз. Если у вас появится желание прочитать значение, которое хранится в не объявленной JavaScript переменной (не созданной, не существующей), то с генерируется ошибка. Если вы присвоите значение JavaScript переменной (инициализируете переменную), не объявляя ее (не используя инструкцию var), то JavaScript интерпретатор неявно объявит переменную.

name = “Ivan”;

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

На этом всё, спасибо за внимание, надеюсь, что был хоть чем-то полезен и до скорых встреч на страницах блога для начинающих вебразработчиков и вебмастеров ZametkiNaPolyah.ru. Не забываем комментировать и делиться с друзьями;)

Что такое переменные и зачем их использовать в JavaScript

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

Итак, начнем эту статью с решения простой задачи.

Подсчет яблок

Если у вас есть 4 яблока и вы покупаете еще 27, сколько яблок у вас будет? Потратьте секунду и напишите свой ответ в текстовом редакторе.

Что ты ответишь?

 // Это?
31
// Или это?
4 + 27
 

Оба ответа верны, но второй метод лучше, потому что вы перекладываете вычисления на JavaScript. Вы учите его, как прийти к ответу.

Но есть еще одна проблема с кодом.

Если вы посмотрите на 4 + 27 без какого-либо контекста нашей проблемы с яблоками, знаете ли вы, что мы подсчитываем количество яблок, которые вы сейчас держите?

Вероятно, нет.

Итак, лучше использовать алгебру, чтобы заменить 4 и 27 переменными. Когда вы это сделаете, вы получите возможность писать код, который имеет смысл:

 начальныйЯблоки + яблокиКуплено
 

Процесс замены 4 на переменную с именем initialApples называется объявлением переменных.

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

Вы объявляете переменные со следующим синтаксисом:

 const имя_переменной = 'значение'
 

Есть четыре детали, на которые вы должны обратить внимание:

1. Имя переменной
2. Значение
3. Знак =
4. Ключевое слово const

Имя переменной

variableName — это имя переменной, которую вы объявляете. Вы можете назвать его как угодно, если оно соответствует следующим правилам:

1. Должно быть одно слово
2. Должен состоять только из букв, цифр или знаков подчеркивания (0-9, a-z, A-Z, _ ).
3. Не может начинаться с цифры.
4. Это не может быть ни одно из этих зарезервированных ключевых слов

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

Хорошим примером переменной в верблюжьем регистре является applesToBuy .

Значение

Значение — это то, что вы хотите, чтобы была переменная. Это могут быть примитивы (например, строки, числа и т. д.) или объекты (например, массивы и функции).

= в JavaScript

= в JavaScript не работает так, как = в математике. Не запутайтесь.

В JavaScript = означает присвоение . Когда вы используете = , вы устанавливаете (или присваиваете) значение с правой стороны (RHS) знака = левой стороне (LHS) знака = .

В следующем операторе переменной initialApples присваивается значение 4.

 const начальные яблоки = 4
 

Если вы console.log эту переменную, вы можете увидеть, что initialApples равно 4.

 console.log(initialApples) // 4
 

Оценка перед назначением

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

 const начальные яблоки = 4
константа applesToBuy = 27
const totalApples = начальные яблоки + applesToBuy
 

В этом примере JavaScript оценит ответ initialApples + applesToBuy (что дает 31) перед присвоением результатов totalApples . Вот почему вы получаете 31 при попытке войти totalApples .

 console.log(всего яблок) // 31
 

Ключевое слово const

const — одно из трех ключевых слов, которые можно использовать для объявления переменных. Есть еще два ключевых слова — let и var .

Все три ключевых слова объявляют переменные, но они немного отличаются друг от друга.

Константа против пусть против вар

const и let — ключевые слова, доступные нам в ES6. Это лучшие ключевые слова для создания переменных, чем var , потому что они блочные, а var — функции.

А пока давайте сосредоточимся на разнице между const и let .

Константа против пусть

Если вы объявите переменную с const , вы не сможете переназначить ей новое значение. Следующий код выдает ошибку:

 const applesToBuy = 22
// Переназначение переменной, объявленной с помощью const, приводит к ошибке
яблоки на покупку = 27
 

. Если вы объявляете переменную с помощью let , , вы можете переназначить ее с новым значением.

 пусть applesToBuy = 22
яблоки на покупку = 27
console.log(яблоки для покупки)
 

. Следует ли использовать const или let?

Понимание того, следует ли использовать const или let , является более сложной темой.

Когда вы начинаете, используя let было бы намного проще, чем использование const .

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

Так как вы собираетесь использовать const вместо пусть в любом случае, когда вы пишете более сложные программы, лучше привыкнуть предпочитать const вместо пусть , когда вы начинаете.

Если вам интересно, не используйте больше var , потому что в этом нет необходимости. let и const намного лучше, чем var .

Подведение итогов

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

Знак = в JavaScript отличается от знака = в Math. В JavaScript = означает присвоение.

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

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

Эта статья представляет собой пример урока из курса Learn JavaScript 9. 0100 — курс, который поможет вам изучить JavaScript и создавать настоящие практические компоненты с нуля. Если вы нашли эту статью полезной, я приглашаю вас узнать больше о Learn JavaScript.

Если вам понравилась эта статья, поддержите меня, поделившись этой статьей в Твиттере или купив мне кофе 😉. Если вы заметили опечатку, я был бы признателен, если бы вы могли исправить ее на GitHub. Спасибо!

7 способов создания хороших переменных JavaScript

Содержание

• Используйте осмысленные и не требующие пояснений имена переменных
• Сохраняйте переменные локальными
• Предпочитайте let и const var
• Используйте по одному let и const на каждое назначение
• Инициализируйте переменные при их объявлении вы их используете
• Заключение: 7 способов создания хороших переменных JavaScript

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

Используйте осмысленные и не требующие пояснений имена переменных

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

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

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

 // Раньше:
const flb = fs.readFileSync('/foo/bar/bills.txt', 'utf8')
const cdt = новая дата()
const cy = cd.getYear()
константа см = cd.getMonth()
const cd = cd.getDay()
const anms = ['собака', 'кошка', 'медведь', 'волк', 'лев']
const clgs = ['Джек', 'Дрейк', 'Джилл']
// После:
const fileWithBills = fs.readFileSync('/foo/bar/bills.txt', 'utf8')
const текущая дата = новая дата ()
const currentYear = cd.getYear()
константа текущего месяца = cd.getMonth()
const currentDay = cd.getDay()
const animals = ['собака', 'кошка', 'медведь', 'волк', 'лев']
const коллеги = ['Джек', 'Дрейк', 'Джилл']
 

У этой практики есть еще одно преимущество. Ваш код станет легче искать. Легче искать «fileWithBills» или «bills», когда вы хотите найти переменную с файлом со счетами, чем «fl», «flb», «bls» или что-то еще, что пришло в голову в первую очередь. Считайте это сэкономленным/потерянным впустую временем в следующий раз, когда вы захотите назвать переменную.

Сохранять переменные локальными

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

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

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

 // До (глобальная переменная):
const users = ['joejoe', 'стеф', 'филл']
функция someFunctionUsingUsers() {
  // Делаем что-то с данными в переменной "users". ..
}
// После (локальная переменная):
функция someFunctionUsingUsers() {
  // Сделать переменную «users» локальной:
  const users = ['joejoe', 'стеф', 'филл']
  // Делаем что-то с данными в переменной "users"...
}
// Переменная используется в кодовой базе:
// Держите глобальную переменную «users»:
const users = ['joejoe', 'стеф', 'филл']
функция someFunctionUsingUsers() {
  // Делаем что-то с данными в переменной "users"...
}
функция otherFunctionUsingUsers() {
  // Делаем что-то с данными в переменной "users"...
}
функция ещеAnotherFunctionUsingUsers() {
  // Делаем что-то с данными в переменной "users"...
}
 

Предпочесть

 // переменная:
console.log(домашнее животное)
// Выход:
// неопределенный
вар домашнее животное
домашнее животное = «черепаха»
// пусть и константа:
console. log(домашнее животное)
// Выход:
// ReferenceError: невозможно получить доступ к 'домашнему животному' до инициализации
пусть домашнее животное
домашнее животное = 'броненосец'
 

 // Раньше с var:
// Создаем глобальную переменную var:
имя переменной = 'Джек'
если правда) {
  // Создаем переменную var в блоке if...else
  // с тем же именем, что и глобальная переменная:
  имя переменной = 'Тобиас'
}
// Записываем значение глобальной переменной name:
console.log(имя)
// Выход:
// 'Тобиас'
// После с помощью let (а также const):
// Создаем глобальную переменную let:
пусть имя = 'Виктория'
если правда) {
  // Создаем переменную let в блоке if...else
  // с тем же именем, что и глобальная переменная:
  пусть имя = 'Сьюзан'
}
// Записываем значение глобальной переменной name:
console.log(имя)
// Выход:
// 'Виктория'
 

 // До (let/const и множественные присваивания):
константное имя = 'Томми'
возраст = 32
карьера = 'Инженер DevOps'
навыки = ['git', 'docker', 'kubernetes', 'JavaScript', 'бессерверный']
// После (let/const и одно присваивание):
константное имя = 'Томми'
постоянный возраст = 32
const Career = 'Инженер DevOps'
const skills = ['git', 'docker', 'kubernetes', 'JavaScript', 'бессерверный']
 

 // Раньше:
// Объявить переменные:
назовите имя, возраст, увлечения
// ... и инициализируем их позже:
имя = 'Джо'
возраст = 57
хобби = ['играть в игры', 'читать книги']
// После:
// Объявить и инициализировать переменные:
пусть имя = 'Джо'
пусть возраст = 57
let hobbies = ['игры', 'чтение книг']
 

 // Раньше:
константный материал = ['беспорядок']
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
функция functionUsingStuff() {
 // Делаем что-то с данными в переменной "stuff"...
}
// После:
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
// много кода...
константный материал = ['беспорядок']
функция functionUsingStuff() {
 // Делаем что-то с данными в переменной "stuff"...
}
// Альтернативно:
// много кода.