Sonderzeichen in regulären Ausdrücken-js-Tutorial-php.cn

1.JS-Sammlung regulärer Ausdrücke ( auf )

Sonderzeichen in regulären Ausdrücken
Die Zeichenbedeutung
wird als Bedeutungsänderung verwendet, d. h. die Zeichen, die normalerweise nach „“ stehen, werden nicht entsprechend ihrer ursprünglichen Bedeutung interpretiert, z /b/ passt zu den Zeichen „b“, wenn /b/ ein Backslash vorangestellt ist, ändert sich dieser, um mit der Grenze eines Wortes übereinzustimmen.
-oder-
Wiederherstellung von regulären Ausdrucksfunktionszeichen, wie z. B. „*“, das 0 oder öfter mit dem Metazeichen davor übereinstimmt, /a*/ stimmt mit a, aa, aaa überein, nachdem „“ , /a hinzugefügt wurde */ stimmt nur mit „a*“ überein.
^ entspricht einer Eingabe oder dem Anfang einer Zeile, /^a/ entspricht „an A“, aber nicht „An a“
$ entspricht einer Eingabe oder dem Ende einer Zeile, /a$/ stimmt mit „An a“ überein, stimmt nicht mit „an A“ überein
* stimmt mindestens 0 Mal mit dem vorhergehenden Metazeichen überein, /ba*/ stimmt mit b,ba,baa,baaa überein
+ stimmt 1 oder öfter mit dem vorhergehenden Metazeichen überein mal, /ba*/ stimmt mit ba,baa,baaa
überein? Stimmt 0 oder 1 mal mit dem vorhergehenden Metazeichen überein, /ba*/ stimmt mit b,ba
(x) überein. x abgleichen x in einer Datei mit dem Namen $1 speichern ... In der Variablen von $9 stimmt
x|y mit x oder y überein.
{n} stimmt genau n-mal überein.
{n,} stimmt mehr als n-mal überein.
{n,m} stimmt überein n-m mal
[ xyz] Zeichensatz, entspricht jedem Zeichen (oder Metazeichen) in diesem Satz
[^xyz] entspricht keinem Zeichen in diesem Satz
[b] entspricht einem Backspace-Zeichen
b entspricht einer Wortgrenze
B entspricht einer Nicht-Wortgrenze
cX Hier ist X ein Steuerzeichen, /cM/ entspricht Strg-M
d entspricht einem alphanumerischen Zeichen, /d / = /[0- 9]/
D entspricht einem nicht alphanumerischen Zeichen, /D/ = /[^0-9]/
n entspricht einem Zeilenumbruchzeichen
r entspricht einem Wagenrücklaufzeichen
s entspricht einem Leerzeichen Zeichen, einschließlich n, r, f, t, v usw.
S entspricht einem Nicht-Leerzeichen, gleich /[^nfrtv]/
t entspricht einem Tabulatorzeichen
v entspricht einem Wiederholungs-Tab Das Zeichen
w entspricht einem Zeichen, das ein Wort bilden kann (alphanumerisch, dies ist meine freie Übersetzung, einschließlich Zahlen), einschließlich Unterstrichen. Beispielsweise entspricht [w] der 5 in „$5,98“, was gleich [a- ist. zA-Z0-9]
W entspricht einem Zeichen, das kein Wort bilden kann. Beispielsweise entspricht [W] dem $ in „$5,98“, was [^a-zA-Z0-9] entspricht.

2.JS-Sammlung regulärer Ausdrücke (Teil 2)
Ein regulärer Ausdruck ist ein Objekt, das ein Zeichenmuster beschreibt.
Das RegExp-Objekt und das String-Objekt von JavaScript definieren Methoden zur Verwendung regulärer Ausdrücke, um leistungsstarke Mustervergleichs- und Textabruf- und Ersetzungsfunktionen auszuführen.
In JavaScript werden reguläre Ausdrücke durch ein RegExp-Objekt dargestellt. Natürlich können Sie verwenden einen RegExp()-Konstruktor zum Erstellen eines RegExp-Objekts, oder Sie können eine spezielle Syntax verwenden, die in JavaScript 1.2 neu hinzugefügt wurde, um ein RegExp-Objekt zu erstellen. Genauso wie ein String-Literal als ein in Anführungszeichen eingeschlossenes Zeichen definiert wird, werden auch reguläre Ausdrucksliterale als definiert Zeichen zwischen einem Schrägstrichpaar (/). Daher kann JavaScript den folgenden Code enthalten:
var pattern = /s$/;
Diese Codezeile erstellt ein neues RegExp-Objekt und weist es der Variablen zu Dieses spezielle RegExp-Objekt entspricht allen Zeichenfolgen, die mit dem Buchstaben „s“ enden. Ein äquivalenter regulärer Ausdruck kann auch mit RegExp() definiert werden. Der Code lautet wie folgt:
var pattern = new RegExp("s$") ;
Ob Sie ein reguläres Ausdrucksliteral oder den Konstruktor RegExp() verwenden, ist es relativ einfach, ein RegExp-Objekt zu erstellen. Die Aufgabe besteht darin, Zeichenmuster mit regulären Ausdrücken zu beschreiben verwendet eine ziemlich vollständige Teilmenge der regulären Ausdruckssyntax der Perl-Sprache. Die Musterspezifikation eines regulären Ausdrucks besteht aus einer Reihe von Zeichen (einschließlich aller alphanumerischen Zeichen), die auf diese Weise übereinstimmen. Der reguläre Ausdruck /java/ stimmt mit allen Zeichenfolgen überein, die den Teilstring „java“ enthalten. Andere Zeichen im regulären Ausdruck werden zwar nicht wörtlich abgeglichen, aber sie haben alle eine besondere Bedeutung. Der reguläre Ausdruck /s$/ enthält zwei Zeichen Das erste Sonderzeichen „s“ entspricht buchstäblich sich selbst. Das zweite Zeichen „$“ ist ein Sonderzeichen, das dem Ende der Zeichenfolge entspricht. Der reguläre Ausdruck /s$/ entspricht also der Zeichenfolge, die mit dem Buchstaben „s“ endet. .

