Normal ifade, bir karakter desenini tanımlayan bir nesnedir. JavaScript'teki RegExp sınıfı, normal ifadeleri temsil eder ve String ve RegExp sınıflarının nesneleri, kalıp eşleştirme ve metin değiştirme işlemlerini gerçekleştirmek için normal ifadeleri kullanan yöntemleri tanımlar.

Normal ifadeler, gelen verileri işlemek için güçlü bir araçtır. Metin değiştirme veya arama gerektiren bir görev, bu “dil içinde dil” ile güzel bir şekilde çözülebilir.

oluşturma

JavaScript'te normal ifadeler, RegExp nesneleri tarafından temsil edilir. RegExp nesneleri, RegExp() yapıcısı kullanılarak oluşturulabilir, ancak daha sıklıkla özel değişmez sözdizimi kullanılarak oluşturulurlar. Oluşturmanın yolları:

// Bir normal ifade değişmezi kullanma: var re = /ab+c/;

Normal ifade değişmezleri, komut dosyası ayrıştırıldığında normal ifadenin önceden derlenmesine neden olur.

// RegExp nesnesinin yapıcı işlevinin çağrılması var re = new RegExp("ab+c");

Yapıcıyı kullanmak, normal ifadenin komut dosyası zamanında derlenmesini gerektirir. Kullanmak Bu taraftan ifadenin değişeceği biliniyorsa gereklidir.

Normal ifadede özel karakterler

\ – Normal karakterler için onları özel kılar. Örneğin, /s/ ifadesi sadece 's' karakterini arar. Ve s'nin önüne \ koyarsanız, /\s/ zaten bir boşluk karakteri anlamına gelir.

^ – Giriş verilerinin başlangıcını gösterir. Çok satırlı arama bayrağı (“m”) ayarlanmışsa, başlangıçta da çalışacaktır. Yeni hat.

$ – Girilen verilerin sonunu gösterir. Çok satırlı arama bayrağı ayarlanmışsa, satırın sonunda da çalışacaktır.

* – 0 veya daha fazla kez tekrarı ifade eder. Örneğin, /bo*/ "Bir hayalet booooed" içinde 'boooo' ve "Bir kuş öttü" içinde 'b' bulur, ancak "Bir keçi homurdandı" içinde hiçbir şey bulamaz.

+ – 1 veya daha fazla kez tekrarı ifade eder. (1,) ile eşdeğerdir. Örneğin, /a+/ 'şeker'de 'a'yı ve 'caaaaaaaandy'de tüm 'a'yı bulacaktır.

? – Elemanın mevcut olabileceğini veya olmayabileceğini gösterir.

. – (Ondalık nokta) yeni satır dışındaki herhangi bir karakteri belirtir: \n \r \u2028 veya \u2029. (yeni satırlar dahil herhangi bir karakteri aramak için [\s\S] kullanabilirsiniz).

(x)– x'i bulur ve hatırlar. Buna "parantezleri hatırla" denir. Örneğin, /(foo)/, "foo bar"da "foo"yu bulacak ve hatırlayacaktır. Bulunan alt dizi, arama sonucu dizisinde veya RegExp nesnesinin önceden tanımlanmış özelliklerinde depolanır: $1, …, $9.

(?:x)– x'i bulur, ancak ne bulduğunu hatırlamaz. Buna "hatırlanmayan parantezler" denir. Bulunan alt dize, sonuç dizisinde ve RegExp özelliklerinde saklanmaz. Tüm parantezler gibi, içindekileri tek bir alt modelde birleştirin.

x(?=y)– Yalnızca x'in ardından y geliyorsa x'i bulur. Örneğin, /Jack(?=Sprat)/ yalnızca 'Jack'i, ardından 'Sprat' geliyorsa bulur. /Jack(?=Sprat|Frost)/ yalnızca 'Jack' ile, ardından 'Sprat' veya 'Frost' geliyorsa eşleşir. Ancak, arama sonucunda ne 'Çaça' ne de 'Don' görünmez.

x(?!y)– Yalnızca x'in ardından y yoksa x'i bulur. Örneğin, /\d+(?!\.)/ yalnızca bir sayıyı bir ondalık nokta izlemiyorsa eşleştirir. /\d+(?!\.)/.exec(“3.141”) 141'i bulur ancak 3.141'i bulamaz.

x|y– x veya y'yi bulur. Örneğin, /green|red/, "yeşil elma"daki 'yeşil' ve "kırmızı elma"daki 'kırmızı' ile eşleşir.

(n)– Pozitif bir tam sayı. Önceki öğenin tam olarak n tekrarını bulur.

(n,)– Pozitif bir tam sayı. Bir öğenin n veya daha fazla örneğini bulur.

(n,m)- Pozitif tam sayılar. Bir elemanın n'den m'ye tekrarını bulun.

- Karakter seti. Listelenen karakterlerden herhangi birini bulur. Bir tire kullanarak bir yayılma alanı belirtebilirsiniz. Örneğin, ile aynıdır.

[^xyz]– Kümede belirtilenler dışında herhangi bir karakter. Ayrıca bir aralık belirtebilirsiniz. Örneğin, [^abc], [^a-c] ile aynıdır.

