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:

Let 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. Почему «сложно о простом»? Потому что всё, что я буду рассказывать я буду рассказывать учитывая особенности работы интерпретатора, начиная с типов данных. Всё это будет делаться для того, что бы потом можно было рассказать просто о сложном, например, о способах наследования в JavaScript и прочих патернах.

JavaScript – это объектно-ориентированный язык программирования, с прототипной организацией.
Что значит «с прототипной организацией», мы поговорим в следующей статье (она обязательно будет), а вот почему он «объектно-ориентированный» и всё ли в JS - объект, мы узнаем сегодня.
Для выполнения своих целей JS`у достаточно всего 9 типов. Причём только 6 из них доступны программе, оставшиеся же 3 доступны лишь на уровне реализации и используется спецификацией. На первый взгляд(и это первое заблуждение) всё в JS является объектами. Так вот пять из шести доступных программе типов являются так называемыми примитивами и не есть объектами(ниже я поясню почему и как их путают с объектами). Эти пять примитивов это:

- String (s=’str’)
- Number (n=10)
- Boolean (b=true)
И как я их называю «философские типы»:
- null (v = null)
- undefined (u=undefined)

Философские по тому, что null означает, что переменной присвоено ничего, а undefined – означает, что в переменную присвоили пустоту. Чем отличается «ничего» от «пустоты» в данном случае – поразмыслите на досуге. Сейчас мы этого делать не станем.

Шестой, доступный программе тип(объектный) – это:
- Object (не путайте с конструктором Object, мы сейчас ведём речь лишь об абстрактных типах!) – единственный тип, представляющий объекты в JavaScript.
Объект - это структура данных(целый их набор), представленный в виде набора пар «ключ-значение». Значением может быть любой из типов данных - тогда это будет свойство объекта, или даже функция - тогда это будет метод объекта.

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

Вот несколько примеров:

Var v1; //undefined (пустая) локальная переменная var v2="2"; //строковая локальная литеральная переменная var v3 = new String(2); //строковая локальная, объявленная через конструктор переменная. Создаст новый объект типа String v4 = String(2); //строковая глобальная переменная вызванная через конструктор. Создаст переменную window.v4 "2".length; // строка не станет переменной но её можно уже использовать как Объект 34..toString(); //число не станет переменной но его уже можно использовать как объект 12. toString(); //число не станет переменной но его уже можно использовать как объект (22).toString();//число не станет переменной но его уже можно использовать как объект

В последних 4-х командах, как раз хорошо видно как примитив путают с объектом – ведь мы же вызываем метод, через точку – прямо как у объекта. Действительно создаётся впечатление, что эти примитивы – объекты.

Заблуждение усугубляется, когда мы проверяем тип переменной, например

Var v = null; typeof v;

И получаем в ответ «object».

А если мы напишем:
var v = null; v instanceof Object;

То в голове вообще возникнет каша, потому, что результат последней строчки будет «false». То есть переменная v имеет тип object, но не унаследована от типа Object. Что за дела?!

Для начала объясню подвох с typeof null. Этот оператор возвращает тип объекта. А дело в том, что оператор typeof возвращает строковое значение, взятое из жёстко закреплённой таблицы, где прописано: «для null – возвращать «object»». Оператор же instanceof – проверяет принадлежит ли что-то к указанному типу данных. Как он это делает, я расскажу в следующей статье, но, уверяю вас, в данном случае он отработал верно, примитив null ни в коем случае не унаследован от типа Object – он сам по себе, примитив – низшая ступень развития.

Ладно, с typeof и instanceof разобрались, но методы то у примитивов вызываются – как у объектов прям! Как, если это не объект?

Тут дело вот в чём. Существует такая вещь как функции-обёртки(конструкторы)(и снова всё прояснится во второй статье). Они есть для всех примитивов (Number(), Boolean(), String()), а так же и другие. Их суть состоит в том, что бы из примитива создать объект, у которого будут вспомогательные методы для работы с данным типом примитива.
Например переменную можно создать так:

Var num = new Number(23.456);

В таком случае из примитива 23.456 мы получим объект.
Для типа number конструктор Number() имеет вспомогательный метод toPrecision() – он определяет для числа количество значимых цифр. Например, если числу 23.456 установить количество значимых цифр 4, то мы получим число 23.45.
И вот когда мы пытаемся обратится к примитиву как к объекту:

(23.456). toPrecision(4);

Интерпретатор временно оборачивает, примитив в объект вызовом new Number(23.456) и потом уже у этого объекта вызывает метод toPrecision(), который у него теперь есть. Таким образом, многие ошибочно считают, что всё в JS есть объектом.

Так же есть ещё один пример вводящий в заблуждение и вызывающий недопонимание происходящего. Вот код:

Var str = ‘str’; str.test = ‘test’; //ошибки не будет, программа продолжит работать, но console.log(str.test); //undefined

Если бы мы считали, как раньше, что str – это объект, мы бы удивились, почему он не запомнил в себе новое свойство test. Но теперь мы знаем, что при обращении к примитиву как к объекту, он временно оборачивается в объект типа String. Но после выполнения операции эта обёртка исчезает, а вместе с ней и новое свойство test. Вот и всё, никакой магии.

На самом деле, забегая наперёд, во время оборачивания примитива в объект, выстраивается целая цепочка наследования (как это организовано мы поговорим позже), но по сути получается такая вот «матрёшка»:

Object(Number(<примитив>)). Родителем любого объекта в JS, так или иначе, будет Object. При вызове свойства в объекте поиск проходит по всей этой «матрёшке» пока не найдёт в одном из объектов это свойство или вернёт undefined или если искали метод, то выбросит исключение. Таким образом, у примитива также доступны свойства объекта Object. Как работает прототипное наследование и о его тонкостях мы поговорим во второй статье.

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

Var str = "abc"; str+1; // "abc1"

Здесь примитив типа number - 1, будет преобразован в строковый примитив. В объектах эта возможность доступна через вызов метода toString(), в объектах типа number, есть метод valueOf(), который вернёт примитив типа number. Но мы вроде как говорили что методы могут быть только у объектов. Значит в процессе преобразования примитива из одного типа в другой, происходит тоже оборачивание в объект? Уверяю вас что нет. Вызов этого метода происходит не явно, когда функция-конструктор вызывается интерпретатором без оператора new. Что за волшебный оператор new и что происходит когда функция-конструктор вызывается без него, да и что блин в конце то концов за функция-конструктор такая, мы поговорим в следующей статье. Пока поверьте мне на слово - преобразование типов происходит сразу - из примитива в примитив.

Пока, конечно, больше вопросов чем ответов, однако, поверьте, всё станет намного прозрачнее после прочтения второй статьи. Здесь я в основном заинтриговал и поднял ряд вопросов - так сказать взбудоражил умы. Но всё же кое-что можно вынести и из этой статьи:
1. Не смотря на расхожее мнение «всё в JS является объектами» - это не так, мы выяснили, что из 6 доступных программисту типов данных аж 5 является примитивами и лишь один представляет тип объектов.
2. Про объекты мы узнали, что это такая структура данных, которая содержит в себе пары «ключ-значение». При значением может быть любой из типов данных (и это будет свойство объекта) или функция (и это будет метод объекта).
3. А вот примитивы – это не объекты. Хотя с ними и можно работать как с объектом (и это вызывает заблуждение что примитив – это объект), но…
4. Переменные можно объявить как по простому (литерально) (var a = ‘str’), так и через функцию-конструктор (обёртка)(var a = new String(‘str’)). Во втором случае мы получим уже не примитив, а объект созданный функцией-обёрткой String(). (что за магический оператор new и что такое функция-конструктор мы узнаем дальше).
5. Узнали, что именно за счёт создания обёртки над примитивом (new String(‘str’)) c ним можно работать как с объектом. Именно эту обёртку создаёт интерпретатор вокруг примитива, когда мы пытаемся работать с ним как с объектом, но после выполнения операции она разрушается (поэтому примитив никогда не сможет запомнить свойство, которое мы ему присвоим a.test = ‘test’- свойство test исчезнет с обёрткой).
6. Узнали, что у объектов есть метод toString() который возвращает строковое представление объекта (для типа number valueOf() – вернёт числовое значение).
7. Поняли, что при выполнении операций конкатенации или математических операциях примитивы могут переопределить свой тип в нужный. Для этого они используют функции-обёртки своих типов, но без оператора new (str = String(str)).(в чём разница и как это работает, поговорим дальше)
8. И наконец, узнали, что typeof берёт значения из жёстко зафиксированной таблицы (вот откуда ещё одно заблуждение, основанное на typeof null //object).

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

После этого можно задать значение переменной:

x = “Sample string”;

Язык JavaScript позволяет создавать переменные «на лету» без их объявления, например:

y = “Second string”;

При этом переменная y будет создана, и в памяти будет отведено для нее место, однако такая практика затрудняет чтение и отладку скрипта.

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

JavaScript поддерживает пять базовых типов данных: Number – числа; String – строки; Boolean – Булев тип; Undefined – неопределенный; Null – пустой. Эти пять типов данных называются базовыми, т.к. на основе их строятся более сложные типы данных. Фактический интерес с точки зрения хранения данных представляют три: числа, строки и логические значения, неопределенный и пустой типы представляют интерес в определенных ситуациях.

Числа

В языке JavaScript численный тип данных включает целые и вещественные числа. Целые числа могут принимать значения от –2 53 до 2 53 , вещественные могут принимать большие значения в пределах ±1.7976 x 10 308 или быть точными в пределах ±2.2250 x 10 -308 .

Числа также могут записываться в экспоненциальной форме.

Для записи целого шестнадцатеричного числа в начале ставится ноль, затем буква x , затем само число, которое может содержать цифры от 0 до 9 и буквы от A до F .

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

В языке JavaScript также имеется возможность записи чисел в восьмеричной системе счисления: для записи числа в начале ставится 0 , затем идут цифры от 0 до 7 .

Специальные числа

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

Еще одним важным специальным значением является NaN – «не число» (not a number). Типичным примером операции, которая возвращает NaN , является деле­ние на ноль. Для определения, является ли значение переменной NaN , используется функция isNaN() , которая возвращает true , если число является действии­тельным (включая бесконечность), и false , если значение переменной NaN .

К специальным числам относятся максимальное и минимальное значения, кото­рые может принимать переменная. Все специальные числа приведены в таблице:

Строки

Строка – это последовательность символов огрниченная двойными или одинарными кавычками.

После создания строки она имеет одно свойство – length , возвращающее длину строки, и большое количество методов:

charAt (index : Number) : String – возвращает символ, находящийся на определенной позиции;

concat ([string1 : String [, … [, stringN : String]]]]) : String – соединяет строки (аналогично оператору «+»);

indexOf (subString : String [, startIndex : Number]) : Number – возвращает номер вхождения подстроки в строку, необязательным параметром является номер символа, с которого начинается поиск. Если подстрока не найдена, возвращается -1 . Поиск выполняется слева направо, для поиска справа налево используется метод lastIndexOf() , который имеет аналогичный синтаксис;

replace (rgExp : RegExp, replaceText : String) : String – выполняет замену регулярного выражения строкой;

split ([ separator : { String | RegExp } [, limit : Number]]) : Array – разбивает строку на массив подстрок. В качестве первого параметра передается разделитель, на основе которого производится разбиение, если разделитель не указан, возвращается массив, содержащий один элемент с исходной строкой. Второй параметр определяет максимальное количество элементов в возвращаемом массиве;

substr (start : Number [, length : Number]) : String – возвращает подстроку, которая начинается с определенной позиции и имеет определенную длину;

substring (start : Number, end : Number) : String – возвращает подстроку, которая начинается и заканчивается в позициях, определенных параметрами.

Булев тип

Переменные булевого типа могут принимать одно из двух значения: true – истина; false – ложь. Переменные булевого типа часто используются в условном операторе if . Пример:

var doAlert = true;

if (doAlert) { alert(“Hello, World!”); }

Переменные типа Undefined и Null

Тип Undefined используется для несуществующих переменных или переменных, значения которых еще не определены. В следующем примере переменная x будет иметь значение Undefined – то есть не определена.

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

Массивы

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

myArr = “Hello!”;

Объявление пустого массива и массива, содержащего данные:

var emptyArr = ;

var filledArr = ["Hello", "World"];

Массивы могут быть многомерными. Объявление и обращение к многомерному массиву выглядит так:

var myArr = [,,];

//создается массив размером 3х2 и выводится элемент, содержащийся
в третьей строке, во втором столбце, равный 6.

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

Типы данных

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

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

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

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

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

Функции, которые пишутся для инициализации вновь создаваемых объектов (с оператором new), называются конструкторами . Каждый конструктор определяет класс объектов - множество объектов, инициализируемых этим конструктором. Классы можно представлять как подтипы объектного типа.

В дополнение к классам Array и Function в базовом языке JavaScript определены еще три полезных класса. Класс Date определяет объекты, представляющие даты. Класс RegExp определяет объекты, представляющие регулярные выражения (мощный инструмент сопоставления с шаблоном). А класс Error определяет объекты, представляющие синтаксические ошибки и ошибки времени выполнения, которые могут возникать в программах на языке JavaScript. Имеется возможность определять собственные классы объектов, объявляя соответствующие функции-конструкторы.

Числа

В отличие от многих языков программирования, в JavaScript не делается различий между целыми и вещественными значениями. Все числа в JavaScript представляются вещественными значениями (с плавающей точкой). Для представления чисел в JavaScript используется 64-битный формат, определяемый стандартом IEEE 754 . Этот формат способен представлять числа в диапазоне от ±1,8 x 10 308 до ±5 x 10 -324 .

В JavaScript целые десятичные числа записываются как последовательность цифр. Помимо десятичных целых литералов JavaScript распознает шестнадцатеричные значения. Шестнадцатеричные литералы начинаются с последовательности символов «0x», за которой следует строка шестнадцатеричных цифр. Шестнадцатеричная цифра - это одна из цифр от 0 до 9 или букв от A до F, представляющих значения от 10 до 15:

Var a = 255; var b = 0xFF; // Число 255 в шестнадцатеричной системе исчисления

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

Литералы вещественных чисел могут также представляться в экспоненциальной нотации: вещественное число, за которым следует буква e (или E), а затем необязательный знак плюс или минус и целая экспонента. Такая форма записи обозначает вещественное число, умноженное на 10 в степени, определяемой значением экспоненты:

Var a = 16.75; var b = 2e4; // 2 * 10^4 = 20 000

Арифметические операции

Обработка чисел в языке JavaScript выполняется с помощью арифметических операторов. В число таких операторов входят: оператор сложения +, оператор вычитания - , оператор умножения *, оператор деления / и оператор деления по модулю % (возвращает остаток от деления).

Помимо этих простых арифметических операторов JavaScript поддерживает более сложные математические операции, с помощью функций и констант, доступных в виде свойств объекта Math :

Math.pow(2,53) // 2 в степени 53 Math.round(.6) // Округление до ближайшего целого (результат 1.0) Math.ceil(.6) // Округление вверх (результат 1.0) Math.floor(.6) // Округление вниз (результат 0) Math.abs(-5) // Модуль числа (результат 5) Math.max(x,y,z) // Возвращает наибольший аргумент Math.min(x,y,z) // Возвращает наименьший аргумент\ Math.random() // Псевдослучайное число x, где 0

Арифметические операции в JavaScript не возбуждают ошибку в случае переполнения, потери значащих разрядов или деления на ноль. Если результат арифметической операции окажется больше самого большого представимого значения (переполнение), возвращается специальное значение «бесконечность», которое в JavaScript обозначается как Infinity . Аналогично, если абсолютное значение отрицательного результата окажется больше самого большого представимого значения, возвращается значение «отрицательная бесконечность», которое обозначается как -Infinity .

Эти специальные значения, обозначающие бесконечность, ведут себя именно так, как и следовало ожидать: сложение, вычитание, умножение или деление бесконечности на любое значение дают в результате бесконечность (возможно, с обратным знаком).

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

Деление на ноль не считается ошибкой в JavaScript: в этом случае просто возвращается бесконечность или отрицательная бесконечность. Однако есть одно исключение: операция деления нуля на ноль не имеет четко определенного значения, поэтому в качестве результата такой операции возвращается специальное значение «не число» (not-a-number), которое обозначается как NaN . Значение NaN возвращается также при попытке разделить бесконечность на бесконечность, извлечь квадратный корень из отрицательного числа или выполнить арифметическую операцию с нечисловыми операндами, которые не могут быть преобразованы в числа.

В JavaScript имеются предопределенные глобальные переменные Infinity и NaN, хранящие значения положительной бесконечности и «не число». В стандарте ECMAScript 3 эти переменные доступны для чтения/записи и могут изменяться в программах. Стандарт ECMAScript 5 исправляет эту оплошность и требует, чтобы эти переменные были доступны только для чтения.

Дата и время

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

// Несколько версий перегруженного конструктора Date() new Date(); new Date(миллисекунды); new Date(строка_даты); new Date(год, месяц, день, часы, минуты, секунды, мс)

Конструктор Date() без аргументов создает объект Date со значением, равным текущим дате и времени. Если конструктору передается единственный числовой аргумент, он используется как внутреннее числовое представление даты в миллисекундах, аналогичное значению, возвращаемому методом getTime(). Когда передается один строковый аргумент, он рассматривается как строковое представление даты в формате, принимаемом методом Date.parse().

Кроме того, конструктору можно передать от двух до семи числовых аргументов, задающих индивидуальные поля даты и времени. Все аргументы, кроме первых двух - полей года и месяца, - могут отсутствовать. Обратите внимание: эти поля даты и времени задаются на основе локального времени, а не времени UTC (Universal Coordinated Time - универсальное скоординированное время) . В качестве альтернативы может использоваться статический метод Date.UTC(). Date() может также вызываться как функция (без оператора new). При таком вызове Date() игнорирует любые переданные аргументы и возвращает текущие дату и время.

Аргументы, передаваемые конструктору Date()

Аргумент	Обозначение
миллисекунды	Количество миллисекунд между нужной датой и полночью 1 января 1970 года (UTC). Например, передав в качестве аргумента число 5000, мы создадим дату, обозначающую пять секунд после полуночи 1 января 1970 года.
строка_даты	Единственный аргумент, задающий дату и (необязательно) время в виде строки. Строка должна иметь формат, понятный для Date.parse().
год	Год в виде четырех цифр. Например, 2001 для 2001 года. Для совместимости с более ранними реализациями JavaScript к аргументу добавляется 1900, если значение аргумента находится между 0 и 99.
месяц	Месяц, заданный в виде целого от 0 (январь) до 11 (декабрь).
день	День месяца, заданный в виде целого от 1 до 31. Обратите внимание, что наименьшее из значений этого аргумента равно 1, а остальных аргументов - 0. Необязательный аргумент.
часы	Часы, заданные в виде целого от 0 (полночь) до 23 (11 часов вечера). Необязательный аргумент.
минуты	Минуты в часах, указанные в виде целого от 0 до 59. Необязательный аргумент.
секунды	Секунды в минутах, указанные в виде целого от 0 до 59. Необязательный аргумент.
мс	Миллисекунды в секунде, указанные в виде целого от 0 до 999. Необязательный аргумент.

У объекта Date нет доступных для записи или чтения свойств; вместо этого доступ к значениям даты и времени выполняется через методы. Большинство методов объекта Date имеют две формы: одна для работы с локальным временем, другая - с универсальным временем (UTC или GMT). Если в имени метода присутствует строка «UTC», он работает с универсальным временем.

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

Методы объекта Date

Метод	Описание
getDate(), getUTCDate(), setDate(), setUTCDate()	Возвращает/устанавливает день месяца из объекта Date в соответствии с локальным или универсальным временем.
getDay(), getUTCDay()	Возвращает день недели из объекта Date в соответствии с локальным или универсальным временем.
getFullYear(), getUTCFullYear(), setFullYear(), setUTCFullYear()	Возвращает/устанавливает год даты в полном четырехзначном формате в локальном или универсальном времени.
getHours(), getUTCHours(), setHours(), setUTCHours()	Возвращает/устанавливает поле часов в объекте Date в локальном или универсальном времени.
getMilliseconds(), getUTCMilliseconds(), setMilliseconds(), setUTCMilliseconds()	Возвращает/устанавливает поле миллисекунд в объекте Date в локальном или универсальном времени.
getMinutes(), getUTCMinutes(), setMinutes(), setUTCMinutes()	Возвращает/устанавливает поле минут в объекте Date в локальном или универсальном времени.
getMonth(), getUTCMonth(), setMonth(), setUTCMonth()	Возвращает/устанавливает поле месяца в объекте Date в локальном или универсальном времени.
getSeconds, getUTCSeconds(), setSeconds, setUTCSeconds()	Возвращает/устанавливает поле секунд в объекте Date в локальном или универсальном времени.
getTime(), setTime()	Возвращает/устанавливает внутреннее представление (миллисекунды) объекта Date. Обратите внимание: это значение не зависит от часового пояса, следовательно, отдельный метод getUTCTime() не нужен.
getTimezoneOffset()	Возвращает разницу в минутах между локальным и универсальным представлениями даты в минутах. Обратите внимание: возвращаемое значение зависит от того, действует ли для указанной даты летнее время.
getYear(), setYear()	Возвращает/устанавливает поле года в объекте Date. Признаны устаревшими, рекомендуется вместо них применять методы getFullYear() и setFullYear(). .
toDateString()	Возвращает строку, представляющую дату из Date для локального часового пояса.
toGMTString()	Преобразует Date в строку, беря за основу часовой пояс GMT. Признан устаревшим, вместо него рекомендован метод toUTCString().
toISOString()	Преобразует Date в строку, используя стандарт ISO-8601, объединяющий формат представления даты/времени и UTC.
toJSON()	Сериализует объект Date в формат JSON с помощью метода toISOString().
toLocaleDateString()	Возвращает строку, представляющую дату из Date в локальном часовом поясе в соответствии с локальными соглашениями по форматированию дат.
toLocaleString()	Преобразует Date в строку в соответствии с локальным часовым поясом и локальными соглашениями о форматировании дат.
toLocaleTimeString()	Возвращает строку, представляющую время из Date в локальном часовом поясе на основе локальных соглашений о форматировании времени.
toString()	Преобразует Date в строку в соответствии с локальным часовым поясом.
toTimeString()	Возвращает строку, представляющую время из Date в локальном часовом поясе.
toUTCString()	Преобразует Date в строку, используя универсальное время.
valueOf()	Преобразует объект Date в его внутренний миллисекундный формат.

В дополнение к перечисленным методам экземпляра в объекте Date определены три статических метода. Эти методы вызываются через сам конструктор Date(), а не через отдельные объекты Date:

Date.now()

Возвращает текущее время в миллисекундах.

Date.parse()

Анализирует строковое представление даты и времени и возвращает внутреннее представление этой даты в миллисекундах.

Date.UTC()

Возвращает представление указанной даты и времени UTC в миллисекундах.

Объект Date - это тип данных, встроенный в язык JavaScript. Объекты Date создаются с помощью представленного ранее синтаксиса new Date().

После создания объекта Date можно воспользоваться его многочисленными методами. Многие из методов позволяют получать и устанавливать поля года, месяца, дня, часа, минуты, секунды и миллисекунды в соответствии либо с локальным временем, либо с временем UTC (универсальным, или GMT). Метод toString() и его варианты преобразуют даты в понятные для восприятия строки.

getTime() и setTime() преобразуют количество миллисекунд, прошедших с полуночи (GMT) 1 января 1970 года, во внутреннее представление объекта Date и обратно. В этом стандартном миллисекундном формате дата и время представляются одним целым, что делает дату очень простой арифметически. Стандарт ECMAScript требует, чтобы объект Date мог представить любые дату и время с миллисекундной точностью в пределах 100 миллионов дней до и после 01.01.1970. Этот диапазон равен ±273 785 лет, поэтому JavaScript-часы будут правильно работать до 275 755 года.

Примеры использования объекта Date

Известно множество методов, позволяющих работать с созданным объектом Date:

// Получает текущую дату и время d = new Date(); // Показывает дату document.write("Сегодня: " + d.toLocaleDateString() + ". "); // Показывает время document.write("Время: "+ d.toLocaleTimeString()); // День недели var dayOfWeek = d.getDay(); // Сегодня выходной? var weekend = (dayOfWeek == 0) || (dayOfWeek == 6);

Ниже показан простой пример часов, использующих объект Date. Здесь используется метод setTimeout() для обновления часов каждую секунду:

Function timer() { // Находим элемент h1 в документе h1 = document.getElementsByTagName("h1"); // Устанавливаем дату var date = new Date(); var hours = date.getHours(); var minutes = date.getMinutes(); var seconds = date.getSeconds(); if (hours

Разметка страницы довольно простая и подключает функцию timer() в обработчике события onload() элемента body:

Строки

Строка - это неизменяемая, упорядоченная последовательность 16-битных значений, каждое из которых обычно представляет символ Юникода. Строки в JavaScript являются типом данных, используемым для представления текста. Длина строки - это количество 16-битных значений, содержащихся в ней. Нумерация символов в строках (и элементов в массивах) в языке JavaScript начинается с нуля: первое 16-битное значение находится в позиции 0, второе - в позиции 1 и т.д. Пустая строка - это строка, длина которой равна 0.

В языке JavaScript нет специального типа для представления единственного элемента строки. Для представления единственного 16-битного значения просто используется строка с длиной, равной 1.

Чтобы включить литерал строки в JavaScript-программу, достаточно просто заключить символы строки в парные одинарные или двойные кавычки (" или "). Символы двойных кавычек могут содержаться в строках, ограниченных символами одинарных кавычек, а символы одинарных кавычек - в строках, ограниченных символами двойных кавычек. Ниже приводятся несколько примеров строковых литералов:

Var str = ""; // Пустая строка str = "простая строка"; str = "строка с "кавычками" внутри"; str = "В этом строковом литерале\nдве строки";

В ECMAScript 3 строковые литералы должны записываться в одной строке программы и не могут разбиваться на две строки. Однако в ECMAScript 5 строковые литералы можно разбивать на несколько строк, заканчивая каждую строку, кроме последней, символом обратного слеша (\). Ни один из символов обратного слеша, как и следующие за ними символы перевода строки, не будут включены в строковый литерал. Чтобы включить в строковый литерал символ перевода строки, следует использовать последовательность символов \n (как показано выше).

Символ обратного слеша (\) имеет специальное назначение в JavaScript-строках. Вместе с символами, следующими за ним, он обозначает символ, не представимый внутри строки другими способами. Например, \n - это управляющая последовательность (escape sequence) , обозначающая символ перевода строки.

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

Var str = "\"JavaScript\" - интерпретируемый язык программирования";

В таблице ниже перечислены управляющие последовательности JavaScript и обозначаемые ими символы. Две управляющие последовательности являются обобщенными; они могут применяться для представления любого символа путем указания кода символа из набора Latin-1 или Unicode в виде шестнадцатеричного числа. Например, последовательность \xA9 обозначает символ копирайта, который в кодировке Latin-1 имеет шестнадцатеричный код A9. Аналогично управляющая последовательность, начинающаяся с символов \u, обозначает произвольный символ Юникода, заданный четырьмя шестнадцатеричными цифрами. Например, \u03c0 обозначает символ π .

Управляющие последовательности JavaScript

Последовательность	Представляемый символ
\0	Символ NUL (\u0000)
\b	Обратное перемещение (\u0008)
\t	Горизонтальная табуляция (\u0009)
\n	Перевод строки (\u000A)
\v	Вертикальная табуляция (\u000B)
\f	Перевод страницы (\u000C)
\r	Возврат каретки (\u000D)
\"	Двойная кавычка (\u0022)
\"	Одинарная кавычка (\u0027)
\\	Обратный слеш (\u005C)
\xZZ	Символ Latin-1, заданный двумя шестнадцатеричными цифрами ZZ
\uxZZZZ	Символ Unicode, заданный четырьмя шестнадцатеричными цифрами ZZZZ

Если символ «\» предшествует любому символу, отличному от приведенных в этой таблице, обратный слеш просто игнорируется (хотя будущие версии могут, конечно, определять новые управляющие последовательности). Например, \# - это то же самое, что и #. Наконец, как отмечалось выше, стандарт ECMAScript 5 позволяет добавлять в многострочные строковые литералы символ обратного слеша перед разрывом строки.

Работа со строками

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

Var str = "Hello, " + "world!"; // Получается строка Hello, world! // Конкатенация строки с переменной var name = "Александр"; str = "Добро пожаловать, " + name + "!";

Строки в JavaScript представлены объектом String , имеющим один конструктор, в котором передается строка. Когда функция String() вызывается в качестве конструктора (с оператором new), она возвращает объект String, содержащий строку s или строковое представление s. Конструктор String(), вызванный без оператора new, преобразует s в элементарное строковое значение и возвращает преобразованное значение:

New String(s); // Функция-конструктор String(s); // Функция преобразования

Объект String имеет единственное свойство - length , которое возвращает количество символов в строке.

В следующей таблице перечислены методы объекта String:

Методы класса String

Метод	Описание	Пример использования
charAt()	Извлекает из строки символ, находящийся в указанной позиции. Номер первого символа в строке равен нулю.	var str = "Hello, world!"; document.write(str.charAt(4)); // Результат "o"
charCodeAt()	Возвращает код символа, находящегося в указанной позиции. (Код Юникода n-го символа в строке - 16-разрядное целое число между 0 и 65 535.)	var str = "Hello, world!"; document.write(str.charCodeAt(4)); // Результат 111 - код символа "o"
concat()	Выполняет конкатенацию одного или нескольких значений со строкой. concat() преобразует все свои аргументы в строки (если это нужно) и добавляет их по порядку в конец строки. Возвращает полученную объединенную строку.	// Получаем одну строку (new String()).concat("Мы рады ", "приветствовать ", "вас на нашем сайте");
indexOf (подстрока, начало)	Выполняет поиск в строке от начала к концу, чтобы увидеть, содержит ли она искомую подстроку. Поиск начинается с позиции "начало" в строке или с начала строки, если аргумент "начало" не указан. Если подстрока найдена, String.indexOf() возвращает позицию первого символа первого вхождения подстроки в строку. Позиции символов в строке нумеруются с нуля. Если подстрока в строке не найдена, String.indexOf() возвращает -1.	var str = "Hello, world!"; if (str.indexOf("world", 0) != -1) document.write("Подстрока \"world\" найдена в исходной строке.");
lastIndexOf()	Выполняет поиск символа или подстроки в строке с конца.	var str = "Hello, world!"; document.write("Позиция последней буквы "o" в исходной строке: " + + str.lastIndexOf("o")); // Результат 8
localeCompare()	Сравнивает строки с учетом порядка следования символов национальных алфавитов. Возвращает число, обозначающее результат сравнения. Если строка «меньше» целевой строки, localeCompare() возвращает отрицательное число. Если строка «больше» целевой строки, метод возвращает положительное число. Если строки идентичны или неразличимы в соответствии с региональными соглашениями о сортировке, метод возвращает 0. Когда к строкам применяются операторы, сравнение выполняется только по кодам Юникода этих символов; порядок сортировки, принятый в текущем регионе, не учитывается. Сортировка, выполняемая подобным образом, не всегда оказывается верной. Стандарт ECMAScript не определяет, как должно выполняться сравнение с учетом региона; в нем просто указано, что эта функция руководствуется порядком сортировки, определенным операционной системой.	var str1 = "Строка1"; var str2 = "Строка2"; if (str1.localeCompare(str2) != 0) document.write("Строки не идентичны");
match()	Выполняет поиск по шаблону с помощью регулярного выражения.	var str = "1 плюс 2 равно 3".match(/\d+/g); // Вернет массив {"1", "2", "3"}
replace()	Метод replace() выполняет операцию поиска и замены для строки. Он ищет в строке одну или несколько подстрок, соответствующих регулярному выражению и заменяет их. Если в регулярном выражении указан глобальный атрибут «g», replace() заменяет все найденные подстроки. В противном случае метод заменяет только первую найденную подстроку. В стандарте ECMAScript v3 определено, что второй аргумент метода replace() может быть функцией, а не строкой. В этом случае функция будет вызываться для каждого найденного соответствия, а возвращаемая ею строка будет использоваться в качестве текста для замены.	var str = "javascript - интерпретируемый язык программирования."; // Обеспечение правильного регистра букв в слове «JavaScript» str = str.replace(/JavaScript/i, "JavaScript");
search()	Метод search() ищет подстроку в строке, соответствующую регулярному выражению regexp, и возвращает позицию первого символа найденной подстроки или -1, если соответствие не найдено. Метод не выполняет глобального поиска, игнорируя флаг «g». Он также игнорирует свойство regexp.lastIndex и всегда выполняет поиск с начала строки, следовательно, всегда возвращает позицию первого соответствия, найденного в строке.	var str = "JavaScript - интерпретируемый язык программирования."; i = str.search("язык"); // Результат 30 (позиция слова "язык" в исходной строке)
slice()	Метод slice() возвращает строку, содержащую фрагмент, или подстроку строки, но не изменяет строку. Первый аргумент - это индекс в строке, с которого должен начинаться фрагмент. Если этот аргумент отрицателен, он обозначает позицию, измеряемую от конца строки. То есть -1 соответствует последнему символу, -2 - второму с конца и т.д.. Второй аргумент - индекс символа исходной строки непосредственно после конца извлекаемого фрагмента. Если он не указан, фрагмент включает все символы от позиции начало до конца строки. Если этот аргумент отрицателен, он обозначает позицию, отсчитываемую от конца строки.	var str = "абвгдежзик"; str1 = str.slice(0,4); // Вернет "абвг" str2 = str.slice(2,4); // Вернет "вг" str3 = str.slice(4); // Вернет "дежзик" str4 = str.slice(3,-1); // Вернет "гдежзи" str5 = str.slice(3,-2); // Вернет "гдежз" str6 = str.slice(-4,-2); // Вернет "жз"
split()	Разбивает строку на массив строк по указанной строке-разделителю. Метод split() создает и возвращает массив подстрок указанной строки, причем размер возвращаемого массива не превышает указанный лимит (передается во втором аргументе). Эти подстроки создаются путем поиска текста, соответствующего разделителю (первый аргумент), в строке от начала до конца и разбиения строки до и после найденного текста. Ограничивающий текст не включается ни в одну из возвращаемых строк.	// Метод split() наиболее полезен при работе // с сильно структурированными строками var str = "1:2:3:4:5"; str.split(":"); // Вернет ["1","2","3","4","5"] str = "a||b||c"; str.split("||"); // Вернет ["a","b","c"] // Чтобы разбить строку на массив символов, // возьмите в качестве разделителя пустую строку str = "hello"; str.split(""); // Вернет ["h","e","l","l","o"] str.split("",3); // Вернет ["h","e","l"]
substr()	Метод substr() извлекает и возвращает подстроку строки, но не изменяет строку. Обратите внимание: метод substr() задает нужную подстроку с помощью позиции символа и длины. Благодаря этому появляется удобная альтернатива методам String.substring() и String.splice(), в которых подстрока задается двумя символьными позициями. При этом следует отметить, что метод не стандартизован в ECMAScript и, следовательно, считается устаревшим.	var str = "абвгдежзик"; str = str.substr(2,5); // Результат "вгдеж"
substring()	Метод String.substring() возвращает подстроку строки, содержащую символы между позициями от (первый аргумент) и до (второй аргумент). Символ в позиции "от" включается в подстроку, а символ в позиции "до" не включается.	var str = "абвгдежзик"; str = str.substring(2,7); // Результат "вгдеж"
toLowerCase()	Возвращает копию строки, в которой все символы переведены в нижний регистр.	var str = "JavaScript"; str = str.toLowerCase(); // Результат "javascript"
toString()	Возвращает элементарное строковое значение. Вызов этого метода требуется редко. Исключение TypeError генерируется, если метод вызывается для объекта, не являющегося объектом String.
toUpperCase()	Возвращает копию строки, в которой все символы переведены в верхний регистр.	var str = "JavaScript"; str = str.toUpperCase(); // Результат "JAVASCRIPT"
trim()	Возвращает копию строки, из которой удалены все начальные и конечные пробельные символы.
valueOf()	Возвращает элементарное строковое значение (аналогично toString(), используется редко).

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

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

Логические значения

Логическое значение говорит об истинности или ложности чего-то. Логический тип данных имеет только два допустимых логических значения. Эти два значения представлены литералами true и false.

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

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

Логические значения обычно используются в управляющих конструкциях JavaScript. Например, инструкция if/else в JavaScript выполняет одно действие, если логическое значение равно true, и другое действие, если false. Обычно сравнение, создающее логическое значение, непосредственно объединяется с инструкцией, в которой оно используется. Результат выглядит так:

If (a == 4) { // ... } else { // ... }

Любое значение в языке JavaScript может быть преобразовано в логическое значение. Следующие значения в результате такого преобразования дают логическое значение (и затем работают как) false:

Undefined null 0 -0 NaN "" // пустая строка

Все остальные значения, включая все объекты (и массивы), при преобразовании дают в результате значение (и работают как) true. Значение false и шесть значений, которые при преобразовании приводятся к этому значению, иногда называют ложными, а все остальные - истинными. В любом контексте, когда интерпретатор JavaScript ожидает получить логическое значение, ложные значения интерпретируются как false, а истинные значения - как true.

Логические значения имеют метод toString(), который можно использовать для преобразования этих значений в строки «true» или «false», но они не имеют других полезных методов.

Значения null и undefined

Ключевое слово null в языке JavaScript имеет специальное назначение и обычно используется для обозначения отсутствия значения. Оператор typeof для значения null возвращает строку «object», что говорит о том, что значение null является специальным «пустым» объектом. Однако на практике значение null обычно считается единственным членом собственного типа и может использоваться как признак отсутствия значения, такого как число, строка или объект. В большинстве других языков программирования имеются значения, аналогичные значению null в JavaScript: вам они могут быть известны как null или nil.

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

Идентификатор undefined является именем предопределенной глобальной переменной (а не ключевым словом, как null), которая инициализирована значением undefined. В ECMAScript 3 undefined является переменной, доступной для чтения/записи, которой можно присвоить любое другое значение. Эта проблема была исправлена в ECMAScript 5, и в реализациях JavaScript, соответствующих этому стандарту, переменная undefined доступна только для чтения. Оператор typeof для значения undefined возвращает строку «undefined», показывающую, что данное значение является единственным членом специального типа.

Несмотря на эти отличия, оба значения, null и undefined, являются признаком отсутствия значения и часто являются взаимозаменяемыми. Оператор равенства == считает их равными. (Чтобы отличать их в программе, можно использовать оператор идентичности ===.) Оба они являются ложными значениями - в логическом контексте они интерпретируются как значение false. Ни null, ни undefined не имеют каких-либо свойств или методов. На практике попытка использовать. или , чтобы обратиться к свойству или методу этих значений, вызывает ошибку TypeError.

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

Неизменяемые простые значения и ссылки на изменяемые объекты

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

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

Var str = "простая строка"; str.slice(8,14); console.log(str); // Отобразит "простая строка" // Чтобы явно изменить строку нужно использовать присваивание str = str.slice(8,14); console.log(str); // Отобразит "строка"

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

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

Var o = { x:1 }; // Начальное значение объекта o.x = 2; // Изменить, изменив значение свойства o.y = 3; // Изменить, добавив новое свойство var a = ; // Массивы также являются изменяемыми объектами a = 0; // Изменить значение первого элемента массива a = 4; // Добавить новый элемент (индекс 3 соответствует четвертой позиции в массиве)

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

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

Var a = ; // Переменная a ссылается на пустой массив. var b = a; // Теперь b ссылается на тот же массив. b = 1; // Изменение массива с помощью ссылки в переменной b. console.log(a === b); // Вернет "true" console.log("a = " + a); // Изменение объекта b изменяет объект a

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

Последнее обновление: 26.03.2018

Все используемые данные в javascript имеют определенный тип. В JavaScript имеется пять примитивных типов данных:

String : представляет строку

Number : представляет числовое значение

Boolean : представляет логическое значение true или false

undefined : указывает, что значение не установлено

null : указывает на неопределенное значение

Все данные, которые не попадают под вышеперечисленные пять типов, относятся к типу object

Числовые данные

Числа в JavaScript могут иметь две формы:

Целые числа, например, 35. Мы можем использовать как положительные, так и отрицательные числа. Диапазон используемых чисел: от -2 53 до 2 53

Дробные числа (числа с плавающей точкой), например, 3.5575. Опять же можно использовать как положительные, так и отрицательные числа. Для чисел с плавающей точкой используется тот же диапазон: от -2 53 до 2 53

Например:

Var x = 45; var y = 23.897;

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

Строки

Тип string представляет строки, то есть такие данные, которые заключены в кавычки. Например, "Привет мир" . Причем мы можем использовать как двойные, так и одинарные кавычки: "Привет мир" и "Привет мир" . Единственно ограничение: тип закрывающей кавычки должен быть тот же, что и тип открывающей, то есть либо обе двойные, либо обе одинарные.

Если внутри строки встречаются кавычки, то мы их должны экранировать слешем. Например, пусть у нас есть текст "Бюро "Рога и копыта"" . Теперь экранируем кавычки:

Var companyName = "Бюро \"Рога и копыта\"";

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

Var companyName1 = "Бюро "Рога и копыта""; var companyName2 = "Бюро "Рога и копыта"";

Тип Boolean

Тип Boolean представляет булевые или логические значения true и false (то есть да или нет):

Var isAlive = true; var isDead = false;

null и undefined

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

Var isAlive; console.log(isAlive); // выведет undefined

Присвоение значение null означает, что переменная имеет некоторое неопределенное значение (не число, не строка, не логическое значение), но все-таки имеет значение (undefined означает, что переменная не имеет значения):

Var isAlive; console.log(isAlive); // undefined isAlive = null; console.log(isAlive); // null isAlive = undefined; // снова установим тип undefined console.log(isAlive); // undefined

object

Тип object представляет сложный объект. Простейшее определение объекта представляют фигурные скобки:

Var user = {};

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

Var user = {name: "Tom", age:24}; console.log(user.name);

В данном случае объект называется user, и он имеет два свойства: name и age. Это краткое описание объектов, более подробное описание приводится в соответствующей главе.

Слабая типизация

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

Var xNumber; // тип undefined console.log(xNumber); xNumber = 45; // тип number console.log(xNumber); xNumber = "45"; // тип string console.log(xNumber);

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

Это важный момент, который надо учитывать и от которого зависит поведение переменной в программе:

Var xNumber = 45; // тип number var yNumber = xNumber + 5; console.log(yNumber); // 50 xNumber = "45"; // тип string var zNumber = xNumber + 5 console.log(zNumber); // 455

Выше в обоих случая к переменной xNumber применяется операция сложения (+). Но в первом случае xNumber представляет число, поэтому результатом операции xNumber + 5 будет число 50.

Во втором случае xNumber представляет строку. Но операция сложения между строкой и числом 5 невозможна. Поэтому число 5 будет преобразовываться к строке, и будет происходить операция объединения строк. И результатом выражения xNumber + 5 будет стока "455".

Оператор typeof

С помощью оператора typeof можно получить тип переменной:

Var name = "Tom"; console.log(typeof name); // string var income = 45.8; console.log(typeof income); // number var isEnabled = true; console.log(typeof isEnabled); // boolean var undefVariable; console.log(typeof undefVariable); // undefined