Переменные — Основы JavaScript
Представьте себе задачу: нам нужно напечатать на экран фразу Father! два раза или даже пять раз. Эту задачу можно решить в лоб:
console.log('Father!'); // => Father! console.log('Father!'); // => Father! В простейшем случае так и стоит поступить, но если фраза Father! начнет использоваться чаще, да еще и в разных частях программы, то придется ее везде повторять. Проблемы с таким подходом начнутся тогда, когда понадобится изменить нашу фразу, а такое происходит довольно часто. Нам придется найти все места, где использовалась фраза Father!, и выполнить необходимую замену. А можно поступить по-другому. Вместо копирования нашего выражения достаточно создать (объявить) переменную с этой фразой.
// greeting – переводится как приветствие let greeting = 'Father!'; console.log(greeting); // => Father! console.log(greeting); // => Father! Переменная указывает на данные, которые были в нее записаны. Благодаря этому, данные можно использовать многократно без необходимости их постоянно дублировать. Сама переменная создается и наполняется данными (инициализируется) с помощью инструкции let greeting = ‘Father!’ .
Для имени переменной используется любой набор допустимых символов, к которым относятся буквы английского алфавита, цифры, а также знаки _ и $. При этом цифру нельзя ставить в начале. Имена переменных регистрозависимы, то есть имя hello и имя heLLo – это два разных имени, а значит и две переменные. Регистр в JavaScript имеет важное значение, никогда не забывайте про него.
Переменную не обязательно инициализировать данными во время объявления. Иногда бывает нужно ее создать, а наполняться она будет потом:
let greeting; // Использование console.log(greeting); // undefined // Изменение переменной в следующем уроке Объявленная, но не инициализированная переменная, содержит внутри себя значение undefined . Это специальное значение, используемое тогда, когда ничего не определено.
Количество создаваемых переменных ничем не ограничено, большие программы содержат десятки и сотни тысяч имен переменных:
let greeting1 = 'Father!'; console.log(greeting1); // => Father! console.log(greeting1); // => Father! let greeting2 = 'Mother!'; console.log(greeting2); // => Mother! console.log(greeting2); // => Mother! Для удобства анализа программы, переменные принято создавать как можно ближе к тому месту, где они используются.
Изменение переменной
Само слово «переменная» говорит, что ее можно менять. И действительно, с течением времени внутри программы значения переменных могут изменяться.
let greeting = 'Father!'; console.log(greeting); // => Father! console.log(greeting); // => Father! greeting = 'Mother!'; console.log(greeting); // => Mother! console.log(greeting); // => Mother! Имя осталось тем же, но внутри другие данные. Обратите внимание на ключевое различие между объявлением переменной и ее изменением. Ключевое слово let ставится только при создании переменной, но при изменении оно уже не используется.
Ошибки при работе с переменными
Порядок следования инструкций в коде с переменными имеет огромное значение. Переменная должна быть определена до того, как будет использована. Ниже пример ошибки, которую очень часто допускают новички:
// Uncaught ReferenceError: greeting is not defined console.log(greeting); let greeting = 'Father!'; Запуск программы с примера выше завершается ошибкой ReferenceError: greeting is not defined. ReferenceError – это ошибка обращения, она означает, что в коде используется имя (говорят идентификатор), которое не определено. Причем в самой ошибке об этом говорят прямо: greeting is not defined, что переводится как greeting не определен. Кроме неправильного порядка определения, в JavaScript встречаются банальные опечатки — как при использовании переменной, так и при ее объявлении.
Количество подобных ошибок уменьшается за счет использования правильно настроенного редактора. Такой редактор подсвечивает имена, которые используются без объявления, и предупреждает о возможных проблемах.
Еще одна распространенная ошибка — попытаться объявить уже объявленную переменную:
let greeting = 'Father!'; let greeting = 'Father!'; Так делать нельзя. Придется создать новую переменную.
Константы
Во всем модуле подавляющее большинство примеров кода использовало переменные в качестве имен (псевдонимы) конкретных значений, а не как переменные, которые меняют свое значение со временем.
let dollarsInEuro = 1.25; let rublesInDollar = 60; let dollarsCount = 50 * dollarsInEuro; // 62.5 let rublesCount = dollarsCount * rublesInDollar; // 3750 console.log(rublesCount); // => 3750 В программировании принято называть такие имена константами, и многие языки поддерживают константы как конструкцию. JavaScript, как раз, относится к таким языкам, и его стандарты кодирования говорят прямо — если значение не меняется, то мы имеем дело с константой. Перепишем пример выше с использованием констант:
const dollarsInEuro = 1.25; const rublesInDollar = 60; const euros = 1000; const dollars = euros * dollarsInEuro; // 1250 const rubles = dollars * rublesInDollar; // 75000 console.log(rubles); // => 75000 Единственное изменение заключается в том, что ключевое слово let заменилось на const , но это только синтаксис. Теперь, если попытаться изменить любую константу, то мы получим сообщение об ошибке. В остальном они используются точно так же, как и переменные.
const pi = 3.14; pi = 5; // TypeError: Assignment to constant variable. Зачем такие сложности? Почему бы не оставить только переменные? Даже если бы мы оставили только переменные, то это не отменяет того факта, что они часто использовались бы как константы, более того, код на JavaScript можно и идиоматично писать без использования переменных вообще. Посмотрите на пример из реального кода Хекслета . На текущем этапе вы его вряд ли поймете, но попробуйте посчитать количество констант и переменных внутри него, вы увидите, что здесь ровно одна переменная, и целая куча констант.
Константы значительно проще для анализа, когда мы видим константу в коде, то нам сразу понятно, что ее значение всегда остается прежним. При использовании констант отсутствует понятие времени. С переменными все не так, мы не можем быть уверены в их значении, приходится анализировать весь код, чтобы понять, как они могли измениться.
Переменные жизненно необходимы только в одном случае (во всех остальных гарантированно можно обойтись без них) – при работе с циклами, до которых мы еще дойдем.
В дальнейшем мы будем предпочитать константы и использовать переменные только тогда, когда без них никак.
Остались вопросы? Задайте их в разделе «Обсуждение»
Вам ответят команда поддержки Хекслета или другие студенты
JavaScript Переменные
Ключевые слова let и const объясняются в следующих главах.
Переменные
JavaScript переменные — это контейнеры для хранения значений данных.
В этом примере x , y , и z переменные, объявляются с ключевым словом var :
Пример
var x = 5;
var y = 6;
var z = x + y;
Из приведенного выше примера результат будет такой:
- Переменная x сохранит значение 5
- Переменная y сохранит значение 6
- Переменная z сохранит значение 11
Программирование как в алгебре
В этом примере price1 , price2 и total , тоже являются переменными:
Пример
var price1 = 5;
var price2 = 6;
var total = price1 + price2;
В программирование, как и в алгебре, мы используем переменные (например, price1) для хранения значений.
В программирование, как и в алгебре, мы используем переменные в выражениях (total = price1 + price2).
Из приведенного выше примера вы можете рассчитать, что общая сумма будет 11.
JavaScript переменные — это контейнеры для хранения значений данных.
JavaScript Идентификаторы
Все JavaScript переменные должны быть определены с уникальным именами.
Уникальные имена называются идентификаторами.
К примеру, идентификаторы могут быть короткими именами (например, x и y) или более описательными именами (age, sum, totalVolume).
Общие правила построения для имен переменных (уникальных идентификаторов):
- Имена переменных могут содержать буквы, цифры, символы подчеркивания и знаки доллара
- Имена переменных должны начинаться с буквы
- Имена переменных, также могут начинаться с $ и _ (но мы не будем использовать в этом руководстве)
- Имена переменных чувствительны к регистру (y и Y — разные переменные)
- Зарезервированные слова (например, ключевые слова JavaScript) нельзя использовать в качестве переменных имен
JavaScript идентификаторы чувствительны к регистру.
JavaScript Оператор присваивания
В JavaScript знак равенства ( = ) является оператором «присваивания», а не оператором «равно».
Отличие от алгебры. Следующий пример не имеет смысла в алгебре:
Однако в JavaScript смысл таков: он присваивает значение x + 5 к переменной x.
(Он вычисляет значение x + 5 и помещает результат в x. Значение x увеличивается на 5.)
Оператор «равно» написан, как == в JavaScript.
JavaScript Типы данных
JavaScript переменные могут содержать числа, такие как 100, и текстовые значения, например «Щипунов Андрей».
В программировании, текстовые значения называются текстовыми строками.
JavaScript может обрабатывать многие типы данных, но пока просто подумайте о числах и строках.
Строки заключаются в двойные или одинарные кавычки. Числа пишутся без кавычек.
Если вы поместите число в кавычки, оно будет рассматриваться, как текстовая строка.
Пример
var pi = 3.14;
var person = «Щипунов Андрей»;
var answer = ‘Да это я!’;
JavaScript Объявление (создание переменной)
Создание переменной в JavaScript называется «объявлением» переменной.
К примеру, вы объявляете переменную JavaScript с ключевым словом var :
var carName;
После объявления, переменная не имеет значения (технически имеет значение undefined ).
Чтобы присвоить значение переменной, используйте знак равенства:
carName = «Вольво»;
Вы также, можете присвоить значение к переменной при объявлении:
var carName = «Вольво»;
В приведенном ниже примере создаем переменную с именем carName и присваиваеваете к ней значение «Вольво».
Затем «выводим» значение внутри параграфа HTML с :
Пример
var carName = «Вольво»;
document.getElementById(«demo»).innerHTML = carName;
Хорошая практика программирования — объявлять все переменные в начале скрипта.
Подтверждение
Вы можете объявить большое количество переменных в одном операторе.
Начните с var и разделите переменные запятыми:
var person = «Щипунов Андрей», carName = «Вольво», price = 200;
Объявление может занимать несколько строк:
var person = «Щипунов Андрей»,
carName = «Вольво»,
price = 200;
Значение = undefined
В компьютерных программах переменные часто объявляются без значения. Значение может быть чем-то, что нужно вычислить, или чем-то, что будет предоставлено позже, введенным пользователем.
Переменная, которая объявленная без значения, будет иметь значение undefined .
Переменная carName, будет иметь значение undefined после выполнения этого оператора:
Пример
var carName;
JavaScript Повторное объявление переменных
Если вы повторно объявите переменную JavaScript, она не потеряет своего значения.
После carName выполнения этих операторов переменная по-прежнему будет иметь значение «Вольво»:
Пример
var carName = «Вольво»;
var carName;
JavaScript Арифметика
Как и в случае с алгеброй, вы можете выполнять арифметические операции с переменными JavaScript, используя такие операторы, как = и + :
Пример
var x = 5 + 2 + 3;
Вы также, можете добавить строки, но они будут объединены:
Переменные в JavaScript
Переменная JavaScritp — это именованная область в памяти, которая хранит в себе данные (значение). К этим данным можно получить доступ, обратившись по имени переменной в которой они хранятся.
Создание переменной в JavaScript (объявление)
Прежде чем использовать переменные в JavaScript, их нужно создать:
// создание (объявление) переменной var имяПеременной;
При создании переменной, перед её именем, ставится ключевое слово var , а в конце имени точка с запятой ; . Обычно, все переменные участвующие в скрипте, размещаются в его начале. Создание переменной, также еще называют — объявлением переменной.
Имена переменным, вы придумываете самостоятельно, по правилам задания имён идентификаторов.
Создаём сразу несколько переменных:
var имяПеременной; var имяПеременной2; var имяПеременной3;
Если создаются сразу несколько переменных, то их имена можно разделить запятыми.
var имяПеременной, имяПеременной2, имяПеременной3;
Присваивание переменной значения в JavaScript (инициализация)
Чтобы присвоить переменной значение в JavaScript, нужно использовать операцию присваивания =
имяПеременной = значение;
Присваивание переменной значения, также еще называют — инициализацией переменной.
В итоге, начало любого скрипта может выглядеть следующим образом:
var имяПеременной; имяПеременной = значение;
Обратите внимание на то, что во второй строке, при инициализации, использовать ключевое слово var уже нет необходимости. В качестве значения, может выступать любой тип данных, поддерживаемый стандартом JavaScript.
Определение переменной JavaScript
Можно также одновременно, создать переменную и присвоить ей значение, это называется определение переменной.
var имяПеременной = значение;
Определение переменной — это сокращённый вариант написания объявления и инициализации переменной.
Определить можно сразу несколько переменных, их нужно располагать через запятую:
var имяПеременной = значение, имяПеременной2 = значение, имяПеременной3 = значение;
Получаем доступ к значению переменной
Чтобы получить доступ к значению переменной, нужно обратится к ней по имени:
var имяПеременной; имяПеременной = значение; // обращаемся к переменной по имени alert(имяПеременной);
Присваиваем переменной, значение другой переменной
Переменным, можно присваивать значения других переменных, для этого вместо значения нужно вставить имя той переменной, чьё значение вы хотите присвоить.
var carColor; var carColor2; carColor = "чёрный"; carColor2 = carColor; // строка снизу выведет слово "чёрный" alert(carColor2);
Переменные — место хранения необходимой информации
После прочтения последних двух статей вы знаете, что такое JavaScript, что он может сделать для вас, как использовать его вместе с другими веб-технологиями и какими он обладает функциями высокого уровня. В этой статье мы перейдём к реальным основам, рассмотрим, как работать с большинством базовых блоков JavaScript — Переменными.
| Необходимые навыки: | Базовая компьютерная грамотность, базовое понимание HTML и CSS, понимание того, что такое JavaScript. |
|---|---|
| Цель: | Ознакомиться с основами переменных в JavaScript. |
Инструменты, которые вам нужны
В этой статье вам будет предложено ввести строки кода, чтобы проверить ваше понимание материала. Если вы используете браузер для настольных компьютеров, лучшим примером для ввода кода примера является консоль JavaScript вашего браузера (см. What are browser developer tools для получения дополнительной информации о том, как получить доступ к этому инструменту).
Также мы предоставили простую консоль JavaScript, встроенную ниже в странице, для ввода кода, если вы не используете браузер с консолью JavaScript или консоль на странице окажется для вас более комфортной.
Что такое переменные?
Переменные — это контейнер для таких значений, как числа, используемые в сложении, или строка, которую мы могли бы использовать как часть предложения. Но одна из особенностей переменных — их значение может меняться. Давайте взглянем на простой пример:
button>Нажми на меняbutton>
const button = document.querySelector("button"); button.onclick = function () let name = prompt("Как вас зовут?"); alert("Привет " + name + ", рады видеть вас!"); >;
В примере, по нажатию кнопки выполнится несколько строк кода. Первая строка в функции покажет пользователю окно, где попросит ввести его имя и сохранит значение в переменной. Вторая строка отобразит приветствие с включённым введённым именем, взятым из значения переменной.
Чтобы лучше понять действие переменной здесь, давайте подумаем о том, как мы будем писать этот пример без использования переменной. Это будет выглядеть примерно так:
var name = prompt('Как вас зовут?'); if (name === 'Адам') < alert('Привет, Адам, рады тебя видеть!'); >else if (name === 'Алан') < alert('Привет, Алан, рады тебя видеть!'); >else if (name === 'Белла') < alert('Привет, Белла, рады тебя видеть!'); >else if (name === 'Бьянка') < alert('Привет, Бьянка, рады тебя видеть!'); >else if (name === 'Крис') < alert('Привет, Крис, рады тебя видеть!'); >// . и так далее .
Вам сейчас не обязательно понимать синтаксис, который мы используем (пока!), но вы должны понять идею: если бы у нас не было доступных переменных, нам пришлось бы реализовать гигантский блок кода, который проверял, какое имя было введено, а затем отображал соответствующее сообщение для этого имени. Очевидно, что это неэффективно (код намного больше, даже для четырёх вариантов), и он просто не сработает, так как вы не можете хранить все возможные варианты.
Переменные имеют смысл, и, когда вы узнаете больше о JavaScript, они начнут становиться второй натурой.
Ещё одна особенность переменных заключается в том, что они могут содержать практически все, а не только строки и числа. Переменные могут также содержать сложные данные и даже целые функции. Об этом вы узнаете больше при дальнейшем изучении курса..
Заметьте: мы говорим, что переменные содержат значения. Это важное различие. Переменные не являются самими значениями; они представляют собой контейнеры для значений. Представьте, что они похожи на маленькие картонные коробки, в которых вы можете хранить вещи.
Объявление переменной
Чтобы использовать переменную, вы сначала должны её создать, или, если быть точнее, объявить переменную. Чтобы сделать это, мы вводим ключевое слово var, за которым следует имя, которое вы хотите дать своей переменной:
var myName; var myAge;
Здесь мы создаём две переменные myName и myAge. Попробуйте ввести эти строки сейчас в консоли вашего веб-браузера или в консоли ниже (можно открыть эту консоль в отдельной вкладке или в новом окне). После этого попробуйте создать переменную (или две) с вашими именами.
doctype html> html> head> meta charset="utf-8" /> title>JavaScript consoletitle> style> * box-sizing: border-box; > html background-color: #0c323d; color: #809089; font-family: monospace; > body max-width: 700px; > p margin: 0; width: 1%; padding: 0 1%; font-size: 16px; line-height: 1.5; float: left; > .input p margin-right: 1%; > .output p width: 100%; > .input input width: 96%; float: left; border: none; font-size: 16px; line-height: 1.5; font-family: monospace; padding: 0; background: #0c323d; color: #809089; > div clear: both; > style> head> body>body> script> var geval = eval; function createInput() var inputDiv = document.createElement("div"); var inputPara = document.createElement("p"); var inputForm = document.createElement("input"); inputDiv.setAttribute("class", "input"); inputPara.textContent = ">"; inputDiv.appendChild(inputPara); inputDiv.appendChild(inputForm); document.body.appendChild(inputDiv); if (document.querySelectorAll("div").length > 1) inputForm.focus(); > inputForm.addEventListener("change", executeCode); > function executeCode(e) try var result = geval(e.target.value); > catch (e) var result = "error — " + e.message; > var outputDiv = document.createElement("div"); var outputPara = document.createElement("p"); outputDiv.setAttribute("class", "output"); outputPara.textContent = "Result: " + result; outputDiv.appendChild(outputPara); document.body.appendChild(outputDiv); e.target.disabled = true; e.target.parentNode.style.opacity = "0.5"; createInput(); > createInput(); script> html>
Примечание: в JavaScript все инструкции кода должны заканчиваться точкой с запятой (;) — ваш код может работать правильно для отдельных строк, но, вероятно, не будет, когда вы пишете несколько строк кода вместе. Попытайтесь превратить написание точки с запятой в привычку.
Теперь проверим, существуют ли эти значения в среде выполнения. Для этого введём только имя переменной.
; myAge;
В настоящее время они не содержат значения, это пустые контейнеры. В этом случае, когда вы вводите имена переменных, вы должны получить значение undefined . Если они не существуют, вы получите сообщение об ошибке — попробуйте сейчас ввести в консоли имя переменной ниже:
Примечание: Не путайте переменную, которая существует, но не имеет значения, с переменной, которая вообще не существует — это разные вещи.
Присвоение значения переменной
Как только переменная объявлена, ей можно присвоить значение. Для этого пишется имя переменной, затем следует знак равенства ( = ), а за ним значение, которое вы хотите присвоить. Например:
= "Chris"; myAge = 37;
Попробуйте вернуться в консоль и ввести эти строки. Вы должны увидеть значение, которое вы назначили переменной, возвращаемой в консоли. Чтобы посмотреть значения переменных, нужно набрать их имя в консоли:
; myAge;
Вы можете объявить переменную и задать ей значение одновременно:
var myName = "Chris";
Скорее всего, так вы будете писать большую часть времени, так как запись и выполнения кода с одно строки происходит быстрее, чем выполнение двух действий на двух отдельных строках.
Примечание: Если вы пишете многострочную программу JavaScript, которая объявляет и инициализирует (задаёт значение) переменную, вы можете объявить её после её инициализации, и она всё равно будет работать. Это связано с тем, что объявления переменных обычно выполняются первыми, прежде чем остальная часть кода будет выполнена. Это называется hoisting — прочитайте var hoisting для более подробной информации по этому вопросу.
Обновление переменной
Когда переменной присваивается значение, вы можете изменить (обновить) это значение, просто указав другое значение. Попробуйте ввести следующие строки в консоль:
= "Bob"; myAge = 40;
Правила именования переменных
Вы можете назвать переменную как угодно, но есть ограничения. Как правило, вы должны придерживаться только латинских символов (0-9, a-z, A-Z) и символа подчёркивания.
- Не рекомендуется использование других символов, потому что они могут вызывать ошибки или быть непонятными для международной аудитории.
- Не используйте символы подчёркивания в начале имён переменных — это используется в некоторых конструкциях JavaScript для обозначения конкретных вещей.
- Не используйте числа в начале переменных. Это недопустимо и приведёт к ошибке.
- Общепринято придерживаться так называемый «lower camel case», где вы склеиваете несколько слов, используя строчные буквы для всего первого слова, а затем заглавные буквы последующих слов. Мы использовали это для наших имён переменных в этой статье.
- Делайте имена переменных такими, чтобы было интуитивно понятно, какие данные они содержат. Не используйте только отдельные буквы / цифры или большие длинные фразы.
- Переменные чувствительны к регистру, так что myage и myAge — разные переменные.
- И последнее — вам также нужно избегать использования зарезервированных слов JavaScript в качестве имён переменных — под этим мы подразумеваем слова, которые составляют фактический синтаксис JavaScript! Таким образом, вы не можете использовать слова типа var , function , let , и for для имён переменных. Браузеры распознают их как разные элементы кода, и поэтому возникают ошибки.
Примечание: По ссылке можно найти довольно полный список зарезервированных ключевых слов: Lexical grammar — keywords.
Примеры хороших имён переменных:
age myAge init initialColor finalOutputValue audio1 audio2
Примеры плохих имён переменных:
1 a _12 myage MYAGE var Document skjfndskjfnbdskjfb thisisareallylongstupidvariablenameman
Примеры имён переменных, которые вызовут ошибки:
var Document
Попытайтесь создать ещё несколько переменных прямо сейчас, используя знания, изложенные выше.
Типы переменных
Есть несколько различных типов данных, которые мы можем хранить в переменных. В этом разделе мы кратко опишем их, а затем в будущих статьях вы узнаете о них более подробно.
Числа (Numbers)
Вы можете хранить числа в переменных (целые числа, такие как 30, или десятичные числа, такие как 2.456, также называемые числами с плавающей точкой или с плавающей запятой). Вам не нужно объявлять типы переменных в JavaScript, в отличие от некоторых других языков программирования Если давать переменной значение числа,кавычки не используются:
var myAge = 17;
Строки (‘Strings’)
Строки — это фрагменты текста. Когда вы даёте переменной значение строки, вам нужно обернуть её в одиночные или двойные кавычки, в противном случае JavaScript попытается проиндексировать её как другое имя переменной.
var dolphinGoodbye = "So long and thanks for all the fish";
Логические (Booleans)
Booleans — истинные / ложные значения — они могут иметь два значения: true или false. Они обычно используются для проверки состояния, после чего код запускается соответствующим образом. Вот простой пример:
var iAmAlive = true;
В действительности вы чаще будете использовать этот тип переменных так:
var test = 6 3;
Массивы (Arrays)
Массив — это один объект, который содержит несколько значений, заключённых в квадратные скобки и разделённых запятыми. Попробуйте ввести следующие строки в консоль:
var myNameArray = ["Chris", "Bob", "Jim"]; var myNumberArray = [10, 15, 40];
Как только эти массивы определены, можно получить доступ к каждому значению по их местоположению в массиве. Наберите следующие строки:
[0]; // should return 'Chris' myNumberArray[2]; // should return 40
Квадратные скобки указывают значение индекса, соответствующее позиции возвращаемого значения. Возможно, вы заметили, что массивы в JavaScript индексируются с нулевой отметкой: первый элемент имеет индекс 0.
В следующей статье вы узнаете больше о массивах.
Объекты (Objects)
В программировании объект представляет собой структуру кода, который моделирует объект реальной жизни. У вас может быть простой объект, представляющий автостоянку, и содержит информацию о её ширине и длине; или вы можете иметь объект, который представляет человека, и содержит данные о его имени, росте, весе, на каком языке он говорит, как сказать ему привет и многое другое.
Попробуйте ввести следующую строку в консоль:
var dog = name: "Spot", breed: "Dalmatian" >;
Чтобы получить информацию, хранящуюся в объекте, вы можете использовать следующий синтаксис:
.name;
Мы больше не будем рассматривать объекты в данном курсе — вы можете больше узнать о них в будущем модуле.
Динамическая типизация
JavaScript — это «динамически типизируемый язык», что означает, что в отличие от некоторых других языков вам не нужно указывать, какой тип данных будет содержать переменная (например, числа, строки, массивы и т. д.).
Например, если вы объявите переменную и присвоите ей значение, заключённое в кавычки, браузер будет обрабатывать переменную как строку:
var myString = "Привет";
Он всё равно будет строкой, даже если он содержит числа, поэтому будьте осторожны:
var myNumber = "500"; // упс, это все ещё строка (string) typeof myNumber; myNumber = 500; // так-то лучше, теперь это число (number) typeof myNumber;
Попробуйте ввести четыре строки выше в консоль одну за другой и посмотреть результаты. Вы заметите, что мы используем специальную функцию typeof() — она возвращает тип данных переменной, которую вы передаёте в неё. В первый раз, когда она вызывается, она должа возвращать строку, так как переменная myNumber содержит строку ‘500’ . Посмотрите, что она вернёт во второй раз, когда вы её вызовите.
Подведение итогов
К настоящему времени вы должны знать достаточно о переменных JavaScript и о том, как их создавать. В следующей статье мы остановимся на числах более подробно, рассмотрев, как сделать базовую математику в JavaScript.
Found a content problem with this page?
- Edit the page on GitHub.
- Report the content issue.
- View the source on GitHub.
This page was last modified on 3 авг. 2023 г. by MDN contributors.
Your blueprint for a better internet.