Настройка. Восстановление. Обслуживание. Windows. Безопасность
Урок №3
Типы данных в языке JavaScript
В прошлом уроке мы выяснили, что переменная — это именованная область памяти, которая хранит в себе какие-либо данные (значения).
У каждого значения в JavaScript, имеется свой тип данных
. Всего в JavaScript существует 6 типов данных, в этом уроке по JavaScript, мы рассмотрим 4 типа данных:
— числовой тип данных number ,
— строковый тип данных string ,
— логический тип данных boolean ,
— неопределённый тип данных undefined .
Остальные два изучим чуть позже:
— объектный тип данных object
— пустой тип данных null
Прежде чем рассмотреть типы данных JavaScript , познакомимся сначала с оператором typeof , он позволяет узнать какой тип данных присвоен переменной, делается это следующим образом:
Alert(typeof имяПеременной);
После этого скрипт должен выдать какое-либо сообщение: number , string , boolean , undefined , object .
Тип данных: число (number)Когда переменной, в качестве значения, присваивается какое-либо число (без кавычек) , её тип данных становится number
Var myNumber; myNumber = 5; alert(typeof myNumber);
В первой строке мы создали переменную с именем myNumber , во второй строке, присвоили переменной значение 5 , в третьей с помощью оператора typeof вычислили тип данных у переменной myNumber , а функция alert() показала нам результат этих вычислений.
В итоге, данный скрипт выведет нам сообщение number . Если число обрамить кавычками (одинарными "5" или двойными "5" ) , то оно превратится в строку string .
Тип данных: строка (string)Когда переменной в качестве значения присваивается какое-либо значение, заключённое в двойные " " или одинарные кавычки " " , то её тип данных становится string .
Var myString; myString = "Привет, я строка JavaScript!"; alert(typeof myString);
В первой строке мы создали переменную с именем myString , во второй строке, присвоили переменной значение "Привет, я строка JavaScript!" , в третьей с помощью оператора typeof вычислили тип данных у переменной myString , а функция alert() показала нам результат этих вычислений. В итоге, данный скрипт должен вывести нам сообщение string .
Тип данных: логический тип данных (boolean)Когда переменной в качестве значения присваивается true или false , без кавычек , то её тип данных становится boolean .
Тип данных boolean — это логический тип данных, он имеет всего два значения: true (правда) или false (ложь) .
Var myBoolean; myBoolean = true; alert(typeof myBoolean);
В первой строке мы создали переменную с именем myBoolean , во второй строке, присвоили переменной значение true , в третьей с помощью оператора typeof вычислили тип данных у переменной myBoolean , а функция alert() показала нам результат этих вычислений. В итоге, данный скрипт должен вывести нам сообщение boolean .
Логический тип данных, мы изучим более подробно в следующих уроках, посвящённых операциям сравнения, логическим операциям и оператору ветвления if
Тип данных: undefinedТип данных undefined появляется тогда, когда переменная объявлена, но не инициализирована, т.е. переменная создана, но значения ей не присвоили.
Var myUndefined; alert(typeof myUndefined);
В первой строке мы создали переменную с именем myUndefined , во второй строке с помощью оператора typeof вычислили тип данных у переменной myUndefined , а функция alert() показала нам результат этих вычислений. В итоге, данный скрипт должен вывести нам сообщение undefined .
Доступ к значению переменнойЧтобы получить доступ, к значению переменной, нужно обратиться к ней по имени:
// объявляем переменные var myString; var myNumber; // инициализируем переменные myString = "Привет, МИР!"; myNumber = 5; // обращаемся к переменным alert(myString); alert(myNumber);В первой и второй строках кода мы создали переменные myString и myNumber , в третьей и четвёртой строках присвоили переменным значения "Привет, МИР!" и 5 , в пятой и шестой строках с помощью функции alert() вывели результаты Привет, МИР! и 5
The typeof operator returns a string indicating the type of the unevaluated operand.
The source for this interactive example is stored in a GitHub repository. If you"d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.
SyntaxThe typeof operator is followed by its operand:
Typeof operand typeof(operand )
Parameters operand An expression representing the object or whose type is to be returned. DescriptionThe following table summarizes the possible return values of typeof . For more information about types and primitives, see also the JavaScript data structure page.
| "undefined" | |
| Null | "object" (see ) |
| Boolean | "boolean" |
| Number | "number" |
| BigInt | "bigint" |
| String | "string" |
| Symbol (new in ECMAScript 2015) | "symbol" |
| Host object (provided by the JS environment) | Implementation-dependent |
| Function object (implements [] in ECMA-262 terms) | "function" |
| Any other object | "object" |
In the first implementation of JavaScript, JavaScript values were represented as a type tag and a value. The type tag for objects was 0. null was represented as the NULL pointer (0x00 in most platforms). Consequently, null had 0 as type tag, hence the "object" typeof return value. (reference)
A fix was proposed for ECMAScript (via an opt-in), but was rejected . It would have resulted in typeof null === "null" .
Using new operator // All constructor functions, with the exception of the Function constructor, will always be typeof "object" var str = new String("String"); var num = new Number(100); typeof str; // It will return "object" typeof num; // It will return "object" var func = new Function(); typeof func; // It will return "function" Need for parentheses in Syntax // Parentheses can be used for determining the data type of expressions. var iData = 99; typeof iData + " Wisen"; // "number Wisen" typeof (iData + " Wisen"); // "string" Regular expressionsCallable regular expressions were a non-standard addition in some browsers.
Typeof /s/ === "function"; // Chrome 1-12 Non-conform to ECMAScript 5.1 typeof /s/ === "object"; // Firefox 5+ Conform to ECMAScript 5.1
ErrorsBefore ECMAScript 2015, typeof was always guaranteed to return a string for any operand it was supplied with. Even with undeclared identifiers, typeof will return "undefined" . Using typeof could never generate an error.
But with the addition of block-scoped let and Statements/const using typeof on let and const variables (or using typeof on a class) in a block before they are declared will throw a ReferenceError . Block scoped variables are in a "temporal dead zone " from the start of the block until the initialization is processed, during which, it will throw an error if accessed.
Typeof undeclaredVariable === "undefined"; typeof newLetVariable; // ReferenceError typeof newConstVariable; // ReferenceError typeof newClass; // ReferenceError let newLetVariable; const newConstVariable = "hello"; class newClass{};
ExceptionsAll current browsers expose a non-standard host object document.all with type undefined .
Typeof document.all === "undefined";
Although the specification allows custom type tags for non-standard exotic objects, it requires those type tags to be different from the predefined ones. The case of document.all having type "undefined" is classified in the web standards as a "willful violation" of the original ECMA JavaScript standard.
Specifications| ECMAScript Latest Draft (ECMA-262) |
Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of "The typeof Operator" in that specification. |
Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of "The typeof Operator" in that specification. |
Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of "The typeof Operator" in that specification. |
Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of "The typeof Operator" in that specification. |
Standard | Initial definition. Implemented in JavaScript 1.1. |
The compatibility table on this page is generated from structured data. If you"d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request.
Update compatibility data on GitHub
| Desktop Mobile Server | ||||||||||||
| Chrome Edge Firefox Internet Explorer Opera Safari Android webview Chrome for Android Firefox for Android Opera for Android Safari on iOS Samsung Internet Node.js | ||||||||||||
| Chrome Full support Yes | Edge Full support 12 | Firefox Full support 1 | IE Full support Yes | Opera Full support Yes | Safari Full support Yes | WebView Android Full support Yes | Chrome Android Full support Yes | Firefox Android Full support 4 | Opera Android Full support Yes | Safari iOS Full support Yes | Samsung Internet Android Full support Yes | nodejs Full support Yes |
В этом уроке мы познакомимся с очень важным понятием – типы данных JavaScript. Мы рекомендуем внимательно отнестись к данному понятию – если не осознать его с самого начала, то потом придется часто сталкиваться со странным поведением созданной вами программы.
Динамическая типизацияВ процессе работы компьютерные программы манипулируют различными значениями, каждое из которых может быть обработано в языке программирования и относится к определённому типу данных.
В JavaScript типы данных можно разделить на две категории: простые (их также называют примитивными) типы и составные (их также называют ссылочными или объекты).
JavaScript – это слабо типизированный или динамический язык программирования, который позволяет определять типы данных, осуществлять синтаксический анализ и компиляцию как говорится «на лету», на этапе выполнения программы. Это значит, что вам не нужно определять тип переменной заранее. Тип определится автоматически во время выполнения программы.
Таким образом, в различных участках программы одна и та же переменная может принимать значения разных типов:
Стандарт ECMAScript® определяет следующие типы данных:
- Простые
(их также называют примитивными) типы:
- логический (англ. Boolean) - может принимать два возможных значения, иногда называемых истиной (true) и ложью (false);
- нулевой (англ. Null) – значение null представляет ссылку, которая указывает, обычно намеренно, на несуществующий или некорректный объект или адрес;
- неопределённый (англ. Undefined) – обозначает предопределенную глобальную переменную, инициализированную неопределенным значением;
- числовой (англ. Number) – числовой тип данных в формате 64-битного числа двойной точности с плавающей запятой;
- строковый (англ. String) – представляет собой последовательность символов, используемых для представления текста;
- символ (англ. Symbol) - тип данных, экземпляры которого уникальны и неизменяемы. (новый в ECMAScript 6).
- Объектный (англ. Object) – это коллекция именованных значений, которые обычно называют свойствами (properties) объекта.
Прежде чем рассмотреть каждый тип данных, познакомимся сначала с оператором typeof . Оператор typeof возвращает строку, описывающую тип данных переменной.
Продемонстрируем его работу на следующем примере:
Сценарий в приведенном примере объявляет переменные, выполняет их инициализацию (присваивает значения), а затем выводит тип каждой переменной.
Разница между примитивными и составными типами данных проявляется при копировании их значений.
Когда переменной присваивается значение простого типа, то в переменную записывается само значение (например число). Когда мы присваиваем переменную простого типа в другую, она копирует значение . В результате каждая переменная будет иметь своё значение и изменения в одной из переменных никак не сказывается на значении другой переменной:
Когда переменной присваиваем значение составного (ссылочного) типа, то в переменную записывается ссылка на значение (ссылка на объект ). Когда мы присваиваем одну переменную (в значении которой ссылка на составное значение) другой переменной, то происходит копирование ссылки на составное значение. В результате обе переменные ссылаются на одно и то же составное значение и изменения в значении одной из переменных будут сказываться на другой переменной:
Примитивные типыВсе типы данных в JavaScript, кроме объектов, являются неизменяемыми или иммутабельными (англ. immutable). Это значит, что их значения не могут быть модифицированы, а только перезаписаны новым другим значением. Например, строки нельзя корректировать посимвольно – их можно переписать только полностью. Значения таких типов называются "примитивными".
Простейшие данные, с которыми может оперировать программа, называются литералами. Литералы - это числа или строки, которые используются для представления значений в JavaScript. Предоставляемая информация может быть самой разнообразной, а поэтому значения бывают различных типов. Простейшие типы данных в JavaScript называются основными типами данных: числа, строки и логические значения. Все они относятся к "примитивным".
Булевый (логический) тип «boolean»Логические, или булевы значения (по фамилии их изобретателя - Буля), могут иметь лишь одно из двух значений: true (истина) или false (ложь). Значения true или false обычно появляются в операциях сравнения или логических операциях.
Приведенная ниже программа создает булеву переменную, а затем тестирует ее значение с использованием инструкции if/else:
В качестве сравнительного выражения можно использовать любое выражение. Любое выражение, которое возвращает значение 0, null, undefined или пустую строку, интерпретируется как false . Выражение, определяющее какое-либо другое значение, интерпретируется как true .
Примечание:
При записи булевых значений их не заключают в кавычки: var myVar = true;
В то же время объявление var myVar = "true" создает строковую переменную.
В JavaScript, нет различия между целым числом и числом с плавающей точкой – по сути, JavaScript представляет все числа в качестве значения с плавающей точкой.
Для представления чисел в JavaScript используется 64-битный формат, определяемый стандартом IEEE-754 . Этот формат способен представлять числа в диапазоне от ±1,7976931348623157 × 10 308 до ±5 × 10 -324 .
Число, находящееся непосредственно в коде программы, называется числовым литералом. Помимо десятичных целых литералов JavaScript распознает шестнадцатеричные значения.
Числа в шестнадцатиричном формате могут включать любую последовательность цифр от 0 до 9 и буквы от a до f, которая обязательно начинается с последовательности символов «0x».
Var a = 255; var b = 0xFF; // Число 255 в шестнадцатеричной системе исчисления
Кроме того, JavaScript содержит специальные числовые значения:
- NaN (не число или ошибка вычислений). Является результатом некорректной математической операции над недопустимыми данными, такими как строки или неопределенное значение.
- Infinity (положительная бесконечность). Используется, если положительное число слишком велико и не может быть представлено в JavaScript.
- -Infinity (отрицательная бесконечность). Используется, если отрицательное число слишком велико и не может быть представлено в JavaScript.
- ±0 (положительный и отрицательный 0). JavaScript различает положительный и отрицательный ноль.
Строковый тип (string) - это неизменяемая, упорядоченная последовательность 16-битных значений, каждое из которых представляет символ Unicode (буквы, цифры, знаки пунктуации, специальные символы и пробелы). Строки могут быть пустыми либо состоять из одного и более символов. Строки создаются при помощи двойных (") или одинарных (") кавычек. В строке, ограниченной парой одинарных кавычек, можно использовать двойные кавычки, и наоборот – одинарные кавычки можно использовать в строке, заключенной в пару двойных кавычек:
В JavaScript нет разницы между двойными и одинарными кавычками, но кавычки в начале и конце строки не должны различаться. Например, такое выражение вызовет синтаксическую ошибку:
var firstName = "Max"; //синтаксическая ошибка - разные кавычки
Примечание: В JavaScript нет специального типа данных для одного символа, такого как char в C, C++ и Java. Одиночный символ представлен строкой единичной длины.
Тип данных Null Нулевой тип (null) содержит единственное специальное значение – null .Ключевое слово null невозможно использовать в качестве имени функции или переменной. Значение null является ссылкой на «пустой» объект и имеет специальное назначение – обычно оно используется для инициализации переменной, которой впоследствии будет присвоено значение.
Оператор typeof для значения null возвращает строку «object», что свидетельствует о том, что значение null является специальным «пустым» объектом.
Тип данных UndefinedНеопределенный тип (undefined) образует свой собственный тип, который содержит единственное специальное значение – undefined . Такое значение имеет переменная, объявленная с помощью оператора var , но не инициализированная:
Значение undefined возвращается при обращении к переменной, которой никогда не присваивалось значение, а также к несуществующему свойству объекта или элементу массива.
Следует отметить, что переменная со значением undefined отличается от переменной, которая вообще не определена:
В этом примере метод alert() выводит значение переменной age , то есть undefined . Во втором случае в метод alert() передается необъявленная переменная car , что приводит к ошибке.
Следующй пример может несколько запутать начинающих программистов, т.к. оператор typeof и для неинициализированной, и для необъявленной переменной возвращает значение undefined:
В приведенном примере переменная age объявлена, но в неё ничего не записано, поэтому её значение как раз и есть undefined . Переменная car не объявлена – её, по сути, нет. Тем не менее, typeof возвращает строку undefined в обоих случаях. Некоторый смысл в этом, конечно, есть, потому что с любой из этих переменных невозможно выполнить никаких операций, хотя технически они совершенно разные.
Примечание: Рекомендуется всегда выполнять инициализацию объявленной пременной. В таком случае вы будете знать, что оператор typeof возвращает undefined из-за того, что переменная не была объявлена, а не потому, что она не инициализирована.
Значение undefined является производным от null , так что в ЕСМА-262 оператор эквивалентности == считает их равными:
Несмотря на то, что значения null и undefined связаны, используются они по-разному. Не следует явно присваивать переменной значение undefined , однако к null это требование не относится. В случае, когда необходимый объект недоступен, вместо него следует использовать null . Это указывает на то, что значение null было введено как указатель на пустой объект, и подчеркивает его отличие от undefined .
Чтобы отличать null и undefined в программе можно использовать оператор идентичности === :
Тип данных Символ (Symbol)Символ (symbol) является нововведением JavaScript начиная с ECMAScript версии 6. Символ – это уникальное, неизменяемое, примитивное значение, которое служит для создания уникальных идентификаторов.
Чтобы создать символ нужно вызвать функцию Symbol:
var mySymbol = Symbol();
Для определения символа можно использовать оператор typeof , в случае если значения является символом будет возвращена строка symbol:
У функции Symbol есть необязательный параметр - строка, которая служит для описания символа:
Важной особенностью символа также является то, что его значение уникально. Вы можете использовать символ как имя свойства, которое гарантированно не будет повторяться с любым другим свойством. Даже, если у двух символов одинаковое имя, то это не значит, что они равны:
Тип данных ObjectВ дополнение к рассмотренным выше примитивным типам данных JavaScript поддерживает составной тип данных – объект (object). Объект состоит из многих значений (либо элементарных, таких как числа и строки, либо сложных, например других объектов), которые называются свойствами объекта. Доступ к свойствам осуществляется по имени свойства (иногда говорят «по ключу»).
Имя свойства является строкой, поэтому можно считать, что объекты связывают строки со значениями. Вместе эти фрагменты информации образуют пары «ключ-значение».
В JavaScript объекты можно создавать одним из двух синтаксисов:
1. var obj = {}; // с помощью объектного литерала 2. var obj = new Object(); // с помощью метода, называемого конструктором
Создание объекта с помощью объектного литерала начинается с определения обычной переменной. В правой части этой инструкции записывается литерал объекта – это заключенный в фигурные скобки {} список разделенных запятой пар "имя-значение" , заключенный в фигурные скобки. Имя свойства и значение отделены друг от друга двоеточием:
var cat = { "legs": 4, "name": "Мурзик", "color": "Рыжий" }
Второй способ создания объектов связан с использованием конструктора Object() . При этом сначала используется выражение new Object() , а затем определяются и инициализируются свойства полученного объекта:
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 . Добавление или изменение глобальных переменных автоматически обновляет глобальный объект. В свою очередь, обновление глобального объекта автоматически приводит к обновлению глобального пространства имен.
Если глобальная и локальная переменная имеют одинаковые имена, то локальная переменная будет иметь преимущество перед глобальной.
Локальные переменные, объявленные внутри функции в разных блоках кода, имеют одинаковые области видимости. Тем не менее, рекомендуется помещать объявления всех переменных в начале функции.
Типы данных
Типы данных в 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() игнорирует любые переданные аргументы и возвращает текущие дату и время.
| миллисекунды | Количество миллисекунд между нужной датой и полночью 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, если вызывать их для объектов другого типа.
| 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 обозначает символ π .
| \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:
| 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
Как следует из примера выше, операция присваивания объекта (или массива) переменной фактически присваивает ссылку: она не создает новую копию объекта. Если в программе потребуется создать новую копию объекта или массива, необходимо будет явно скопировать свойства объекта или элементы массива.