[\B]– Bir geri alma karakteri bulur.

\B– Kelimelerin (Latince) sınırlarını bulur.

\B– Kelime sınırı olmadığını belirtir. Örneğin, /\w\Bn/ "öğlen"de "on" ile eşleşir ve /y\B\w/ "muhtemelen dün"de "ye" ile eşleşir.

\cX– X, A'dan Z'ye bir harftir. Bir dizgede bir kontrol karakteri belirler. Örneğin, /\cM/ Ctrl-M karakterini temsil eder.

\D– Herhangi bir alfabeden bir sayı bulur.

\D– Sayısal olmayan bir karakter bulur (tüm harfler). [^0-9] normal rakamların karşılığıdır.

\f,\r,\n– Eşleşen özel karakterler form besleme, satır besleme, satır besleme.

\s– Boşluklar, sekmeler, yeni satırlar ve diğer unicode boşluk karakterleri dahil olmak üzere herhangi bir boşluk karakteriyle eşleşir.

\S– Boşluk dışında herhangi bir karakterle eşleşir.

\T- Sekme karakteri.

\v– Dikey sekme karakteri.

\w– Harfler, sayılar ve alt çizgiler dahil olmak üzere herhangi bir (Latin) kelime karakteriyle eşleşir. Eşittir .

\W– Herhangi bir (Latin olmayan) kelime karakteriyle eşleşir. [^A-Za-z0-9_] ile eşdeğerdir.

\0 – NUL karakterini bulur.

\xhh– hh (2 onaltılık basamak) kodlu karakteri arar.

\uhhhh– hhhh (4 onaltılık basamak) kodlu karakteri arar.

Bayraklar

Normal ifade bayrakları, üst düzey desen eşleştirme kurallarını tanımlar. Normal ifade dilbilgisinin geri kalanından farklı olarak, bayraklar eğik çizgi karakterleri arasında değil, ikincisinden sonra belirtilir. JavaScript dili üç bayrağı destekler.

bayrak Bence desen eşleştirmenin büyük/küçük harfe duyarsız olması gerektiğini belirtir ve bayrak G– aramanın global olması gerektiği, yani dizedeki tüm eşleşmeler bulunmalıdır. bayrak mçok satırlı modda bir desen araması gerçekleştirir. Aranan dize ifadesi yeni satırlar içeriyorsa, bu modda ^ ve $ bağlantı karakterleri, tüm dize ifadesinin başlangıcını ve sonunu eşleştirmenin yanı sıra her metin satırının başlangıcını ve sonunu da eşleştirir. Bayraklar herhangi bir kombinasyonda birleştirilebilir.

Dize sınıfı yöntemleri

Dizeler, normal ifadeler kullanan dört yöntemi destekler.

arama() yöntemi

Argüman olarak normal bir ifade alır ve bulunan alt dizenin ilk karakterinin konumunu veya eşleşme bulunamazsa -1'i döndürür. Örneğin, aşağıdaki çağrı 4 döndürür:

Varresult = "JavaScript".search(/script/i); // 4

search() yöntemi argümanı normal bir ifade değilse, önce RegExp yapıcısına iletilerek dönüştürülür. search() yöntemi genel aramaları desteklemez ve bayrağı yok sayar G senin argümanında.

replace() yöntemi

Bir arama ve değiştirme işlemi gerçekleştirir. İlk argümanı olarak normal bir ifade ve ikinci argümanı olarak bir yedek dize alır. Yöntem, belirtilen kalıpla eşleşmesi için çağrıldığı dizeyi arar. Normal ifade g bayrağını içeriyorsa, replace() yöntemi, bulunan tüm eşleşmeleri değiştirme dizesiyle değiştirir. Aksi takdirde, yalnızca bulunan ilk eşleşmenin yerini alır.

maç() yöntemi

Tek argümanı olarak normal bir ifadeyi alır (veya argümanını RegExp() yapıcısına ileterek normal ifadeye dönüştürür) ve arama sonuçlarını içeren bir dizi döndürür. Normal ifadede g bayrağı ayarlanırsa, yöntem dizede bulunan tüm eşleşmelerin bir dizisini döndürür. Örneğin:

// ["1", "2", "3"] döndürür var sonuç = "1 artı 2 eşittir 3".match(/\d+/g);

Normal ifade g bayrağını içermiyorsa, match() yöntemi genel bir arama gerçekleştirmez; sadece ilk eşleşmeyi arar. Ancak match(), yöntem genel bir arama yapmasa bile bir dizi döndürür. Bu durumda, dizinin ilk öğesi bulunan alt dizedir ve kalan tüm öğeler normal ifadenin alt ifadeleridir.

split() yöntemi

Bu yöntem, sınırlayıcı olarak bağımsız değişkeni kullanarak çağrıldığı dizeyi bir dizi alt dizeye böler. Örneğin:

"123.456,789".split(","); // ["123","456","789"] döndürür

split() yöntemi ayrıca argüman olarak normal bir ifade alabilir. Bu, yöntemi daha güçlü hale getirir.

normal ifade nesnesi

RegExp() yapıcısı bir veya iki dize argümanı alır ve yeni bir RegExp nesnesi oluşturur. Yapıcıya yönelik ilk argüman, normal ifadenin gövdesini içeren bir dizedir, yani. normal ifade değişmezinde eğik çizgiler arasında görünmesi gereken metin. RegExp() için ikinci argüman eksik olabilir. Belirtilirse, normal ifade bayraklarını belirtir. karakterlerden biri olmalı g, ben, m veya bu karakterlerin bir kombinasyonu.

Normal ifade özellikleri

Her RegExp nesnesinin beş özelliği vardır:

• kaynak– normal ifadenin metnini içeren salt okunur bir dize.
• küresel– bayrağın varlığını gösteren salt okunur bir boole G düzenli bir ifadede.
• yok saymak Bence düzenli bir ifadede.
• çok satırlı bayrağın varlığını gösteren salt okunur bir boole m düzenli bir ifadede.
• lastIndex okunabilen ve yazılabilen bir tamsayıdır. Bayrak şablonları için G bu özellik, bir sonraki aramanın başlaması gereken dizideki konum numarasını içerir.

Normal İfade Yöntemleri

RegExp nesneleri, desen eşleştirme gerçekleştiren iki yöntemi tanımlar.

exec() yöntemi

exec() yöntemi, belirtilen dize için normal ifadeyi yürütür, yani. bir dizgede bir eşleşme arar. Eşleşme bulunamazsa, yöntem null değerini döndürür. Ancak, bir eşleşme bulunursa, bayrak olmadan arama yapmak için match() yöntemi tarafından döndürülen diziyle aynı diziyi döndürür. G.

Dizinin sıfır öğesi, normal ifadeyle eşleşen dizeyi içerir ve sonraki tüm öğeler, tüm alt ifadelerle eşleşen alt dizelerdir. Match()'den farklı olarak, exec() yöntemi, yapısı normal ifadedeki bayrağın varlığına bağlı olmayan bir dizi döndürür. G.

exec() yöntemi aynı normal ifade için ikinci kez çağrıldığında, lastIndex özelliğinde belirtilen karakter konumunda aramaya başlar. exec() bir eşleşme bulamazsa, lastIndex özelliği 0'a ayarlanır.

test metodu

Bir dize alır ve dize normal ifadeyle eşleşirse true değerini döndürür:

Varpattern = /java/i; model.test("JavaScript"); // true döndür

test() öğesinin çağrılması, exec() öğesinin null olmayan bir değer döndürmesi durumunda true öğesinin çağrılmasıyla eşdeğerdir. Bu nedenle, test() yöntemi, global bir düzenli ifadede çağrıldığında exec() yöntemiyle aynı şekilde davranır: aramaya başlar. belirtilen dize lastIndex özelliği tarafından belirtilen konumdan alır ve bir eşleşme bulursa, lastIndex özelliğini eşleşmeden hemen sonraki karakterin konum numarasına ayarlar.

Şablon Yazma

Normal ifade kalıbı, /abc/ gibi sıradan karakterlerden veya /ab*c/ veya /Bölüm (\d+)\.\d*/ gibi sıradan ve özel karakterlerin kombinasyonlarından oluşur. Son örnek, "bellek mekanizması" olarak kullanılan parantezleri içerir. Desenin bu kısmıyla eşleşme daha sonra kullanılmak üzere hatırlanır.

Basit Şablonları Kullanma

Metinde doğrudan eşleşmeleri bulmak için basit desenler kullanılır. Örneğin, /abc/ kalıbı, yalnızca 'abc' karakterleri birlikte ve aynı sırada yer aldığında bir dizedeki karakter kombinasyonuyla eşleşir.

Düzenli ifadeler ( Normalİfade) - bu çok etkili yöntem dize çalışması.

Özel sözdizimi kullanarak normal bir ifade oluşturarak şunları yapabilirsiniz:

• arama metniÇizgide
• alt dizeleri değiştirÇizgide
• bilgi ayıklamak dizeden

Hemen hemen tüm programlama dillerinde düzenli ifadeler bulunur. Uygulamada küçük farklılıklar vardır, ancak genel kavramlar hemen hemen her yerde geçerlidir.

Düzenli ifadeler, dize işleme algoritmaları için kavramsal bir arama modeli olarak resmileştirildikleri 1950'lere kadar uzanır.

UNIX'te uygulanan grep, sed ve popular gibi düzenli ifadeler metin editörleri, popülerlik kazanmaya başladı ve Perl programlama diline ve daha sonra diğer birçok dile eklendi.

JavaScript, Perl ile birlikte, dilin içine yerleştirilmiş düzenli ifade desteğine sahip programlama dillerinden biridir.

zor ama yardımcı

Normal ifadeler, yeni başlayanlar için mutlak saçmalık gibi görünebilir ve onları anlamak için gerekli zamanı ayırmazsanız, çoğu zaman profesyonel geliştiricilere bile.

Düzenli ifadeler yazmak zor, Okunması zor ve bakımı/değiştirilmesi zor.

Ancak bazen düzenli ifadeler tek mantıklı yol bir tür dizi manipülasyonu gerçekleştirin, bu nedenle çok değerli bir araçtır.

Bu kılavuzun amacı basit bir şekilde JavaScript'teki normal ifadeleri biraz anlamanızı sağlamak ve normal ifadelerin nasıl okunacağı ve oluşturulacağı hakkında bilgi sağlamak için.

Temel kural şu ​​ki basit düzenli ifadelerin okunması ve yazılması kolaydır, sırasında karmaşık düzenli ifadeler hızla bir karmaşaya dönüşebilir Temelleri derinlemesine anlamadıysanız.

Normal ifadeler nasıl görünür?

JavaScript'te normal ifade, iki şekilde tanımlanabilen bir nesnedir.

İlk yol, yaratmaktır. yeni RegExp nesnesi yapıcıyı kullanarak:

Const re1 = yeni RegExp("hey")

İkinci yol kullanmaktır düzenli ifade değişmezleri:

Sabit re1 = /hey/

JavaScript'in ne olduğunu biliyor musun? nesne değişmezleri ve dizi değişmezleri? Ayrıca .... sahip normal ifade değişmezleri.

Yukarıdaki örnekte, hey denir şablon. Kelimenin tam anlamıyla, iki eğik çizgi arasındadır, ancak bir nesne oluşturucu durumunda değildir.

Bu, normal ifadeleri tanımlamanın iki yolu arasındaki ilk önemli farktır, gerisini daha sonra göreceğiz.

Nasıl çalışırlar?

Yukarıda re1 olarak tanımladığımız normal ifade çok basittir. hey dizesini herhangi bir kısıtlama olmaksızın arar: dize çok fazla metin içerebilir ve hey kelimesi ortada bir yerdedir ve normal ifade işe yarayacaktır. Dize yalnızca hey kelimesini içerebilir ve normal ifade tekrar çalışır.

Oldukça basit.

Bir boole değeri döndüren RegExp.test(String) yöntemiyle normal ifadeyi test etmeyi deneyebilirsiniz:

Re1.test("hey") // ✅ re1.test("blablabla hey blablabla") // ✅ re1.test("o") // ❌ re1.test("blablabla") // ❌

Yukarıdaki örnekte, "hey" ifadesinin re1'de depolanan normal ifade modeliyle eşleşip eşleşmediğini kontrol ettik.

Armutları bombalamak kadar kolay, ancak düzenli ifadeler hakkında zaten çok şey biliyorsunuz.

demirleme

dize içinde hey nerede olursa olsun çalışacaktır.

hey ile başlayan satırları bulmak istiyorsanız, ^ operatörünü kullanın:

/^hey/.test("hey") // ✅ /^hey/.test("hey hey") // ❌

hey ile biten satırları bulmak istiyorsanız, $ operatörünü kullanın:

/hey$/.test("hey") // ✅ /hey$/.test("hey hey") // ✅ /hey$/.test("hey sen") // ❌

Önceki iki ifadeyi birleştirerek, hey ile tam olarak eşleşen bir satır bulabilirsiniz:

/^hey$/.test("hey") // ✅

Bir alt dizeyle başlayan ve başka bir alt dizeyle biten bir dize bulmak için, 0 veya daha fazla kez tekrarlanan herhangi bir karakterle eşleşecek olan .* öğesini kullanabilirsiniz:

/^hey.*joe$/.test("hey joe") // ✅ /^hey.*joe$/.test("heyjoe") // ✅ /^hey.*joe$/.test("hey joe nasılsın") // ✅ /^hey.*joe$/.test("hey joe!") // ❌

Aralığa göre eleman bulma

Belirli bir dize aramak yerine, aşağıdaki gibi bir dizi karakter belirtebilirsiniz:

// // a, b, c, ... , x, y, z // // A, B, C, ... , X, Y, Z // // a, b, c // / / 0, 1, 2, 3, ... , 8, 9

Bu normal ifadeler, seçilen aralıktan en az bir karakter içeren dizeleri arar:

//.test("a") // ✅ //.test("1") // ❌ //.test("A") // ❌ //.test("d") // ❌ // .test("dc") // ✅

Aralıklar birleştirilebilir:

// //.test("a") // ✅ //.test("1") // ✅ //.test("A") // ✅

Bir Aralık Öğesinin Birden Çok Eşleşmesini Bulma

- karakterini kullanarak bir dizenin bir aralıktan yalnızca bir karakter içerip içermediğini kontrol edebilirsiniz:

/^$/ /^$/.test("A") // ✅ /^$/.test("Ab") // ❌

Desen inversiyonu

Bir kalıbın başındaki ^ karakteri onu satırın başına sabitler.

Bu karakteri bir aralık içinde kullanmak, aralığı tersine çevirir, bu nedenle:

/[^A-Za-z0-9]/.test("a") // ❌ /[^A-Za-z0-9]/.test("1") // ❌ /[^A-Za -z0-9]/.test("A") // ❌ /[^A-Za-z0-9]/.test("@") // ✅

meta karakterler

• \d herhangi bir sayıyla eşleşir, eşdeğerdir
• \D, sayı olmayan, [^0-9] ile eşdeğer olan herhangi bir karakterle eşleşir
• \w herhangi bir alfasayısal karakterle eşleşir, buna eşdeğerdir
• \W, [^A-Za-z0-9] ile eşdeğer, alfasayısal bir değer olmayan herhangi bir karakterle eşleşir
• \s herhangi bir boşluk karakteriyle eşleşir: boşluk, sekme, yeni satır ve Unicode boşlukları
• \S boşluk olmayan herhangi bir karakterle eşleşir
• \0 null ile eşleşir
• \n yeni satır karakteriyle eşleşiyor
• \t bir sekme karakteriyle eşleşir
• \uXXXX, Unicode karakteriyle XXXX koduyla eşleşir (u bayrağını gerektirir)
• . yeni satır (\n gibi) dışında herhangi bir karakterle eşleşir (s bayrağını kullanmazsanız, daha sonra açıklanacaktır)
• [^], yeni satır karakteri de dahil olmak üzere herhangi bir karakterle eşleşir. Çok satırlı dizelerle uğraşırken kullanışlıdır

Normal ifadelerde seçim

birini seçmek istersen veya başka bir satırda | .

/hey|ho/.test("hey") // ✅ /hey|ho/.test("ho") // ✅

niceleyiciler

Bir dizenin yalnızca bir rakam içerip içermediğini kontrol eden normal bir ifadeniz olduğunu hayal edin:

kullanabilirsiniz niceleyici? , bu karakteri isteğe bağlı yapacak. Bizim durumumuzda, sayı 0 veya 1 kez olmalıdır:

peki ya normal ifadenin birden çok rakamla eşleşmesini istiyorsak?

+ , * , (n) ve (n,m) kullanarak 4 şekilde yapabilirsiniz.

+

Bir veya daha fazla (>=1) öğeyle eşleşir:

/^\d+$/ /^\d+$/.test("12") // ✅ /^\d+$/.test("14") // ✅ /^\d+$/.test("144343" ) // ✅ /^\d+$/.test("") // ❌ /^\d+$/.test("1a") // ❌

*

0 veya daha fazla (>=0) öğeyle eşleşir:

/^\d+$/ /^\d*$/.test("12") // ✅ /^\d*$/.test("14") // ✅ /^\d*$/.test( "144343") // ✅ /^\d*$/.test("") // ✅ /^\d*$/.test("1a") // ❌

(n)

Tam olarak n sayıda öğeyle eşleşir:

/^\d(3)$/ /^\d(3)$/.test("123") // ✅ /^\d(3)$/.test("12") // ❌ /^\ d(3)$/.test("1234") // ❌ /^(3)$/.test("Abc") // ✅

(n,m)

n'den m'ye kadar bir dizi öğeyle eşleşir:

/^\d(3,5)$/ /^\d(3,5)$/.test("123") // ✅ /^\d(3,5)$/.test("1234") // ✅ /^\d(3,5)$/.test("12345") // ✅ /^\d(3,5)$/.test("123456") // ❌

m atlanabilir ve en az n eleman olacak şekilde ikinci sınır kısıtlanmadan bırakılır:

/^\d(3,)$/ /^\d(3,)$/.test("12") // ❌ /^\d(3,)$/.test("123") // ✅ /^\d(3,)$/.test("12345") // ✅ /^\d(3,)$/.test("123456789") // ✅

Opsiyonel elemanlar

Öğeyi takip eden karakter? , isteğe bağlı hale getirecek:

/^\d(3)\w?$/ /^\d(3)\w?$/.test("123") // ✅ /^\d(3)\w?$/.test(" 123a") // ✅ /^\d(3)\w?$/.test("123ab") // ❌

Gruplar

Parantez kullanarak karakter grupları oluşturabilirsiniz (...) .

Aşağıdaki örnek, bir veya daha fazla alfasayısal karakterin izlediği 3 basamaklı tam eşleşmeyi arar:

/^(\d(3))(\w+)$/ /^(\d(3))(\w+)$/.test("123") // ❌ /^(\d(3))( \w+)$/.test("123s") // ✅ /^(\d(3))(\w+)$/.test("123bir şey") // ✅ /^(\d(3))( \w+)$/.test("1234") // ✅

Grup kapatma parantezinden sonra görünen yinelenen karakterler tüm grup için geçerlidir:

/^(\d(2))+$/ /^(\d(2))+$/.test("12") // ✅ /^(\d(2))+$/.test(" 123") // ❌ /^(\d(2))+$/.test("1234") // ✅

Grupları yakalama

Şimdiye kadar, dizilerin nasıl test edileceğini ve belirli bir kalıp içerip içermediklerini gördük.

Normal ifadelerin harika bir özelliği, bir dizenin belirli kısımlarını yakalamak ve bunları bir diziye ekleyin.

Bunu gruplarla, daha spesifik olarak yakalama grupları.

Varsayılan olarak, gruplar bu şekilde yakalanır. Şimdi, basitçe bir boole döndüren RegExp.test(String) kullanmak yerine, aşağıdaki yöntemlerden birini kullanacağız:

• Dize eşleşmesi(RegExp)
• RegExp.exec(Dize)

Bunlar tamamen aynıdır ve her ikisi de ilk öğe olarak test edilen dize ile bir dizi döndürür ve kalan öğelerde bulunan her grup için bir eşleşme vardır.

Eşleşme bulunamazsa, null değerini döndürür.

"123s".match(/^(\d(3))(\w+)$/) //Dizi [ "123s", "123", "123s" ] /^(\d(3))(\w+ )$/.exec("123s") //Array [ "123s", "123", "s" ] "hey".match(/(hey|ho)/) //Array [ "hey", "hey " ] /(hey|ho)/.exec("hey") //Dizi [ "hey", "hey" ] /(hey|ho)/.exec("ha!") //null

Bir grup birden çok kez eşleştiğinde, döndürülen diziye yalnızca bulunan son değer eklenir.

"123456789".match(/(\d)+/) //Dizi [ "123456789", "9" ]

İsteğe bağlı gruplar

Yakalama grupları (...) ile isteğe bağlı hale getirilebilir? . Hiçbir şey bulunamazsa, döndürülen diziye tanımsız bir öğe eklenir:

/^(\d(3))(\s)?(\w+)$/.exec("123 s") //Array [ "123 s", "123", " ", "s" ] /^ (\d(3))(\s)?(\w+)$/.exec("123s") //Array [ "123s", "123", undefined, "s" ]

Bulunan gruba bağlantı

Bulunan her gruba bir numara atanır. $1 birinci öğeyi, $2 ikinci öğeyi vb. ifade eder. Bu, bir dizgenin bir kısmını değiştirmekten bahsettiğimizde kullanışlıdır.

Adlandırılmış grup yakalama

Bu yeni fırsat ES2018.

Döndürülen dizide yalnızca bir yuva yerine bir gruba bir ad atayabilirsiniz:

Sabit yeniden = /(? \d(4))-(? \d(2))-(? \d(2))/ const sonuç = re.exec("2015-01-02") // sonuç.gruplar.yıl === "2015"; // sonuç.gruplar.ay === "01"; // sonuç.gruplar.gün === "02";

Gruplar olmadan eşleşme ve yürütme kullanma

Gruplar olmadan eşleşme ve yürütmeyi kullanırken bir fark vardır: dizinin ilk öğesi tamamen bulunan bir dize değil, doğrudan eşleşme içerecektir:

/hey|ho/.exec("hey") // [ "hey" ] /(hey).(ho)/.exec("hey ho") // [ "hey ho", "hey", "ho "]

Yakalamayan gruplar

Gruplar varsayılan olarak yakalanabilir olduğundan, döndürülen dizideki bazı grupları yok saymanın bir yoluna ihtiyacımız var. Bu ile mümkündür ele geçirilemeyen gruplar, hangisi (?:...) ile başlar.

"123s".match(/^(\d(3))(?:\s)(\w+)$/) // null "123 s".match(/^(\d(3))(?: \s)(\w+)$/) // Dizi [ "123 s", "123", "s" ]

Bayraklar

Herhangi bir normal ifadede aşağıdaki bayrakları kullanabilirsiniz:

• g: küresel olarak eşleşmeleri arar
• i: normal ifadeyi büyük/küçük harfe duyarsız hale getirir
• m: Çoklu hat modunu etkinleştirir. Bu modda, ^ ve $ tüm dizenin başlangıcı ve sonuyla eşleşir. Bu bayrak olmadan, çok satırlı dizelerle, her satırın başı ve sonuyla eşleşirler.
• u: Unicode desteğini etkinleştirir (ES6/ES2015'te eklenmiştir)
• s: (ES2018'de yeni) "tek satır" için kısa, izin verir. yeni satır karakterlerini eşleştir

Bayraklar birleştirilebilir ve ayrıca değişmez dizenin sonuna eklenirler:

/hey/ig.test("Hey") // ✅

veya RegExp nesnesinin yapıcısına ikinci parametre olarak iletilir:

Yeni RegExp("hey", "ig").test("HEy") // ✅

Normal İfade Denetimi

Normal ifadelerin özelliklerini inceleyebilirsiniz:

• kaynak - şablon dizesi
• multiline - m bayrağı ayarlanmışsa doğru
• global - g bayrağı ayarlanmışsa true
• görmezdenCase - i bayrağı ayarlanmışsa doğru
• lastIndex

ekranlama

Özel semboller:

Bunlar özel karakterlerdir çünkü normal ifade kalıpları oluştururken kontrol karakterleridirler, bu nedenle onları bir kalıp içinde eşleştirmek için kullanmak istiyorsanız, onlardan bir ters eğik çizgi karakteri ile çıkmanız gerekir:

satır sınırları

\b ve \B, bir dizenin bir kelimenin başında mı yoksa sonunda mı olduğunu belirlemenize izin verir:

• \b, karakter kümesi bir kelimenin başında veya sonundaysa eşleşir
• \B, karakter kümesi bir kelimenin başında veya sonunda değilse eşleşir

"Bir ayı gördüm".match(/\bbear/) //Dizi ["ayı"] "Bir ayı gördüm".match(/\bbear/) //Array ["ayı"] "Bir ayı gördüm" .match(/\bbear\b/) //null "cool_bear".match(/\bbear\b/) //null

Normal ifadelerle değiştirme

Dizelerin bir kalıba karşı nasıl kontrol edileceğini zaten gördük.

Ayrıca, desenle eşleşen dizelerin bir kısmını bir diziye nasıl çıkarabileceğinizi de gördük.

Şimdi nasıl olduğuna bakalım bir dizenin parçalarını değiştir bir şablona dayalıdır.

JavaScript'teki String nesnesi, düzenli ifadeler olmadan kullanılabilen bir replace() yöntemine sahiptir. bir yedekÇizgide:

"Merhaba dünya!".replace("dünya", "köpek") //Merhaba köpek! "Köpeğim iyi bir köpek!".replace("köpek", "kedi") //Kedim iyi bir köpek!

Bu yöntem ayrıca argüman olarak normal bir ifade alabilir:

"Merhaba dünya!".replace(/world/, "köpek") //Merhaba köpek!

g bayrağının kullanımı tek yol bir dizedeki birden çok oluşumu vanilya JavaScript ile değiştirin:

"Köpeğim iyi bir köpek!".replace(/dog/g, "cat") //Kedim iyi bir kedi!

Gruplar, daha süslü şeyler yapmamıza, satırların parçalarını değiştirmemize izin verir:

"Merhaba dünya!".replace(/(\w+), (\w+)!/, "$2: $1!!!") // "dünya: Merhaba!!!"

Daha da ilginç şeyler yapmak için bir dize yerine bir işlev kullanabilirsiniz. Argüman sayısının grup sayısına bağlı olduğu String.match(RegExp) veya RegExp.exec(String) yöntemleri tarafından döndürülenler gibi bir dizi argüman iletilecektir:

"Merhaba dünya!".replace(/(\w+), (\w+)!/, (matchedString, birinci, saniye) => ( console.log(first); console.log(second); return `$( saniye.toUpperCase()): $(ilk)!!!` )) //"DÜNYA: Merhaba!!!"

Açgözlülük

Düzenli ifadeler denir aç gözlü varsayılan.

Bunun anlamı ne?

Örneğin bu normal ifadeyi alın:

/\$(.+)\s?/

Dizeden dolar miktarını çıkarmamız gerektiği varsayılır:

/\$(.+)\s?/.exec("Bunun maliyeti 100$") //0

ama ya sayıdan sonra daha fazla kelimemiz varsa, bu dikkat dağıtıyor

/\$(.+)\s?/.exec("Bunun maliyeti 100$ ve 200$'dan az") //100 ve 200$'dan az

Niye ya? Çünkü $ işaretinden sonraki normal ifade herhangi bir .+ karakteriyle eşleşir ve satırın sonuna ulaşana kadar durmaz. Sonra durur çünkü \s? sondaki alanı isteğe bağlı hale getirir.

Bunu düzeltmek için normal ifadenin olması gerektiğini belirtmemiz gerekiyor. tembel ve en az eşleşme sayısını bulun. Bunu bir sembolle yapabilir miyiz? niceleyiciden sonra:

/\$(.+?)\s/.exec("Bunun maliyeti 100$ ve 200$'dan az") //100

Yani sembol? konumuna bağlı olarak farklı anlamlara gelebilir, dolayısıyla hem niceleyici hem de gösterge olabilir. tembel modu.

Önceki: onu izleyene bağlı olarak bir dize eşleştirin

Bir dizeyi ve ardından belirli bir alt dizeyi eşleştirmek için ?= kullanın

/Roger(?=Waters)/ /Roger(?= Waters)/.test("Roger benim köpeğim") //false /Roger(?= Waters)/.test("Roger benim köpeğim ve Roger Waters ünlü bir müzisyen") //true

Ters işlemi gerçekleştirir ve ardından satırda eşleşmeleri bulur. olumsuzluk ardından belirli bir alt dize:

/Roger(?!Waters)/ /Roger(?! Waters)/.test("Roger benim köpeğim") //true /Roger(?! Waters)/.test("Roger benim köpeğim ve Roger Waters ünlü bir müzisyen") //false

Geriye dönük: bir dizeyi kendisinden önce gelene bağlı olarak eşleştirin

Bu, ES2018'deki yeni bir özelliktir.

Öngörü, ?= sembolünü kullanır. Retrospektif kullanımlar?<= :

/(?<=Roger) Waters/ /(?<=Roger) Waters/.test("Pink Waters is my dog") //false /(?<=Roger) Waters/.test("Roger is my dog and Roger Waters is a famous musician") //true

Retrospektif inversiyon kullanır mı?

/(?

Normal İfadeler ve Unicode

u bayrağı, Unicode dizileriyle uğraşırken, özellikle de ilk 1600 Unicode karakterinde yer almayan astral planlardaki dizileri işlemek gerektiğinde gereklidir.

Örneğin, emoji, ancak yalnızca onlar.

/^.$/.test("a") // ✅ /^.$/.test("?") // ❌ /^.$/u.test("?") // ✅

Bu nedenle, her zaman u bayrağını kullanın.

Unicode, normal karakterler gibi, aralıkları işleyebilir:

//.test("a") // ✅ //.test("1") // ✅ /[?-?]/u.test("?") // ✅ /[?-?]/u .test("?") // ❌

JavaScript dahili temsil kodlarını kontrol eder, bu yüzden mi?< ? < ? на самом деле \u1F436 < \u1F43A < \u1F98A . Посмотрите полный список эмодзи чтобы увидеть коды и узнать их порядок.

Unicode özelliklerinden kaçış

Yukarıda söylediğimiz gibi, bir normal ifade modelinde herhangi bir rakamı eşleştirmek için \d'yi, boşluk dışında herhangi bir karakteri eşleştirmek için \s'yi, herhangi bir alfasayısal karakteri eşleştirmek için \w'yi vb. kullanabilirsiniz.

Unicode özelliğinden kaçış, bu konsepti tüm Unicode karakterlerine genişleterek ve \p() ve \P() ekleyerek çok güzel bir özellik ekleyen bir ES2018 özelliğidir.

Her Unicode karakterinin bir dizi özelliği vardır. Örneğin, Komut Dosyası bir dil ailesini tanımlar, ASCII, ASCII karakterleri için doğru olan bir boole değeridir vb. Bu özelliği kaşlı ayraçlar içine koyabilirsiniz ve normal ifade, değerinin doğru olup olmadığını kontrol edecektir:

/^\p(ASCII)+$/u.test("abc") // ✅ /^\p(ASCII)+$/u.test(" [e-posta korumalı]") // ✅ /^\p(ASCII)+$/u.test("ABC?") // ❌

ASCII_Hex_Digit, bir dizenin yalnızca geçerli onaltılık basamaklar içerip içermediğini kontrol eden başka bir boole özelliğidir:

/^\p(ASCII_Hex_Digit)+$/u.test("0123456789ABCDEF") //✅ /^\p(ASCII_Hex_Digit)+$/u.test("h")

Büyük harf , Küçük harf , White_Space , Alphabetic , Emoji ve daha fazlası dahil olmak üzere, adlarını küme parantezlerine ekleyerek kontrol edebileceğiniz birçok boole özelliği vardır:

/^\p(Küçük Harf)$/u.test("h") // ✅ /^\p(Büyük Harf)$/u.test("H") // ✅ /^\p(Emoji)+$/ u.test("H") // ❌ /^\p(Emoji)+$/u.test("??") // ✅

Bu ikili özelliklere ek olarak, belirli bir değerle eşleşmesi için bir Unicode karakterinin herhangi bir özelliğini test edebilirsiniz. Aşağıdaki örnekte, dizenin Yunan veya Latin alfabesiyle yazılmış olup olmadığını kontrol ediyorum:

/^\p(Script=Yunanca)+$/u.test("ελληνικά") // ✅ /^\p(Script=Latin)+$/u.test("hey") // ✅

Örnekler

Bir diziden sayı çıkarma

Çıkarılacak yalnızca bir sayı içeren bir dize olduğunu varsayalım. /\d+/ şunu yapmalıdır:

"123123329 Testi".match(/\d+/) // Dizi [ "123123329" ]

E-posta adresi arama:

En basit yaklaşım, \S kullanarak @ işaretinden önce ve sonra boşluk olmayan karakterleri kontrol etmektir:

/(\S+)@(\S+)\.(\S+)/ /(\S+)@(\S+)\.(\S+)/.exec(" [e-posta korumalı]") //["[e-posta korumalı]", "copesc", "gmail", "com"]

Ancak bu, çok sayıda geçerli olmayan e-posta adresi içerdiğinden basit bir örnektir.

Çift tırnak arasında metin yakalama

Çift tırnak içine alınmış metin içeren bir dizginiz olduğunu ve bu metni çıkarmanız gerektiğini düşünelim.

Bunu yapmanın en iyi yolu kullanmaktır. grup yakalama, çünkü eşleşmemizin " ile başlayıp bitmesi gerektiğini bildiğimizden, kalıbı kolayca özelleştirebiliriz, ancak bu alıntıları sonuçtan da kaldırmak istiyoruz.

Sonuç olarak ihtiyacımız olanı bulacağız:

Const merhaba = "Merhaba "güzel çiçek"" const sonuç = /"([^"]*)"/.exec(merhaba) //Dizi [ "\"güzel çiçek\"", "güzel çiçek" ]

HTML etiketinden içerik alma

Örneğin, etiket için herhangi bir sayıda bağımsız değişkene izin verirken içeriği span etiketinden alın:

/]*>(.*?)<\/span>/ /]*>(.*?)<\/span>/.exec("deneme") // boş / ]*>(.*?)<\/span>/.exec("deneme") // ["deneme", "deneme"] / ]*>(.*?)<\/span>/.exec(" Ölçek") // ["Ölçek", "Ölçek"]