Арифметические операции
Арифметические операции
Арифметические операции принимают в качестве операндов числовые значения (литералы или переменные) и возвращают единственное значение-результат. Стандартными арифметическими операциями являются операции сложения (+), вычитания (-), умножения (*) и деления (/). Эти операции работают так же, как и в большинстве других языков программирования, только операция / в JavaScript возвращает частное с плавающей точкой, а не округлённое частное, как в C или Java. Например:
1/2 //возвращает 0.5 в JavaScript
1/2 //возвращает 0 в Java
Кроме того, JavaScript предоставляет арифметические операции, перечисленные в таблице.
Битовые логические операции
Битовые логические операции
Концептуально битовые логические операции работают так:
Операнды конвертируются в 32-битные целые и выражаются серией битов (нулей и единиц).Каждый бит первого операнда образует пару с соответствующим битом второго операнда: первый бит с первым, второй со вторым и т.д.
Операция применяется к каждой паре битов, и результат конструируется побитно.
Например, цифра 9 имеет двоичное/бинарное представление 1001, а цифра 15 - 1111. Поэтому результаты применения битовых операций к этим значениям будут такими:
15 & 9 даст 9 (1111 & 1001 = 1001)
15 | 9 даст 15 (1111 | 1001 = 1111)
15 ^ 9 даст 6 (1111 ^ 1001 = 0110)
Битовые операции
Битовые операции
Битовые операции рассматривают свои операнды как 32-битные целые значения (последовательность 0 и 1), а не как 10-ричные, 16-ричные или 8-ричные числа. Например, десятеричное 9 имеет бинарное представление 1001. Битовые операции выполняются над такими двоичными представлениями, но возвращают стандартные числовые значения JavaScript.
В таблице приведены битовые операции JavaScript.
Битовые операции сдвига
Битовые операции сдвига
Операции битового сдвига принимают два операнда: первый это сдвигаемое число, а второй специфицирует количество битовых позиций, на которое сдвигается первый операнд. Направление сдвига контролируется самой операцией.
Операции сдвига конвертируют свои операнды в 32-битные целые числа и возвращают результат того же типа, что и у левого операнда.
Операции сдвига перечислены в следующей таблице.
Delete
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 (можно удалять объект, определённый пользователем)
Выражения и Операции
Глава 3
Выражения и Операции
В этой главе рассматриваются выражения и операции JavaScript, в том числе - операции присвоения, сравнения, арифметические, битовые, логические, строковые и специальные.
В главе имеются следующие разделы:
ВыраженияОперации
Логические операции
Логические операции
Логические операции обычно используются с Булевыми (логическими) значения; эти операции возвращают Булево значение. Однако операции && и || в действительности возвращают значение одного из специфицированных операндов, поэтому, если эти операции используются с не-Булевыми значениями, они могут вернуть не-Булево значение. Логические операции перечислены в таблице.
New
new
Операция new используется для создания нового экземпляра объекта пользовательского типа или предопределённых типов Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp или String. На сервере Вы можете также использовать эту операцию с объектами DbPool, Lock, File или SendMail.
Используйте new так:
objectName = new objectType ( param1 [,param2] ...[,paramN] )
Вы можете также создавать объекты с использованием инициализаторов объектов, как описано в разделе "Использование Инициализаторов Объектов".
Клиентский JavaScript. Справочник.
Операции
В этом разделе рассматриваются операции и приоритет выполнения. В JavaScript имеются следующие типы операций:
Операции присвоения
Операции сравненияАрифметические
БитовыеЛогические Строковые
Специальные
В JavaScript есть как бинарные, так и унарные операции. Бинарная операция работает с двумя операндами, один - до знака операции, другой - после:
операнд1 операция операнд2
Например, 3+4 или x*y.
Для унарной операции нужен один операнд, до или после знака операции:
операция операнд
или
операнд операция
Например, x++ или ++x.
Кроме того, в JavaScript имеется тернарная условная операция. Тернарная операция требует трёх операндов.
Операции присвоения
Операции присвоения
Операция присвоения присваивает левому операнду значение правого операнда. Базовой операцией присвоения является "равно" (=), которая присваивает левому операнду значение правого операнда. То есть, x = y присваивает значение у переменной х.
Другие операции присвоения являются аббревиатурами стандартных операций, как видно из таблицы.
Операции сравнения
Операции сравнения
Операция сравнения сравнивает операнды и возвращает значение, основанное на true/верности сравнения. Операнды могут быть числами или строками. Строки сравниваются на основе стандартного лексикографического (словарного) порядка с использованием Unicode-значений. В таблице даны операции сравнения.
Операция , (запятая)
операция , (запятая)
Операция "запятая" (,) просто вычисляет два операнда и возвращает значение второго операнда. Эта операция используется в основном в цикле for, позволяя обновлять несколько переменных при каждом проходе цикла.
Например, если a это 2-мерный массив из 10 элементов по измерению, следующий код использует операцию , для инкремента сразу двух переменных. Код печатает значения элементов по диагонали массива:
for (var i=0, j=9; i <= 9; i++, j--)
document.writeln("a["+i+","+j+"]= " + a[i,j])
Функция validate проверяет свойство value
Функция validate проверяет свойство value объекта, имея high и low-значения:
function validate(obj, lowval, hival) {
if ((obj.value < lowval) || (obj.value > hival))
alert("Invalid Value!")
}
Вы можете вызывать validate в обработчике onChange каждого элемента формы, используя this для передачи в функцию элемента формы, как в следующем примере:
<B>Enter a number between 18 and 99:</B>
<INPUT TYPE = "text" NAME = "age" SIZE = 3
onChange="validate(this, 18, 99)">
В сочетании со свойством form,
В сочетании со свойством form, слово 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>
Приоритет операций
Приоритет операций
Приоритет операций определяет порядок, в котором они выполняются при вычислении выражения. Вы можете переопределить приоритет операций путём использования скобок.
В следующей таблице показан приоритет выполнения операций, от низшего к высшему.
Сокращённый цикл вычисления
Сокращённый цикл вычисления
Поскольку логические выражения вычисляются слева направо, они проверяются на возможность "сокращённого/short-circuit" вычисления по следующим правилам:
false && anything ускоренно вычисляется в false.
true || anything ускоренно вычисляется в true.
Правила логики гарантируют, что эти вычисления всегда корректны. Обратите внимание, что часть anything вышеприведённых выражений не вычисляется, поэтому выполнение полного вычисления не даст никакого эффекта.
Специальные операции
Специальные операции
В JavaScript имеются следующие специальные операции:
условная операцияоперация , (запятая)
deletenew
thistypeof
void
Строковые операции
Строковые операции
Помимо операций сравнения, которые могут использоваться со строковыми значениями, операция конкатенации (+) объединяет два строковых значения, возвращая строку, которая является результатом объединения двух строк-операндов. Например, "my " + "string" возвращает строку "my string".
Операция-аббревиатура присвоения += также может использоваться для конкатенации строк. Например, если переменная mystring имеет значение "alpha", то выражение mystring += "bet" вычисляется в "alphabet" и это значение присваивается переменной mystring.
Операции присвоения
Таблица 3.1 Операции присвоения
| x += y | x = x + y |
| x -= y | x = x - y |
| x *= y | x = x * y |
| x /= y | x = x / y |
| x %= y | x = x % y |
| x <<= y | x = x << y |
| x >>= y | x = x >> y |
| x >>>= y | x = x >>> y |
| x &= y | x = x & y |
| x ^= y | x = x ^ y |
| x |= y | x = x | y |
Операции сравнения
Таблица 3.2 Операции сравнения
| Равно (==) | Возвращает true, если операнды равны. Если два операнда имеют разные типы, JavaScript пытается конвертировать операнды в значения, подходящие для сравнения. | 3 == var1 "3" == var1 3 == '3' | ||
| Не равно (!=) | Возвращает true, если операнды не равны. Если два операнда имеют разные типы, JavaScript пытается конвертировать операнды в значения, подходящие для сравнения. | var1 != 4 var2 != "3" | ||
| Строго равно (===) | Возвращает true, если операнды равны и одного типа. | 3 === var1 | ||
| Строго не равно (!==) | Возвращает true, если операнды не равны и/или не одного типа. | var1 !== "3" 3 !== '3' | ||
| Больше (>) | Возвращает true, если левый операнд больше правого операнда. | var2 > var1 | ||
| Больше или равно (>=) | Возвращает true, если левый операнд больше правого операнда или равен ему. | var2 >= var1 var1 >= 3 | ||
| Меньше (<) | Возвращает true, если левый операнд меньше правого операнда. | var1 < var2 | ||
| Меньше или равно (<=) | Возвращает true, если левый операнд меньше правого операнда или равен ему. | var1 <= var2 var2 <= 5 |
| 1В этих примерах принимается, что переменной var1 присвоено значение 3, а переменной var2 присвоено значение 4. |
Арифметические операции
Таблица 3.3 Арифметические операции
| % (Целочисленный остаток) | Бинарная операция. Возвращает целочисленный остаток от деления двух операндов. | 2 % 5 возвращает 2. | |||
| ++ (Инкремент) | Унарная операция. Прибавляет 1 к операнду. Если используется как префикс (++x), возвращает значение операнда после прибавления 1; если используется как постфикс (x++), возвращает значение операнда до прибавления 1. | Если x равен 3, то ++x устанавливает 4 в x и возвращает 4, а x++ устанавливает 4 в x и возвращает 3. | |||
| -- (Декремент) | Унарная операция. Вычитает 1 из операнда. Возвращаемые значения аналогичны оператору инкремента. | Если x равен 3, то --x устанавливает 2 в x и возвращает 2, а x++ устанавливает 2 в x и возвращает 3. | |||
| - (Унарное отрицание) | Унарная операция. Возвращает отрицание операнда. | Если x равен 3, то -x возвращает -3. |
Битовые операции
Таблица 3.4 Битовые операции
| И | a & b | Возвращает 1 в позиции каждого бита, где соответствующий бит обоих операндов равен 1. | ||
| ИЛИ | a | b | Возвращает 1 в позиции каждого бита, где соответствующий бит одного или обоих операндов равен 1. | ||
| Исключающее ИЛИ/XOR | a ^ b | Возвращает 1 в позиции каждого бита, где соответствующий бит одного, но не обоих, операндов равен 1. | ||
| НЕ | ~ a | Инвертирует биты операнда. | ||
| Сдвиг влево | a << b | Сдвигает операнд a в бинарном представлении на b битов влево, заполняя справа нулями . | ||
| Сдвиг вправо с сохранением знака | a >> b | Сдвигает операнд a в бинарном представлении на b битов вправо, отбрасывая смещённые биты. | ||
| Сдвиг вправо с заполнением нулями | a >>> b | Сдвигает операнд a в бинарном представлении на b битов вправо, отбрасывая смещённые биты и заполняя слева нулями. |
Операции битового сдвига
Таблица 3.5 Операции битового сдвига
| << (Сдвиг влево) | Эта операция сдвигает влево первый операнд на специфицированное вторым операндом количество битов. Излишние биты, сдвинутые влево, отбрасываются. Справа идёт заполнение нулями. | 9<<2 даёт 36, поскольку 1001, сдвинутое на 2 бита влево, становится 100100, что равно 36. | |||
| >> (Сдвиг вправо с сохранением знака) | Эта операция сдвигает вправо первый операнд на специфицированное вторым операндом количество битов. Излишние биты, сдвинутые вправо, отбрасываются. Копии левых битов вставляются слева. | 9>>2 даёт 2, поскольку 1001, сдвинутое на 2 бита вправо, становится 10, что равно 2. Аналогично -9>>2 даёт -3, поскольку знак сохраняется. | |||
| >>> (Сдвиг вправо с заполнением нулями) | Эта операция сдвигает вправо первый операнд на специфицированное вторым операндом количество битов. Излишние биты, сдвинутые вправо, отбрасываются. Слева идёт заполнение нулями. | 19>>>2 даёт 4, поскольку 10011, сдвинутое на 2 бита вправо, становится 100, то есть 4. Для неотрицательных чисел сдвиг вправо с заполнением нулями и сдвиг вправо с сохранением знака дают одинаковые результаты. |
Логические операции
Таблица 3.6 Логические операции
| && | expr1 && expr2 | (Логическое И) Возвращает expr1, если может быть конвертировано в false; иначе возвращает expr2. Таким образом, при использовании с Булевыми значениями && возвращает true, если оба операнда true; иначе, возвращает false. | ||
| || | expr1 || expr2 | (Логическое ИЛИ) Возвращает expr1, если может быть конвертировано в false; иначе возвращает expr2. Таким образом, при использовании с Булевыми значениями || возвращает true, если любой из операндов true; если оба false, возвращает false. | ||
| ! | !expr | (Логическое НЕ) Возвращает false, если её единственный операнд может быть конвертирован в true; иначе возвращает true. |
Примерами выражений, которые могут быть конвертированы в false, являются выражения, вычисляемые в null, 0, пустую строку ("") или undefined.
А это примеры операции && (logical AND).
a1=true && true // t && t возвращает true
a2=true && false // t && f возвращает false
a3=false && true // f && t возвращает false
a4=false && (3 == 4) // f && f возвращает false
a5="Cat" && "Dog" // t && t возвращает Dog
a6=false && "Cat" // f && t возвращает false
a7="Cat" && false // t && f возвращает false
Следующий код это примеры операции || (logical OR).
o1=true || true // t || t возвращает true
o2=false || true // f || t возвращает true
o3=true || false // t || f возвращает true
o4=false || (3 == 4) // f || f возвращает false
o5="Cat" || "Dog" // t || t возвращает Cat
o6=false || "Cat" // f || t возвращает Cat
o7="Cat" || false // t || f возвращает Cat
Следующий код это примеры операции ! (logical NOT).
n1=!true // !t возвращает false
n2=!false // !f возвращает true
n3=!"Cat" // !t возвращает false
This
this
Используйте ключевое слово this для обращения к текущему объекту. Вообще this ссылается на вызывающий объект в методе. Используйте this так:
this[.propertyName]
Typeof
typeof
Операция typeof используется двумя способами:
1. typeof operand
2. typeof (operand)
Операция typeof возвращает строку - тип невычисленного операнда.
operand это строка, переменная, ключевое слово или объект, тип которого возвращается. Скобки не обязательны.
Предположим, Вы определяете следующие переменные:
var myFun = new Function("5+2")
var shape="round"
var size=1
var today=new Date()
Операция typeof возвращает для этих переменных следующие результаты:
typeof myFun is object
typeof shape is string
typeof size is number
typeof today is object
typeof dontExist is undefined
Для ключевых слов true и null операция typeof возвращает:
typeof true is boolean
typeof null is object
Для числа или строки операция typeof возвращает:
typeof 62 is number
typeof 'Hello world' is string
Для значений свойств операция typeof возвращает тип значения, содержащегося в свойстве:
typeof document.lastModified is string
typeof window.length is number
typeof Math.LN2 is number
Для методов и функций операция typeof возвращает такие результаты:
typeof blur is function
typeof eval is function
typeof parseInt is function
typeof shape.split is function
Для предопределённых объектов операция typeof возвращает:
typeof Date is function
typeof Function is function
typeof Math is function
typeof Option is function
typeof String is function
Удаление элементов массива
Удаление элементов массива
Если Вы удаляете элемент массива, размер массива не изменяется. Например, если Вы удаляете 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, принимающая три операнда. Эта операция может иметь одно из двух значений на основе выполнения условия. Синтаксис таков:
condition ? val1 : val2
Если condition true, операция выдаёт значение val1. Иначе она выдаёт значение val2. Вы можете использовать условную операцию там же, где используется стандартный оператор if.
Например,
status = (age >= 18) ? "adult" : "minor"
Этот оператор присваивает значение "adult" переменной status, если age имеет значение 18 или более. Иначе переменной status присваивается значение "minor".
Void
void
Операция void используется одним из следующих способов:
1. void (expression)
2. void expression
Операция void специфицирует выражение, вычисляемое без возвращения значения.
expression это вычисляемое выражение JavaScript. Скобки вокруг expression не обязательны, но их использование является хорошим стилем.
Вы можете использовать операцию void для специфицирования выражения как гиперссылки. Выражение вычисляется, но не загружается вместо текущего документа.
Следующий код создаёт гиперссылку, которая не выполняет никаких действий, если пользователь щёлкнет по ней. Если пользователь щёлкает по этой ссылке, void(0) вычисляется в 0, но это не вызывает никаких действий в JavaScript.
<A HREF="javascript:void(0)">Click here to do nothing</A>
Следующий код создаёт гиперссылку, которая отправляет форму на сервер, если пользователь щёлкнул по этой ссылке.
<A HREF="javascript:void(document.form.submit())">
Click here to submit</A>
Выражения
Выражение\expression это правильный набор литералов, переменных, операций и выражений, который вычисляется в единственное значение; значение может быть числом, строкой или логическим значением.
Концептуально имеются выражения двух типов: присваивающие значение переменной, и те, которые просто имеют значение. Например, выражение x= 7 присваивает переменной x значение 7. Это выражение вычисляется в 7. Такие выражения используют операции присвоения.
Выражение 3 + 4 вычисляется в 7; оно выполняет операцию присвоения значения. Операции в таких выражениях называются просто операции.
В JavaScript имеются следующие типы выражений:
Арифметические: вычисляются в число, например, 3.14159
Строковые: вычисляются в строку символов, например, "Fred" или "234"
Логические: вычисляются в true или false
Регулярные Выражения
Глава 4
Регулярные Выражения
Регулярные выражения являются патэрнами, используемыми при поиске совпадений комбинаций символов в строках. В JavaScript регулярные выражения являются также объектами. Эти патэрны используются с методами exec и test объекта RegExp и с методами match, replace, search и split объекта String. В этой главы рассматриваются регулярные выражения JavaScript.
JavaScript 1.1 и более ранние версии.
Регулярные выражения недоступны в JavaScript 1.1 и предыдущих версиях.
В главе имеются следующие разделы:
Создание регулярного выражения
Написание патэрна регулярного выражения
Работа в регулярными выражениями
Примеры
Использование простых патэрнов
Использование простых патэрнов
Простые патэрны состоят из символов, для которых ищется прямое совпадение. Например, патэрн /abc/ совпадает с комбинацией символов в строке только тогда, когда символы 'abc' появляются вместе и в указанном порядке. Такое совпадение будет найдено в строках "Hi, do you know your abc's?" и "The latest airplane designs evolved from slabcraft." В обоих случаях имеется совпадение с подстрокой 'abc'. В строке "Grab crab" совпадения нет, потому что она не содержит подстроки 'abc'.
Использование скобок
Использование скобок
Скобки вокруг любой части патэрна регулярного выражения вызывают запоминание этой части совпавшей подстроки. После запоминания подстрока может быть вызвана для другого использования, как описано в разделе "Использование Совпадений Подстроки в Скобках".
Например, патэрн /Chapter (\d+)\.\d*/ иллюстрирует совпадение дополнительных заменяющих и специальных символов и указывает, что эту часть патэрна нужно запомнить. Совпадает с точно символами 'Chapter ' и последующими одной или более цифрами (\d означает любую цифру, а + означает 1 или более раз), с последующей десятичной точкой (которая является сама по себе специальным символом; поэтому её предшествует \ , что означает, что патэрн обязан искать литеральный символ '.'), с последующим цифровым символом, 0 или более раз (\d означает цифру, * означает 0 или более раз). Кроме того, скобки используются для запоминания первых совпавших цифровых символов.
Этот патэрн находит совпадение в "Open Chapter 4.3, paragraph 6", и '4' запоминается. Патэрн не находит совпадение в "Chapter 3 and 4", поскольку эта строка не содержит точку после '3'.
Использование совпадений подстрок в скобках
Использование совпадений подстрок в скобках
Включение скобок в патэрн регулярного выражения вызывает запоминание соответствующего подсовпадения. Например, /a(b)c/ совпадает с символами 'abc' и запоминает 'b'. Для последующего вызова этих запомненных подсовпадений используйте свойства $1, ..., $9 объекта RegExp или элементы [1], ..., [n] объекта Array.
Количество подстрок в скобках не ограничено. Предопределённый объект RegExp хранит последние 9 подстрок, а массив содержит всё, что найдено. Следующие примеры иллюстрируют использование совпадений подстрок в скобках.
Пример 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 в качестве аргумента. Заметьте, что RegExp обязан быть присоединён как префикс к его свойствам $ (поскольку они появляются вне замещающей строки). (Пример 3 это более эффективный, хотя, может быть, и более завуалированный способ сделать то же самое.)
<HTML><SCRIPT LANGUAGE="JavaScript1.2">
function getInfo(){
re = /(\w+)\s(\d+)/
re.exec();
window.alert(RegExp.$1 + ", your age is " + RegExp.$2);
}
</SCRIPT>Enter your first name and your age, and then press Enter.<FORM>
<INPUT TYPE="text" NAME="NameAge" onChange="getInfo(this);">
</FORM></HTML>
Пример 3.
Это пример похож на Пример 2. Но вместо использования RegExp.$1 и RegExp.$2 этот пример создаёт массив и использует a[1] и a[2]. Здесь используется также сокращённая нотация для метода exec.
<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'.
В таблице дан полный список - описание специальных символов, которые могут использоваться в регулярных выражениях.
Изменение порядка в строке ввода
Изменение порядка в строке ввода
Это пример форматирования регулярных выражений и использования методов string.split() и string.replace(). Здесь зачищается грубо отформатированная строка ввода, содержащая имена (первое имя идёт первым), разделённые пробелом, табуляцией и одним символом "точка с запятой". Затем порядок имён разворачивается (последнее имя идёт первым) и список сортируется.
<SCRIPT LANGUAGE="JavaScript1.2">// Строка name содержит несколько пробелов и табуляций,
// и может иметь несколько пробелов между первым и последним именами.
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 = /\s*;\s*/// Разбивка строки на куски, разделённые вышеуказанным патэрном,
// и сохранение этих кусков в массиве nameList
nameList = names.split (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>
Написание патэрна регулярного выражения
Патэрн регулярного выражения состоит из простых символов, например, /abc/, или из комбинаций простых и специальных символов, как /ab*c/ или /Chapter(\d+)\.\d*/. В последнем примере имеются скобки, которые использованы как запоминающее устройство. Совпадение, сделанное этой частью патэрна, запоминается для последующего использования, как описано в разделе "Использование Совпадений Подстрок в Скобках".
Далее идут пример использования регулярных
Далее идут пример использования регулярных выражений.
Работа в регулярными выражениями
Регулярные выражения используются с методами test и exec объекта RegExp и с методами match, replace, search и split объекта String. Эти методы детально рассмотрены в книге
Клиентский JavaScript. Справочник.
Создание регулярного выражения
Вы конструируете регулярное выражение одним из двух способов:
Используя инициализатор объекта:re = /ab+c/
Инициализаторы объектов выполняют компиляцию регулярного выражения при вычислении скрипта. Если регулярное выражение является константным, используйте инициализатор для повышения производительности. Инициализаторы объектов обсуждаются в разделе "Использование Инициализаторов Объектов".
Вызывая функцию-конструктор объекта RegExp:re = new RegExp("ab+c")
Использование функции-конструктора предоставляет компиляцию регулярного выражения на этапе прогона. Это делается, если известно, что патэрн регулярного выражения будет изменяться, или если Вы не знаете патэрн и получаете его из другого источника, такого как пользовательский ввод. После того как регулярное выражение определено, и если оно используется в скрипте и исходное значение изменяется, Вы можете использовать метод compile
для компиляции нового регулярного выражения для более эффективного многократного использования.
Специальные символы в регулярных выражениях
Таблица 4.1 Специальные символы в регулярных выражениях
| \ | Один из следующих вариантов:
Для символов, которые обычно рассматриваются литерально, указывает, что следующий символ является специальным и не должен интерпретироваться литерально. Например, /b/ совпадает с символом 'b'. При помещении символа backslash перед b, то есть /\b/, символ становится специальным, обозначая границу слова. Для символов, которые обычно рассматриваются как специальные, указывает что следующий символ не является специальным и должен интерпретироваться литерально. Например, * это специальный символ, который означает 0 или более совпадений с вхождением предыдущего символа; например, /a*/ означает 0 или более символов а. Для подстановки * литерально, поставьте передним backslash; например, /a\*/ совпадает с 'a*'. | |
| ^ | Совпадает с началом ввода или строки.
Например, /^A/ не совпадает с 'A' в строке "an A," но совпадает с первой А в строке "An A". | |
| $ | Совпадает с концом ввода или строки.
Например, /t$/ не совпадает с 't' в "eater", но совпадает в "eat". | |
| * | Предшествующий символ совпадает 0 или более раз.
Например, /bo*/ совпадает с 'boooo' в "A ghost booooed" и с 'b' в "A bird warbled", но не совпадает в "A goat grunted". | |
| + | Предшествующий символ совпадает 1 или более раз. Эквивалентно {1,}.
Например, /a+/ совпадает с 'a' в "candy" and all the a's in "caaaaaaandy." | |
| ? | Предшествующий символ совпадает 0 или 1 раз.
Например, /e?le?/ совпадает с 'el' в "angel" и с 'le' в "angle." | |
| . | (Десятичная точка) совпадает с любым одиночным символом, кроме символа новой строки.
Например, /.n/ совпадает с 'an' и с 'on' в "nay, an apple is on the tree", но не с 'nay'. | |
| (x) | Совпадает с 'x' и запоминает совпадение.
Например, /(foo)/ совпадает (и запоминает) с 'foo' в "foo bar." Совпавшая подстрока может быть вызвана из результирующего массива элементов [1], ..., [n] или из свойств $1, ..., $9 предопределённого объекта RegExp. | |
| x|y | Совпадает с 'x' или с 'y'.
Например, /green|red/ совпадает с 'green' в "green apple" и с 'red' в "red apple." | |
| {n} | Где n это положительное целое. Предшествующий символ совпадает точно n раз.
Например, /a{2}/ не совпадает с 'a' в "candy", но совпадает со всеми 'a' в "caandy" и с первыми двумя 'a' в "caaandy." | |
| {n,} | Где n это положительное целое. Предшествующий символ совпадает как минимум n раз.
Например, /a{2,} не совпадает с 'a' в "candy", но совпадает со всеми 'a' в "caandy" и в "caaaaaaandy." | |
| {n,m} | Где n и m это положительные целые. Предшествующий символ совпадает как минимум n и максимум m раз.
Например, /a{1,3}/ не совпадает ни с чем в "cndy", совпадает с 'a' in "candy," первыми двумя 'a' в "caandy" и первыми тремя 'a' в "caaaaaaandy" Обратите внимание, что в "caaaaaaandy" совпадает только "aaa", хотя строка-оригинал содержит больше символов 'a'. | |
| [xyz] | Набор символов. Совпадает с любым одним из символов патэрна. Вы можете специфицировать диапазон символов, используя дефис.
Например, [abcd] эквивалентно [a-d]. Совпадает с 'b' в "brisket" и с 'c' в "ache". | |
| [^xyz] | Отрицание набора символов. То есть совпадение со всем, кроме того, что находится в скобках. Вы можете специфицировать диапазон символов, используя дефис.
Например, [^abc] это то же самое, что [^a-c]. Первоначально совпадает с 'r' в "brisket" и с 'h' в "chop". | |
| [\b] | Совпадает с backspace. (Не путайте с \b.) | |
| \b | Совпадает с границей слова, такой как пробел/space или символ новой строки. (Не путайте с [\b].)
Например, /\bn\w/ совпадает с 'no' in "noonday"; /\wy\b/ совпадает с 'ly' in "possibly yesterday". | |
| \B | Совпадает с не-границей слова.
Например, /\w\Bn/ совпадает с 'on' в "noonday"; /y\B\w/ совпадает с 'ye' в "possibly yesterday". | |
| \cX | Где X это управляющий символ. Совпадает с управляющим символом в строке.
Например, /\cM/ совпадает с комбинацией control-M. | |
| \d | Совпадает с цифрой. Эквивалентно [0-9].
Например, /\d/ или /[0-9]/ совпадает с '2' в строке "B2 is the suite number". | |
| \D | Совпадает с не-цифрой. Эквивалентно [^0-9].
Например, /\D/ или /[^0-9]/ совпадает с 'B' в "B2 is the suite number". | |
| \f | Совпадает с form-feed. | |
| \n | Совпадает с linefeed. | |
| \r | Совпадает с carriage return. | |
| \s | Совпадает с одиночным пробельным символом, включая space, tab, form feed, line feed. Эквивалентно [ \f\n\r\t\v]. Например, /\s\w*/ совпадает с ' bar' в "foo bar". | |
| \S | Совпадает с одиночным символом, отличным от пробела. Эквивалентно [^ \f\n\r\t\v].
Например, /\S\w*/ совпадает с 'foo' в "foo bar." | |
| \t | Совпадает с tab. | |
| \v | Совпадает с vertical tab. | |
| \w | Совпадает с любым алфавитно-цифровым символом, включая символ подчёркивания. Эквивалентно [A-Za-z0-9_].
Например, /\w/ совпадает с 'a' в "apple", с '5' в "$5.28" и с '3' в "3D." | |
| \W | Совпадает с любым не-алфавитно-цифровым символом. Эквивалентно [^A-Za-z0-9_].
Например, /\W/ или /[^$A-Za-z0-9_]/ совпадает с '%' в "50%." | |
| \n | Где n это положительное целое. Обратная ссылка на последнее совпадение подстроки с n в скобках из регулярного выражения (с учётом левых скобок).
Например, /apple(,)\sorange\1/ совпадает с 'apple, orange,' в "apple, orange, cherry, peach." Более сложный пример идёт далее после таблицы. Примечание: Если количество левых скобок меньше числа, специфицированного в \n, то \n считается восьмеричной escape-последовательностью, как описано в следующем ряду. | |
| \ooctal \xhex | Где \ooctal это 8-ричное escape-значение или где \xhex это 16-ричное escape-значение. Даёт возможность внедрять ASCII-коды в регулярные выражения. |
Методы, использующие регулярные выражения
Таблица 4.2 Методы, использующие регулярные выражения
| exec | Метод объекта RegExp, выполняющий поиск совпадения в строке. Возвращает массив информации. | |
| test | Метод объекта RegExp, тестирующий на наличие совпадений в строке. Возвращает true или false. | |
| match | Метод объекта String, выполняющий поиск совпадения в строке. Возвращает массив информации, или null при отсутствии совпадения. | |
| search | Метод объекта String, тестирующий на наличие совпадений в строке. Возвращает индекс совпадения или -1, если поиск завершился неудачно. | |
| replace | Метод объекта String, выполняющий поиск совпадения в строке и заменяющий найденные подстроки замещающей подстрокой. | |
| split | Метод объекта String, использующий регулярное выражение или фиксированную строку для разделения строки на массив подстрок. |
Если Вам необходимо выяснить, найден ли патэрн в строке, используйте методы test или search; для получения большего количества информации (и более медленного выполнения) используйте методы exec или match.
Если Вы используете exec или match и если совпадение найдено, эти методы возвращают массив и обновляют свойства ассоциированного объекта регулярного выражения и предопределённого объекта регулярного выражения, RegExp. Если совпадения нет, метод exec возвращает значение null (которое конвертируется в false).
В следующем примере скрипт использует метод exec для поиска совпадения в строке:
<SCRIPT LANGUAGE="JavaScript1.2">
myRe=/d(b+)d/g;
myArray = myRe.exec("cdbbdbsbz");
</SCRIPT>
Если Вам не нужен доступ к свойствам регулярного выражения, можно создать myArray таким скриптом:
<SCRIPT LANGUAGE="JavaScript1.2">
myArray = /d(b+)d/g.exec("cdbbdbsbz");
</SCRIPT>
Если Вы хотите иметь возможность рекомпиляции регулярного выражения, то вот ещё один скрипт:
<SCRIPT LANGUAGE="JavaScript1.2">
myRe= new RegExp ("d(b+)d", "g:);
myArray = myRe.exec("cdbbdbsbz");
</SCRIPT>
При выполнении скриптов производится поиск совпадения, возвращается массив и обновляются свойства, показанные в таблице.
Результаты выполнения регулярного выражения
Таблица 4.3 Результаты выполнения регулярного выражения
| myArray | Совпавшая строка и все запомненные подстроки. | ["dbbd", "bb"] | |||
| index | Индекс с базой 0 совпадения в строке ввода. | 1 | |||
| input | Строка-оригинал. | "cdbbdbsbz" | |||
| [0] | Последние совпавшие символы. | "dbbd" | |||
| myRe | lastIndex | Индекс, по которому находится начало следующего совпадения. (Это свойство устанавливается, только если регулярное выражение использует опцию g, описанную в разделе "Выполнение Глобального Поиска и Игнорирование Регистра Символов".) | 5 | ||
| source | Текст патэрна. | "d(b+)d" | |||
| RegExp | lastMatch | Последние совпавшие символы. | "dbbd" | ||
| leftContext | Подстрока, предшествующая самому последнему совпадению. | "c" | |||
| rightContext | Подстрока, идущая после самого последнего совпадения. | "bsbz" |
RegExp.leftContext и RegExp.rightContext могут быть высчитаны из других значений.
RegExp.leftContext эквивалентно:
myArray.input.substring(0, myArray.index)
а RegExp.rightContext эквивалентно:
myArray.input.substring(myArray.index + myArray[0].length)
Как видно из второй формы этого примера, Вы можете использовать регулярное выражение, созданное инициализатором объекта, без присвоения его переменной. Если Вы это сделаете, каждое вхождение будет новым регулярным выражением. Поэтому, если Вы используете эту форму без присвоения значения, Вы не сможете получить доступ к свойствам этого регулярного выражения. Например, у Вас имеется такой скрипт:
<SCRIPT LANGUAGE="JavaScript1.2">
myRe=/d(b+)d/g;
myArray = myRe.exec("cdbbdbsbz");
document.writeln("The value of lastIndex is " + myRe.lastIndex);
</SCRIPT>
Он выводит:
The value of lastIndex is 5
Но если у Вас такой скрипт:
<SCRIPT LANGUAGE="JavaScript1.2">
myArray = /d(b+)d/g.exec("cdbbdbsbz");
document.writeln("The value of lastIndex is " + /d(b+)d/g.lastIndex);
</SCRIPT>
Он выведет:
The value of lastIndex is 0
Появления /d(b+)d/g в этих двух операторах являются разными объектами регулярного выражения и, следовательно, имеют разные значения своих свойств lastIndex. Если Вам нужен доступ к свойствам регулярного выражения, созданного инициализатором объекта, Вы должны сначала присвоить его переменной.
Выполнение глобального поиска и игнорирование регистра символов
Выполнение глобального поиска и игнорирование регистра символов
Регулярное выражение имеет две не обязательные опции-флаги, которые дают возможность проводить поиск глобально и без учёта регистра символов.
Для глобального поиска используйте флаг g.
Для поиска без учёта регистра используйте флаг i.
Эти флаги можно использовать вместе или по отдельности в любом порядке, и они включаются как часть регулярного выражения.
Синтаксис для включения флага:
re = /pattern/[g|i|gi]
re = new RegExp("pattern", ['g'|'i'|'gi'])
Заметьте, что флаги i и g являются неотъемлемой частью регулярного выражения. Они не могут быть добавлены и удалены позднее.
Например, re = /\w+\s/g создаёт регулярное выражение, которое ищет один или более символов с последующим пробелом, и ищет такую комбинацию по всей строке.
<SCRIPT LANGUAGE="JavaScript1.2">
re = /\w+\s/g;
str = "fee fi fo fum";
myArray = str.match(re);
document.write(myArray);
</SCRIPT>
Это выведет ["fee ", "fi ", "fo "]. В данном примере Вы можете заменить строку:
re = /\w+\s/g;
на строку:
re = new RegExp("\\w+\\s", "g");
и получить тот же самый результат.
