###
  • Программы
  • Безопасность
  • Новости
  • Интересное
  • Советы 
  • Новости 
  • Обзоры 

    • Типы переменных в javascript. Как правильно проверить тип переменной в JavaScript. Тип данных String

    23.10.2023 Программы


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

    Сама по себе переменная в 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 //регулярное выражение () //группировка

    Выражения инициализации массивов и объектов //литерал массива {} //объектный литерал {a: 1, b: 2} {a: {b: 1}} Логические выражения В логических выражениях используются логические операторы, результатом их вычисления оказываются логические значения.

    A && b a || b !a

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

    Object.property //обращение к свойству (или методу) объекта object 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.

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

    Объявление (создание) переменных осуществляется с помощью ключевого слова var .

    // message - имя переменной var message;

    При создании переменной ей сразу же можно присвоить значение.

    Присвоение переменной значения осуществляется с помощью оператора «=».

    // например, создадим переменную email и присвоим ей строку "[email protected]" var email = "[email protected]"; // установим переменной email новое значение email = "[email protected]";

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

    // например, выведем в консоль браузера значение переменной email: console.log(email);

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

    Var price = 78.55, quantity = 10, message;

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

    Var output = "успех"; // переменная имеет строковый тип данных output = 28; // эта же переменная, но уже имеющая тип данных «число» output = true; // эта же переменная, но уже хранящая булевское значение

    Значение переменной можно изменять неограниченное количество раз.

    // создана переменная age var age; // переменной age присвоено значения 67 age = 67; // переменной age установлено значение «Пенсионный возраст» age = "Пенсионный возраст"; // переменной age установлено число 55 age = 55;

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

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

    // создание двух переменных, первая переменная имеет имя phone, вторая - meassage; var phone, message;

    Регистр букв в имени переменной имеет значение. Т.е., например, переменная phone и Phone - это две разные переменные.

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

    Price = 250.00; // создали переменную и инициализировали её числом 250.00 percent = "20%"; // создали переменную и инициализировали её строкой «20%»

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

    Типы данных

    В JavaScript типы данных можно разделить на примитивные и объектные.

    Переменные, содержащие примитивные типы данных хранят значение явно.

    В JavaScript выделяют 5 примитивных типов данных:

    • число (number);
    • строка (string);
    • булевый тип (boolean);
    • null;
    • undefined.

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

    Var x = 77, y = x; x = 55; y; // 77

    Переменные, содержащие объект, на самом деле хранят не сам объект, а ссылку на него.

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

    // пример 1 (с типом данных «объект») var coord1 = {x: 77, y: 100}, coord2 = coord1; coord1.x = 55; // установим свойству x объекта новое значение coord2.x; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 2 (с типом данных «массив») var coord1 = , coord2 = coord1; coord1 = 55; // установим элементу с 0 индексом новое значение coord2; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 3 (с типом данных «дата») var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // увеличим дату на 7 дней date1; // 07.01.2018, т.к. date1 и date2 содержат ссылку на один и тот же объект

    Число (number)

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

    Var int = 5; // целое число var float = 5.98; // дробное число

    Формат представления чисел в JavaScript осуществляется в соответствии со стандартом IEEE 754-2008.

    Целые числа в JavaScript можно задавать не только в десятичной системе счисления, но и в восьмеричной (0) или шестнадцатеричной системе счисления (0x) с использованием префиксов, указанных в круглых скобках:

    Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184

    Записывать числа возможно в экспоненциальной форме :

    Var num = 2e3; // экспоненциальная запись числа 2*10^3 (2000) num = 2e-3; // экспоненциальная запись числа 2*10^-3 (0,002) num = 3.2e3; // 3200 num = 1.5e-2; // 0.015

    Числовой тип данных кроме чисел содержит ещё специальные числовые значения :

    • Infinity (положительная бесконечность);
    • -Infinity (отрицательная бесконечность);
    • NaN (Not a Number – не число).

    Специальное значения Infinity означает очень большое положительное число, т.е. число, которое не может быть представлено в JavaScript по причине того, что оно слишком велико.

    Специальные значения -Infinity означает наоборот очень большое отрицательное число, т.е. число, которое не может быть представлено JavaScript по причине того, что оно тоже слишком велико.

    Пример выражений в результате вычисления которых будет возвращены специальные числовые значения :

    5/0; // Infinity -5/0; // -Infinity Math.pow(10,399); // Infinity (10 в степене 399) Math.pow(10,399); // -Infinity (-10 в степене 399)

    Значение NaN возвращается в результате выполнения математических операций, которые JavaScript не может вычислить.

    5 - "Hi"; // NaN (от числа 5 отнять строку) 1000 / "20px"; // NaN (число поделить на строку) true * "1rem"; // NaN (логическое значение true умножить на строку)

    При этом очень интересным является то, что значение NaN в JavaScript не равно ничему включая себя.

    NaN == NaN; // false NaN === NaN; //false

    Логический тип данных (Boolean)

    Boolean – примитивный тип данных, который имеет всего два значения: true (истина) и false (ложь).

    Var a = true; var b = false;

    Строка (String)

    Строка (String) – это тип данных, который используется в JavaScript для представления текста.

    Строка JavaScript может состоять из 0 или большего количества символов.

    В качестве формата строки в JavaScript всегда использутся кодировка Unicode.

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

    "JavaScript"; "ECMAScript";

    В JavaScript нет разницы между одинарными и двойными кавычками.

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

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

    ""ECMAScript""; // без экранирования (с использованием одинарных кавычек) "\"ECMAScript\""; // с экранированием

    Строка в JavaScript может содержать специальные символы. Например, \n (перевод строки), \t (табуляция), \r (возврат каретки) и др.

    "Это предложение.\nА это тоже предложение, но оно будет начинаться с новой линии.";

    Со строками можно произовдить операцию сложения (объединения) или другими словами конкатенацию. Для этого используется оператор "+". Сымысл данной операции заключается в присоединении второй строки к концу первой.

    "Я люблю " + "JavaScript"; // Я люблю JavaScript

    Значение "undefined"

    undefined - специальный примитивный тип данных, который имеет одно значение, равное undefined .

    Этот тип данных имеет объявленная переменная, которой ещё не присвоено значение.

    Var num; // undefined

    Значение undefined также будет возвращено при обращении к несуществующему свойству объекта.

    Var obj = {}; // пустой объект obj.prop; // undefined

    Значение "null"

    null - специальный примитивный тип данных, который имеет одно значение, равное null .

    null - это просто специальное значение, которое имеет смысл «ничего» или «неизвестное значение», т.е. оно явно ничего не означает.

    Объект (Object)

    Объект – это структура данных, состоящая из пар имя-значение.

    Создание объекта с помощью нотации литерала объекта осуществляется следующим образом:

    { имя_1: значение_1, имя_2: значение_2, имя_3: значение_3, ... }

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

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

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

    Var person = { name: "Виталий", age: 27, getAge: function () { return "Возраст: " + this.age; } }

    Обращение к свойствам объекта выполняется через точку или посредством скобочной записи.

    // выведем значение свойства age в консоль браузера // 1 способ (через точку) console.log(person.age); // 2 способ (с помощью скобок) console.log(person["age"]); // вызовем метод getAge; значение, которое он вернет, выведем в консоль console.log(person.getAge());

    Оператор typeof

    Оператор typeof используется для получения информации о типе данных выражения в виде строки.

    Синтаксис оператора typeof (вариант без круглых скобок):

    Typeof выражение

    Синтаксис оператора typeof (с использованием круглых скобок):

    Typeof(выражение)

    Var name, age = 37, email = "[email protected]", isLicense = true, interest: null, lastExperience: { period: "June 2011 - June 2018", place: "ISACA, Moscow", position: "Web designer" }, getExperience: function() { return lastExperience.period + " ("+ lastExperience.position + " - " + lastExperience.place + ")"; }; typeof name; // "undefined" typeof age; // "number" typeof isLicense; // "boolean" typeof interest; // "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) - это ошибка, которая присутствует в языке, начиная с его первой реализации; она не была исправлена в целях сохранения совместимости и это необходимо учитывать, при написании сценариев; null - это примитивный тип данных, он не является объектом */ /* (2) - это очень удобно, что оператор typeof выделяет функции отдельно; но функция в JavaScipt - это тоже объект; в этом легко убедиться если выполнить следующую конструкцию: */ typeof getExperience.__proto__.__proto__ // "object" (прототипом функции является объект)

    Константы

    С выходом ECMAScript 6 появилось возможность создавать константы. Осуществляется это с помощью ключевого слова const.

    Const COLOR_RED = "#ff0000";

    Константа – это переменная, значение которой защищено от изменения. Т.е. при попытке поменять значение будет брошена ошибка.

    Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Assignment to constant variable.

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

    Const COLORS = { red: "#ff0000", green: "#00ff00", blue: "#00ff00" } COLORS = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Assignment to constant variable. COLORS.green = "#4caf50";

    JavaScript был создан программистом Brendan Eich из Netscape и представлен в декабре 1995 года под названием LiveScript. Довольно быстро он был переименован в JavaScript, хотя официальным названием JavaScript является ECMAScript. ECMAScript разрабатывается и поддерживается Международной организацией ECMA (Европейская ассоциация производителей компьютеров).

    Что такое JavaScript?
    1) JavaScript — язык сценариев, или скриптов. Скрипт представляет собой программный код — набор инструкций, который не требует предварительной обработки (например, компиляции) перед запуском. Код JavaScript интерпретируется движком браузера во время загрузки веб-страницы. Интерпретатор браузера выполняет построчный анализ, обработку и выполнение исходной программы или запроса.

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

    JavaScript на веб-страницах 1. Подключение сценариев к html-документу

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

    или тело страницы.

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

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

    var colorArray = ["#5A9C6E", "#A8BF5A", "#FAC46E", "#FAD5BB", "#F2FEFF"]; // создаем массив с цветами фона var i = 0; function changeColor(){ document.body.style.background = colorArray[i]; i++; if(i > colorArray.length - 1){ i = 0; } } Change background

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

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

    document.write("Введите свое имя");

    2. Типы данных и переменные в JavaScript

    Компьютеры обрабатывают информацию — данные. Данные могут быть представлены в различных формах или типах. Большая часть функциональности JavaScript реализуется за счет простого набора объектов и типов данных. Функциональные возможности, связанные со строками, числами и логикой, базируются на строковых, числовых и логических типах данных. Другая функциональная возможность, включающая регулярные выражения, даты и математические операции, осуществляется с помощью объектов RegExp, Date и Math.

    Литералы в JavaScript представляют собой особый класс типа данных, фиксированные значения одного из трех типов данных — строкового, числового или логического:

    "это строка" 3.14 true alert("Hellow"); // "Hellow" - это литерал var myVariable = 15; // 15 - это литерал

    Примитивный тип данных является экземпляром определенного типа данных, таких как строковый, числовой, логический, null и undefined .

    2.1. Переменные в JavaScript

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

    Имя переменной, или идентификатор , может включать только буквы a-z , A-Z , цифры 0-9 (цифра не может быть первой в имени переменной), символ $ (может быть только первым символом в имени переменной или функции) и символ подчеркивания _ , наличие пробелов не допускается. Длина имени переменной не ограничена. Можно, но не рекомендуется записывать имена переменных буквами русского алфавита, для этого они должны быть записаны в Unicode.

    В качестве имени переменной нельзя использовать ключевые слова JavaScript. Имена переменных в JavaScript чувствительные к регистру, что означает, что переменная var message; и var Message; — разные переменные.

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

    Переменная инициализируется значением с помощью операции присваивания = , например, var message="Hellow"; , т.е. создается переменная message и в ней сохраняется ее первоначальное значение "Hellow" . Переменную можно объявлять без значения, в этом случае ей присваивается значение по умолчанию undefined . Значение переменной может изменяться во время исполнения скрипта. Разные переменные можно объявлять в одной строке, разделив их запятой:

    Var message="Hellow", number_msg = 6, time_msg = 50;

    2.2. Типы данных переменных

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

    Var message = 10 + " дней до отпуска"; // вернет "10 дней до отпуска"

    Получить тип данных, который имеет переменная, можно с помощью оператора typeof . Этот оператор возвращает строку, которая идентифицирует соответствующий тип.

    Typeof 35; // вернет "number" typeof "text"; // вернет "string" typeof true; // вернет "boolean" typeof ; // вернет "object" typeof undefined; // вернет "undefined" typeof null; // вернет "object"

    Все типы данных в JavaScript делятся на две группы — простые типы данных (primitive data types) и составные типы данных (composite data types) .

    К простым типам данных относят строковый, числовой, логический, null и underfined .

    2.2.1. Строковый тип (string)

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

    Var money = ""; // пустая строка, ноль символов var work = "test"; var day = "Sunday"; var x = "150";

    В строку в двойных кавычках можно включить одиночную кавычку и наоборот. Кавычка того же типа отключается с помощью символа обратного слэша \ (так называемая escape-последовательность ):

    Document.writeln("\"Доброе утро, Иван Иваныч!\"\n"); // выведет на экран "Доброе утро, Иван Иваныч!"

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

    2.2.2. Числовой тип (number)

    Используется для числовых значений. Числа в языке JavaScript бывают двух типов: целые числа (integer) и числа с плавающей точкой (floating-point number) . Целочисленные величины могут быть положительными, например 1 , 2 , и отрицательными, например –1 , –2 , или равными нулю. 1 и 1.0 — одно и то же значение. Большинство чисел в JavaScript записываются в десятичной системе счисления, также может использоваться восьмеричная и шестнадцатеричная системы.

    В десятичной системе значения числовых переменных задаются с использованием арабских цифр 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 .

    В восьмеричном формате числа представляет собой последовательность, содержащая цифры от 0 до 7 и начинающаяся с префикса 0 .

    Для шестнадцатеричного формата добавляется префикс 0x (0X), за которым следует последовательность из цифр от 0 до 9 или букв от a (A) до f (F), соответствующие значениям от 10 до 15 .

    Var a = 120; // целое десятичное числовое значение var b = 012; // восьмеричный формат var c = 0xfff; // шестнадцатеричный формат var d = 0xACFE12; // шестнадцатеричный формат

    Числа с плавающей точкой представляют собой числа с дробной десятичной частью, либо это числа, выраженные в экспоненциальном виде. Экспоненциальная запись чисел предполагает следующий вид: число с дробной десятичной частью, за ним следует буква e , которая может быть указана как в верхнем, так и в нижнем регистре, далее — необязательный знак + или - и целая экспонента.

    Var a = 6.24; // вещественное число var b = 1.234E+2; // вещественное число, эквивалентно 1.234 Х 10² var c = 6.1e-2; // вещественное число, эквивалентно 6.1 Х 10‾²

    2.2.3. Логический тип (boolean)

    Данный тип имеет два значения, true (истина), false (ложь). Используется для сравнения и проверки условий.

    Var answer = confirm("Вам понравилась эта статья?\n Нажмите ОК. Если нет, то нажмите Cancel."); if (answer == true) { alert("Спасибо!"); }

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

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

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

    2.3. Глобальные и локальные переменные

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

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

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

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

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

    Локальные переменные, объявленные внутри функции в разных блоках кода, имеют одинаковые области видимости. Тем не менее, рекомендуется помещать объявления всех переменных в начале функции.

    Programming languages all have built-in data structures, but these often differ from one language to another. This article attempts to list the built-in data structures available in JavaScript and what properties they have; these can be used to build other data structures. Wherever possible, comparisons with other languages are drawn.

    Dynamic typing

    JavaScript is a loosely typed or a dynamic language. Variables in JavaScript are not directly associated with any particular value type, and any variable can be assigned (and re-assigned) values of all types:

    Var foo = 42; // foo is now a number foo = "bar"; // foo is now a string foo = true; // foo is now a boolean

    Data types

    The latest ECMAScript standard defines eight data types:

    • Seven data types that are :
    Primitive values

    All types except objects define immutable values (values, which are incapable of being changed). For example and unlike to C, Strings are immutable. We refer to values of these types as "primitive values".

    Boolean type

    Boolean represents a logical entity and can have two values: true , and false . See Boolean and Boolean for more details.

    Null type Properties

    In JavaScript, objects can be seen as a collection of properties. With the object literal syntax , a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using key values. A key value is either a String or a Symbol value.

    There are two types of object properties which have certain attributes: The data property and the accessor property.

    Data property

    Associates a key with a value and has the following attributes:

    Attributes of a data property Attribute Type Description Default value
    [] Any JavaScript type The value retrieved by a get access of the property. undefined
    [] Boolean If false , the property"s [] can"t be changed. false
    [] Boolean for...in loops. See also Enumerability and ownership of properties false
    [] Boolean If false , the property can"t be deleted, can"t be changed to an accessor property and attributes other than [] and [] can"t be changed. false
    Obsolete attributes (as of ECMAScript 3, renamed in ECMAScript 5) Attribute Type Description
    Read-only Boolean Reversed state of the ES5 [] attribute.
    DontEnum Boolean Reversed state of the ES5 [] attribute.
    DontDelete Boolean Reversed state of the ES5 [] attribute.
    Accessor property

    Associates a key with one or two accessor functions (get and set) to retrieve or store a value and has the following attributes:

    Attributes of an accessor property Attribute Type Description Default value
    [] Function object or undefined The function is called with an empty argument list and retrieves the property value whenever a get access to the value is performed. See also get . undefined
    [] Function object or undefined The function is called with an argument that contains the assigned value and is executed whenever a specified property is attempted to be changed. See also set . undefined
    [] Boolean If true , the property will be enumerated in for...in loops. false
    [] Boolean If false , the property can"t be deleted and can"t be changed to a data property. false

    Note: Attribute is usually used by JavaScript engine, so you can"t directly access it (see more about Object.defineProperty()). That"s why the attribute is put in double square brackets instead of single.

    "Normal" objects, and functions

    A JavaScript object is a mapping between keys and values. Keys are strings (or Symbol s) and values can be anything. This makes objects a natural fit for hashmaps .

    Functions are regular objects with the additional capability of being callable.

    Dates

    When representing dates, the best choice is to use the built-in Date utility in JavaScript.

    Indexed collections: Arrays and typed Arrays

    Arrays are regular objects for which there is a particular relationship between integer-key-ed properties and the "length" property. Additionally, arrays inherit from Array.prototype which provides to them a handful of convenient methods to manipulate arrays. For example, indexOf (searching a value in the array) or push (adding an element to the array), etc. This makes Arrays a perfect candidate to represent lists or sets.

    Typed Arrays are new to JavaScript with ECMAScript 2015 and present an array-like view of an underlying binary data buffer. The following table helps you to find the equivalent C data types:

    TypedArray objects
    Type Value Range Size in bytes Description Web IDL type Equivalent C type
    Int8Array -128 to 127 1 8-bit two"s complement signed integer byte int8_t
    Uint8Array 0 to 255 1 8-bit unsigned integer octet uint8_t
    Uint8ClampedArray 0 to 255 1 8-bit unsigned integer (clamped) octet uint8_t
    Int16Array -32768 to 32767 2 16-bit two"s complement signed integer short int16_t
    Uint16Array 0 to 65535 2 16-bit unsigned integer unsigned short uint16_t
    Int32Array -2147483648 to 2147483647 4 32-bit two"s complement signed integer long int32_t
    Uint32Array 0 to 4294967295 4 32-bit unsigned integer unsigned long uint32_t
    Float32Array 1.2x10 -38 to 3.4x10 38 4 32-bit IEEE floating point number (7 significant digits e.g. 1.1234567) unrestricted float float
    Float64Array 5.0x10 -324 to 1.8x10 308 8 64-bit IEEE floating point number (16 significant digits e.g. 1.123...15) unrestricted double double
    BigInt64Array -2 63 to 2 63 -1 8 64-bit two"s complement signed integer bigint int64_t (signed long long)
    BigUint64Array 0 to 2 64 -1 8 64-bit unsigned integer bigint uint64_t (unsigned long long)
    Keyed collections: Maps, Sets, WeakMaps, WeakSets

    These data structures take object references as keys and are introduced in ECMAScript Edition 6. Set and WeakSet represent a set of objects, while Map and WeakMap associate a value to an object. The difference between Maps and WeakMaps is that in the former, object keys can be enumerated over. This allows garbage collection optimizations in the latter case.

    One could implement Maps and Sets in pure ECMAScript 5. However, since objects cannot be compared (in the sense of "less than" for instance), look-up performance would necessarily be linear. Native implementations of them (including WeakMaps) can have look-up performance that is approximately logarithmic to constant time.

    Usually, to bind data to a DOM node, one could set properties directly on the object or use data-* attributes. This has the downside that the data is available to any script running in the same context. Maps and WeakMaps make it easy to privately bind data to an object.

    Structured data: JSON

    JSON (JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript but used by many programming languages. JSON builds universal data structures. See JSON and JSON for more details.

    More objects in the standard library

    JavaScript has a standard library of built-in objects. Please have a look at the reference to find out about more objects.

    Determining types using the typeof operator

    The typeof operator can help you to find the type of your variable. Please read the for more details and edge cases.

    Specifications Specification Status Comment
    ECMAScript 1st Edition (ECMA-262) Standard Initial definition.
    ECMAScript 5.1 (ECMA-262)
    The definition of "Types" in that specification.     		Standard
    ECMAScript 2015 (6th Edition, ECMA-262)
    		 Standard Added Symbol.
    ECMAScript Latest Draft (ECMA-262)
    The definition of "ECMAScript Data Types and Values" in that specification.     		Draft

    Почти в любом языке программировании существуют различные типы переменных и JavaScript тут сюрпризов не преподносит. Как правило, это стандартный набор типов: целый (integer ), вещественный (double ), строковый (string ), булевский (boolean ) и массив (array ). Давайте разберём каждый тип переменной в JavaScript подробнее.

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

    Начнём с самого простого - целого типа, знакомого нам по предыдущей статье. Целый тип - это обычные целое число, например, -100, -34, 0, 15, 259 и так далее. Соответственно, целый тип создаётся с помощью присвоения переменной целого значения, например, так:

    Var number = -323;

    Следующий тип переменной - это вещественный тип, или, как принято его называть, double . Тип double - это вещественные числа, то есть абсолютно любые числа, кроме мнимых (если не знаете, что такое мнимые числа, то не обращайте на это внимание). Например, -3.4, -1.032, 35.599212, 0.0001. Так же как и с другими типами, для создания вещественной переменной необходимо инициализировать переменную одним из подобных значений. Вот пример:

    Var number = 32.3291;

    Обратите внимание, что целая часть от дробной отделяется не "запятой " (как принято у нас), а "точкой ".

    Следующий тип переменной - это строковый. Строковый тип в JavaScript используется очень часто, не реже, чем другие, если не больше. Строковый тип - это какая-либо строка. Для примера такая: "string", "732", "My name"s Michael". Обратите внимание, что строка задаётся в кавычках. В частности, строка "732" отличается от числа 732. Создаётся строка аналогично другим типам в JavaScript :

    Var str = "some string";

    Ещё один тип переменной - это булевский. Тип этой переменной может содержать одно из двух значений: true (истина) или false (ложь). Переменная используется в условных операторах, о которых мы поговорим позднее. А пока пример создания булевской переменной:

    Var bool = true;

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

    Var array = new Array(3, 7, 12, true, 4.5, "some string", true);

    В примере создаётся массив из 7-ми значений, которые могут быть считаны или перезаписаны. Встаёт вопрос: как обратиться к элементу массива. Очень просто! Синтаксис обращения к элементу массива следующий: название_ массива[номер_элемента]. Обратите внимание, что нумерация в массиве начинается с "0 ". Поэтому элемент со значением "3 " - это элемент под номером "0 ". Для примера покажу, как можно вывести элемент массива в окно браузера и перезаписать его.

    Document.write(array);
    array = array + 1;
    document.write(array);

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

    Это все типы переменных в JavaScript .