Js объявление переменных – Использование let объявлений переменных и особенности образуемых при этом замыканий в JavaScript

Содержание

переменные, типы данных, выражения, объекты / RUVDS.com corporate blog / Habr

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

→ Часть 1: первая программа, особенности языка, стандарты
→ Часть 2: стиль кода и структура программ
→ Часть 3: переменные, типы данных, выражения, объекты
→ Часть 4: функции
→ Часть 5: массивы и циклы
→ Часть 6: исключения, точка с запятой, шаблонные литералы
→ Часть 7: строгий режим, ключевое слово this, события, модули, математические вычисления
→ Часть 8: обзор возможностей стандарта ES6
→ Часть 9: обзор возможностей стандартов ES7, ES8 и ES9



Переменные


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

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

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

▍Ключевое слово var


До появления стандарта ES2015 использование ключевого слова var было единственным способом объявления переменных.
var a = 0

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

Так, если включён так называемый строгий режим (strict mode), подобное вызовет ошибку. Если строгий режим не включён, произойдёт неявное объявление переменной и она будет назначена глобальному объекту. В частности, это означает, что переменная, неявно объявленная таким образом в некоей функции, окажется доступной и после того, как функция завершит работу. Обычно же ожидается, что переменные, объявляемые в функциях, не «выходят» за их пределы. Выглядит это так:

function notVar() {
  bNotVar = 1 //лучше так не делать
}
notVar()
console.log(bNotVar)

В консоль попадёт 1, такого поведения от программы обычно никто не ждёт, выражение bNotVar = 1 выглядит не как попытка объявления и инициализации переменной, а как попытка обратиться к переменной, находящейся во внешней по отношению к функции области видимости (это — вполне нормально). Как результат, неявное объявление переменных сбивает с толку того, кто читает код и может приводить к неожиданному поведению программ. Позже мы поговорим и о функциях, и об областях видимости, пока же постарайтесь всегда, когда смысл некоего выражения заключается в объявлении переменной, пользоваться специализированными ключевыми словами. Если в этом примере тело функции переписать в виде var bNotVar = 1, то попытка запустить вышеприведённый фрагмент кода приведёт к появлению сообщения об ошибке (его можно увидеть в консоли браузера).

Выглядеть оно, например, может так: Uncaught ReferenceError: bNotVar is not defined

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

Если, при объявлении переменной, её не инициализируют, не присваивают ей какого-либо значения, ей автоматически будет присвоено значение undefined.

var a //typeof a === 'undefined'

Переменные, объявленные с помощью ключевого слова var, можно многократно объявлять снова, назначая им новые значения (но это может запутать того, кто читает код).
var a = 1
var a = 2

В одном выражении можно объявить несколько переменных:
var a = 1, b = 2

Областью видимости переменной (scope) называют участок программы, в котором доступна (видима) эта переменная.

Переменная, инициализированная с помощью ключевого слова var за пределами какой-либо функции, назначается глобальному объекту. Она имеет глобальную область видимости и доступна из любого места программы. Если переменная объявлена с использованием ключевого слова var

внутри функции, то она видна только внутри этой функции, являясь для неё локальной переменной.

Если в функции, с использованием var, объявлена переменная, имя которой совпадает с именем некоей переменной из глобальной области видимости, она «перекроет» глобальную переменную. То есть, при обращении к такой переменной внутри функции будет использоваться именно её локальный вариант.

Важно понимать, что блоки (области кода, заключённые в фигурные скобки) не создают новых областей видимости. Новая область видимости создаётся при вызове функции. Ключевое слово var имеет так называемую функциональную область видимости, а не блочную.

Если в коде функции объявлена некая переменная, она видна всему коду функции. Даже если переменная объявлена с помощью var в конце кода функции, обратиться к ней можно и в начале кода, так как в JavaScript работает механизм поднятия переменных (hoisting). Этот механизм «поднимает» объявления переменных, но не операции их инициализации. Это может стать источником путаницы, поэтому возьмите себе за правило объявлять переменные в начале функции.

