Аргументы Типа char
В JavaScript 1.4 и позднее Вы можете передавать строку из одного символа в Java-метод, который требует аргумент типа char. Например, Вы можете передать строку "H" в конструктор Character:
c = new java.lang.Character("H")
В JavaScript 1.3 и ранее Вы обязаны передавать в такие методы целое число, соответствующее Unicode-значению символа. Например, следующий код также присваивает значение "H" переменной c:
c = new java.lang.Character(72)
Арифметические Операции
Арифметические операции принимают числовые значения (литералы или переменные) в качестве операндов и возвращают одиночное числовое значение. Стандартными арифметическими операциями являются сложение (+), вычитание (-), умножение (*) и деление (/). Эти операции работают так же, как и во многих других языках программирования, но операция / в JavaScript возвращает результат деления с плавающей точкой, а не округлённое частное, как в языках программирования C или Java. Например:
1/2 //возвращает 0.5 в JavaScript
1/2 //возвращает 0 в Java
Дополнительно JavaScript предоставляет арифметические операции, перечисленные в следующей таблице:
%
(Modulus)
Бинарная операция. Возвращает целочисленный остаток от деления двух операндов.
12 % 5 возвращает 2.
++
(Инкремент)
Унарная операция. Добавляет 1 к операнду. Если используется как префикс (++x), добавляет единицу и возвращает значение операнда; если используется как постфикс (x++), возвращает значение операнда и затем прибавляет единицу.
Если x равен 3, то ++x устанавливает x в 4 и возвращает 4; а x++ устанавливает x в 4 и возвращает 3.
(Декремент)
Унарная операция. Вычитает единицу из операнда. Возвращаемое значение аналогично значению для операции инкремента.
Если x равен 3, то --x устанавливает x в 2 и возвращает 2; а x-- устанавливает x в 2 и возвращает 3.
(Унарное отрицание)
Унарная операция. Возвращает операнд с изменённым знаком.
Если x равен -3, то -x возвращает 3.
Блок Операторов
Блок операторов используется для группирования операторов. Блок ограничен фигурными скобками:
{statement1 statement2 . . .statementn}
Более Гибкие Конструкторы
Конструкторы функций не позволяют специфицировать значения свойств при создании экземпляра. Как и в Java, Вы можете предоставлять конструктору аргументы для инициализации значений свойств экземпляров. На рисунке показан один из способов реализации этого.
Рисунок 8.5 Специфицирование свойств в конструкторе, шаг 1
В таблице даны определения Java и JavaScript для этих объектов.
|
function Employee (name, dept) { this.name = name ""; this.dept = dept "general"; } |
public class Employee { public String name; public String dept; public Employee () { this("", "general"); } public Employee (name) { this(name, "general"); } public Employee (name, dept) { this.name = name; this.dept = dept; } } |
|
function WorkerBee (projs) { this.projects = projs []; } WorkerBee.prototype = new Employee; |
public class WorkerBee extends Employee { public String[] projects; public WorkerBee () { this(new String[0]); } public WorkerBee (String[] projs) { this.projects = projs; } } |
|
function Engineer (mach) { this.dept = "engineering"; this.machine = mach ""; } Engineer.prototype = new WorkerBee; |
public class Engineer extends WorkerBee { public String machine; public WorkerBee () { this.dept = "engineering"; this.machine = ""; } public WorkerBee (mach) { this.dept = "engineering"; this.machine = mach; } } |
Эти определения JavaScript используют специальную идиому для установки значений по умолчанию:
this.name = name "";
Операция JavaScript "логическое ИЛИ" () вычисляет свой первый аргумент. Если он конвертируется в true, операция возвращает его. Иначе, операция возвращает значение второго аргумента. Следовательно, эта строка кода проверяет, имеет ли name используемое значение для свойства name. Если это так, в this.name устанавливается это значение. В ином случае, в this.name устанавливается пустая строка. В этой главе используется эта идиома используется для краткости; однако это может на первый взгляд показаться непонятным.
Имея эти определения при создании экземпляра объекта, Вы можете специфицировать значения для локально определяемых свойств. Как показано на , Вы можете использовать следующий оператор для создания нового Engineer:
jane = new Engineer("belau");
Jane-свойства теперь:
jane.name == "";
jane.dept == "general";
jane.projects == [];
jane.machine == "belau"
Заметьте, что с помощью этих определений Вы не можете специфицировать начальное значение наследуемого свойства, такого как name. Если Вы не хотите специфицировать начальные значения наследуемых свойств в JavaScript, Вам нужно добавить дополнительный код в конструктор функции.
Пока что конструктор функции создал общий объект и специфицировал локальные свойства и значения для нового объекта. Вы можете заставить конструктор добавить свойства, непосредственно вызывая конструктор функции для объект, стоящего выше в цепочке прототипов. Следующий рисунок показывает эти новые определения.
Рисунок 8.6   Специфицирование свойств в конструкторе, шаг 2
Давайте рассмотрим одно из этих определений подробнее. Вот новое определение конструктора Engineer:
function Engineer (name, projs, mach) {
this.base = WorkerBee;
this.base(name, "engineering", projs);
this.machine = mach "";
}
Предположим, Вы создаёте новый Engineer-объект:
jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
JavaScript выполняет следующие шаги:
Оператор new создаёт общий объект и устанавливает в его свойство __proto__ значение Engineer.prototype.
Оператор new передаёт новый объект Engineer-конструктору как значение ключевого слова this.
Конструктор создаёт новое свойство base для этого объекта и присваивает значение конструктора WorkerBee свойству base. Это делает конструктор WorkerBee методом Engineer-объекта.
Имя свойства base не является специальным. Вы можете использовать любое правильное имя свойства; base просто более понятно в данной ситуации.
Конструктор вызывает метод base, передавая в качестве его аргументов два из аргументов, переданных конструктору ("Doe, Jane" и ["navigator", "javascript"]), а также строку "engineering". Явное использование "engineering" в конструкторе указывает, что все Engineer-объекты имеют одинаковые значения для наследуемого свойства dept и это значение переопределяет значение, унаследованное от Employee.
Поскольку base является методом в Engineer, внутри вызова base JavaScript связывает ключевое слово this с объектом, созданным в . Таким образом, функция WorkerBee, в свою очередь, передаёт аргументы "Doe, Jane" и ["navigator", "javascript"] конструктору функции Employee. После возвращения из конструктора функции Employee, функция WorkerBee использует остальные аргументы для установки свойства projects.
После возвращения из метода base, конструктор Engineer инициализирует свойство machine объекта значением "belau".
После возвращения из конструктора, JavaScript присваивает новый объект переменной jane.
Вы можете подумать, что, имея вызов конструктора WorkerBee из конструктора Engineer, Вы установили соответствующее наследование для Engineer-объектов, но это не так. Вызов конструктора WorkerBee гарантирует, что Engineer-объект стартует со свойствами, специфицированными во всех конструкторах функций, которые были вызваны. Однако, если Вы позднее добавите свойства к прототипам Employee или WorkerBee, эти свойства не будут наследоваться Engineer-объектом. Например, мы имеем следующие операторы:
function Engineer (name, projs, mach) {
this.base = WorkerBee;
this.base(name, "engineering", projs);
this.machine = mach "";
}
jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
Employee.prototype.specialty = "none";
Объект jane не наследует свойство specialty. Вы всё ещё должны явно установить прототип, чтобы гарантировать динамическое наследование. Предположим, у нас есть такие операторы:
function Engineer (name, projs, mach) {
this.base = WorkerBee;
this.base(name, "engineering", projs);
this.machine = mach "";
}
Engineer.prototype = new WorkerBee;
jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
Employee.prototype.specialty = "none";
Теперь значение свойства specialty объекта jane установлено в "none".
Булевы Литералы
Тип Boolean имеет два литеральных значения: true и false.
Не путайте примитивные Boolean-значения true и false со значениями true и false объекта Boolean. Объект Boolean является "обёрткой"-оболочкой примитивного типа данных Boolean. См. .
Булевы Значения
Если Вы передаёте Булевы типы JavaScript как параметры для Java-методов, Java конвертирует значения в соответствии с правилами, описанными в следующей таблице:
boolean
Все значения конвертируются непосредственно в Java-эквиваленты.
lava.lang.Boolean
java.lang.Object
Создаётся новый экземпляр объекта java.lang.Boolean. Каждый параметр создаёт новый экземпляр, а не один экземпляр с тем же примитивным значением.
java.lang.String
Значения конвертируются в строки. Например:
true становится "true"
false становится "false"
byte
char
double
float
int
long
short
true становится 1
false становится 0
Если Булево значение JavaScript передаётся в качестве параметра Java-методу, ожидающему экземпляр объекта java.lang.String, Булево значение конвертируется в строку. Используйте операцию == для сравнения результата этой конвертации с другими строковыми значениями.
Целочисленные Литералы
Целые числа могут иметь десятеричную базу (база 10), 16-ричную (база 16) и 8-ричную (база 8). Десятеричный целочисленный литерал состоит из последовательности цифр без ведущего 0 (нуля). Ведущий 0 (нуль) в целочисленном литерале означает, что это 8-ричный литерал; ведущие символы 0x (или 0X) означают 16-ричный. 16-ричные целые числа могут состоять из цифр (0 - 9) и букв a-f и A-F. 8-ричные целые могут состоять только из цифр 0 - 7.
8-ричные целочисленные литералы использовать не рекомендуется, и они будут удалены из стандарта ECMA-262, Edition 3. JavaScript 1.5 ещё поддерживает их для обеспечения обратной совместимости.
Примеры целочисленных литералов: 42, 0xFFF, -345.
Числа
Если Вы передаёте числовые типы JavaScript в качестве параметров методам Java, Java конвертирует эти значения в соответствии с правилами, описанными в следующей таблице:
double
Точное значение переносится в Java без округления и без потери точности или знака.
lava.lang.Double
java.lang.Object
Создаётся новый экземпляр java.lang.Double, и точное значение передаётся в Java без округления и без потери точности или знака.
float
Значения округляются до чисел с плавающей точкой.
Значения, которые слишком малы или велики, чтобы быть представленными, округляются до +infinity или -infinity.
byte
char
int
long
short
Значения округляются с использованием режима round-to-negative-infinity/округление-в-сторону-отрицательной-бесконечности.
Значения, которые слишком малы или велики, чтобы быть представленными, дают ошибку времени выполнения.
Значения NaN конвертируются до нуля.
java.lang.String
Значения конвертируются в строки. Например,
237 становится "237"
boolean
Значения 0 и NaN конвертируются в false.
Другие значения конвертируются в true.
Если число JavaScript передаётся в качестве параметра в Java-метод, который ожидает экземпляр объекта java.lang.String, это число конвертируется в строку. Используйте метод equals() для сравнения результата этой конвертации с другими строковыми значениями.
Что Такое JavaScript?
JavaScript это созданный фирмой Netscape межплатформенный объектно-ориентированный язык скриптинга (сценариев). JavaScript это небольшой компактный язык; он не используется для создания самостоятельных приложений, а разработан специально для упрощенного внедрения в другие приложения и продукты, такие как web-браузеры. Находясь внутри рабочей среды-хозяина, JavaScript может подключаться к объектам этой среды для предоставления программного управления ими.
Ядро JavaScript содержит набор основных объектов, таких как Array, Date и Math, и основной набор элементов языка, таких как операции, управляющие структуры и операторы. Ядро JavaScript может быть расширено для различных целей путём дополнения его новыми объектами; например:
Клиентский JavaScript расширяет ядро языка, добавляя объекты управления браузером (Navigator или другой аналогичный web-браузер) и Document Object Model/Объектную Модель Документа (DOM). Например, клиентские расширения позволяют приложению размещать элементы на HTML-форме и реагировать на пользовательские события, такие как щелчок мышью, ввод данных в форму или навигация по страницам.
Серверный JavaScript расширяет ядро языка, добавляя объекты, относящиеся к запуску JavaScript на сервере. Например, серверные расширения позволяют приложению взаимодействовать с реляционной базой данных, сохраняя информацию между вызовами приложения, или выполнять манипуляции с файлами на сервере.
Посредством функциональности LiveConnect, Вы можете осуществлять взаимодействие кодов Java и JavaScript. Из JavaScript Вы можете инстанциировать Java-объекты и получать доступ к их public-методам и полям. Из Java Вы можете иметь доступ к объектам, свойствам и методам JavaScript.
Netscape изобрела JavaScript, и JavaScript был впервые использован в браузерах Netscape.
Что Вы Уже Должны Знать
Предполагается, что Вы уже имеете базовые знания:
Общее понятие об Internet и World Wide Web (WWW).
Хорошее владение HyperText Markup Language (HTML).
Некоторый опыт программирования в таких языках как C или Visual Basic (не обязательно).
Delete
Операция delete удаляет объект, свойство объекта или элемент массива по специфицированному индексу. Синтаксис таков:
delete objectName
delete objectName.property
delete objectName[index]
delete property // верно только внутри оператора with
где objectName это имя объекта, property это существующее свойство, а index это целое число - место элемента в массиве.
Четвёртая форма верна только внутри оператора with при удалении свойства объекта.
Можно использовать операцию delete для удаления переменных, объявленных неявно, но не переменных, объявленных оператором var.
Если операция delete выполнена успешно, она устанавливает свойство или элемент в undefined. Операция delete возвращает true, если операция возможна, и false - если операция невозможна.
x=42
var y= 43
myobj=new Number()
myobj.h=4 // создаёт свойство h
delete x // возвращает true (может удалить, если х объявлена неявно)
delete y // возвращает false (не может удалить, если у объявлена через var)
delete Math.PI // возвращает false (не может удалить предопределённое свойство)
delete myobj.h // возвращает true (может удалить свойство, определённое пользователем)
delete myobj // возвращает true (может удалить, если myobj объявлен неявно)
Удаление элемента массива
Если Вы удаляете элемент массива, размер массива не изменяется. Например, если удалить a[3], a[4] всё ещё остаётся a[4], а a[3] станет undefined.
Если операция delete удаляет элемент массива, этот элемент больше не присутствует в массиве. В следующем примере trees[3] удаляется с помощью delete.
trees=new Array("redwood","bay","cedar","oak","maple")
delete trees[3]
if (3 in trees) {
// это не будет выполняться
}
Если Вы хотите, чтобы элемент массива существовал, но имел значение undefined/неопределённое, используйте ключевое слово undefined вместо операции delete. В следующем примере элементу trees[3] присваивается значение undefined, но элемент массива продолжает существовать:
trees=new Array("redwood","bay","cedar","oak","maple")
trees[3]=undefined
if (3 in trees) {
// это будет выполняться
}
Добавление и Удаление Свойств
В языках на базе классов Вы обычно создаёте класс на этапе компиляции и затем создаёте экземпляры класса на этапе компиляции или на этапе прогона программы. Вы не можете изменить количество или типы свойств класса после того, как Вы определили этот класс. В JavaScript, напротив, на этапе прогона Вы можете добавлять и удалять свойства любого объекта. Если Вы добавляете свойство к объекту, который используется как прототип для набора объектов, эти объекты также получают новое свойство.
Добавление Свойств
В JavaScript Вы можете добавлять свойства любому объекту на этапе прогона программы. Отсутствует ограничение на использование только свойств, предоставленных конструктором функции. Чтобы добавить свойство отдельному объекту, Вы присваиваете значение этому свойству объекта таким образом:
mark.bonus = 3000;
Теперь объект mark имеет свойство bonus, но другие потомки WorkerBee этого свойства не имеют.
Если Вы добавляете новое свойство объекту, который используется как прототип конструктора функции, вы добавляете это свойство всем объектам, наследующим свойства от этого прототипа. Например, Вы можете добавить свойство specialty всем employee с помощью следующего оператора:
Employee.prototype.specialty = "none";
Когда JavaScript выполнит этот оператор, объект mark также получит свойство specialty со значением "none". На рисунке показано эффект от добавления этого свойства прототипу Employee и последующего переопределения этого свойства для прототипа Engineer.
Рисунок 8.4 Добавление Свойств
Документация JavaScript и Спецификация ECMA
Спецификация ECMA это набор требований по реализации ECMAScript; она необходима, если Вы хотите убедиться, что данная возможность JavaScript поддерживается ECMA. Если Вы планируете писать код JavaScript, использующий только поддерживаемые ECMA возможности, то Вам, возможно, понадобится просмотреть и спецификацию ECMA.
Документ ECMA не предназначен для помощи программистам - создателям скриптов; для получения информации о написании скриптов используйте документацию JavaScript.
Доступ к JavaScript через JSObject
Например, предположим, Вы работаете с Java-классом JavaDog. Как показано в следующем коде, конструктор JavaDog принимает в качестве аргумента JavaScript-объект jsDog, который определён как имеющий тип JSObject:
import netscape.javascript.*;
public class JavaDog
{
public String dogBreed;
public String dogColor;
public String dogSex;
// определяется конструктор класса
public JavaDog(JSObject jsDog)
{
// здесь try...catch используется для обработки JSExceptions
this.dogBreed = (String)jsDog.getMember("breed");
this.dogColor = (String)jsDog.getMember("color");
this.dogSex = (String)jsDog.getMember("sex");
}
}
Обратите внимание, что метод getMember из JSObject используется для доступа к свойствам JavaScript-объекта. Предыдущий пример использует getMember для присвоения значения JavaScript-свойства jsDog.breed члену данных Java JavaDog.dogBreed.
Примечание
Более жизненный пример - помещение вызова метода getMember внутрь блока try...catch для обработки ошибок типа JSException. См. также .
Чтобы лучше понять, как работает getMember, посмотрите на определение специального JavaScript-объекта Dog:
function Dog(breed,color,sex) {
this.breed = breed
this.color = color
this.sex = sex
}
Вы можете создать в JavaScript экземпляр объекта Dog под названием gabby:
gabby = new Dog("lab","chocolate","female")
Если Вы вычисляете gabby.color, то увидите, что это свойство имеет значение "chocolate". Теперь предположим, что Вы создаёте экземпляр JavaDog в Вашем JavaScript-коде, передавая конструктору объект gabby:
javaDog = new Packages.JavaDog(gabby)
Если Вы вычисляете javaDog.dogColor, то увидите, что это свойство также имеет значение "chocolate", потому что метод getMember в Java-конструкторе присваивает переменной dogColor значение свойства gabby.color.
Другие Объекты JavaScript
Если Вы передаёте любой иной объект JavaScript в качестве параметра Java-методу, Java конвертирует значение в соответствии с правилами, описанными в следующей таблице:
java.lang.JSObject
java.lang.Object
Объект разворачивается в новый экземпляр объекта java.lang.JSObject.
java.lang.String
Объект разворачивается, вызывается метод toString развёрнутого Java-объекта и результат возвращается как новый экземпляр объекта java.lang.String.
byte
char
double
float
int
long
short
Объект конвертируется в значение с использованием логики оператора ToPrimitive, описанного в . Подсказка PreferredType, используемая с этим оператором, является Number.
boolean
В JavaScript 1.3 и позднее, объект разворачивается, и возникает одна из следующих ситуаций:
Если объект - null, он конвертируется в false.
Если объект имеет какое-либо другое значение, он конвертируется в true.
В JavaScript 1.2 и ранее, объект разворачивается, и возникает одна из следующих ситуаций:
Если развёрнутый объект имеет метод booleanValue, исходный объект конвертируется в return-значение.
Если развёрнутый объект не имеет метода booleanValue, конвертация терпит неудачу.
Escape-Последовательности Unicode
Вы можете использовать заменяющие последовательности Unicode в строковых литералах, регулярных выражениях и идентификаторах. Заменяющая (escape) последовательность состоит из шести символов ASCII: \u и 16-ричного числа из четырёх цифр. Например, \u00A9 представляет символ copyright. Каждая escape-последовательность Unicode интерпретируется в JavaScript как одиночный символ.
Следующий код возвращает символ copyright и строку "Netscape Communications":
x="\u00A9 Netscape Communications"
В таблице приведён список часто используемых специальных символов и их значения Unicode.
Пробельные символы
Табуляция
\u000C
<FF>
\u0020
<SP>
\u000A
<LF>
\u000D
<CR>
<BS>
\u0009
<HT>
\u0022
"
\u0027
'
Использование escape-последовательнотей Unicode в JavaScript отличается от Java. В JavaScript escape-последовательность сразу никогда не интерпретируется как спецсимвол. Например, последовательность терминатора строки внутри строки не оканчивает строку до того, как она будет интерпретирована функцией. JavaScript игнорирует любую escape-последовательность, если она находится в комментарии. В Java, если escape-последовательность используется в однострочном комментарии, она интерпретируется как символ Unicode. В строковом литерале компилятор Java сначала интерпретирует escape-последовательности. Например, если последовательность "терминатор строки" (\u000A) используется в Java, она оканчивает строковой литерал. В Java это приводит к ошибке, поскольку терминаторы строки не допускаются в строковых литералах. Вы обязаны использовать \n в строковом литерале в качестве символа новой строки. В JavaScript escape-последовательность работает так же, как \n.
Функции escape и unescape
Функции escape и unescape позволяют Вам кодировать и декодировать строки. Функция escape возвращает 16-ричное кодированное представление аргумента - набора символов ISO Latin. Функция unescape возвращает ASCII-строку для специфицированного аргумента - 16-ричного кодированного значения.
Синтаксис этих функций таков:
escape(string)
unescape(string)
Эти функции используются в основном в серверном JavaScript для кодирования и декодирования пар имя/значение в URL.
Функции escape и unescape неправильно работают с не- ASCII символами.
В JavaScript 1.5 и далее, используйте encodeURI, decodeURI, encodeURIComponent и decodeURIComponent.
Copyright © 2000 Все Права Зарезервированы.
Дата последнего обновления 28 сентября 2000 года.
Функции Number и String
Функции Number и String позволяют конвертировать объект в число или строку. Синтаксис этих функций таков:
Number(objRef)
String(objRef)
где objRef это ссылка на объект.
Следующий код конвертирует объект Date в читабельную строку:
D = new Date (430054663215)
// возвращается следующее
// "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983"
x = String(D)
Функции parseInt и parseFloat
Две "разбирающие" функции, parseInt и parseFloat, возвращают числовое значение, имея в качестве аргумента строку.
Синтаксис parseFloat:
parseFloat(str)
где parseFloat разбирает свой аргумент, строку str, и пытается возвратить число с плавающей точкой. Если она обнаруживает символ, отличный от знака (+ или -), цифры (0-9), десятичной точки или экспоненты, тогда она возвращает значение до этой позиции и игнорирует этот символ и последующие символы. Если первый символ не может быть конвертирован в число, функция возвращает "NaN" (не-число).
Синтаксис parseInt:
parseInt(str [, radix])
parseInt разбирает свой первый аргумент, строку str, и пытается вернуть целое число со специфицированным основанием (radix), обозначенным вторым необязательным аргументом, radix. Например, radix 10 означает конвертацию к десятеричному числу, 8 - восьмеричному, 16 - шестнадцатеричному и так далее. Для radix свыше 10, буквы алфавита обозначают цифры больше 9. Например, для 16-ричных чисел (база 16), используются буквы от A до F.
Если parseInt вычисляет символ, который не является числом со специфицированным основанием, она игнорирует это число и все последующие символы и возвратит целое число, разобранное до этой позиции. Если первый символ не может быть конвертирован в число со специфицированным основанием, возвращается "NaN." Функция parseInt усекает строку до целочисленного значения.
Функция eval
Функция eval вычисляет строку кода JavaScript без ссылки на конкретный объект. Синтаксис eval таков:
eval(expr)
где expr это вычисляемая строка.
Если строка представляет собой выражение, eval вычисляет это выражение. Если аргументом является один или более операторов JavaScript, eval выполняет эти операторы. Не вызывайте eval для вычисления арифметических выражений; JavaScript вычисляет арифметические выражения автоматически.
Функция isFinite
Функция isFinite вычисляет аргумент для определения конечности числа. Синтаксис isFinite таков:
isFinite(number)
где number это обсчитываемое число.
Если аргумент имеет значение NaN, положительная или отрицательная бесконечность, этот метод возвращает false, иначе возвращает true.
Следующий код проверяет ввод клиента для определения конечности введённого числа.
if(isFinite(ClientInput) == true)
{
/* специфицированные шаги */
}
Функция isNaN
Функция isNaN вычисляет, является ли аргумент "NaN" (не-числом). Синтаксис isNaN:
isNaN(testValue)
где testValue это вычисляемое выражение.
Функции parseFloat и parseInt возвращают "NaN", если они вычисляют значение, не являющееся числом. isNaN возвращает true, если передано "NaN," и false - в ином случае.
Следующий код вычисляет floatValue для определения, является ли оно числом, а затем вызывает соответствующую процедуру:
floatValue=parseFloat(toFloat)
if (isNaN(floatValue)) {
notFloat()
} else {
isFloat()
}
Где Найти Информацию о JavaScript
Документация о ядре JavaScript состоит из следующих книг:
(эта книга) предоставляет информацию о ядре языка JavaScript и его объектах.
Книга содержит справочный материал о ядре языка JavaScript.
Если Вы новичок в JavaScript, начните с книги . После того как Вы овладеете основами, можете использовать книгу . для получения более детальной информации об объектах и операторах.
DevEdge, онлайновый ресурс Netscape для разработчиков, содержит информацию, которая поможет при работе с JavaScript. Следующие URL представляют особый интерес:
Страница JavaScript библиотеки DevEdge содержит документацию о JavaScript. Эта страница часто изменяется. Вы должны периодически посещать её для получения свежей информации.
Библиотека DevEdge содержит документацию о многочисленных продуктах и технологиях Netscape.
Домашняя страница DevEdge - доступ ко всем ресурсам DevEdge.
Mozilla.org координирует усилия по разработке Mozilla-браузера, открытого ресурса. на котором базируется Netscape 6. Вы можете найти на странице JavaScript-проекта информацию о JavaScript, а также дискуссию по вопросам JavaScript в публичной группе новостей netscape.public.mozilla.jseng.
JavaScript. Обзор.
В этой главе содержится введение в JavaScript, обсуждаются некоторые фундаментальные положения и новые возможности релиза 1.5.
В главе имеются следующие разделы:
Значения, Переменные и Литералы.
В этой главе рассматриваются значения, распознаваемые в JavaScript, и даётся описание фундаментальных строительных блоков выражений JavaScript: значений, переменных и литералов.
В главе имеются следующие разделы:
Выражения и Операции
В этой главе рассматриваются выражения и операции JavaScript, в том числе: операции присвоения, сравнения, арифметические, побитовые, логические строковые и специальные.
Глава состоит из разделов:
Регулярные Выражения
Регулярные выражения являются патэрнами, используемыми при поиске совпадений комбинаций символов в строках. В JavaScript регулярные выражения являются также объектами. Эти патэрны используются вместе с методами exec и test объекта RegExp и с методами match, replace, search и split объекта String.
В этой главе рассматриваются регулярные выражения JavaScript.
JavaScript 1.1 и ранее.
Регулярные выражения недоступны в JavaScript 1.1 и более ранних версиях.
В этой главе имеются следующие разделы:
Операторы
JavaScript поддерживает компактный набор операторов, которые могут использоваться для создания интерактивных Web-страниц. В данной главе дан обзор этих операторов.
В этой главе имеются следующие разделы, предоставляющие краткий обзор каждого оператора:
: if...else и switch
: for, while, do...while, label, break и continue (label сам по себе не является оператором цикла, но часто используется с указанными операторами)
: for...in и with
: try...catch и throw
Любое выражение также является оператором. См. в полную информацию об операциях.
Используйте символ "точка с запятой" (;) для разделения операторов в коде JavaScript.
См. в книге
детали об операторах из этой главы.
Функции
Функции являются одним из фундаментальных блоков конструкций JavaScript. Функция это процедура JavaScript - набор операторов, выполняющих определённую задачу. Чтобы использовать функцию Вы должны сначала определить её; затем Ваш скрипт может вызвать её.
В этой главе имеются следующие разделы:
Работа с Объектами
JavaScript разработан с использованием простой объектно-ориентированной парадигмы. Объект - это конструкция со свойствами, которые являются переменными JavaScript или другими объектами. Объект также может иметь ассоциированные с ним функции, которые известны как методы объекта. В дополнение к имеющимся в Navigator клиентским и серверным объектам Вы можете определять свои собственные объекты.
В этой главе рассматривается использование объектов, их свойств, функций и методов и создание собственных объектов.
Имеются следующие разделы:
Объектная Модель. Детали.
JavaScript это объектно-ориентированный язык, базирующийся на прототипах, а не на классах. Из-за этой разницы базисов менее очевидно то, что JavaScript позволяет создавать иерархии объектов и наследовать свойства и их значения. В этой главе мы попытаемся прояснить ситуацию.
Мы предполагаем, что Вы уже немного знакомы с JavaScript и использовали функции JavaScript для создания простых объектов.
В главе имеются следующие разделы:
LiveConnect. Обзор.
В этой главе рассматривается использование технологии LiveConnect, обеспечивающей совместную работу кодов, написанных на Java и JavaScript. Предполагается, что Вы уже знакомы с программированием на Java.
В главе имеются следующие разделы:
Дополнительную информацию об использовании LiveConnect см. в на сайте DevEdge.
Объектная Модель. Детали.
Copyright © 2000 Все Права Зарезервированы.
Дата последнего обновления 28 сентября 2000 года.
LiveConnect. Обзор.
Copyright © 2000 Все Права Зарезервированы.
Дата последнего обновления 28 сентября 2000 года.
Глобальная Информация в Конструкторах
Когда Вы создаёте конструкторы, нужно проявлять осторожность при установке глобальной информации в конструкторе. Например, предположим, Вы хотите автоматически присваивать уникальный ID каждому новому employee. Вы можете использовать для Employee следующее определение:
var idCounter = 1;
function Employee (name, dept) {
this.name = name "";
this.dept = dept "general";
this.id = idCounter++;
}
При таком определении, когда Вы создаёте новый Employee-объект, конструктор присваивает ему следующий порядковый ID и выполняет затем инкремент глобального счётчика ID. Так, если Ваш следующий оператор будет таким, как ниже, victoria.id будет 1, а harry.id будет 2:
victoria = new Employee("Pigbert, Victoria", "pubs")
harry = new Employee("Tschopik, Harry", "sales")
На первый взгляд - всё отлично. Однако idCounter будет увеличиваться каждый раз при создании Employee-объекта. Если Вы создаёте всю иерархию Employee, данную в этой главе, конструктор Employee вызывается каждый раз, когда Вы устанавливаете прототип. Предположим, у Вас есть такой код:
var idCounter = 1;
function Employee (name, dept) {
this.name = name "";
this.dept = dept "general";
this.id = idCounter++;
}
function Manager (name, dept, reports) {...}
Manager.prototype = new Employee;
function WorkerBee (name, dept, projs) {...}
WorkerBee.prototype = new Employee;
function Engineer (name, projs, mach) {...}
Engineer.prototype = new WorkerBee;
function SalesPerson (name, projs, quota) {...}
SalesPerson.prototype = new WorkerBee;
mac = new Engineer("Wood, Mac");
Предположим далее, что отсутствующие здесь определения имеют свойство base и вызывают конструктор, находящийся над ним в цепи прототипов. В этом случае, когда создаётся объект mac, mac.id будет 5.
В зависимости от приложения, такое излишнее увеличение счётчика может иметь или не иметь значения. Если Вас интересует точное значение счётчика, реализуется ещё одно дополнительное решение путём использования следующего конструктора:
function Employee (name, dept) {
this.name = name "";
this.dept = dept "general";
if (name)
this.id = idCounter++;
}
Если Вы создаёте экземпляр объекта Employee для использования в качестве прототипа, Вы не должны предоставлять аргументы конструктору. Если Вы используете это определение конструктора и не предоставляете аргументы, конструктор не присваивает значение идентификатору id и не обновляет значение счётчика. Следовательно, для того чтобы Employee получил присвоенный id, Вы обязаны специфицировать name для employee. В этом примере, mac.id будет 1.
In
Операция in возвращает true, если специфицированное свойство имеется в специфицированном объекте. Синтаксис таков:
propNameOrNumber in objectName
где propNameOrNumber это строка или числовое выражение, представляющее имя свойства или индекс массива, а objectName это имя объекта.
Некоторые примеры использования операции in:
// Массивы
trees=new Array("redwood","bay","cedar","oak","maple")
0 in trees // возвращает true
3 in trees // возвращает true
6 in trees // возвращает false
"bay" in trees // возвращает false (Вы обязаны специфицировать число индекса,
// а не значение, находящееся по этому индексу)
"length" in trees // возвращает true (length это Array-свойство)
// Предопределённые объекты
"PI" in Math // возвращает true
myString=new String("coral")
"length" in myString // возвращает true
// Специальные объекты
mycar = {make:"Honda",model:"Accord",year:1998}
"make" in mycar // возвращает true
"model" in mycar // возвращает true
Индексирование Свойств Объекта
В JavaScript 1.0 Вы можете ссылаться на свойства объектов по имени свойства или по порядковому индексу. В JavaScript 1.1 и позднее, однако, если Вы первоначально определили свойство по имени, Вы всегда обязаны будете обращаться к нему по имени, и, если Вы первоначально определили свойство по индексу, Вы всегда обязаны будете обращаться к нему по его индексу.
Это применимо при создании объекта и его свойств с помощью конструктора функции, как в примере с типом объекта Car, и если Вы определяете отдельные свойства явным образом (например, myCar.color = "red"). Так, если Вы определили свойства объекта по индексу, как, например, myCar[5] = "25 mpg", Вы можете затем обращаться к этому свойству только как myCar[5].
Исключением из этого правила являются объекты, отражённые из HTML, такие как массивы форм. Вы всегда обращаетесь к этим объектам по порядковому номеру (зависящим от местонахождения объекта в документе) или по их именам (если они определены). Например, если второй тэг <FORM> в документе имеет в атрибуте NAME значение "myForm", Вы можете ссылаться на форму document.forms[1], или document.forms["myForm"] или document.myForm.
Instanceof
Операция instanceof возвращает true, если специфицированный объект имеет специфицированный тип объекта. Синтаксис:
objectName instanceof objectType
где objectName это имя объекта, сравниваемого с objectType, а objectType это тип объекта, такой как Date или Array.
Используйте instanceof, если Вам нужно подтвердить тип объекта на этапе прогона. Например, при отлове исключений Вы можете выполнить ветвление по разным вариантам кода обработки исключений, в зависимости от типа вызываемого исключения.
Например, следующий код использует instanceof для определения того, является ли theDay Date-объектом. Поскольку theDay это Date-объект, операторы в операторе if выполняются.
theDay=new Date(1995, 12, 17)
if (theDay instanceof Date) {
// выполняемые операторы
}
Использование Инициализаторов Объектов
Помимо создания объектов с использованием конструктора функции, Вы можете создать объекты, используя инициализаторы объектов. Использование инициализаторов иногда называется созданием объектов в литеральной нотации. "Инициализатор Объекта" следует терминологии C++.
Синтаксис объекта, использующего инициализатор, таков:
объектаИмя = {свойство1:значение1, свойство2:значение2,..., свойствоN:значениеN}
где объектаИмя это имя нового объекта, каждое свойствоI является идентификатором (именем, числом или строковым литералом), а каждое значениеI является выражением, значение которого присваивается свойствуI.
объектаИмя и присвоение являются необязательными. Если Вам не нужно ссылаться где-либо на этот объект, то нет необходимости присваивать его переменной.
Если объект создаётся инициализатором в скрипте верхнего уровня, JavaScript интерпретирует этот объект каждый раз при вычислении выражения, содержащего литерал объекта. Кроме того, инициализатор, используемый в функции, создаётся каждый раз при вызове функции.
Следующий оператор создаёт объект и присваивает его переменной x, если, и только если, выражение cond будет true:
if (cond) x = {hi:"there"}
Следующий пример создаёт myHonda с тремя свойствами. Обратите внимание, что свойство engine также является объектом со своими собственными свойствами.
myHonda = {color:"red",wheels:4,engine:{cylinders:4,size:2.2}}
Вы можете также использовать инициализаторы объектов для создания массивов. См. .
JavaScript 1.1 и ранее.
Вы не можете использовать инициализаторы объектов. Можно создать объекты только с помощью конструкторов функций или используя функцию, предоставляемую для этих целей каким-нибудь другим объектом. См. .
Использование Классов LiveConnect
Все объекты JavaScript появляются в коде Java как экземпляры netscape.javascript.JSObject. Если Вы вызываете метод в Java-коде, Вы можете передать в него JavaScript-объект как один из аргументов. Чтобы выполнить это, Вы обязаны определить соответствующий формальный параметр этого метода как имеющий тип JSObject.
Итак, при использовании JavaScript-объектов в Java-коде Вы всегда должны помещать вызов JavaScript-объекта внутри оператора try...catch, который обрабатывает исключения типа netscape.javascript.JSException. Это даёт Вашему Java-коду возможность обрабатывать ошибки при выполнении JavaScript-кода, которые появляются в Java как исключения типа JSException.
Использование Конструктора Функции
Альтернативно Вы можете создать объект в два этапа:
Определить тип объекта, написав конструктор функции.
Создав экземпляр объекта с помощью оператора new.
Чтобы определить тип объекта, создайте функцию для типа объекта, которая специфицирует его имя , свойства и методы. Например, предположим, Вы хотите создать тип объекта для автомобилей и назвать его car, и чтобы он имел свойства make, model, year и color. Для этого нужно написать такую функцию:
function car(make, model, year) {
this.make = make;
this.model = model;
this.year = year;
}
Обратите внимание на использование this для присвоения значений свойствам объекта на базе значений, передаваемых в эту функцию.
Теперь можно создать объект с названием mycar:
mycar = new car("Eagle", "Talon TSi", 1993);
Этот оператор создаёт объект mycar и присваивает его свойствам специфицированные значения. Теперь значением свойства mycar.make является строка "Eagle", значением свойства mycar.year - целое число 1993 и так далее.
Можно создать любое количество объектов car с помощью оператора new. Например,
kenscar = new car("Nissan", "300ZX", 1992);
vpgscar = new car("Mazda", "Miata", 1990);
Объект может иметь свойство, которое само является объектом. Например, предположим, Вы определяете объект person:
function person(name, age, sex) {
this.name = name
this.age = age
this.sex = sex
}
и затем инстанциируете два новых объекта person:
rand = new person("Rand McKinnon", 33, "M");
ken = new person("Ken Jones", 39, "M");
Затем Вы можете переписать определение car, чтобы включить свойство owner, принимаемое объектом person:
function car(make, model, year, owner) {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner
}
Для создания новых экземпляров Вы теперь используете:
car1 = new car("Eagle", "Talon TSi", 1993, rand);
car2 = new car("Nissan", "300ZX", 1992, ken);
Заметьте, что теперь, вместо передачи литеральной строки или целочисленного значения при создании новых объектов, вышеприведённые операторы передают rand и ken как аргументы свойства owner. Теперь, чтобы определить имя владельца машины car2, Вы осуществляете доступ к свойству:
car2.owner.name
Заметьте, что таким образом Вы всегда добавляете свойство к ранее определённому объекту. Например, оператор
car1.color = "black"
добавляет свойство color объекту car1 и присваивает ему значение "black." Однако это не влияет на другие объекты. Чтобы добавить новое свойство ко всем объектам того же типа, Вы должны добавить свойство в определение типа объекта car.
Использование массива arguments
Аргументы функции обслуживаются в массиве. Внутри функции вы можете адресовать передаваемые ей аргументы таким образом:
arguments[i]
где i это порядковый номер аргумента, начиная с 0. Итак, первым аргументом, передаваемым функции, будет arguments[0]. Общее количество аргументов обозначается свойством arguments.length.
Используя массив arguments, Вы можете вызывать функцию с бòльшим количеством аргументов, чем она принимает по формальному объявлению. Это часто используется в тех случаях, когда Вы заранее не знаете, сколько аргументов будет передано функции. Вы можете использовать arguments.length для определения реального количества аргументов, передаваемых функции, и затем просматривать каждый аргумент в массиве arguments.
Например, рассмотрим функцию, объединяющую несколько строк. Единственным формальным аргументом функции является строка, специфицирующая символ-разделитель объединяемых строк. Функция определяется так:
function myConcat(separator) {
var result="" // initialize list
// iterate through arguments
for (var i=1; i<arguments.length; i++) {
result += arguments[i] + separator
}
return result
}
Вы можете передать этой функции любое количество аргументов, и она создаст список, используя каждый аргумент как элемент этого списка.
// возвращает "red, orange, blue, "
myConcat(", ","red","orange","blue")
// возвращает "elephant; giraffe; lion; cheetah; "
myConcat("; ","elephant","giraffe","lion", "cheetah")
// возвращает "sage. basil. oregano. pepper. parsley. "
myConcat(". ","sage","basil","oregano", "pepper", "parsley")
См. объект Function в книге
JavaScript 1.3 и предыдущие версии.
Массив arguments является свойством объекта Function, и ему может предшествовать имя функции таким образом:
functionName.arguments[i]
Использование Простых Патэрнов
Простые патэрны составляются из символов, для которых Вы ищете прямое совпадение. Например, патэрн /abc/ совпадает в строке только с точными комбинациями указанных символов 'abc' в указанном порядке. Такое совпадение произойдёт в строках "Hi, do you know your abc's?" и "The latest airplane designs evolved from slabcraft." В обоих случаях совпадение произойдёт с подстрокой 'abc'. В строке "Grab crab" совпадения не будет, поскольку она не содержит подстроки 'abc'.
Использование Скобок
Скобки вокруг любой части патэрна регулярного выражения вызывают запоминание этой части совпавшей подстроки. Затем эта подстрока может быть вызвана для последующего использования, как описано в разделе .
Например, патэрн /Chapter (\d+)\.\d*/ иллюстрирует использование дополнительных escape-ированных и специальных символов и указывает, что эта часть патэрна должна быть запомнена. Он совпадает точно с символами 'Chapter ' с последующими одним или более цифровыми символами (\d означает любой цифровой символ, а + означает 1 или более раз), с последующей десятичной точкой (которая сама по себе является специальным символом; предварение десятичной точки символом \ означает, что патэрн обязан искать специальный литеральный символ '.'), с последующим любым цифровым символом 0 или более раз(\d означает цифровой символ, * означает 0 или более раз). Кроме того, используются скобки для запоминания первых совпавших цифровых символов.
Этот патэрн будет найден в строке "Open Chapter 4.3, paragraph 6", и '4' будет запомнена. Патэрн не будет найден в строке "Chapter 3 and 4", поскольку здесь отсутствует десятичная точка после цифры '3'.
Чтобы найти совпадение с подстрокой без запоминания совпавшей части, предваряйте патэрн внутри скобок символами ?:. Например, (?:\d+) совпадает с единицей или числовым символом, но не запоминает совпавшие символы.
Использование Слова this для Ссылок на Объект
JavaScript имеет специальное ключевое слово this, которое может использоваться внутри метода для ссылки на текущий объект. Например, если у Вас имеется функция validate, проверяющая значение свойства объекта и значения high и low:
function validate(obj, lowval, hival) {
if ((obj.value < lowval) (obj.value > hival))
alert("Invalid Value!")
}
то Вы можете вызвать validate в обработчике события onChange любого элемента формы, используя this для передачи обработчику элемента формы, как в этом примере:
<INPUT TYPE="text" NAME="age" SIZE=3
onChange="validate(this, 18, 99)">
В общем, this ссылается в методе на вызывающий объект.
В сочетании со свойством формы, this может обращаться к родительской форме текущего объекта. В следующем примере форма myForm содержит Text-объект и кнопку. Если пользователь щёлкает на кнопке, значением Text-объекта становится имя формы. Обработчик нажатия кнопки onClick использует this.form для ссылки на родительскую форму, myForm.
<FORM NAME="myForm">
Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga">
<P>
<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
onClick="this.form.text1.value=this.form.name">
</FORM>
Использование Совпадений Подстрок в Скобках
Включение скобок в патэрн регулярного выражения вызывает запоминание соответствующего подсовпадения. Например, /a(b)c/ совпадает с символами 'abc' и запоминает 'b'. Чтобы вызвать эту подстроку в скобках, используйте Array-элементы [1], ..., [n].
Количество подстрок, заключённых в скобки, не ограничивается. Возвращаемый массив содержит все найденные совпадения. Следующие примеры иллюстрируют использование подстрок в скобках.
Пример 1.
В этом скрипте используется метод replace для изменения-переключения слов в строке. Для замещающего текста в скрипте используется $1 и $2 для обозначения первой строки и второй подстроки в скобках.
<SCRIPT LANGUAGE="JavaScript1.2">
re = /(\w+)\s(\w+)/;
str = "John Smith";
newstr = str.replace(re, "$2, $1");
document.write(newstr)
</SCRIPT>
Будет напечатано "Smith, John".
Пример 2.
Здесь RegExp.input устанавливается событием Change. В функции getInfo метод exec, вызываемый с использованием сокращённой нотации (), использует значение RegExp.input в качестве аргумента.
<HTML>
<SCRIPT LANGUAGE="JavaScript1.2">
function getInfo(){
a = /(\w+)\s(\d+)/();
window.alert(a[1] + ", your age is " + a[2]);
}
</SCRIPT>
Enter your first name and your age, and then press Enter.
<FORM>
<INPUT TYPE="text" NAME="NameAge" onChange="getInfo(this);">
</FORM>
</HTML>
Использование Специальных Символов
Если при поиске требуется нечто большее, чем простое совпадение, например, найти один или более символов b или найти пробел, в патэрн включаются специальные символы. Например, патэрн /ab*c/ совпадает с любой комбинацией символов, в которой после одиночной 'a' идёт нуль или более символов 'b" (* означает 0 или более вхождений предшествующего элемента/символа) и сразу за ними - 'c'. В строке "cbbabbbbcdebc" этот патэрн совпадёт с подстрокой 'abbbbc'.
В следующей таблице дан полный список и и описание специальных символов, используемых в регулярных выражениях.
| \ |
Одно из следующих:
Для символов, которые обычно рассматриваются литерально, означает, что следующий символ является специальным и не должен интерпретироваться литерально.
Например, /b/ совпадает с символом 'b'. Поместив backslash перед b, то есть так: /\b/, мы делаем символ специальным, в данном случае - означающим границу слова.
Для символов, которые обычно рассматриваются специально, означает, что следующий символ является литеральным и не должен интерпретироваться как специальный.
Например, * это специальный символ, означающий 0 или более вхождений предыдущего символа; например, /a*/ означает 0 или более 'a'. Чтобы подставит * литерально, ставим перед ним backslash; например, /a\*/ совпадает с 'a*'.
Соответствует началу ввода. Если многострочный флаг установлен в true, совпадает также сразу после символа разрыва строки.
Например, /^A/ не совпадает с 'A' в строке "an A", но совпадает с первым 'A' в строке "An A".
Совпадает с концом ввода. Если многострочный флаг установлен в true, совпадает также непосредственно перед символом разрыва строки.
Например, /t$/ не совпадает с 't' в строке "eater", но совпадает с в строке "eat".
*
Предшествующий символ совпадает 0 или более раз.
Например, /bo*/ совпадает с 'boooo' в строке "A ghost booooed" и с 'b' в "A bird warbled", но не совпадает ни с чем в строке "A goat grunted".
+
Например, /a+/ совпадает с 'a' в "candy" и со всеми 'a' в "caaaaaaandy".
?
Например, /e?le?/ совпадает с 'el' в "angel" и с 'le' в "angle."
Если используется сразу после квантификаторов *, +, ? или {}, делает квантификатор нежадным (совпадает минимальное число раз), что противоположно действию по умолчанию, когда квантификатор - жадный (совпадает максимальное число раз).
Используется также во вперёдсмотрящих/lookahead утверждениях, описанных в пунктах о x(?=y) и x(?!y) в этой таблице.
Например, /.n/ совпадает с 'an' и с 'on' в "nay, an apple is on the tree", но не с 'nay'.
Например, /(foo)/ совпадает с 'foo', и запоминает её, в "foo bar." Совпадающая подстрока может быть вызвана из элементов результирующего массива [1], ..., [n].
x(?!y)
x|y
Например, /green|red/ совпадает с 'green' в "green apple" и с 'red' в "red apple."
Например, /a{2}/ не совпадает с 'a' в "candy," но совпадает со всеми 'a' в "caandy" и с первыми двумя 'a's в "caaandy."
{n,}
Например, /a{2,} не совпадает с 'a' в "candy", но совпадает со всеми 'a' в "caandy" и в "caaaaaaandy."
Например, /a{1,3}/ не совпадает ни с чем в "cndy", совпадает с 'a' в "candy", с первыми двумя 'a' в "caandy" и с первыми тремя 'a' в "caaaaaaandy" Заметьте, что при совпадении с "caaaaaaandy", совпадёт "aaa", хотя оригинальная строка содержит большее количество 'a'.
[xyz]
Например, [abcd] это то же самое, что и [a-d]. Совпадает с 'b' в "brisket" и с 'c' в "ache".
Например, [^abc] это то же самое, что [^a-c]. Они совпадают с 'r' в "brisket" и с 'h' в "chop."
\b
Например, /\bn\w/ совпадает с 'no' в "noonday"; /\wy\b/ совпадает с 'ly' в "possibly yesterday."
Например, /\w\Bn/ совпадает с 'on' в "noonday", а /y\B\w/ совпадает с 'ye' в "possibly yesterday."
Например, /\cM/ совпадает с control-M в строке.
\d
Например, /\d/ или /[0-9]/ совпадает с '2' в "B2 is the suite number."
\D
Например, /\D/ или /[^0-9]/ совпадает с 'B' в "B2 is the suite number."
\f
\n
\r
\s
Например, /\s\w*/ совпадает с ' bar' в "foo bar."
\S
[ ^\f\n\r\t\v\u00A0\u2028\u2029].
Например, /\S\w*/ совпадает с 'foo' в "foo bar."
Например, /\w/ совпадает с 'a' в "apple," с '5' в "$5.28" и с '3' в "3D."
\W
Например, /\W/ или /[^$A-Za-z0-9_]/ совпадает с '%' в "50%."
\n
Например, /apple(,)\sorange\1/ совпадает с 'apple, orange,' в "apple, orange, cherry, peach."
\xhh
\uhhhh
Использование Специальных Символов для Проверки Ввода
В этом примере пользователь вводит телефонный номер. Когда нажимается Enter, скрипт проверяет правильность ведённого номера. Если номер введён правильно (соответствует последовательности символов, специфицированной регулярным выражением), скрипт выводит окно с подтверждением и благодарностью. Если номер введён неправильно, скрипт выводит окно, информирующее пользователя, что номер введён неправильно.
Регулярное выражение ищет 0 или более открывающих скобок \(? с последующими тремя цифрами \d{3}, с последующими 0 или более закрывающими скобками \)?, с последующим тире, слэшем или или десятичной точкой и, если найдёт, запоминает символ ([-\/\.]), последующие три цифры \d{3}, тире, слэш или десятичную точку \1, с последующими 4 цифрами\d{4}.
Событие Change активируется, когда пользователь нажимает Enter, и устанавливает значение RegExp.input.
<HTML>
<SCRIPT LANGUAGE = "JavaScript1.2">
re = /\(?\d{3}\)?([-\/\.])\d{3}\1\d{4}/;
function testInfo() {
OK = re.exec();
if (!OK)
window.alert (RegExp.input +
" isn't a phone number with area code!")
else
window.alert ("Thanks, your phone number is " + OK[0])
}
</SCRIPT>
Enter your phone number (with area code) and then press Enter.
<FORM>
<INPUT TYPE="text" NAME="Phone" onChange="testInfo(this);">
</FORM>
</HTML>
Copyright © 2000 Все Права Зарезервированы.
Дата последнего обновления 28 сентября 2000 года.
Изменение Порядка в Строке Ввода
В этом примере показано форматирование регулярного выражения и использование методов string.split() и string.replace(). Очищается необработанная строка ввода, содержащая имена (сначала имя, потом фамилия), разделённые пробелами, табуляцией и одиночным символом "точка с запятой". Наконец, имена и фамилии меняются местами (сначала - фамилия) и список сортируется.
<SCRIPT LANGUAGE="JavaScript1.2">
// Строка names содержит несколько пробелов и табуляций,
// и может содержать несколько пробелов между первым и последним именем.
names = new String ( "Harry Trump ;Fred Barney; Helen Rigby ;\
Bill Abel ;Chris Hand ")
document.write ("---------- Original String" + "<BR>" + "<BR>");
document.write (names + "<BR>" + "<BR>");
// Подготавливаются два патэрна регулярных выражения и массив для хранения.
// Строка делится на элементы массива.
// pattern: возможен пробел, затем точка с запятой, затем пустое пространство
pattern = /\s*;\s*/;
// Строка разбивается на куски, разделённые патэрном, и
// эти куски сохраняются в массиве nameList
nameList = names.split (pattern);
// Новый pattern: один или более символов, затем пробелы, затем символы.
// Используются скобки для "запоминания" части патэрна.
// Запомненная часть будет использоваться позднее.
pattern = /(\w+)\s+(\w+)/;
// Новый массив для содержания имён.
bySurnameList = new Array;
// Выводит массив имён и заполняет новый массив
// именами, разделёнными запятыми, сначала - фамилия.
//
// Метод replace удаляет любое совпадение с патэрном
// и замещает его запомненной строкой - второй запомненной частью,
// после которой идёт запятая, пробел и первая запомненная часть.
//
// Переменные $1 и $2 ссылаются на части,
// запомненные при совпадении патэрна.
document.write ("---------- After Split by Regular Expression" + "<BR>");
for ( i = 0; i < nameList.length; i++) {
document.write (nameList[i] + "<BR>");
bySurnameList[i] = nameList[i].replace (pattern, "$2, $1")
}
// Отображается новый массив.
document.write ("---------- Names Reversed" + "<BR>");
for ( i = 0; i < bySurnameList.length; i++) {
document.write (bySurnameList[i] + "<BR>")
}
// Сортируется по фамилии, затем выводится отсортированный массив.
bySurnameList.sort();
document.write ("---------- Sorted" + "<BR>");
for ( i = 0; i < bySurnameList.length; i++) {
document.write (bySurnameList[i] + "<BR>")
}
document.write ("---------- End" + "<BR>")
</SCRIPT>