1. Literale Zeichen

Wir haben festgestellt, dass alle alphabetischen Zeichen und Zahlen in regulären Ausdrücken auch Escape-Sequenzen verwenden, die mit einem Backslash () beginnen. Alphabetische Zeichen. Beispielsweise entspricht die Sequenz „n“ einem Literal-Neuzeilenzeichen in der Zeichenfolge. In regulären Ausdrücken haben viele Satzzeichen eine besondere Bedeutung. Hier sind diese Zeichen und ihre Bedeutung: Literalzeichen für reguläre Ausdrücke Zeichen Übereinstimmung
____________________________
Alphanumerisches Zeichen selbst
f Formularvorschubzeichen
n Zeilenumbruchzeichen
r Wagenrücklauf
t Tab
v vertikaler Tabulator
/ a/ direkte Menge
eine direkte Menge
. a. literal
+ a + literal
(a (literal
) [. a [ literal
] a ] literal
{ a { literal
} a } literal
XXX ASCII-Codezeichen, angegeben durch die Dezimalzahl XXX
Um spezielle Satzzeichen zu verwenden, müssen Sie a hinzufügen „“ vor ihnen.

2. Zeichenklasse

Setzen Sie einzelne direkte Zeichen in Klammern, um eine Zeichenklasse zu bilden, sodass der reguläre Ausdruck / [abc ] / entspricht jedem der Buchstaben „a“, „b“ und „c“. Darüber hinaus können negative Zeichenklassen definiert werden. Diese Klassen entsprechen allen Zeichen außer denen, die in eckigen Klammern stehen Das Symbol ^ wird als erstes Zeichen ab der linken eckigen Klammer verwendet. Der Satz regulärer Ausdrücke ist / [a-zA-z0-9] / . Da bestimmte Zeichenklassen sehr häufig verwendet werden, enthält die Syntax regulärer Ausdrücke Einige Sonderzeichen und Escape-Sequenzen zur Darstellung dieser häufig verwendeten Klassen. s entspricht beispielsweise einem Leerzeichen, einem Tabulatorzeichen und anderen Leerzeichen, und s entspricht jedem Zeichen außer einem Leerzeichen. Typzeichenklasse
Zeichenübereinstimmung
____________________________________________________
[.. .] Alle Zeichen in Klammern
[^...] Alle Zeichen, die nicht in Klammern stehen Alle Zeichen außer Zeilenumbrüchen, äquivalent zu [^n] w Alle Einzelwortzeichen, äquivalent zu [a-zA-Z0-9]
W Alle Nicht-Einzelwortzeichen, äquivalent zu [^a-zA-Z0-9]
s Alle Leerzeichen, äquivalent zu [t n r f v ]
S Alle Nicht-Leerzeichen, äquivalent zu [^ t n r f v]
d Beliebige Zahl, äquivalent zu [0-9]
D Alle anderen Zeichen als Zahlen, äquivalent zu [^0 -9]
[b] Ein Backspace-Literal (Sonderfall)
______________________________________________________________

3. Unter Verwendung der oben genannten Syntax für reguläre Ausdrücke können Sie kann zwei Ziffern umwandeln. Beschrieben als / d d /, die vierstellige Zahl wird als / d d d d / beschrieben. Wir haben jedoch noch keine Möglichkeit, eine Zahl mit einer beliebigen Anzahl von Ziffern oder einer Zeichenfolge zu beschreiben durch einen Buchstaben besteht aus einer einzelnen Ziffer. Die von diesen komplexen Mustern verwendete reguläre Ausdruckssyntax gibt an, wie oft jedes Element im Ausdruck wiederholt werden soll.
gibt an, dass kopierte Zeichen immer nach dem Muster erscheinen, auf das sie angewendet werden. Da bestimmte Kopiertypen recht häufig vorkommen, werden für deren Darstellung einige Sonderzeichen verwendet. Beispiel: + entspricht einem Muster, das das vorherige Muster einmal oder mehrmals kopiert. Schauen wir uns zunächst ein Beispiel an . :
/d{2, 4}/ //Zahlen zwischen 2 und 4 zuordnen.
/w{3} d?/ //Zuordnung von drei einzelnen Zeichen und einer beliebigen Zahl javas+/ //Entspricht der Zeichenfolge „java“, und vor und nach der Zeichenfolge können ein oder mehrere Leerzeichen stehen.
/[^"] * / //Entspricht null oder mehr Zeichen, die keine Anführungszeichen sind.

Zeichen des regulären Ausdrucks kopieren

Zeichenbedeutung ____________________________________________________________________________ {n, m} stimmt mindestens n-mal mit dem vorherigen Element überein, jedoch nicht mehr als m-mal.
{n, } stimmt überein Das vorherige Element n-mal oder mehrmals
{n} stimmt genau n-mal mit dem vorherigen Element überein
? Stimmt das vorherige Element 0 oder 1 Mal überein, was bedeutet, dass das vorherige Element optional ist.
* entspricht 0 oder mehr Mal dem vorherigen Element.
______________________________________________________________

4. Regulär Die Syntax von Ausdrücken umfasst auch Sonderzeichen Zeichen zum Angeben von Auswahlen, zum Gruppieren von Unterausdrücken und zum Verweisen auf vorherige Unterausdrücke. Zum Beispiel: /ab|cd|ef/ entspricht einer Zeichenfolge „ab“ oder der Zeichenfolge „cd“. ef". /d{3}|[a-z]{4}/ entspricht entweder einer dreistelligen Zahl oder vier Kleinbuchstaben. In regulären Klammern in Ausdrücken dienen mehrere Zwecke. Ihr Hauptzweck besteht darin, einzelne Elemente in Unterausdrücke zu gruppieren, sodass diese Elemente können mit *, + oder ? so verarbeitet werden, als wären sie eine unabhängige Einheit. Beispiel: /java( script) ?/ Entspricht der Zeichenfolge „java“, auf die möglicherweise „script /“ folgt. ab|cd) + |ef) / Entspricht entweder der Zeichenfolge „ef“ oder nicht. Ist eine oder mehrere Wiederholungen der Zeichenfolge „ab“ oder „cd“.Die zweite Verwendung von Klammern in regulären Ausdrücken besteht darin, Untermuster innerhalb eines vollständigen Musters zu definieren. Wenn ein regulärer Ausdruck erfolgreich mit einer Zielzeichenfolge übereinstimmt, kann der Teil der Zielzeichenfolge extrahiert werden, der dem Untermuster in Klammern entspricht. Nehmen wir beispielsweise an, dass das Muster, das wir abrufen, aus einem oder mehreren Buchstaben besteht, denen eine oder mehrere Ziffern folgen , dann können wir das Muster /[a-z]+d+/ verwenden. Da wir jedoch davon ausgehen, dass uns die Ziffern am Ende jeder Übereinstimmung wirklich wichtig sind, setzen wir den numerischen Teil des Musters in Klammern (/[a-z ] + (d+)/) können wir aus jeder abgerufenen Übereinstimmung eine Zahl extrahieren, die wir später analysieren werden. Eine weitere Verwendung von
in Klammern gesetzten Unterausdrücken besteht darin, dass die Rückseite des regulären Ausdrucks auf den vorherigen Unterausdruck verweist wird erreicht, indem eine oder mehrere Ziffern nach der Zeichenfolge hinzugefügt werden. Die Zahl bezieht sich auf die Position des Unterausdrucks im regulären Ausdruck. Beispielsweise bezieht sich 1 auf den Unterausdruck der ersten Klammer Da Unterausdrücke in anderen Unterausdrücken verschachtelt sein können, wird ihre Position durch Zählen der Position der linken Klammer bestimmt. Beispiel: Im folgenden regulären Ausdruck wird er als 2 angegeben:
/([Jj]ava([. Ss]cript)) sis s (funw*) /
Paar Ein Verweis auf den vorherigen Unterausdruck in einem regulären Ausdruck gibt nicht das Muster dieses Unterausdrucks an, sondern den Text, der diesem Muster entspricht. Auf diese Weise ist der Verweis Es handelt sich nicht nur um eine Abkürzung, die Ihnen bei der Eingabe wiederholter Teile des regulären Ausdrucks hilft, sondern auch um die Konvention, dass jeder einzelne Teil einer Zeichenfolge genau dieselben Zeichen enthält. Beispiel: Der folgende reguläre Ausdruck entspricht allen Zeichen, die in einfachen Anführungszeichen stehen oder doppelte Anführungszeichen. Es ist jedoch erforderlich, dass die Anfangs- und Endanführungszeichen übereinstimmen (z. B. sind beide doppelte Anführungszeichen oder beide einfache Anführungszeichen):
/[' "] [^ ' "]*[' "]/
Wenn die Anfangs- und Endanführungszeichen erforderlich sind. Um mit dem schließenden Anführungszeichen übereinzustimmen, können wir das folgende Anführungszeichen verwenden:
/( [' "] ) [^ ' "] * 1/
1 entspricht dem übereinstimmenden Muster durch den ersten Unterausdruck der Klammer. In diesem Beispiel wird die Konvention erzwungen, dass das öffnende Anführungszeichen mit dem schließenden Anführungszeichen übereinstimmen muss. Beachten Sie, dass dies der Fall ist, wenn auf den Backslash mehr Zahlen folgen, als die Klammern ersetzen wird als dezimale Escape-Sequenz und nicht als Referenz analysiert. Sie können Verwirrung vermeiden, indem Sie darauf bestehen, die vollständigen drei Zeichen zur Darstellung von Escape-Sequenzen zu verwendenb entspricht der Grenze eines Wortes. Kurz gesagt, es ist die Position zwischen den Zeichen w und w (Hinweis: [b] entspricht dem Rückschrittzeichen)
B entspricht den Zeichen, die keine Wortgrenzen sind
___________________________________________________________________
6. Attribute
Es gibt ein letztes Element in der Grammatik regulärer Ausdrücke, nämlich die Attribute regulärer Ausdrücke, die die Regeln für den erweiterten Mustervergleich beschreiben. Die Ausdruckssyntax ist unterschiedlich , Attribute werden außerhalb des /-Symbols angegeben, das heißt, sie erscheinen nicht zwischen zwei Schrägstrichen, aber nach dem zweiten Schrägstrich unterstützt das Attribut i, dass bei der Musterübereinstimmung die Groß-/Kleinschreibung nicht beachtet werden soll dass der Mustervergleich global sein sollte. Das heißt, alle Übereinstimmungen in der abgerufenen Zeichenfolge sollten kombiniert werden, um einen globalen, nicht beachteten Mustervergleich durchzuführen Um den ersten spezifischen Wert des Wortes „Java“ (oder „Java“, „JAVA“ usw.) zu finden, können wir einen größenunabhängigen regulären Ausdruck verwenden. Ausdruck /b javab/i Wenn wir alle spezifischen Werte finden möchten Werte von „Java“ in einer Zeichenfolge können wir auch das Attribut g hinzufügen, d :
Zeichenbedeutung
_________________________________________
i führt einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung durch
g führt einen globalen Vergleich durch, kurz gesagt, findet alle Übereinstimmungen, anstatt anzuhalten, nachdem der erste gefunden wurde
_______________________________________________
Außer Für die Attribute g und i haben reguläre Ausdrücke keine anderen attributähnlichen Eigenschaften. Wenn Sie das statische Attribut multiline des Konstruktors RegExp Set auf true setzen, wird der Mustervergleich im mehrzeiligen Modus durchgeführt Die Zeichen ^ und $ stimmen nicht nur mit dem Anfang und Ende der Suchzeichenfolge überein, sondern auch mit der Suchzeichenfolge innerhalb einer Zeile. Beispiel: Das Muster /Java$/ stimmt mit „Java“ überein, stimmt jedoch nicht mit „ überein. Javanis fun". Wenn wir das Multiline-Attribut festlegen, wird auch Letzteres abgeglichen:
RegExp.multiline = true ;
Bestimmen Sie, ob eine Zeichenfolge im E-Mail-Format in JAVASCRIPT vorliegt:

if(formname.email.value!=formname.email.value.match(/^\w +[@]\w +[.][\w.] +$/)) 
{ 
alert("您的电子邮件格式错误！"); 
formname.email.focus(); 
return false; 
} 
[RED]function dateVerify(date){ 
var reg = /^(\d{4})(-)(\d{2})\2(\d{2})$/; 
var r = date.match(reg); 
if(r==null) return false; 
var d= new Date(r[1], r[3]-1,r[4]); 
var newStr=d.getFullYear()+r[2]+(d.getMonth()+1)+r[2]+d.getDate(); 
date=r[1]+r[2]+((r[3]-1)+1)+r[2]+((r[4]-1)+1); 
return newStr==date; 
}

Nach dem Login kopieren

javascript的17种正则表达式
"^\\d+$"　　//非负整数（正整数 + 0）
"^[0-9]*[1-9][0-9]*$"　　//正整数
"^((-\\d+)|(0+))$"　　//非正整数（负整数 + 0）
"^-[0-9]*[1-9][0-9]*$"　　//负整数
"^-?\\d+$"　　　　//整数
"^\\d+(\\.\\d+)?$"　　//非负浮点数（正浮点数 + 0）
"^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数
"^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$"　　//非正浮点数（负浮点数 + 0）
"^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数
"^(-?\\d+)(\\.\\d+)?$"　　//浮点数
"^[A-Za-z]+$"　　//由26个英文字母组成的字符串
"^[A-Z]+$"　　//由26个英文字母的大写组成的字符串
"^[a-z]+$"　　//由26个英文字母的小写组成的字符串
"^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符串
"^\\w+$"　　//由数字、26个英文字母或者下划线组成的字符串
"^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$"　　　　//email地址
"^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$"　　//url
JavaScript中的正则表达式
正则表达式对象的属性及方法
预定义的正则表达式拥有有以下静态属性：input, multiline, lastMatch, lastParen, leftContext, rightContext和$1到$9。其中input和multiline可以预设置。其他属性的值在执行过exec或test方法后被根据不同条件赋以不同的值。许多属性同时拥有长和短(perl风格)的两个名字，并且，这两个名字指向同一个值。(JavaScript模拟perl的正则表达式)
正则表达式对象的属性
属性含义
$1...$9 如果它(们)存在，是匹配到的子串
$_ 参见input
$* 参见multiline
$& 参见lastMatch
$+ 参见lastParen
$` 参见leftContext
$''　　　　　　　　　参见rightContext
constructor　　　创建一个对象的一个特殊的函数原型
global　　　　　　是否在整个串中匹配(bool型)
ignoreCase　　　　匹配时是否忽略大小写(bool型)
input　　　　　　　被匹配的串
lastIndex　　　　最后一次匹配的索引
lastParen　　　　最后一个括号括起来的子串
leftContext　　　最近一次匹配以左的子串
multiline　　　　是否进行多行匹配(bool型)
prototype　　　　允许附加属性给对象
rightContext　　　最近一次匹配以右的子串
source　　　　　　正则表达式模式
lastIndex　　　　最后一次匹配的索引
正则表达式对象的方法
方法含义
compile　　　　　正则表达式比较
exec　　　　　　　执行查找
test　　　　　　　进行匹配
toSource　　　　　返回特定对象的定义(literal representing)，其值可用来创建一个新的对象。重载Object.toSource方法得到的。
toString　　　　　返回特定对象的串。重载Object.toString方法得到的。
valueOf　　　　　返回特定对象的原始值。重载Object.valueOf方法得到
例子

将输出"Smith, John"
JS正则表达式大全

/********************************************************************************* 
* EO_JSLib.js 
* javascript正则表达式检验 
**********************************************************************************/ 
//校验是否全由数字组成 
function isDigit(s) 
{ 
var patrn=/^[0-9]{1,20}$/; 
if (!patrn.exec(s)) return false 
return true 
} 
//校验登录名：只能输入5-20个以字母开头、可带数字、“_”、“.”的字串 
function isRegisterUserName(s) 
{ 
var patrn=/^[a-zA-Z]{1}([a-zA-Z0-9]|[._]){4,19}$/; 
if (!patrn.exec(s)) return false 
return true 
} 
//校验用户姓名：只能输入1-30个以字母开头的字串 
function isTrueName(s) 
{ 
var patrn=/^[a-zA-Z]{1,30}$/; 
if (!patrn.exec(s)) return false 
return true 
} 
//校验密码：只能输入6-20个字母、数字、下划线 
function isPasswd(s) 
{ 
var patrn=/^(\w){6,20}$/; 
if (!patrn.exec(s)) return false 
return true 
} 
//校验普通电话、传真号码：可以“+”开头，除数字外，可含有“-” 
function isTel(s) 
{ 
//var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/; 
var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/; 
if (!patrn.exec(s)) return false 
return true 
} 
//校验手机号码：必须以数字开头，除数字外，可含有“-” 
function isMobil(s) 
{ 
var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/; 
if (!patrn.exec(s)) return false 
return true 
} 
//校验邮政编码 
function isPostalCode(s) 
{ 
//var patrn=/^[a-zA-Z0-9]{3,12}$/; 
var patrn=/^[a-zA-Z0-9 ]{3,12}$/; 
if (!patrn.exec(s)) return false 
return true 
} 
//校验搜索关键字 
function isSearch(s) 
{ 
var patrn=/^[^`~!@#$%^&*()+=|\\\][\]\{\}:;&#39;\,.<>/?]{1}[^`~!@$%^&()+=|\\\][\]\{\}:;&#39;\,.<>?]{0,19}$/; 
if (!patrn.exec(s)) return false 
return true 
} 
function isIP(s) //by zergling 
{ 
var patrn=/^[0-9.]{1,20}$/; 
if (!patrn.exec(s)) return false 
return true 
}

Nach dem Login kopieren

正则表达式regular expression详述
正则表达式是regular expression，看来英文比中文要好理解多了，就是检查表达式符
不符合规定！！正则表达式有一个功能十分强大而又十分复杂的对象RegExp，在JavaScript1.2 版本以上提供。
下面我们看看有关正则表达式的介绍：
正则表达式对象用来规范一个规范的表达式(也就是表达式符不符合特定的要求，比如是不是Email地址格式等)，它具有用来检查给出的字符串是否符合规则的属性和方法。
除此之外，你用RegExp构造器建立的个别正则表达式对象的属性，就已经预先定义好了正则表达式对象的静态属性，你可以随时使用它们。
核心对象：
在JavaScript 1.2, NES 3.0以上版本提供。
在JavaScript 1.3以后版本增加了toSource方法。
建立方法：
文字格式或RegExp构造器函数。
文字建立格式使用以下格式：
/pattern/flags即/模式/标记
构造器函数方法使用方法如下：
new RegExp("pattern"[, "flags"])即new RegExp("模式"[,"标记"])
参数：
pattern(模式) ——表示正则表达式的文本
flags(标记) ——如果指定此项，flags可以是下面值之一：
g: global match(全定匹配)
i: ignore case(忽略大小写)
gi: both global match and ignore case(匹配所有可能的值，也忽略大小写)
注意：文本格式中的参数不要使用引号标记，而构造器函数的参数则要使用引号标记。所以下面的表达式建立同样的正则表达式：
/ab+c/i
new RegExp("ab+c", "i")
描述：当使用构造函数的时候，必须使用正常的字符串避开规则(在字符串中加入前导字符\ )是必须的。例如，下面的两条语句是等价的：
re = new RegExp("\\w+")
re = /\w+/
下面的提供了在正则表达式中能够使用的完整对特殊字符的一个完整的列表和描述。
表1.3：正则表达式中的特殊字符：
字符\ ——意义：对于字符，通常表示按字面意义，指出接着的字符为特殊字符，\不作解释。
例如：/b/匹配字符'b',通过在b 前面加一个反斜杠\，也就是/\b/，则该字符变成特殊字符，表示
匹配一个单词的分界线。
或者： ——对于几个字符，通常说明是特殊的，指出紧接着的字符不是特殊的，而应该按字面解释。
例如：*是一个特殊字符，匹配任意个字符(包括0个字符)；例如：/a*/意味匹配0个或多个a。
为了匹配字面上的*，在a前面加一个反斜杠；例如：/a\*/匹配'a*'。
字符^ ——意义：表示匹配的字符必须在最前边。
例如：/^A/不匹配"an A,"中的'A'，但匹配"An A."中最前面的'A'。
字符$ ——意义：与^类似，匹配最末的字符。
例如：/t$/不匹配"eater"中的't'，但匹配"eat"中的't'。
字符* ——意义：匹配*前面的字符0次或n次。
例如:/bo*/匹配"A ghost booooed"中的'boooo'或"A bird warbled"中的'b'，但不匹配"A goat g
runted"中的任何字符。
字符+ ——意义：匹配+号前面的字符1次或n次。等价于{1,}。
例如：/a+/匹配"candy"中的'a'和"caaaaaaandy."中的所有'a'。
字符? ——意义：匹配?前面的字符0次或1次。
例如：/e?le?/匹配"angel"中的'el'和"angle."中的'le'。
字符. ——意义：(小数点)匹配除换行符外的所有单个的字符。
例如：/.n/匹配"nay, an apple is on the tree"中的'an'和'on'，但不匹配'nay'。
字符(x) ——意义：匹配'x'并记录匹配的值。
例如：/(foo)/匹配和记录"foo bar."中的'foo'。匹配子串能被结果数组中的素[1], ..., [n] 返
回，或被RegExp对象的属性$1, ..., $9返回。
字符x|y ——意义：匹配'x'或者'y'。
例如：/green|red/匹配"green apple"中的'green'和"red apple."中的'red'。
字符{n} ——意义：这里的n是一个正整数。匹配前面的n个字符。
Beispiel: /a{2}/ stimmt nicht mit dem „a“ in „candy“ überein, sondern mit allen „a“ in „caandy“ und den ersten beiden
'a in „caaandy“.
Zeichen {n,} – Bedeutung: n ist hier eine positive ganze Zahl. Entspricht mindestens n vorherigen Zeichen.
Zum Beispiel: /a{2,} stimmt nicht mit dem „a“ in „candy“ überein, sondern mit allen „a“ in „caandy“ und allen „a“ in „caaaaaaandy“.
Zeichen {n ,m} – Bedeutung: n und m sind hier beide positive ganze Zahlen. Entspricht mindestens n und höchstens m vorherigen Zeichen.
Zum Beispiel: /a{1,3}/ stimmt mit keinem Zeichen in „cndy“ überein, stimmt aber mit dem „a“ in „candy“ und den ersten beiden
„a“ in „caandy“ überein. Und die ersten drei 'a's in "caaaaaaandy", Hinweis: Auch wenn es viele 'a's in "caaaaaaandy" gibt, stimmt es nur mit den ersten drei
'a's überein, also mit "aaa".
Zeichen[xyz] – Bedeutung: Eine Liste von Zeichen, die mit jedem Zeichen in der Liste übereinstimmen. Mit dem Bindestrich - können Sie einen Zeichenbereich angeben.
Zum Beispiel: [abcd] ist dasselbe wie [a-c]. Sie entsprechen dem „b“ in „brisket“ und dem „c“ in „ache“.
Zeichen[^xyz]——Bedeutung: Ein-Zeichen-Komplement, das heißt, es stimmt mit allem außer den aufgelisteten Zeichen überein. Sie können Bindestriche verwenden, um einen Zeichenbereich anzugeben.
Zum Beispiel: [^abc] und [^a-c] sind gleichwertig, sie stimmen zuerst mit dem „r“ in „brisket“ und dem „h“ in „chop“ überein.
Zeichen [b] – Bedeutung: Entspricht einem Leerzeichen (nicht zu verwechseln mit b)
Zeichen b – Bedeutung: Entspricht einer Trennlinie eines Wortes, z. B. einem Leerzeichen (nicht zu verwechseln mit [ b])
Zum Beispiel: /bnw/ entspricht „no“ in „noonday“, /wyb/ entspricht „ly“ in „möglicherweise gestern“.
Zeichen B – Bedeutung: Entspricht der geschützten Zeile eines Wortes
Zum Beispiel: /wBn/ entspricht dem „on“ in „noonday“, /yBw/ entspricht dem „ye“ in „möglicherweise gestern“. .
Zeichen cX – Bedeutung: X ist hier ein Steuerzeichen. Entspricht einer Zeichenfolge aus Steuerzeichen.
Zum Beispiel: /cM/ entspricht Control-M in einer Zeichenfolge.
Zeichen d – Bedeutung: Entspricht einer Zahl, äquivalent zu [0-9].
Zum Beispiel: /d/ oder /[0-9]/ stimmt mit „2“ in „B2 ist die Suite-Nummer“ überein.
Zeichen D – Bedeutung: Entspricht einer beliebigen Nicht-Zahl, äquivalent zu [^0-9].
Zum Beispiel: /D/ oder /[^0-9]/ entspricht dem „B“ in „B2 ist die Suite-Nummer.“
Zeichen f——Bedeutung: Übereinstimmung mit einem Formularzeichen
Zeichen n——Bedeutung: Übereinstimmung mit einem Zeilenumbruchzeichen
Zeichen r——Bedeutung: Übereinstimmung mit einem Wagenrücklaufzeichen
Zeichen s——Bedeutung: Übereinstimmung Ein einzelnes Leerzeichen, einschließlich Leerzeichen, Tabulatorzeichen, Formularvorschub und Zeilenumbruchzeichen, entspricht [fnrtv].
Zum Beispiel: /sw*/ stimmt mit „bar“ in „foo bar“ überein.
Zeichen S – Bedeutung: Entspricht einem einzelnen Zeichen außer Leerzeichen, äquivalent zu [^ fnrtv].
Zum Beispiel: /S/w* stimmt mit „foo“ in „foo bar“ überein.
Zeichen t – Bedeutung: Übereinstimmung mit einem Tabulatorzeichen
Zeichen v – Bedeutung: Übereinstimmung mit einem führenden Tabulatorzeichen
Zeichen w – Bedeutung: Übereinstimmung mit allen Zahlen, Buchstaben und Unterstrichen, äquivalent zu [A-Za-z0- 9_].
Zum Beispiel: /w/ entspricht dem „a“ in „apple“, der „5“ in „$5,28“ und der „3“ in „3D“.
Zeichen W – Bedeutung: Entspricht anderen Zeichen außer Zahlen, Buchstaben und Unterstrichen, entspricht [^A-Za-z0-9_].
Zum Beispiel: /W/ oder /[^$A-Za-z0-9_]/ entspricht dem „%“ in „50 %“.
Zeichen n——Bedeutung: n ist hier eine positive ganze Zahl. Der Wert von n, der mit der letzten Teilzeichenfolge eines regulären Ausdrucks übereinstimmt (linke Klammern mitgezählt).
Zum Beispiel: /apple(,)sorange1/ entspricht „apple, orange“ in „apple, orange, Cherry, Peach“. Unten finden Sie ein vollständigeres Beispiel
.
Hinweis: Wenn die Zahl in der linken Klammer kleiner ist als die durch n angegebene Zahl, verwendet n das Oktal-Escape der nächsten Zeile als Beschreibung.
Zeichen ooctal und xhex – Bedeutung: ooctal ist hier ein oktaler Escape-Wert und xhex ist ein hexadezimaler Escape-Wert, der die Einbettung von ASCII-Codes in einen regulären Ausdruck ermöglicht.
Literale Notation bietet eine Möglichkeit, reguläre Ausdrücke zu bearbeiten, wenn der Ausdruck überprüft wird. Reguläre Ausdrücke können mithilfe der Literalschreibweise konstant gehalten werden. Wenn Sie beispielsweise in einer Schleife die Literalschreibweise verwenden, um einen regulären Ausdruck zu erstellen, muss der reguläre Ausdruck nicht wiederholt kompiliert werden.
正则表达式对象构造器，例如，new RegExp("ab+c")，提供正则表达式的运行时编译。当你知道正则表达式的模式会变化的时候，应该使用构造函数，或者你不知道正则表达式的模式，而它们是从另外的源获得的时候，比如由用户输入时。一旦你定义好了正则表达式，该正则表达式可在任何地方使用，并且可以改变，你可以使用编译方法来编译一个新的正则表达式以便重新使用。
一个分离预先定义的RegExp对象可以在每个窗口中使用；也就是说，每个分离的JavaScript线程运行以获得自己的RegExp对象。因为每个脚本在一个线程中是不可中断的，这就确保了不同的脚本不会覆盖RegExp对象的值。
预定义的RegExp对象包含的静态属性：input, multiline, lastMatch,lastParen, leftContext, rightContext, 以及从$1到$9。input和multiline属性能被预设。其它静态属性的值是在执行个别正则表达式对象的exec和test方法后，且在执行字符串的match和replace方法后设置的。
属性
注意RegExp对象的几个属性既有长名字又有短名字(象Perl)。这些名字都是指向相同的值。Perl是一种编程语言，而JavaScript模仿了它的正则表达式。
属性$1, ..., $9
取得匹配的子串，如果有的话
属性$_
参考input
属性$*
参考multiline
属性$&
参考lastMatch
属性$+
参考lastParen
属性$`
参考leftContext
属性$'
参考rightContext
属性constructor
指定用来建立对象原型函
属性global
决定是否测试正则表达式是否不能匹配所有的字符串，或者只是与最先的冲突。
属性ignoreCase
决定试图匹配字符串的时候是否忽略大小写
属性input
当正则表达式被匹配的时候，为相反的字符串。
属性lastIndex
决定下一次匹配从那里开始
属性lastMatch
最后一个匹配的字符
属性lastParen
子串匹配的时候，最后一个parenthesized，如果有的话。
属性leftContext
最近一次匹配前的子串。
属性multiline
是否在串的多行中搜索。
属性prototype
允许附加属性到所有的对象
属性rightContext
最近一次匹配后的的子串。
属性source
模式文本

方法
compile方法
编译一个正则表达式对象
exec方法
运行正则表达式匹配
test方法
测试正则达式匹配
toSource方法
返回一个对象的文字描述指定的对象；你可以使用这个值来建立一个新的对象。不考虑Object.toS
ource方法。
toString方法
返回一个字符串描述指定的对象，不考虑Object.toString对象。
valueOf方法
返回指定对角的原始值。不考虑Object.valueOf方法。
　另外，这个对象继承了对象的watch和unwatch方法

例子：
例１、下述示例脚本使用replace方法来转换串中的单词。在替换的文本中，脚本使用全局 RegExp
对象的$1和$2属性的值。注意，在作为第二个参数传递给replace方法的时候，RegExp对象的$属性的名
称。

<SCRIPT LANGUAGE="JavaScript1.2"> 
re = /(\w+)\s(\w+)/; 
str = "John Smith"; 
newstr=str.replace(re,"$2, $1"); 
document.write(newstr) 
</SCRIPT>

Nach dem Login kopieren

显示结果："Smith, John".
例２、下述示例脚本中，RegExp.input由Change事件处理句柄设置。在getInfo函数中，exec 方法
使用RegExp.input的值作为它的参数，注意RegExp预置了$属性。

<SCRIPT LANGUAGE="JavaScript1.2"> 
function getInfo(abc) 
{ 
re = /(\w+)\s(\d+)/; 
re.exec(abc.value); 
window.alert(RegExp.$1 + ", your age is " + RegExp.$2); 
} 
</SCRIPT> 
　　请输入你的姓和年龄，输入完后按回车键。 
<FORM><INPUT TYPE="TEXT" NAME="NameAge" onChange="getInfo(this);"></FORM> 
</HTML>

Nach dem Login kopieren

$1, ..., $9属性
用圆括号括着的匹配子串，如果有的话。
是RegExp的属性
静态，只读
在JavaScript 1.2, NES 3.0以上版本提供
描述：因为input是静态属性，不是个别正则表达式对象的属性。你可以使用RegExp.input 访问该
属性。
能加上圆括号的子串的数量不受限制，但正则表达式对象只能保留最后9 条。如果你要访问所有的
圆括号内的匹配字串，你可以使用返回的数组。
这些属性能用在RegExp.replace方法替换后的字符串(输出结果)。当使用这种方式的时候，不用预
先考虑RegExp对象。下面给出例子。当正则表达式中没有包含圆括号的时候，该脚本解释成$n的字面意
义。(这里的n是一个正整数)。
例如：
下例脚本使用replace 方法来交换串中单词的位置。在替换后的文本字串中，脚本使用正则表达式
RegExp对象的$1和$2属性的值。注意：当它们向replace方法传递参数的时候，这里没有考虑 $ 属性的
RegExp对象的名称。

<SCRIPT LANGUAGE="JavaScript1.2"> 
re = /(\w+)\s(\w+)/; 
str = "John Smith"; 
newstr=str.replace(re,"$2, $1"); 
document.write(newstr) 
</SCRIPT>

Nach dem Login kopieren

显示的输出结果为：Smith, John。
JS正则表达式大全
正则表达式regular expression详述
以下这些不是正则表达式的新增对象请参阅对应的JavaScript对象的属性 $_属性参考input $*属性
参考multiline $&属性参考lastMatch $+属性参考lastParen $`属性
参考leftContext $'属性参考rightContext compile方法在脚本运行期间编译正则表达式对象
属于RegExp的方法在JavaScript 1.2, NES 3.0以上版本提供语法：
regexp.compile(pattern[, flags]) 以数： regexp 正则表达式的名称，可以是变量名或文字串。
pattern 正则表达式的定义文本。 flags 如果指定的话，可以是下面其中的一个： "g": 匹配所有可能的字串
"i": 忽略大小写 "gi": 匹配所有可能的字串及忽略大小写描述：
使用compile方法来编译一个正则表达式 created with the RegExp constructor function。这样
就强制正则表达式只编译一次，而不是每次遇到正则表达式的时候都编译一次。当你确认正则表达式能
保持不变的时候可使用compile 方法来编译它(在获得它的匹配模式后)，这样就可以在脚本中重复多次使用它。
你亦可以使用compile 方法来改变在运行期间改变正则表达式。例如，假如正则表达式发生变化，
你可以使用compile方法来重新编译该对象来提高使用效率。
使用该方法将改变正则表达式的source, global和ignoreCasesource属性的值。 constructor
指出建立对象原型的function。注意这个属性的值由函数本身提供，而不是一个字串包含RegExp的name.Property提供。
在JavaScript 1.1, NES 2.0以上版本提供 ECMA版本ECMA-262 描述：参考Object.constructor.
exec方法在指定的字符串运行匹配搜索。返回一个结果数组。是RegExp的方法
在JavaScript 1.2, NES 3.0以上版本提供语法： regexp.exec([str])regexp([str])
参数： regexp，正则表达式的名称，可以是一个变量名或文字定义串。
str，要匹配正则表达式的字符串，如果省略，将使用RegExp.input的值。
描述：就如在语法描述中的一样，正则表达工的exec方法能够被直接调用(使用regexp.exec(str))或者间接调用(使用regexp(str))。
假如你只是运行以找出是否匹配，可以使用String搜索方法。
假如匹配成功，exec方法返回一个数组并且更新正则表达式对象属性的值和预先定义的正则表达式对象、RegExp。如果匹配失败，exec方法返回null。
请看下例：下面是该脚本的返回值：对象属性/Index 描述例子
myArray
myArray的内容 ["dbBd", "bB", "d"]
index
基于0的匹配index 1
input
原始字符串 cdbBdbsbz
[0]
最后匹配的字符 dbBd
[1], ...[n]
用圆括号括住的匹配字符串，如果有的话。不限制括号的个数。 [1] = bB
[2] = d
myRe
lastIndex
开始下次匹配操作的index值 5
ignoreCase
指出"i"是否使用以忽略大小写 true
global
指出是否使用"g"标记来进行匹配所有可能的字串 true
source
定义模式的文本字符串 d(b+)(d)
RegExp
lastMatch$&
最后匹配的字符 dbBd
leftContext$\Q
最新匹配前面的子串 c
rightContext$'
最新匹配后面的子串 bsbz
$1, ...$9
圆括号内的匹配子串，如果有的话。圆括号的个数不受限制，但RegExp只能保留最后9个 $1 = bB
$2 = d
lastParen $+
最后一个加上圆括号的匹配子串，如果有的话 d
假如你的正则表达式使用了"g"标记，你可以多次使用exec 方法来连续匹配相同的串。当你这样做
的时候，新的匹配将从由正则表达式的lastIndex 属性值确定的子串中开始。例如，假定你使用下面的脚本：
Ergebnisse: Nächste Übereinstimmung gefunden, beginnt bei 3
Nächste Übereinstimmung gefunden, beginnt bei 9. Beispiel:
Im folgenden Beispiel gibt der Benutzer einen Namen ein und das Skript führt einen Abgleichsvorgang basierend auf der Eingabe durch. Anschließend wird das Array überprüft, um festzustellen, ob es mit dem Namen eines anderen Benutzers übereinstimmt.
Dieses Skript geht davon aus, dass der Nachname des registrierten Benutzers in Array A gespeichert oder aus einer Datenbank abgerufen wurde.