▍Ключевое слово let


Ключевое слово let появилось в ES2015, его, упрощённо, можно назвать «блочной» версией
var
. Область видимости переменных, объявленных с помощью ключевого слова let, ограничивается блоком, оператором или выражением, в котором оно объявлено, а также вложенными блоками.

Если само слово «let» кажется не очень понятным, можно представить, что вместо него используется слово «пусть». Тогда выражение let color = 'red' можно перевести на английский так: «let the color be red», а на русский — так: «пусть цвет будет красным».

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

Например, такой код вызовет ошибку:

for (let i = 0; i < 5; i++) {
    console.log(i)
}
console.log(i)

Если же, при инициализации цикла, счётчик i будет объявлен с использованием ключевого слова var, то i будет доступно и за пределами цикла, после того, как он завершит работу.

В наши дни, при разработке JS-программ на основе современных стандартов, вполне можно полностью отказаться от var и использовать только ключевые слова let и const.

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


Значения переменных, объявленных с использованием ключевых слов var или let, могут быть перезаписаны. Если же вместо этих ключевых слов используется const, то объявленной и инициализированной с его помощью константе новое значение присвоить нельзя.
const a = 'test'

В данном примере константе a нельзя присвоить новое значение. Но надо отметить, что если a — это не примитивное значение, наподобие числа, а объект, использование ключевого слова const не защищает этот объект от изменений.

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

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

const obj = {}
console.log(obj.a)
obj.a = 1 //работает
console.log(obj.a)
//obj = 5 //вызывает ошибку

В константу obj, при инициализации, записывается новый пустой объект. Попытка обращения к его свойству a, несуществующему, ошибки не вызывает. В консоль попадает undefined. После этого мы добавляем в объект новое свойство и снова пытаемся обратиться к нему. В этот раз в консоль попадает значение этого свойства — 1. Если раскомментировать последнюю строку примера, то попытка выполнения этого кода приведёт к ошибке.

Ключевое слово const очень похоже на let, в частности, оно обладает блочной областью видимости.

В современных условиях вполне допустимо использовать для объявления всех сущностей, значения которых менять не планируется, ключевое слово const, прибегая к let только в особых случаях. Почему? Всё дело в том, что лучше всего стремиться к использованию как можно более простых из доступных конструкций для того, чтобы не усложнять программы и избегать ошибок.

Типы данных


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

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

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


Вот список примитивных типов данных JavaScript:
  • number (число)
  • string (строка)
  • boolean (логическое значение)
  • null (специальное значение null)
  • undefined (специальное значение undefined)
  • symbol (символ, используется в особых случаях, появился в ES6)

Здесь названия типов данных приведены в том виде, в котором их возвращает оператор typeof.

Поговорим о наиболее часто используемых типах данных из этого списка.

Тип number

Значения типа
number
в JavaScript представлены в виде 64-битных чисел двойной точности с плавающей запятой.

В коде числовые литералы представлены в виде целых и дробных чисел в десятичной системе счисления. Для записи чисел можно использовать и другие способы. Например, если в начале числового литерала имеется префикс 0x — он воспринимается как число, записанное в шестнадцатеричной системе счисления. Числа можно записывать и в экспоненциальном представлении (в таких числах можно найти букву e).

Вот примеры записи целых чисел:

10
5354576767321
0xCC // шестнадцатеричное число

Вот дробные числа.
3.14
.1234
5.2e4 //5.2 * 10^4

Числовые литералы (такое поведение характерно и для некоторых других примитивных типов), при попытке обращения к ним как к объектам, автоматически, на время выполнения операции, преобразуются в соответствующие объекты, которые называют «объектными обёртками». В данном случае речь идёт об объектной обёртке Number.

Вот, например, как выглядит попытка обратиться к переменной a, в которую записан числовой литерал, как к объекту, в консоли Google Chrome.


Подсказка по объектной обёртке Number

Если, например, воспользоваться методом toString() объекта типа Number, он возвратит строковое представление числа. Выглядит соответствующая команда, которую можно выполнить в консоли браузера (да и в обычном коде) так:

a.toString()

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

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

Тип string

Значения типа string представляют собой последовательности символов. Такие значения задают в виде строковых литералов, заключённых в одинарные или двойные кавычки.
'A string'
"Another string"

Строковые значения можно разбивать на несколько частей, используя символ обратной косой черты (backslash).
"A \
string"

Строка может содержать так называемые escape-последовательности, интерпретируемые при выводе строки в консоль. Например, последовательность \n означает символ перевода строки. Символ обратной косой черты можно использовать и для того, чтобы добавлять кавычки в строки, заключённые в такие же кавычки. Экранирование символа кавычки с помощью \ приводит к тому, что система не воспринимает его как специальный символ.
'I\'m a developer'

Строки можно конкатенировать с использованием оператора +.
"A " + "string"

Шаблонные литералы

В ES2015 появились так называемые шаблонные литералы, или шаблонные строки. Они представляют собой строки, заключённые в обратные кавычки (`) и обладают некоторыми интересными свойствами.
`a string`

Например, в шаблонные литералы можно подставлять некие значения, являющиеся результатом вычисления JavaScript-выражений.
`a string with ${something}`
`a string with ${something+somethingElse}`
`a string with ${obj.something()}`

Использование обратных кавычек упрощает многострочную запись строковых литералов:
`a string
with
${something}`

Тип boolean

В JavaScript есть пара зарезервированных слов, использующихся при работе с логическими значениями — это true (истина), и false (ложь). Операции сравнения, например, такие, как ==, ===, <, >, возвращают true или false.

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

При этом надо отметить, что там, где ожидается значение true или false, можно использовать и другие значения, которые автоматически расцениваются языком как истинные (truthy) или ложные (falsy).

В частности, ложными значениями являются следующие:

0
-0
NaN
undefined
null
'' //пустая строка

Остальные значения являются истинными.
Тип null

В JavaScript имеется специальное значение null, которое указывает на отсутствие значения. Подобные значения используются и в других языках.
Тип undefined

Значение undefined, записанное в некую переменную, указывает на то, что эта переменная не инициализирована и значение для неё отсутствует.

Это значение автоматически возвращается из функций, результат работы которых не возвращается явно, с использованием ключевого слова return. Если функция принимает некий параметр, который, при её вызове, не указан, он также устанавливается в undefined.

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

typeof variable === 'undefined'

▍Объекты


Все значения, не являющиеся примитивными, имеют объектный тип. Речь идёт о функциях, массивах, о том, что мы называем «объектами», и о многих других сущностях. В основе всех этих типов данных лежит тип object, и они, хотя и во многом друг от друга отличаются, имеют и много общего.

Выражения


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

В эту категорию попадают выражения, результатом вычисления которых являются числа.
1 / 2
i++
i -= 2
i * 2

Строковые выражения

Результатом вычисления таких выражений являются строки.
'A ' + 'string'
'A ' += 'string'

Первичные выражения

В эту категорию попадают литералы, константы, ссылки на идентификаторы.
2
0.02
'something'
true
false
this //контекст выполнения, ссылка на текущий объект
undefined
i //где i является переменной или константой

Сюда же можно отнести и некоторые ключевые слова и конструкции JavaScript.
function
class
function* //генератор
yield //команда приостановки/возобновления работы генератора
yield* //делегирование другому итератору или генератору
async function* //асинхронное функциональное выражение 
await //организация ожидания выполнения асинхронной функции
/pattern/i //регулярное выражение
() //группировка

Выражения инициализации массивов и объектов
[] //литерал массива
{} //объектный литерал
[1,2,3]
{a: 1, b: 2}
{a: {b: 1}}

Логические выражения

В логических выражениях используются логические операторы, результатом их вычисления оказываются логические значения.
a && b
a || b
!a

Выражения доступа к свойствам

Эти выражения позволяют обращаться к свойствам и методам объектов.
object.property //обращение к свойству (или методу) объекта
object[property]
object['property']

Выражения создания объектов
new object()
new a(1)
new MyRectangle('name', 2, {a: 4})

Выражения объявления функций
function() {}
function(a, b) { return a * b }
(a, b) => a * b
a => a * 2
() => { return 2 }

Выражения вызова

Такие выражения используются для вызова функций или методов объектов.
a.x(2)
window.resize()

Работа с объектами


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

▍Прототипное наследование


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

У каждого JavaScript-объекта есть особое свойство (__proto__), которое указывает на другой объект, являющийся его прототипом. Объект наследует свойства и методы прототипа.

Предположим, у нас имеется объект, созданный с помощью объектного литерала.

const car = {}

Или мы создали объект, воспользовавшись конструктором Object.
const car = new Object()

В любом из этих случаев прототипом объекта car будет Object.prototype.

Если создать массив, который тоже является объектом, его прототипом будет объект Array.prototype.

const list = []
//или так
const list = new Array()

Проверить это можно следующим образом.
car.__proto__ == Object.prototype //true
car.__proto__ == new Object().__proto__ //true
list.__proto__ == Object.prototype //false
list.__proto__ == Array.prototype //true
list.__proto__ == new Array().__proto__ //true

Здесь мы пользовались свойством __proto__, оно не обязательно должно быть доступно разработчику, но обычно обращаться к нему можно. Надо отметить, что более надёжным способом получить прототип объекта является использование метода getPrototypeOf() глобального объекта Object.
Object.getPrototypeOf(new Object())

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

Базовым прототипом для всех объектов является Object.prototype.

Array.prototype.__proto__ == Object.prototype

У Object.prototype прототипа нет.

То, что мы видели выше, является примером цепочки прототипов.

При попытке обращения к свойству или методу объекта, если такого свойства или метода у самого объекта нет, их поиск выполняется в его прототипе, потом — в прототипе прототипа, и так — до тех пор, пока искомое будет найдено, или до тех пор, пока цепочка прототипов не кончится.

Помимо создания объектов с использованием оператора new и применения объектных литералов или литералов массивов, создать экземпляр объекта можно с помощью метода Object.create(). Первый аргумент, передаваемый этому методу, представляет собой объект, который станет прототипом создаваемого с его помощью объекта.

const car = Object.create(Object.prototype)

Проверить, входит ли некий объект в цепочку прототипов другого объекта, можно с использованием метода isPrototypeOf().
const list = []
Array.prototype.isPrototypeOf(list)

Функции-конструкторы

Выше мы создавали новые объекты, пользуясь уже имеющимися в языке функциями-конструкторами (при их вызове используется ключевое слово new). Такие функции можно создавать и самостоятельно. Рассмотрим пример.
function Person(name) {
  this.name = name
}

Person.prototype.hello = function() {
  console.log(this.name)
}

let person = new Person('Flavio')
person.hello()

console.log(Person.prototype.isPrototypeOf(person))

Здесь мы создаём функцию-конструктор. При её вызове создаётся новый объект, на который указывает ключевое слово this в теле конструктора. Мы добавляем в этот объект свойство name и записываем в него то, что передано конструктору. Этот объект возвращается из конструктора автоматически. С помощью функции-конструктора можно создать множество объектов, свойства name которых будут содержать то, что передано при их создании конструктору.

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

hello(). Это несложно проверить, создав ещё один объект типа Person и сравнив его функцию hello() с функцией уже имеющегося в примере объекта (имя функции в таком случае записывают без скобок).

▍Классы


В стандарте ES6 в JavaScript пришло такое понятие как «класс».

До этого в JavaScript можно было пользоваться лишь вышеописанным механизмом прототипного наследования. Этот механизм непривычно выглядел для программистов, пришедших в JS из других языков. Поэтому в языке и появились классы, которые, по сути, являются «синтаксическим сахаром» для прототипного механизма наследования. То есть, и объекты, созданные традиционным способом, и объекты, созданные с использованием классов, имеют прототипы.

Объявление класса

Вот как выглядит объявление класса.
class Person {
  constructor(name) {
    this.name = name
  }
  hello() {
    return 'Hello, I am ' + this.name + '.'
  }
}

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

При создании нового объекта вызывается метод

constructor, ему передаются параметры.

В классе можно объявлять методы. В нашем случае hello() — это метод, который могут вызывать все объекты, созданные на основе класса. Вот как выглядит создание нового объекта с использованием класса Person.

const flavio = new Person('Flavio')
flavio.hello()

Наследование, основанное на классах

Классы могут расширять другие классы. Объекты, созданные на основе таких классов, будут наследовать и методы исходного класса, и методы, заданные в расширенном классе.

Если класс, расширяющий другой класс (наследник этого класса) имеет метод, имя которого совпадает с тем, который есть у класса-родителя, этот метод имеет преимущество перед исходным.

class Programmer extends Person {
  hello() {
    return super.hello() + ' I am a programmer.'
  }
}
const flavio = new Programmer('Flavio')
flavio.hello()

При вызове метода hello() в вышеприведённом примере будет возвращена строка Hello, I am Flavio. I am a programmer.

В классах не предусмотрено наличие переменных (свойств), свойства создаваемых с помощью классов объектов нужно настраивать в конструкторе.

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

Статические методы

Методы, описываемые в классе, можно вызывать, обращаясь к объектам, созданным на основе этого класса, но не к самому классу. Статические (static) методы можно вызывать, обращаясь непосредственно к классу.
Приватные методы

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

В классе можно описывать методы, предваряя их ключевыми словами get или set. Это позволяет создавать так называемые геттеры и сеттеры — функции, которые используются для управления доступом к свойствам объектов, созданных на основе класса. Геттер вызывается при попытке чтения значения псевдо-свойства, а сеттер — при попытке записи в него нового значения.
class Person {
    constructor(name) {
      this.userName = name
    }
    set name(value) {
      this.userName = value
    }
    get name() {
      return this.userName
    }
  }

Итоги


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

Уважаемые читатели! Если вы уже давно пишете на JS, просим рассказать о том, как вы относитесь к появлению в языке ключевого слова class.

Переменные Javascript

Переменные в JavaScript это контейнеры для хранения различных данных.

В следующем примере x, y, z это переменные:


var x = 5;
var y = 6;
var z = x + y; 

Как видно из этого примера, переменные

  • могут хранить значения, как x и y
  • могут использоваться в различных выражениях (z = x + y; в z будет вычислено значение 11)

Идентификаторы JavaScript

Все переменные JavaScript должны идентифицироваться при помощи уникальных имен. Эти уникальные имена называются идентификаторами.

Идентификаторы могут быть короткими (как x и y) или же более описательными (age, sum, totalVolume).

Общие правила составления имен для переменных (уникальных идентификаторов) следующие:

  • Имена могут содержать буквы, цифры, символ подчеркивания (_) и символ доллара ($).
  • Имена должны начинаться с буквы.
  • Также имена могут начинаться с символа доллара ($) и символа подчеркивания (_) (но в данном учебнике это не используется).
  • Имена являются регистрозависимыми (y и Y — разные переменные).
  • Зарезервированные слова (например, ключевые слова JavaScript) не могут использоваться в качестве имен.

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

В JavaScript знак "равно" (=) является оператором "присваивания", а не оператором "равен чему-то".

И это прямое отличие от математики. В математике следующее выражение не имеет смысла:


 x = x + 5 

В JavaScript же данное выражение вполне себе наполнено смыслом — оно означает, что значение x + 5 присваивается переменной x (вычисляется значение x + 5, а результат помещается в переменную x, т. е. значение в переменной x увеличивается на 5.)

Оператор "равен чему-то" в JavaScript записывается как ==.

Типы данных в JavaScript

Переменные JavaScript могут хранить как числа, так и текст.

В программировании текстовые значения называются текстовые строки.

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

Строки записываются в двойных или одинарных кавычках. Числа записываются без кавычек. Если поместить число в кавычки, то оно будет восприниматься обработчиком JavaScript, как текстовая строка.


var pi = 3.14;
var person = "Иван Петров";
var answer = 'Да, это я!'; 

Декларирование (создание) переменных JavaScript

Процесс создания переменной в JavaScript называется "декларирование" переменной.

Переменная JavaScript декларируется при помощи ключевого слова var:


var carName; 

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

Чтобы присвоить переменной значение, следует воспользоваться оператором присваивания:


 carName = "Volvo"; 

Также присвоить значение можно и во время декларирования переменной:


var carName = "Volvo"; 

В следующем примере мы создаем переменную с именем carName и сразу же присваиваем ей значение "Volvo". Затем мы "выводим" значение переменной в HTML параграфе с атрибутом:


<p></p>

<script>
 var carName = "Volvo";
 document.getElementById("demo").innerHTML = carName; 
</script>

Декларирование всех переменных в начале скрипта считается хорошей практикой программирования.

Одно выражение, много переменных

Вы можете декларировать в одном выражении несколько переменных.

Для этого нужно начать выражение с ключевого слова var и разделять декларируемые переменные запятой:


var person = "John Doe", carName = "Volvo", price = 200; 

Декларация может располагаться на нескольких строках:


 var person = "John Doe",
 carName = "Volvo",
 price = 200; 

Значение = undefined

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

После выполнения кода следующего примера у переменной carName будет установлено значение undefined:


var carName; 

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

Если вы повторно декларируете переменную JavaScript, то она не потеряет значение, которое у нее было до этого.

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


var carName = "Volvo";
var carName; 

Арифметика JavaScript

Как и в математике, с переменными JavaScript вы можете при помощи, например, оператора сложения (+) осуществлять арифметические вычисления:


var x = 5 + 2 + 3;

Также можно складывать и строки, но при этом строки будут конкатенироваться, т.е. объединяться:


var x = "John" + " " + "Doe"; 

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


var x = 2 + 3 + "5";

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

Что такое переменная

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

Переменная состоит их двух частей - имя и значение. Например:

x = 5

В приведённом примере x - это имя переменной, а 5 - это значение переменной. Имя остаётся неизменным, а значение может изменяться, поэтому она и назавается переменная. Переменная имеет два основных свойства:

  1. В любой момент можно получить значение переменной
  2. В любой момент можно изменить значение переменной и записать в неё новое значение

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

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

Объявление переменной - это её создание. Для объявления переменной в JavaScript используется ключевое слово var. После объявления, переменной можно присваивать значение.

+

В JavaScript Можно объявить переменную и присвоить ей значение в одной строке:

Одно слово var можно использовать для объявления сразу несколько переменных:

12
13

var a, b;
var inf = 10, pr = 15;

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

Имена переменных

Имена переменных могут состоять из латинских букв, цифр, занака $, и нижнего подчёркивания. Русские буквы тоже можно использовать, но не желательно. Имя не должно начинаться с цифры. При написании имён регистр символов имеет значение. В следующем примере объявлены разные переменные:

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

Но чаще для разделения слов каждое новое слово начинается с большой буквы. Именно такой способ используется для стандартных объектов и методов JavaScript.

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

JavaScript Переменные



JavaScript переменные

JavaScript переменные являются контейнерами для хранения значений данных.

В этом примере x, y, и z, являются переменными:

Из примера выше можно узнать, что:

  • x, хранит значение 5
  • y, хранит значение 6
  • z, хранит значение 11

Как в математике

В этом примере: price1, price2, и total, являются переменными:

В программировании, как и в математике, мы используем переменные (например: price1) для хранения значений.

В программировании, как и в математике, мы используем переменные в выражении total = price1 + price2.

Из приведенного выше примера можно вычислить total равно 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 может обрабатывать многие типы данных, но пока только подумайте о числах и строках.

Строки записываются в двойные или одинарные кавычки. Числа пишутся без кавычек.

Если поместить число в кавычки, оно будет обработано как текстовая строка.


JavaScript создание переменной

Создание переменной в JavaScript называется "объявление" одной переменной.

Мы объявляем переменную JavaScript с ключевым словом var:

После объявления, переменная не имеет значения (технически она имеет значение, не определено).

К присваиванию значения переменной, используйется знак равенства:

carName = "Вольво";

Можно также присвоить значение переменной при ее объявлении:

var carName = "Вольво";

В приведенном ниже примере создается переменная carName и к нему присваивается значение "Вольво"

Тогда мы "выводим" .innerHTML значение внутри HTML параграфа в id="demo":

Пример

<script>
var carName = "Вольво";
document.getElementById("demo").innerHTML = carName;
</script>

Редактор кода »

Очень хорошая привычка программирования, чтобы объявить все переменные в начале скрипта.


Переменные в одном заявлении

Можно объявить много переменных в одном заявлении.

Объявить заявление с var и разделите переменные точкой с занятой:

Объявление может охватывать несколько строк:


Значение undefined

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

Переменная, объявленная без значения, будет иметь неопределенное значение undefined.

Переменная carName, будет иметь неопределенное значение undefined после выполнения этой инструкции:


JavaScript повторное объявление переменных

При повторном объявлении переменной JavaScript значение не потеряется.

Последнее выполнение заявление, переменная carName будет так же иметь значение "Вольво":


JavaScript сложение

Как и в математике, вы можете выполнять сложение с переменными JavaScript, используя такие операторы, как ( = ) и ( + ):

Можно также добавить строки, но строки будут объединены:

Также попробуйте:

Если поместить число в кавычки, то остальные числа будут рассматриваться как строки и объединятся вместе.

Теперь попробуйте:



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

Hello everybody! В этой статье я покажу, как работать с переменными в JavaScript, а так же расскажу о типах этих переменных. Это вводная статья для понимания дальнейшего материала.

Какие бывают типы данных в JavaScript?

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

Отдельным типом данных в JS является объект (object). Он имеет некие сходства с массивами, но поведение этих двух типов сильно различаются. Более детально работу с объектами я опишу с следующих статьях.

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

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

var varible;
var box, red, sS;

Для объявления нескольких переменных их нужно разделить запятой.

Так же объявление переменной можно совмещать с присваиванием ей значения.

var message = "Привет";
var i = 15, j = 4;

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

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

Создание различных типов переменных:
var count = 0; // численный тип
var string = "строка" // строковой тип
var arr = ['0','1']; // массив
var obj = {};// пустой объект

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

javascript

Я на своей практики сталкивался с такой забавной ошибкой от которой потом было просто смешно. Когда я работал с объектом который приходил ко мне ответом от сервера я выводил его в консоль разработчика. Все бы хорошо, но только в месте с выводом я прибавлял к объекту строку «Ответ сервера:»... и получал соответственно вывод в консоль в виде строки, так как объект + стока = [object Object]. но ни как не вывод того, что я хотел. Найдя потом ошибку меня это очень позабавило и с тех пор я начал более обдуманно работать с типами переменных.

Работа с переменными (операторы языка)

Как и в любом другом языке программирования, в JavaScript для работы с переменными используются специальные символы(операторы). Из математики Вам должны быть известны самые распространенные операторы: + — / * = > < и т.д.

Рассмотрим на примере работу с некоторыми операторами.

//Умножение
var sum = 15, count = 5, result = 0;
result = sum * count;
// в result будет записано 75
// Сравнение
var sum = 15, count = 5, result = 0;
if(count &amp;lt; sum) result = sum + count;
// если 5 меньше 15 то в result будет записано 20
// Сложение
var string = 'Имя:', name = 'Дмитрий';
string + name;
// в string будет записано Имя:Дмитрий

Подробный список операторов и их описание можете увидеть по следующей ссылке.

На этом думаю заканчивать. Если у Вас остались какие-нибудь вопросы по этой теме пишите в комментарии или лично мне. До скорого и удачи в начинаниях!

dmkweb.ru Права на контент защищены.

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

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

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

name=”John”;

 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *