Типы переменных в javascript. Типы данных Java Script

String, Number, Boolean, Array, Object.

Типы данных JavaScript

Переменные JavaScript может содержать множество типов данных: numbers, strings, arrays, objects и многое другое:

var length = 16; // Number
var lastName = "Johnson"; // String
var cars = ["Saab", "Volvo", "BMW"]; // Array
var x = {firstName:"John", lastName:"Doe"}; // Object

Концепция типов данных

В программировании, типы данных является важным понятием.

Для того, чтобы иметь возможность работать с переменными, важно знать, что-то о типе.

Без типов данных, компьютер не может безопасно решить эту проблему:

Var x = 16 + "Volvo";

Имеет ли смысл добавить "Volvo" до шестнадцати? Будет ли выдавать ошибку или он будет производить результат?

JavaScript будет рассматривать приведенный выше пример, как:

Var x = "16" + "Volvo";

При добавлении числа и строки, JavaScript будет рассматривать номер как строку.

JavaScript вычисляет выражения слева направо. Различные последовательности могут привести к разным результатам:

В первом примере, JavaScript обрабатывает 16 и 4 , как числа, до тех пор, пока не достигнет "Volvo" .

Во втором примере, так как первый операнд является строкой, то все операнды обрабатываются как строки.

JavaScript имеет динамические типы

JavaScript имеет динамические типы. Это означает, что та же переменная может использоваться в качестве различных типов:

пример

var x; // Now x is undefined
var x = 5; // Now x is a Number
var x = "John"; // Now x is a String

JavaScript Строки

Строка (или текстовая строка) представляет собой серию символов, как "John Doe" .

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

пример

var carName = "Volvo XC60"; // Using double quotes
var carName = "Volvo XC60"; // Using single quotes

Вы можете использовать кавычки внутри строки, до тех пор, пока они не совпадают кавычки вокруг строки:

пример

var answer = "It"s alright"; // Single quote inside double quotes
var answer = "He is called "Johnny""; // Single quotes inside double quotes
var answer = "He is called "Johnny""; // Double quotes inside single quotes

Попробуй сам "

Вы узнаете больше о строках позже в этом руководстве.

JavaScript Числа

JavaScript имеет только один тип чисел.

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

пример

var x1 = 34.00; // Written with decimals
var x2 = 34; // Written without decimals

Очень большие или экстра маленькие числа могут быть написаны с научной (экспоненциальной) нотации:

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

JavaScript Booleans

Булев может иметь только два значения: истина или ложь.

пример

var x = true;
var y = false;

Booleans часто используются в условном тестировании.

Вы узнаете больше об условном тестировании позже в этом руководстве.

Массивы JavaScript

массивы JavaScript записываются с помощью квадратных скобок.

элементы массива разделяются запятыми.

Следующий код объявляет (создает) массив называется автомобилей, содержащий три пункта (названия автомобиля):

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

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

Объекты JavaScript

Объекты JavaScript записываются в фигурные скобки.

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

Объект (человек) в приведенном выше примере имеет 4 свойства: firstName, lastName, age и eyeColor .

Вы узнаете больше об объектах позже в этом руководстве.

TypeOf Оператор

Вы можете использовать код JavaScript typeof оператора, чтобы найти тип переменной JavaScript:

пример

typeof "John" // Returns string
typeof 3.14 // Returns number
typeof false // Returns boolean
typeof // Returns object
typeof {name:"John", age:34} // Returns object

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

Console.log(10 + " машин"); // "10 машин". Число неявно преобразуется в строку console.log("7" * "4"); // 28. Обе строки неявно преобразуются в числа

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

Console.log("7" * "4"); // 28. Неявное преобразование console.log(Number("7") * Number("4")); // 28. Явное преобразование

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

Значение Преобразование в: Строку Число Булево Объект

undefined null	"undefined" "null"	NaN 0	false false	ошибка typeError ошибка typeError
true false	"true" "false"	1 0		new Boolean(true) new Boolean(false)
"" (пустая строка) "1.2" "one" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	false true true true true true true	new String("") new String("1.2") new String("one") new String("-10") new String("+10") new String("011") new String("0xff")
0 -0 NaN Infinity -Infinity 3	"0" "0" "NaN" "Infinity" "-Infinity" "3"		false false false true true true	new Number(0) new Number(-0) new Number(NaN) new Number(Infinity) new Number(-Infinity) new Number(3)
{} (любой объект) (пустой массив) (1 числовой элемент) arr (любой другой массив) function(){} (любая функция)	см. Преобразование объектов "" "9" см. Преобразование объектов см. Преобразование объектов	см. Преобразование объектов 0 9 NaN NaN	true true true true true

Для явного преобразования в простые типы используются следующие функции: Boolean() , Number() , String() . При неявном преобразования интерпретатор использует те же функции, что используются для явного преобразования.

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

X + "" // То же, что и String(x) +x // То же, что и Number(x). Можно также встретить x - 0 !!х // То же, что и Boolean(x)

Преобразование в числа

Функция Number() преобразует значения по следующим правилам:

• Логические значения true и false преобразуются в 1 и 0 соответственно.
• Числа возвращаются без изменения.
• Значение null преобразуется в 0 .
• Значение undefined преобразуется в NaN .

Для строк действуют особые правила:

• Если строка содержит только цифры с начальным знаком + или - либо без знака, она всегда преобразуется в целое десятичное число. Начальные нули игнорируются, например "0011" преобразуется в 11.
• Если строка представляет собой число с плавающей точкой с начальным знаком + или - либо без знака, она преобразуется в соответствующее число с плавающей точкой (начальные нули также игнорируются).
• Если строка представляет собой число в шестнадцатеричном формате, она преобразуется в соответствующее целое десятичное число.
• Если строка пустая, она преобразуется в 0 .
• Если строка содержит что-то отличное от предыдущих вариантов, она преобразуется в NaN .
• Для объектов вызывается метод valueOf() , а возвращаемое им значение автоматически преобразуется по предыдущим правилам. Если это преобразование даёт в результате NaN , вызывается метод toString() и применяются правила преобразования строк в числа.

Унарные операторы + и - работают по тем же правилам, что и функция Number() .

Преобразование в булевы значения

Функция Boolean() преобразует значение в его логический эквивалент:

• Следующие значения в результате преобразования дают значение false: undefined , null , 0 , -0 , NaN , "" .
• Значение false возвращается без изменения.
• Все остальные значения в результате преобразования дают значение true .

Преобразование в строки

Функция String() преобразует значения по следующим правилам:

• Для всех значений кроме null и undefined автоматически вызывается метод toString() и возвращается строковое представление значения.
• Для значения null возвращается строка "null" .
• Для значения undefined возвращается строка "undefined" .

Преобразование простых типов в объекты

Для преобразования простых значений в объекты используются конструкторы Boolean() , Number() , String() :

Var oNum = new Number(3); var oStr = new String("1.2"); var oBool = new Boolean(true); alert(typeof oNum); // "object" alert(typeof oStr); // "object" alert(typeof oBool); // "object"

Преобразование объектов в простые значения

Все объекты наследуют два метода преобразования: toString() и valueOf() .

Метод toString() возвращает строковое представление объекта. По умолчанию он ничего интересного не возвращает:

Alert({x: 1}.toString()); // ""

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

Alert(.toString()); // "1,2,3"

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

Alert(typeof {x:2}.valueOf()); // "object"

При преобразовании объекта в строку интерпретатор JavaScript выполняет следующие действия:

• Если объект имеет метод toString() , интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует значение в строку (если оно не является строкой) и возвращает результат преобразования.
• Если объект не имеет метода toString() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода valueOf() . Если этот метод определён, интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует это значение в строку (если оно не является строкой) и возвращает результат преобразования.

При преобразовании объекта в число интерпретатор выполняет те же действия, но первым пытается применить метод valueOf() :

• Если объект имеет метод valueOf() , возвращающий простое значение, интерпретатор преобразует (при необходимости) это значение в число и возвращает результат.
• Если объект не имеет метода valueOf() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода toString() . Если объект имеет метод toString() , возвращающий простое значение, интерпретатор выполняет преобразование и возвращает полученное значение.
• В противном случае интерпретатор делает вывод, что ни toString() ни valueOf() не позволяют получить простое значение и возбуждает ошибку TypeError .

Методы toString() и valueOf() доступны для чтения и записи, поэтому их можно переопределить и явно указать, что будет возвращаться при преобразовании:

Var obj = {}; obj.toString = function() { return "объект"; }; alert("Это " + obj); // "Это объект"

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

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

Объявление (создание) переменных осуществляется с помощью ключевого слова 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 . Добавление или изменение глобальных переменных автоматически обновляет глобальный объект. В свою очередь, обновление глобального объекта автоматически приводит к обновлению глобального пространства имен.

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

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