JS正規表現のためのRegexpオブジェクトとブラケットの使用に関する簡単な議論

regexpオブジェクトの作成：

通常の正規表現の作成は、直接、つまりスラッシュ「/」で囲まれたキャラクターを直接行うことができます。ただし、パラメーターの変更が必要な環境では、regexp（）コンストラクターがより良い選択です。

var reg1 =/'/w+'/g;

var reg2 = new regexp（ '/' // w+/''、 'g'）;

2つの作成方法を比較すると、Regexpの最初のパラメーターは、作成される通常の文字列です。一方では、それは量の直接的な表現ではないため、スラッシュ "/"で囲まれていません。代わりに、引用符は「 '"" "" "" "" "" "" "" "" ""/"が弦の中で2次脱出する必要があります。

さらに、直接的な数量であろうとregexp（）コンストラクターであろうと、新しいregexpオブジェクトが生成され、変数に割り当てられます。

match（）とexec（）の類似性と相違点：

マッチとエグゼクティブは、定期的な表現の文字列を一致させる一般的な方法です。 2つによって実装された関数は類似しており、いくつかの微妙な違いがあります。

1。使い方

一致は、文字列でオブジェクトをラッピングする方法であり、使用法：string.match（regexp）;

execは正規表現オブジェクトの方法です。使用法：regexp.exec（string）;

2。返された結果

regexpがグローバルフラグ「G」を設定しない場合：

両方の返品結果は同じです。つまり、一致する値がない場合、nullを返し、一致する値がある場合、配列を返します（配列にしましょう）。配列[0]は、一致する文字列、配列[1]、配列[2] ...は、正規表現の括弧を一致させるサブストリングに対応しています。同時に、配列には2つのプロパティがあります。 array.indexは、一致する文字列の初期位置を表し、array.inputは取得している文字列を表します。

regexpにグローバルフラグ「G」セットがある場合：

値がある場合は、マッチアレイアレイを返します。配列内の各アイテムは、一致するすべての文字列を表しているため、括弧を一致させるサブストリングはもうありません。現時点では、配列にはインデックス属性と入力属性がありません。

execは、グローバルレーベル「G」のないパフォーマンスと違いはありません。返された配列配列、配列[0]は、現在の一致する文字列、配列[1]、配列[2] ...は現在の一致する文字列です。現時点では、元の文字列の一致する文字列の最後の最後の位置を表すRegexpオブジェクトのLastIndexプロパティに注意してください。それ以上一致する結果がない場合、LastIndexプロパティは0に設定されているため、LastIndexループを使用してすべての一致する文字列を見つけることができます。

複数のマッチング方法をサポートします：

JSコード

var testStr = "now test001 test002"; var re =/test（/d+）/ig; var r = ""; while（r = re.exec（teststr））{alert（r [0] + "" + r [1]）; }

さらに、TestStr.Match（RE）を使用することもできますが、このようにしてGにはオプションがなく、最初の試合しか取得できません。

1。正規表現ルール

1.1通常の文字

次の章で具体的に定義されていない文字、数字、漢字、アンダースコア、および句読点はすべて「通常の文字」です。式の通常の文字が文字列と一致する場合、それと同じ文字と一致します。

例1：式「C」、文字列「ABCDE」を一致させるとき、一致する結果は次のとおりです。成功。一致するコンテンツは「C」です。一致する位置は次のとおりです。2で開始し、3で終了します（注：添え字は0または1から始まります。

例2：「bcd」という式「bcd」の場合、文字列「abcde」を一致させるとき、一致する結果は次のとおりです。一致するコンテンツは「BCD」です。一致する位置は次のとおりです。1で開始し、4で終了します。

1.2シンプルなエスケープキャラクター

書くのが不便な一部のキャラクターの場合、「/」を前面に追加する方法を使用します。私たちはすでにこれらのキャラクターに精通しています。

次の章で使用するために特別な句読点があります。 「/」を前面に追加した後、それらはシンボル自体を表します。たとえば、 ^と$には特別な意味があります。文字列内の「^」と「$」文字を一致させたい場合は、式を「/^」と「/$」と書く必要があります。

これらの脱出されたキャラクターの一致する方法は、「通常の文字」に似ています。また、同じキャラクターと一致します。

例1：式「/$ d」の場合、文字列「abc $ de」を一致させるとき、一致する結果は次のとおりです。一致するコンテンツは次のとおりです。「$ d」;一致する位置は次のとおりです。3で開始し、5で終了します。

1.3「複数の文字」に一致する可能性のある表現

正規表現のいくつかの表現方法は、「複数の文字」のいずれかに一致します。たとえば、式「/d」は任意の数と一致させることができます。それはその中のどのキャラクターにも一致することができますが、それは複数ではなく1つだけではありません。これは、ポーカーカードをプレイするときに、大小の王は任意のカードを置き換えることができますが、1枚のカードしか交換できません。

例1：式「/d/d」の場合、「ABC123」を一致させるとき、一致の結果は次のとおりです。一致したコンテンツは次のとおりです。一致した位置は次のとおりです。3で開始し、5で終了します。

例2：「AAA100」を一致させるとき、「a./d」という式の場合、一致の結果は次のとおりです。一致したコンテンツは次のとおりです。「AA1」;一致した位置は次のとおりです。1で開始し、4で終了します。

1.4「複数の文字」に一致する可能性のある式をカスタマイズする

正方形の括弧[]を使用して、それらのいずれかに一致する一連の文字を含む。 [^]を使用して一連のキャラクターを含める場合、文字以外のキャラクターと一致させることができます。同様に、それらのいずれかに一致することはできますが、複数ではなく1つだけではありません。

例1：「[bcd] [bcd]」という式が「abc123」と一致する場合、一致の結果は次のとおりです。一致したコンテンツは次のとおりです。一致した位置は次のとおりです。1で開始し、3で終了します。

例2：「[^abc]」という式が「ABC123」と一致する場合、一致の結果は次のとおりです。一致したコンテンツは次のとおりです。一致した位置は次のとおりです。3で開始し、4で終了します。

1.5一致数を変更する特別なシンボル

前の章で言及されている表現は、1人の文字または複数の文字のいずれかのみを一致させることができます。式に加えて、一致数を変更する特別なシンボルを使用する場合、式を繰り返し書くことなくマッチを繰り返すことができます。

それを使用する方法は、「変更の数」が「修正式」の後に配置されます。たとえば、「[bcd] [bcd]」は「[bcd] {2}」と書くことができます。

例1：式「/d+/.?/d*」が「$ 12.5」と一致する場合、一致の結果は次のとおりです。一致したコンテンツは次のとおりです。 "12.5";一致した位置は次のとおりです。10で開始し、14で終了します。

例2：式「go {2,8} gle」が「Goooogleによる広告」と一致する場合、一致の結果は次のとおりです。一致したコンテンツは次のとおりです。一致した位置は次のとおりです。7で開始し、17で終了します。

1.6抽象的な意味を表す他のいくつかの特別なシンボル

いくつかのシンボルは、表現の抽象化の特別な意味を表しています。

さらなるテキストの説明はまだ比較的抽象的なので、誰もが理解できるように例を挙げてください。

例1：「^aaa」という式が「xxx aaa xxx」と一致する場合、一致する結果は次のとおりです。 「^」では、文字列が始まる場所で一致する必要があるため、「^aaa」は「aaa」が文字列の先頭にある場合にのみ一致することができます。たとえば、「aaa xxx xxx」です。

例2：「aaa $」という式が「xxx aaa xxx」と一致する場合、一致する結果は次のとおりです。 「$」では文字列の端を一致させる必要があるため、「aaa $」は「aaa」が文字列の最後にある場合にのみ一致します： "xxx xxx aaa"。

例3：式「./B」の場合「@@@ABC」と一致すると、一致する結果は次のとおりです。一致するコンテンツは次のとおりです。一致する位置は次のとおりです。2で開始し、4で終了します。

さらなる説明：「/b」は「^」と「$」に似ており、文字自体と一致しませんが、一致する結果の位置の左右にある必要があります。一方は「/w」範囲で、もう一方は非 "/w"範囲です。

例4：「/bend/b」という式が週末、終了、終了」と一致するとき、一致する結果は次のとおりです。一致するコンテンツは次のとおりです。一致する位置は次のとおりです。15で開始し、18で終了します。

いくつかのシンボルは、式内のサブ発現間の関係に影響を与える可能性があります。

例5：「トム|ジャック」という表現が文字列「私はトム、彼はジャック」と一致するとき、一致する結果は次のとおりです。一致するコンテンツは次のとおりです。一致する位置は次のとおりです。4で開始し、7で終了します。次の位置と一致するとき、マッチング結果は次のとおりです。一致するコンテンツは「ジャック」です。一致する位置：15から始まり、19で終わります。

例6：式 "（go/s*）+" "let's go go！"を一致させるとき、マッチング結果は次のとおりです。一致するコンテンツは、「Go Go Go」です。一致する位置は次のとおりです。6で開始し、14で終了します。

例7：式「￥（/d+/。？/d*）」が「￥10.9、￥20.5」と一致する場合、一致の結果は成功します。一致したコンテンツは次のとおりです。一致した位置は次のとおりです。6で開始し、10で終了します。ブラケット範囲の一致を個別に取得するコンテンツは、「20.5」です。

2。正規表現のいくつかの高度なルール

2.1マッチタイムの貪欲と非グリーディ

一致数を変更する特別なシンボルを使用する場合、「{m、n}」、 "{m、}"、 "？"、 "？"、 "*"、 "+"など、同じ式が異なる時間に一致するようにするいくつかの表現方法があります。一致の特定の数は、一致する文字列によって異なります。不確実な数の繰り返し一致を伴うこの表現は、マッチングプロセス中に常にできるだけ多くの倍に一致します。たとえば、テキスト「dxxxdxxxd」については、以下は次のとおりです。

「/w+」が一致するとき、それは常にルールをできるだけ多くのキャラクターと一致させることがわかります。 2番目の例では、最後の「d」と一致しませんが、式全体を正常に一致させることでもあります。同様に、「*」と「{m、n}」を含む式は、できるだけ多く一致し、「？」での式が一致します。また、一致またはミスマッチできる場合、可能な限り「一致」されます。この一致する原則は、「貪欲」パターンと呼ばれます。

非グリーディモード：

「？」を追加する署名マッチ数の特別なシンボルを変更した後、さまざまな数の一致の一致数でできるだけ少ない式で式を作成できるため、一致またはミスマッチができる限り「一致」できるようになります。この一致する原理は、「非グリーディ」パターンとも呼ばれ、「バーブ」パターンとも呼ばれます。一致が少ない場合、表現全体が失敗します。貪欲なモードと同様に、非グリーディモードは最小範囲と一致して、式全体を正常に一致させます。たとえば、テキスト「dxxxdxxxd」の場合：

その他の場合は、次を参照してください。

例1：式「<td>（。*）</td>」が文字列に一致する場合、<td> <p> aa </p> </td> <td> <p> bb </p> </td> "、マッチング結果は次のとおりです。試合は「<td> <p> aa </p> </td>」です。文字列全体で、式の「</td>」は文字列の最後の「</td>」と一致します。

例2：対照的に、式「<td>（。*？）</td>」が例1の同じ文字列と一致する場合、「<td> <p> aa </p> </td>」のみを取得します。次のものをもう一度一致させると、2番目の「<td> <p> bb </p> </td>」が取得されます。

2.2背景 /1、 /2 ...

式が一致すると、式エンジンは、ブラケット「（）」に含まれる式に一致する文字列を記録します。一致する結果を取得するとき、括弧内に含まれる式に一致する文字列は、個別に取得できます。これは、以前の例で何度も実証されています。実際のアプリケーションでは、特定の境界を検索に使用し、取得するコンテンツに境界が含まれていない場合、括弧を使用して目的の範囲を指定する必要があります。たとえば、以前の「<td>（。*？）</td>」。

実際、「ブラケットに含まれる式に一致する文字列」は、試合が終わった後だけでなく、マッチングプロセス中にも使用できます。式の後の部分は、括弧内の以前の「一致したサブマッチ文字列」を参照できます。参照方法は、番号「/」を追加することです。 「/1」とは、括弧の最初のペアで一致する文字列を指し、「/2」は、ブラケットの2番目のペアに一致する文字列を指します。言い換えれば、ペアが左ブラケットを持っている場合、「前に、その後、ペアは最初にソートされます。

例として：

例1：式 "（ '|"）（。*？）（/1） "" hello'、 "world" "を一致させると、一致する結果は成功します。一致したコンテンツは「 'hello'"です。

例2：式「（/w）/1 {4、}」が「aa bbbb abcdefg ccccc11112111119999999999」と一致する場合、一致の結果は次のとおりです。一致したコンテンツは「CCCCCC」です。次のものをもう一度一致させると、999999999を取得します。この式では、「/w」範囲内の文字を少なくとも5回繰り返す必要があり、「/w {5、}」との違いに注意を払います。

例3：式 "<（/w+）/s*（/w+（=（ '|"）。*？/4）？/s*> 成功。

2.3事前検索、不一致。リバースプレシーチ、ミスマッチ

前の章では、「^」、「$」、「/b」という抽象的な意味を表すいくつかの特別なシンボルについて説明しました。それらはすべて共通のものを1つ持っています。彼ら自身は文字と一致しませんが、条件を「文字列の両端」または「文字間のスリット」にのみ添付します。この概念を理解した後、このセクションでは、「2つの端」または「スリット」に条件を追加する別のより柔軟な表現方法を導入し続けます。

フォワードプレシーチ： "（？= xxxxx）、"（？！xxxxx） "

形式：「（？= xxxxx）」、一致する文字列で、「スリット」または「両端」に付随する条件は、ギャップの右側がxxxxx部分の式と一致する必要があることです。このギャップの追加の条件であるため、このギャップの後にキャラクターを真に一致させるための後続の表現に影響しません。これは「/b」に似ており、キャラクター自体と一致しません。 「/b」は、ギャップの前後にキャラクターを取り、判断を下し、真に一致するために背後の表現に影響を与えません。

例1：「Windows（？= nt | xp）」という式が「Windows 98、Windows NT、Windows 2000」と一致する場合、「Windows NT」の「Windows」のみに一致し、他の単語「Windows」は一致しません。

例2：式 "（/w）（（？=/1/1/1）（/1））+" string "aaa ffffff 999999999"を一致させると、6 "Fの最初の4" F "と9" 9 "の最初の7を一致させることができます。この式は読み取り、次のように解釈できます。3桁以上の英数字数を繰り返すと、最後の2桁の前のパーツと一致します。もちろん、この表現はこのように書くことはできません。ここでの目的はデモンストレーションの目的です。

形式： "（？！xxxxx）"、ギャップの右側はxxxxx式と一致してはなりません。

例3：式 "（？！/bstop/b）。）+" "fdjka ljfdl stop fjdsla fdj"を一致させると、「停止」の前に最初から位置に一致します。文字列に「停止」がない場合、文字列全体が一致します。

例4：「do（？！/w）」という式は、文字列「do、do、do」を一致させるときにのみ「do」と一致させることができます。この記事では、「do」の後に「do」（？！/w）を使用して「/b」を使用する効果は同じです。

リバースプレシーチ： "（？<= xxxxx）"、 "（？<！xxxxx）"

これらの2つの形式の概念は、フォワードプレシーチャーに似ています。逆の事前検索の要件は次のとおりです。ギャップの「左側」。 2つの形式では、右側を判断するのではなく、指定された式を一致させ、一致させないことが必要です。 「Forward Pre-Search」のように：どちらも、それらが位置するギャップに対する追加の条件であり、キャラクター自身と一致しません。

例5：式 "（？<=/d {4}）/d+（？=/d {4}）" "1234567890123456"を一致させると、最初の4つの数字を除く中央の8の数字と最後の4つの数値が一致します。 jscript.regexpはリバースプレシーチャーをサポートしていないため、この記事は実証できません。他の多くのエンジンは、java.util.regexパッケージ上のjava.util.regexパッケージ、system.text.regularexpressionsの名前空間、このサイトで推奨される最も簡単で最も簡単なdeelx通常のエンジンなど、リバースプレシーチをサポートできます。

3。その他の一般的なルール

また、さまざまな正規表現エンジンの間でより一般的なルールもいくつかありますが、これは前の説明では言及されていません。

3.1式では、「/xxx」および「/uxxxx」を使用して文字を表すことができます（ "x"は16進数を意味します）

3.2式「/s」、「/d」、「/w」、「/b」は特別な意味を表しますが、対応する大文字は反対の意味を表します

3.3表現には特別な意味があり、文字自体の文字概要を一致させるために「/」を追加する必要があります。

3.4括弧内のサブエクスペッション "（）"。将来の使用のために一致する結果を記録しないようにしたい場合は、「（？：xxxxx）」形式を使用できます

例1：式 "（？：（/w）/1）+「bbccdd efg」と一致する場合、結果は「bbccdd」になります。ブラケット「（？:)」範囲の一致する結果は記録されていないため、 "（/w）"を参照するために使用されます。

3.5一般的に使用される式属性属性の概要設定：IngreCase、Singleline、Multiline、Global

4。その他のヒント

4.1高度な通常のエンジンも複雑な通常の構文をサポートしていることを理解したい場合は、このサイトのDEELX通常のエンジンのドキュメントを参照してください。

4.2文字列全体に一致するように式を要求する場合は、文字列から部分を見つける代わりに、式の最初と最後に「^」と「$」を使用できます。たとえば、「^/d+$」では、文字列全体に数値のみが必要です。

4.3一致するコンテンツが単語の一部ではなく完全な単語である場合、式の最初と終わりに「/b」を使用します。たとえば、「/b（whif| whif -while| void|int..)/b」を使用して、プログラムのキーワードを一致させます。

4.4式は空の文字列と一致しません。それ以外の場合、試合は常に成功し、何も一致しません。たとえば、「123」、「123。」、「123.5」、「.5」などに一致する式を書く準備をしている場合、整数、小数点、小数点、小数点は省略できますが、「/d*/./d*」という表現を書きません。それを書くためのより良い方法は、 "/d+/.?/d*|/./D+"です。

4.5空の文字列に一致するサブマッチの場合、無限にループしないでください。括弧内のサブエクスペッションの各部分が0回一致し、ブラケット全体が無限に一致する場合がある場合、状況は前の記事よりも深刻である可能性があり、マッチングプロセスはデッドループである可能性があります。いくつかの正規表現エンジンは、.NETの正規表現など、この状況では死んだループを避けていますが、この状況を避けようとする必要があります。表現を書くときにデッドループに遭遇した場合、この観点から始めて、これがこの記事で言及されている理由であるかどうかを調べることもできます。

4.6貪欲なモードと非グリーディモードを合理的に選択してください。トピックのディスカッションを参照してください。

4.7または「|」左側と右側では、特定のキャラクターの片側のみのみを一致させるのが最善です。そうすれば、「|」の両側の表現が交換位置のために違いはありません。

Next article-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1。正規表現を定義します

1）正規表現の定義には2つの形式があります。1つは通常の方法で、もう1つはコンストラクターメソッドです。

2）通常の方法：var reg =/expression/追加パラメーター

式：特定のルールを表す文字列。特定の特殊文字を使用して特別なルールを表すことができます。これについては、後で詳しく説明します。

追加のパラメーター：式の意味を拡張するために使用されます。現在、3つの主要なパラメーターがあります。

G：グローバルマッチングを実行できることを意味します。

I：症例の鈍感なマッチングを意味します。

M：複数の行のマッチングを実行できることを意味します。

上記の3つのパラメーターを任意に組み合わせて複合意味を表すことができます。もちろん、パラメーターは追加されていません。

例：

var reg =/a*b/;

var reg =/abc+f/g;

3）コンストラクター方法：var reg = new regexp（ "expression"、 "パラメーターの追加"）;

「式」と「追加のパラメーター」の意味は、上記の定義方法と同じです。

例：

var reg = new regexp（ "a*b"）;

var reg = new regexp（ "abc+f"、 "g"）;

4）通常の方法とコンストラクターの方法の違い

通常の方法での式は一定の文字列でなければなりませんが、コンストラクターの式は、ユーザーの入力などに基づく式パラメーターなど、一定の文字列またはJS変数になります。

var reg = new regexp（document.forms [0] .exprfiled.value、 "g"）;

2。発現パターン

1）式パターンとは、式の表現方法とスタイル、つまり、var reg =/式/追加パラメーターの「式」をどのように説明するかを指します。

2）標準化された観点から、式パターンは単純なパターンと複合パターンに分割されます。

3）単純なパターン：たとえば、通常の文字の組み合わせで表現されたパターンを指します

var reg =/abc0d/;

単純なパターンは特定の一致のみを表すことができることがわかります。

4）複合パターン：ワイルドカード文字で表現されたパターンを指します。

var reg =/a+b？/w/;

+、？および /wはすべてワイルドカードのキャラクターであり、特別な意味を表しています。したがって、複合パターンは、より抽象的なロジックを表現できます。

複合モードでの各ワイルドカードの意味と使用に焦点を当てましょう。

5）複合モードの特殊文字の説明：

1>/：多くのプログラミング言語でエスケープキャラクターとして使用されます。一般的に言えば

/シンボルの後に通常の文字cが続く場合、 / cは特別な意味を表します。たとえば、nは元々文字nを表しますが、 /nは新しい線を表します。

/シンボルの後に特殊文字cが続く場合、 / cは通常の文字cを表します。たとえば、 /は一般にエスケープキャラクターとして使用されますが、//は通常の文字 /をチューニングするために使用されます。

JavaScriptの正規表現の使用は上記と同じですが、さまざまなプログラミング言語では、特別な文字テーブルが異なる場合があります。

2>^：入力文字列の先頭に一致します。マルチラインの一致、つまり、式の追加パラメーターにはMが含まれている場合、新しいラインの後にも一致します。

例：

/^b/「BAB BC」の最初のbを一致させる

例2：

/^b/gmマッチング

「バッドb

cdaf

b dsfb "

最初のbの最初の行、3行目の最初のb

3> $：入力文字作成の終わりを一致させます。マルチラインの一致、つまり、式の追加パラメーターにはMが含まれている場合、新しいラインの前にも一致します。

^の使用に反して。

例： / t $ /「bat」でtを一致させますが、「憎しみ」でtを一致させません

例2： /t $ /一致

「タグ

バット"

最初の行の最後のtと2行目のt。

4>*：前の文字を0回以上一致させます。

例： /ab* /「dddabbbbc」の「abbbb」を一致させ、「ddda」の「a a」も一致させます

5>+：前の文字を1回以上一致させます。

例： / ab+ /「dddabbbbc」の「abbbb」を一致させますが、「ddda」と一致しません

次の{1、}（プロトタイプ：{n、}）の使用と同様

6>？：の使用？かなり特別です。一般的に言えば、前の文字を0回または1回一致させるために使用されますが、他にも2つの特別な用途があります。

すぐに *、 +、？ {}、たとえば、元の一致の最小試合数を意味します。

/ ba*/「bbbaaaa」で「baaaa」を元々一致させたが、/ ba*？/「bbbaaaa」で「b」を一致させた（*が0以上の一致を意味し、プラスは？

同様に： / ba+？ /「baaaa」の「ba」を一致させます。

構文構造シンボルとして、プリアサート、つまりx（？= y）およびx（？！= y）で使用されます。

7>。：「。」小数点内のサインインは、NewLine文字を除き、単一の文字と一致します。

合計で標準のキャラクターは何ですか？参照してください：文字セット

たとえば、 / AB /「ACBA」の「ACB」を「ACBAA」と一致させますが、「ABB」と一致しません。

8>（x）：xを一致させることを意味します（文字xを具体的に参照していないか、xを特に参照するのではなく、xは文字列を表します）、試合は記憶されます。構文では、この種の（）は「親のキャプチャ」、つまりキャプチャに使用されるブラケットと呼ばれます。

式によって提供される関数では、一部の関数がexec（）関数などのすべての一致する文字列を保持する配列を返すため、一致が記憶されています。

また、x in（）が記憶されているという前提は、xと一致することであることに注意してください。

例1：

var regx =/a（b）c/;

var rs = regx.exec（ "abcddd"）;

上記からわかるように、 / a（b）c /「abcddd」の「abc」と一致します。 （）のために、Bはそれを記録するため、Rsによって返される数のコンテンツは次のとおりです。

{ABC、B}

例2：

var regx =/a（b）c/;

var rs = regx.exec（ "acbcddd"）;

RSはnullを返します。なぜなら、 / a（b）c /は「acbcddd」と一致しないため、b in（）は記録されません（ただし、文字列にはbが含まれています）

9>（？：x）：xを一致させますが、xを覚えていません。 （）この形式では、「非キャプチャの親」、つまりキャプチャのないブラケットと呼ばれます。

例：

var regx =/a（？：b）c/;

var rs = regx.exec（ "abcddd"）;

上記からわかるように、 / a（？：b）c /は「abcddd」の「abc」と一致します。

{ABC}

10> x（？= y）：yがすぐに従う場合のみxを一致させます。マッチが一致する場合、xのみが記憶され、yは記憶されません。

例：

var regx =/user（？= name）/;

var rs = regx.exec（ "ユーザー名はメアリー"）;

結果：試合は成功し、RSの値は{ユーザー}です

11> x（？！y）：yがすぐに追跡されない場合にのみxを一致させます。マッチが一致する場合、xのみが記憶され、yは記憶されません。

例：

var regx =/user（？！name）/;

var rs = regx.exec（ "ユーザー名はメアリー"）;

結果：試合は成功し、RSの値は{ユーザー}です

例2：

var regx = // d+（？！/。）/;

var rs=regx.exec(“54.235”);

Result: The matching result, the value of rs is {5}, and the mismatch is because 54 is followed by the "."サイン。 Of course, 235 also matches, but due to the behavior of the exec method, 235 will not be returned.

12>x|y：匹配x或y。注意如果x和y都匹配上了，那么只记住x。

例：

var regx=/beijing|shanghai/;

var rs=regx.exec(“I love beijing and shanghai”);

结果：匹配成功，rs的值为{beijing}，虽然shanghai也匹配，但不会被记住。

13>{n}：匹配前一个字符的n次出现。

n必须是一个非负数，当然如果是一个负数或小数也不会报语法错误。

例：

var regx=/ab{2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

14>{n,}：匹配前一个字符的至少n次出现。

例：

var regx=/ab{2,}c/;

var rs=regx.exec(“abbcdabbbc”);

结果：匹配成功，rs的值为：{abbc}。注意为什么abbbc也符合条件为什么没有被记住，这与exec方法的行为有关，后面会统一讲解。

15>{n,m}：匹配前一个字符的至少n次最多m次的出现。

只要n与m为数字，而且m>=n就不会报语法错误。

例：

var regx=/ab{2,5}c/;

var rs=regx.exec(“abbbcd”);

结果：匹配成功，rs的值为：{abbbc}。

例2：

var regx=/ab{2,2}c/;

var rs=regx.exec(“abbcd”);

结果：匹配成功，rs的值为：{abbc}。

例子3：

var regx=/ab(2,5)/;

var rs=regx.exec(“abbbbbbbbbb”);

Result: The match is successful, and the value of rs is: {abbbbb}, which means that if the previous character appears more than m times, it will only match m times.加えて：

var regx=/ab(2,5)c/;

var rs=regx.exec(“abbbbbbbbbbc”);

结果：匹配失败，rs的值为：null，为什么匹配失败，因为b多于5个则b(2,5)会匹配前5个b，，而表达式/ab(2,5)c/中b后面是c，但字符串中5个b之后还是b所以会报错。

16>[xyz]：xyz表示一个字符串，该模式表示匹配[]中的一个字符，形式上[xyz]等同于[xz]。

例：

var regx=/a[bc]d/;

var rs=regx.exec(“abddgg”);

结果：匹配成功，rs的值为：{abd}

例2：

var regx=/a[bc]d/;

var rs=regx.exec(“abcd”);

结果：匹配失败，rs的值为：null，之所以失败，是因为[bc]表示匹配b或c中的一个，但不会同时匹配。

17>[^xyz]：该模式表示匹配非[]中的一个字符，形式上[^xyz]等同于[^xz]。

例：

var regx=/a[^bc]d/;

var rs=regx.exec(“afddgg”);

结果：匹配成功，rs的值为：{afd}

例2：

var regx=/a[^bc]d/;

var rs=regx.exec(“abd”);

结果：匹配失败，rs的值为：。

18>[/b]：匹配退格键。

19>/b：匹配一个词的边界符，例如空格和换行符等等，当然匹配换行符时，表达式应该附加参数m。

例：

var regx=//bc./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ci}，注意c前边的空格不会匹配到结果中，即{ ci}是不正确的。

20>/B：代表一个非单词边界。

例：

var regx=//Bi./;

var rs=regx.exec(“Beijing is a beautiful city”);

结果：匹配成功，rs的值为：{ij}，即匹配了Beijing中的ij。

21>/cX，匹配一个控制字符。例如， /cM 匹配一个Control-M 或

回车符。 x 的值必须为AZ 或az 之一。否则，将c 视为一

个原义的'c' 字符。（实际的例子还需补充）

21>/d：匹配一个数字字符，等同于[0-9]。

例：

var regx=/user/d/;

var rs=regx.exec(“user1”);

结果：匹配成功，rs的值为：{user1}

22>/D：匹配一个非数字字符，等同于[^0-9]。

例：

var regx=/user/D/;

var rs=regx.exec(“userA”);

结果：匹配成功，rs的值为：{userA}

23>/f：匹配一个换页符。

24>/n：匹配一个换行符。因为是换行符，所以在表达式中要加入m参数。

例：

var regx=/a/nbc/m;

var str=“a

紀元前";

var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

25>/r：匹配一个回车符

26>/s：匹配一个空格符，等同于[ /f/n/r/t/v/u00A0/u2028/u2029].

例：

var regx=//si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ i}

27>/S：匹配一个非空格符，等同于[ ^/f/n/r/t/v/u00A0/u2028/u2029].

例：

var regx=//Si/;

var rs=regx.exec(“Beijing is a city”);

结果：匹配成功，rs的值为：{ei}

28>/t：匹配一个tab

例：

var regx=/a/tb/;

var rs=regx.exec(“a bc”);

结果：匹配成功，rs的值为： {a bc}

29>/v：匹配一个竖向的tab

30>/w：匹配一个数字、_或字母表字符，即[A-Za-z0-9_ ]。

例：

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{2}

31>/W：匹配一个非数字、_或字母表字符，即[^A-Za-z0-9_ ]。

例：

var regx=//w/;

var rs=regx.exec(“$25.23”);

结果：匹配成功，rs的值为：{$}

32>/n：注意不是/n，这里n是一个正整数，表示匹配第n个()中的字符。

例：

var regx=/user([,-])group/1role/;

var rs=regx.exec(“user-group-role”);

结果：匹配成功，rs的值为：{user-group-role,-}，同样对user,group,role的匹配也是成功的，但像user-group,role等就不对了。

33>/0：匹配一个NUL字符。

34>/xhh：匹配一个由两位16进制数字所表达的字符。

35>/uhhhh：匹配一个由四位16进制数字所表达的字符。

3，表达式操作

1）表达式操作，在这里是指和表达式相关的方法，我们将介绍六个方法。

2）表达式对象（RegExp）方法：

1>exec(str)，返回str中与表达式相匹配的第一个字符串，而且以数组的形式表现，当然如果表达式中含有捕捉用的小括号，则返回的数组中也可能含有()中的匹配字符串，例如：

var regx=//d+/;

var rs=regx.exec(“3432ddf53”);

返回的rs值为：{3432}

var regx2=new RegExp(“ab(/d+)c”);

var rs2=regx2.exec(“ab234c44”);

返回的rs值为：{ab234c,234}

In addition, if there are multiple suitable matches, exec is executed for the first time and exec is continued, the second and third matches are returned in turn.例えば：

var regx=/user/d/g;

var rs=regx.exec(“ddduser1dsfuser2dd”);

var rs1=regx.exec(“ddduser1dsfuser2dd”);

则rs的值为{user1}，rs的值为{rs2}，当然注意regx中的g参数是必须的，否则无论exec执行多少次，都返回第一个匹配。后面还有相关内容涉及到对此想象的解释。

2>test(str), determines whether the string str matches the expression, and returns a boolean value.例えば：

var regx=/user/d+/g;

var flag=regx.test(“user12dd”);

flag的值为true。

3）String对象方法

1>match(expr)，返回与expr相匹配的一个字符串数组，如果没有加参数g，则返回第一个匹配，加入参数g则返回所有的匹配

例：

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.match(regx);

rs的值为：{user1,user3}

2>search(expr)，返回字符串中与expr相匹配的第一个匹配的index值。

例：

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.search(regx);

rs的值为：0

3>replace(expr,str)，将字符串中匹配expr的部分替换为str。另外在replace方法中，str中可以含有一种变量符号$，格式为$n，代表匹配中被记住的第n的匹配字符串（注意小括号可以记忆匹配）。

例：

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为：003userddd0045

例2：

var regx=/u(se)r/d/g;

var str=“user13userddduser345”;

var rs=str.replace(regx,”$1”);

rs的值为：se3userdddse45

对于replace(expr,str)方法还要特别注意一点，如果expr是一个表达式对象则会进行全局替换（此时表达式必须附加参数g，否则也只是替换第一个匹配），如果expr是一个字符串对象，则只会替换第一个匹配的部分，例如：

var regx=“user”

var str=“user13userddduser345”;

var rs=str.replace(regx,”00”);

rs的值为： 0013userddduser345

4>split(expr)，将字符串以匹配expr的部分做分割，返回一个数组，而且表达式是否附加参数g都没有关系，结果是一样的。

例：

var regx=/user/d/g;

var str=“user13userddduser345”;

var rs=str.split(regx);

rs的值为：{3userddd,45}

4，表达式相关属性

1）表达式相关属性，是指和表达式相关的属性，如下面的形式：

var regx=/myexpr/;

var rs=regx.exec(str);

其中，和表达式自身regx相关的属性有两个，和表达式匹配结果rs相关的属性有三个，下面将逐一介绍。

2）和表达式自身相关的两个属性：

1>lastIndex，返回开始下一个匹配的位置，注意必须是全局匹配（表达式中带有g参数）时，lastIndex才会有不断返回下一个匹配值，否则该值为总是返回第一个下一个匹配位置，例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex1=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex2=regx.lastIndex;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var lastIndex3=regx.lastIndex;

上面lastIndex1为9，第二个lastIndex2也为9，第三个也是9；如果regx=/user/d/g，则第一个为9，第二个为18，第三个为0。

2>source, return the expression string itself.例えば：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var source=regx.source;

source的值为user/d

3）和匹配结果相关的三个属性：

1>index, return the current matching position.例えば：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var index1=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index2=rs.index;

rs=regx.exec(“sdsfuser1dfsfuser2”);

var index3=rs.index;

index1为4，index2为4，index3为4，如果表达式加入参数g，则index1为4，index2为13，index3会报错（index为空或不是对象）。

2>input, used for matching strings.例えば：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var input=rs.input;

input的值为sdsfuser1dfsfuser2。

3>[0]，返回匹配结果中的第一个匹配值，对于match而言可能返回一个多值的数字，则除了[0]外，还可以取[1]、[2]等等。例如：

var regx=/user/d/;

var rs=regx.exec(“sdsfuser1dfsfuser2”);

var value1=rs[0];

rs=regx.exec(“sdsfuser1dfsfuser2”);

var value2=rs[0];

value1的值为user1,value2的值为user2

5，实际应用

1）实际应用一

描述：有一表单，其中有一个“用户名”input域

要求：汉字，而且不能少于2个汉字，不能多于4个汉字。

成し遂げる：

 <script>function checkForm(obj){ var username=obj.username.value; var regx=/^[/u4e00-/u9fa5]{2,4}$/g if(!regx.test(username)){ alert(“Invalid username!”); return false; } return true;}</script><form name=“myForm”onSubmit=“return checkForm(this)”> <input type=“text” name=“username”/> <input type=“submit” vlaue=“submit”/></form>

2）实际应用二

描述：给定一个含有html标记的字符串，要求将其中的html标记去掉。

成し遂げる：

 <script>function toPlainText(htmlStr){ var regx=/<[^>]*>|<//[^>]*>/gm; var str=htmlStr.replace(regx,""); return str;}</script><form name=“myForm”> <textarea id=“htmlInput”></textarea> <input type=“button” value=“submit” onclick=“toPlainText(document.getElementById('htmlInput').value”/></form>

三，小结

1，Javascript正则表达式，我想在一般的程序员之中，使用者应该不是很多，因为我们处理的页面一般都不是很复杂，而复杂的逻辑一般我们都在后台处理完成了。但是目前趋势已经出现了扭转，富客户端已经被越来越多的人接受，而Javascript就是其中的关键技术，对于复杂的客户端逻辑而言，正则表达式的作用也是很关键的，同时它也是Javascript高手必须要掌握的重要技术之一。

2，为了能够便于大家对前面讲述的内容有一个更为综合和深刻的认识，我将前面的一些关键点和容易犯糊涂的地方再系统总结一下，这部分很关键！

总结1：附件参数g的用法

表达式加上参数g之后，表明可以进行全局匹配，注意这里“可以”的含义。我们详细叙述：

1) For the exec method of the expression object, if g is not added, it will only return the first match, no matter how many times it is executed, if g is added, the first execution will also return the first match, and then the execution will return the second match, and so on.例えば

var regx=/user/d/;

var str=“user18dsdfuser2dsfsd”;

var rs=regx.exec(str);//此时rs的值为{user1}

var rs2=regx.exec(str);//此时rs的值依然为{user1}

如果regx=/user/d/g；则rs的值为{user1}，rs2的值为{user2}

通过这个例子说明：对于exec方法，表达式加入了g，并不是说执行exec方法就可以返回所有的匹配，而是说加入了g之后，我可以通过某种方式得到所有的匹配，这里的“方式”对于exec而言，就是依次执行这个方法即可。

2）对于表达式对象的test方法，加入g于不加上g没有什么区别。

3) For the match method of the String object, g is not added, and it only returns the first match. If the match method is executed all the time, it always returns the first match. If g is added, then all matches will be returned at once (note that this is different from the exec method of the expression object. For exec, even if g is added, all matches will not be returned at once).例えば：

var regx=/user/d/;

var str=“user1sdfsffuser2dfsdf”;

var rs=str.match(regx);//此时rs的值为{user1}

var rs2=str.match(regx);//此时rs的值依然为{user1}

如果regx=/user/d/g，则rs的值为{user1,user2}，rs2的值也为{user1,user2}

4）对于String对象的replace方法，表达式不加入g，则只替换第一个匹配，如果加入g，则替换所有匹配。（开头的三道测试题能很好的说明这一点）

5）对于String对象的split方法，加上g与不加g是一样的，即：

var sep=/user/d/;

var array=“user1dfsfuser2dfsf”.split(sep);

则array的值为{dfsf, dfsf}

此时sep=/user/d/g，返回值是一样的。

6）对于String对象的search方法，加不加g也是一样的。

总结2：附加参数m的用法

附加参数m，表明可以进行多行匹配，但是这个只有当使用^和$模式时才会起作用，在其他的模式中，加不加入m都可以进行多行匹配（其实说多行的字符串也是一个普通字符串），我们举例说明这一点

1）使用^的例子

var regx=/^b./g;var str=“bd76 dfsdf sdfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时加入g和不加入g，都只返回第一个匹配{bd}，如果regx=/^b./gm，则返回所有的匹配{bd,b7}，注意如果regx=/^b./m，则也只返回第一个匹配。所以，加入m表明可以进行多行匹配，加入g表明可以进行全局匹配，综合到一起就是可以进行多行全局匹配

2）使用其他模式的例子，例如

var regx=/user/d/;var str=“sdfsfsdfsdf sdfsuser3 dffs b76dsf user6”;var rs=str.match(regx);

此时不加参数g，则返回{user3}，加入参数g返回{user3,user6}，加不加入m对此没有影响。

3）因此对于m我们要清楚它的使用，记住它只对^和$模式起作用，在这两种模式中，m的作用为：如果不加入m，则只能在第一行进行匹配，如果加入m则可以在所有的行进行匹配。我们再看一个^的例子

var regx=/^b./;var str=“ret76 dfsdf bjfsdfs dffs b76dsf sdfsdf”;var rs=str.match(regx);

此时rs的值为null，如果加入g，rs的值仍然为null，如果加入m，则rs的值为{bj}（也就是说，在第一行没有找到匹配，因为有参数m，所以可以继续去下面的行去找是否有匹配），如果m和g都加上，则返回{bj,b7}（只加m不加g说明，可以去多行进行匹配，但是找到一个匹配后就返回，加入g表明将多行中所有的匹配返回，当然对于match方法是如此，对于exec呢，则需要执行多次才能依次返回）

总结3：

在HTML的textarea输入域中，按一个Enter键，对应的控制字符为“/r/n”，即“回车换行”，而不是“/n/r”，即“换行回车”，我们看一个前面我们举过的例子：

 var regx=/a/r/nbc/;var str=“a bc”;var rs=regx.exec(str);

结果：匹配成功，rs的值为：{ }，如果表达式为/a/n/rbc/，则不会被匹配，因此在一般的编辑器中一个”Enter”键代表着“回车换行”，而非“换行回车”，至少在textarea域中是这样的。

The above article briefly discusses the use of RegExp objects and brackets for JS regular expressions is all the content I share with you.私はそれがあなたに参照を与えることができることを願っています、そしてあなたがwulin.comをもっとサポートできることを願っています。