Düzenli ifadeler - Bu, metasimmbollere dayalı sıra desenlerini tanımlayan bir dildir. MetaSimwall, bazı sınıf karakter karakter sınıfını tanımlayan düzenli ifadedeki bir semboldür, alt dizinin konumunu belirtir, bir alt dizideki tekrarların veya grup karakterlerinin sayısını gösterir. Örneğin, metacimol \\ d sayıları açıklar ve $ dizgenin sonunu belirtir. Düzenli ifadede, kendilerini tanımlayan geleneksel karakterler olabilir. MetaSimVols'in düzenli ifadelerdeki seti ve değeri, çoğu JS'de desteklenen PCRE standardını açıklar.

Düzenli ifade kapsamı

Düzenli ifadeler, aşağıdaki görevler için bir kural olarak kullanılır:

• Karşılaştırma. Bu görevin amacı belirtilen düzenli düzenli ifadenin tanımlanmış metne uygun olup olmadığını öğrenecektir.
• Arama. Düzenli ifadeler yardımıyla, uygun alt diziyi bulmak ve metinden çıkarmak uygundur.
• Değiştirme. Düzenli ifadeler genellikle sadece bulamıyor, aynı zamanda normal ifadeye karşılık gelen bir alt yuva metninde de değiştirilmesine yardımcı olur.

Sonuçta, düzenli ifadelerle, örneğin:

• Özel verilerin formunu doldurduğunu kontrol edin.
• Kullanıcının giriş metni bağlantısını, ardından mesaja daha sonraki otomatik bağlanma için görüntüye bul.
• HTML etiketlerinin metninden çıkarın.
• Basit sözdizimsel hataların varlığını derlemeden önce kodu kontrol edin.

JS'de düzenli ifadelerin özellikleri. Düzenli ifadelerin değişmezleri

JS'deki düzenli ifadelerin ana özelliği, onlar için ayrı bir tipte değişmezlik olmasıdır. Tıpkı dize edebiyatı tırnaklarla çerçevelendikçe, düzenli ifade değişmezleri eğik çizgi (/) ile çerçevelenmiştir. Böylece, JS kodu formun ifadelerini içerebilir:

konsol.log (typeof / tcoder /); // Nesne.

Aslında, dizede belirlenen düzenli bir ifade

var paterni \u003d yeni regexp ("tcoder");

Bu oluşturma yöntemi, normal ifadedeki değişkenleri kullanmanız gerektiğinde veya dinamik olarak düzenli bir ifade oluşturmanız gerektiğinde yaygın olarak kullanılır. Diğer tüm durumlarda, normal ifadelerin değişmezleri, daha kısa sözdizimi ve bazı karakterleri ek olarak korumak için ihtiyaç duyulması nedeniyle kullanılır.

Düzenli ifadelerdeki semboller

Düzenli ifadelerdeki tüm alfasayısal karakterler metasimvol değildir ve kendilerini tanımlar. Bu, normal ifade olduğu anlamına gelir / tcoder / Bir substring tcoder'a karşılık gelecektir. Düzenli ifadelerde, aşağıdaki gibi alfabetik karakterleri belirtmek de mümkündür: Dize (\\ n), tablolama (\\ t) vb. Çevirisi. Bütün bu karakterler de kendilerine karşılık gelir. Alfabetik sembolden önce teslim edilen ters eğik çizgi (\\), eğer varsa bir metachamir yapacaktır. Örneğin, "D" alfabetik sembolü, bir katman (\\ D) ile tahmin edilirse sayıları tanımlayan bir metachamir olacaktır.

Sembol sınıfları

Düzenli ifadelerdeki tek karakterler, köşeli parantez kullanan sınıflara gruplandırılabilir. Bu şekilde oluşturulan sınıf, içine dahil olan karakterlerden herhangi birine karşılık gelir. Örneğin, düzenli ifade // "T", "C", "O", "D", "E", "R" harfleri karşılık gelecektir.

Sınıfta, karakter aralığını bir tire kullanarak da ayarlayabilirsiniz. Örneğin, sınıf sınıfa karşılık gelir. Düzenli ifadelerdeki bazı MetaSimwall'ların zaten karakter sınıflarını tanımladığını unutmayın. Örneğin, metacimol \\ d sınıfa eşdeğerdir. Karakterlerin sınıflarını tanımlayan meta karakterlerin sınıflara da dahil edilebileceğini unutmayın. Örneğin, [\\ DA-F] sınıfı, sayılara ve "a", "B", "D", "E", "F" harflerine, yani herhangi bir onaltılık sembolüdür.

Ayrıca, girmemesi gereken karakterleri belirten karakter sınıfını tanımlama yeteneği de vardır. Bu, Metasimvol ^ kullanılarak yapılır. Örneğin, [^ \\ d] sınıfı, sayı dışında herhangi bir karaktere karşılık gelecektir.

Tekrar et

Şimdi, belirli bir uzunluğun ondalık sayısını, bu sayede, bu numarada kaç numarayı yazarak tarif edebiliriz. Bu yaklaşımın çok uygun olmadığına katılıyorum. Ek olarak, istenen sayıda tekrarların aralığını tanımlayamayız. Örneğin, numarayı bir veya iki rakamdan tarif edemeyiz. Neyse ki, düzenli ifadelerde, metaSimvols kullanarak tekrarlama aralıklarını tanımlamak mümkündür. Bunu yapmak için, sembolden sonra, tekrarlama aralığını kıvırcık parantez içinde belirlemek yeterlidir. Örneğin, düzenli ifade / TCO (1, 3) der / "TCODER", "TCOODER" ve "TCOOODER" dizeleri karşılık gelecektir. Maksimum tekrar sayısını atlarsanız, virgülten ve minimum tekrarlama sayısını terk ederseniz, daha belirlenen tekrarların sayısını belirleyebilirsiniz. Örneğin, düzenli ifade / Bo (2,) BS / "Göğüsler", "Booobs", "Boooobs" dizeleri, en az iki tane "O") herhangi bir sayıda harfle karşılık gelecektir.

Kıvırcık parantez içinde omit ve virgül ise, sadece bir numara belirlemek, o zaman tam tekrarlama sayısını belirtir. Örneğin, düzenli ifade / \\ D (5) / Beş basamaklı sayılar karşılık gelir.

Bazı tekrarlar aralıkları oldukça sık kullanılır ve tanımları için metaçoları vardır.

Açgözlü tekrarlar

Yukarıdaki sözdizimi, maksimum tekrar sayısını, yani, belirtilen aralıkta yatan, maksimum aralıkta kalan tüm tekrarların sayısını açıklar. Bu tekrarlar açgözlü denir. Bu, Düzenli İfade / \\ D + / Çizgi Hattı! 111, "111", "11" ya da "1" değil, metaSimmol "+", aynı tekrarları açıklamasına rağmen, "111" veya "1" olarak karşılık geleceği anlamına gelir.

Belirsiz bir tekrarı uygulamak istiyorsanız, belirtilen aralıktan minimum olası bir tekrarlama sayısı vardır, daha sonra "?" Sembolünü oluşturun. Tekrarlama aralığından sonra. Örneğin, düzenli ifade / \\ D +? / "Evet !! 111" satırında "1" alt dizisine ve düzenli ifadeye karşılık gelecektir. / \\ D (2,) / Aynı satırda "11" alt dizisine karşılık gelecektir.

Belirgin bir tekrarlamanın önemli bir özelliğine dikkat etmeye değer. Düzenli ifadeyi düşünün / Bo (2,)? BS /. "Big Boooobs'u severim" hattında, açgözlü bir tekrarı, beooobs substring ve göğüsler değil, düşünmek mümkün olduğu gibi uyacak. Gerçek şu ki, bir karşılaştırma ile düzenli bir ifadenin, dizenin farklı yerlerinde bulunan birkaç alt yuvaya karşılık gelemez. Yani, düzenli ifademiz "BOO" ve "BS" alt dizişi bir satıra yapıştırılmış olarak eşleşemez.

Alternatifler

Düzenli ifadelerde, alternatifler de kullanılabilir - normal bir ifadenin bir veya başka bir kısmına karşılık gelen bir satır kümesini tanımlamak için. Bu tür parçaların alternatif olarak adlandırılır ve dikey özelliğe bölünür. Örneğin, düzenli ifade / İki | iki kez | \\ 2 / "İki" ikameye veya "iki kez" alt diziye veya "2" alt dizisine karşılık gelebilir. Alternatif zincir, ilk tesadüf öncesinde sola doğru işlenir ve yalnızca yalnızca bir alternatifin tanımladığı alt tabakaya karşılık gelebilir. Örneğin, düzenli ifade / Java | Script / "JavaScript'i severim" hattının yalnızca "Java" alt dizişiyle eşleşecek.

Gruplama

Tekrarlama aralıklarını, sembol sınıflarını ve diğer her şeyi kullanırken, tek bir tamsayı olarak birkaç karakteri düşünmek için, sadece parantez içine almak için yeterlidir. Örneğin, düzenli ifade / Doğru (Kodlayıcı)? / "Truecoder" ve "gerçek" dizeleri karşılık gelecektir.

Linkler

Ek olarak, yuvarlak parantezler normal ifadedeki sembolleri tek bir bütün halinde birleştirir, sadece sol braketin parantezi çiftinden işaretleyerek uygun alt dizeye başvurabilirsiniz. Parantezler soldan sağa doğru bir şekilde numaralandırılır. Örneğin, düzenli olarak / (Bir (iki) (dört) / \\ 1, "üç", \\ 3'te "dört", "dört" de bir, \\ 2'de bir tane ifade eder. Bu tür bağlantıları kullanmanın bir örneği olarak, düzenli bir ifade veriyoruz / (\\ d) \\ 1 /Bu, aynı sayılarla iki basamaklı sayılara karşılık gelir. Backlinks kullanımının önemli bir sınırlaması, sınıflarda kullanımlarını kullanmanın imkansızlığıdır, yani, örneğin farklı sayılarla iki basamaklı bir sayıyı tanımlayın. / (\\ d) [^ \\ 1] / Bu imkansız.

Maskelenme parantez

Genellikle, karakterleri basitçe gruplamak gerekir, ancak bir bağlantı oluşturmanıza gerek yoktur. Bu durumda, sol gruplama braketinden sonra hemen yazabilirsiniz?:. Örneğin, düzenli olarak / (Bir, iki, üç) / \\ 2 üçüne işaret edecektir.

Bu parantez bazen istemsiz olarak adlandırılır. Bir sonraki derste konuşacağımız bir başka önemli özelliğe sahipler.

Not pozisyonu

Düzenli ifadelerde, hatta bazı pozisyonu gösteren metasimwills de vardır. Kalan tüm sembollerden daha sık, ^, $ satırın başlangıcını ve sonunu belirten. Örneğin, düzenli ifade /\..+$/ Dosyaların isimlerindeki genişlemeye ve düzenli ifadeye karşılık gelir / ^ \\ d / Eğer varsa, dizedeki ilk rakam.

Olumlu ve negatif gelişmiş kontroller

Düzenli ifadelerle, alt tabakayı, ardından başka bir şablon tarafından açıklanan alt diziyi de tanımlayabilirsiniz. Örneğin, Java kelimesini yalnızca "komut dosyasını" takip ederse bulmamız gerekiyor. Bu görev normal ifade ile çözülebilir / Java (? \u003d Script) /. Komut dosyasının düzenli ifade tarafından kullanılmaması gerektiğinin arkasındaki "Java" alt dizesini tanımlamamız gerekirse / Java (?! Script) /.

Tek bir plaka içinde konuştuğumuz her şeyi topluyoruz.

Sembol	Değer vermek
a | B.	Ya da ya da ya da.
(…)	Gruplama parantezleri. Ayrıca alt tabakada, parantez içindeki uygun desen referte edilebilir.
(?:…)	Sadece gruplandırma, atıfta bulunma fırsatı olmadan.
\\ N.	N-M şablonuna karşılık gelen bir alt yuvaya referans.
^	Giriş verilerinin başlangıcı veya dizenin başlangıcı.
$	Giriş verilerinin sonu veya dizenin sonu.
a (? \u003d b)	Şablonu tanımlayan alt yuvaya uyar, ancak b şablonu tarafından açıklanan alt tabloyu izlerse, b şablonu.
a (?! B)	Sadece şablonu tanımlayan alt tabakaya karşılık gelir değil B şablonu tarafından açıklanan alt dizgiyi takip eder.

Bayrak

Ve nihayet, normal ifadelerin sözdiziminin son unsuru. Bayraklar, düzenli ifadeye ait olan uygunluk kurallarını belirler. Diğer tüm elementlerin aksine, düzenli ifadelerin sözdizimi, gerçek ifadeden hemen sonra yazılır veya hatta nesne yapıcısının ikinci parametresi olarak hatta iletilir. Regexp..

Javascript, normal ifadelerin sadece üç bayrağı var:

bEN. - Bu bayrağı belirlerken, kayıt dikkate alınmaz, yani, örneğin normal ifadedir. \\ javascript \\ i "Javascript", "JavaScript", "JavaScript", "JavaScript", vb. Yapılandırılacak.

m. - Bu bayrak çok satırlı bir arama içerir. Bu, eğer metinde karakter çeviri sembolleri ve bu bayrak teslim edilirse, başlangıcın yanı sıra ve tüm metnin sonunun yanı sıra karakterlerin yanı sıra, metindeki her satırın başlangıcına ve sonuna karşılık geleceği anlamına gelir. Örneğin, düzenli ifade / Satır $ / m Hem "ilk satır" satırında hem de bir \\ nsecond line \\ ntwo dizesinde "satır" alt dizisine uygundur.

g. - Küresel bir arama, yani, normal bir ifade, bu bayrak etkinleştirildiyse, alt yörünge ile çakışırsa, bu bayrak gibi değil, sadece ilk değil.

Bayraklar keyfi bir sırayla birleştirilebilir, yani \\ Tcoder \\ mig, \\ Tcoder \\ gim, \\ Tocder \\ gmi vs., bu aynı. Bayrakların sırası, nesne yapıcısının ikinci argümanı olarak dize içinde iletildikleri önemli değil. Regexp., yani yeni Regexp ("tcoder", "im") ve yeni Regexp ("tcoder", "im") Ayrıca bir şey.

Zy

Düzenli ifadeler, satırlarla çalışmak için çok güçlü ve kullanışlı bir araçtır, yüzlerce kod dizesinin bir ifadeye azaltmasına izin verir. Ne yazık ki, sözdizimi bazen çok karmaşık ve sert ve en deneyimli geliştirici bile, yorum yapmadıysa, birkaç gün önce yazdığı oldukça karmaşık bir düzenli ifade olduğunu unutabilir. Bu nedenlerden dolayı, bazen hala satırlarla çalışmak için geleneksel yöntemlerin lehine düzenli ifadeleri terk etmeye değer.

Düzenli ifadeler ( Regexp.) - Bu satırlarla çalışmak için çok etkili bir yoldur.

Özel bir sözdizimi kullanarak düzenli bir ifadeyi eşleme yapabilirsiniz:

• arama metni Çizgide
• substring'i değiştirin Çizgide
• bilgileri kaldır Dizeden

Neredeyse tüm programlama dilleri düzenli ifadeler var. Uygulamada küçük farklılıklar var, ancak genel kavramlar hemen hemen her yerde uygulanır.

Düzenli ifadeler, string işleme algoritmaları için kavramsal bir arama şablonu olarak resmileştirildiklerinde 1950'lere atıfta bulunur.

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

Javascript, Perl ile birlikte, bu, normal ifadelerin desteğinin doğrudan dilde yapıldığı programlama dillerinden biridir.

Zor, faydalı

Newbies Düzenli ifadeler mutlak saçmalık ve çoğu zaman profesyonel geliştiriciler gibi görünebilir, eğer yatırım yapmamak için anlayışlar için gereklidir.

Düzenli ifadeler yazmak zor, okumak zor ve korumak / değiştirmek zor.

Ancak bazen düzenli ifadeler tek makul yol Satırların üstünde bazı manipülasyonlar yapın, bu yüzden çok değerli bir araçtır.

Bu kılavuz, size JavaScript'te düzenli ifadeler hakkında bir fikir vermenin ve normal ifadelerin nasıl okunacağı ve oluşturulacağı hakkında bilgi vermenin en kolay yoludur.

Ampirik kural budur basit normal ifadeler okumak ve yazmak için basittir., süre karmaşık düzenli ifadeler hızlı bir şekilde karışıklığa dönüşebilirTemelleri derinden anlamıyorsanız.

Düzenli ifadeler neye benziyor?

Javascript'te, düzenli ifadeler iki şekilde tanımlanabilecek bir nesnedir.

İlk yol oluşturmaktır. yeni RegeXP nesnesi Bir tasarımcı yardımı ile:

Const Re1 \u003d Yeni Regexp ("Hey")

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

Const Re1 \u003d / Hey /

Javascript'te ne olduğunu biliyorsun. değişmez nesneler ve edebiyat Masifi? İçinde ayrıca var regexp edebiyatları.

Yukarıdaki örnekte, hey denir şablon. Edebiyat formunda, iki sınır arasındadır ve nesnenin tasarımcısı durumunda, hayır.

Bu, normal ifadeleri tanımlamanın iki yolu arasındaki ilk önemli fark, geri kalanını daha sonra göreceğiz.

Nasıl çalışıyorlar?

Yukarıda RE1 olarak belirlediğimiz düzenli ifade çok basittir. Herhangi bir sınırlama olmadan hey bir dize arar: Dize çok fazla metin içerebilir ve hey kelimesi ortada bir yerdeydi ve düzenli ifade çalışacaktır. Dize sadece HEY kelimeyi içerebilir ve düzenli olarak tekrar çalışacak.

Bu oldukça basit.

Mantıksal (Boolean) değerini döndüren REGEXP.Test (string) yöntemini kullanarak normal ifadeyi test etmeye çalışabilirsiniz:

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

Yukarıdaki örnekte, RE1'de depolanan düzenli bir ifadenin "HEY" paterni olup olmadığını kontrol ettik.

Basitten daha kolaydır, ancak normal ifadeler hakkında çok şey tanıyorsunuz.

Düzeltme

/ Hey /

hey dizenin içinde olduğundan bağımsız olarak çalışacak.

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

/^hey/.Test ("Hey") // ✅ / ^ hey / .test ("Bla Hey") // ❌

Hey sona eren satırları bulmak istiyorsanız, operatörü $ kullanın:

/hey$/.test ("Hey") // ✅ /hey$/.Test ("Bla Hey") // ✅ /hey$/.test("hey siz ") // ❌

Önceki iki operatörü birleştirerek, HEY ile tamamen çakışan bir dize bulabilirsiniz:

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

Bir alt dizişle başlayan bir dize bulmak için ve bir bitiş onayını kullanabilirsiniz. *, Bu, 0 veya daha fazla kez tekrarlanan herhangi bir sembolle çakışacak:

/ ^hey.*joe$/.Test ("Hey Joe") // ✅ / ^ Hey. * Joe $ /. Test ("Heyjoe") // ✅ /^hey.*Joe$/.Test("hey Nasılsınız Joe ") // ✅ / ^hey.*joe$/.test("hey joe!") // ❌

Aralığa göre arama öğeleri

Belirli bir dize aramak yerine, karakter aralığını belirleyebilirsiniz, örneğin:

// // a, b, c, ..., x, y, z // // a, b, c, ..., x, y, z // // a, b, c // / / 0, 1, 2, 3, ..., 8, 9

Bu düzenli ifadeler, seçilen aralıktan en az bir karakter içeren satırları arıyor:

//.test("a ") // ✅ //.test("1) // ❌ //.test("a") // ❌ //.test("d ") // ❌ // .Test ("DC") // ✅

Aralıklar birleştirilebilir:

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

Aralık öğesinin birden fazla tesadüfini arayın

String'in sembolü kullanarak aralıktan yalnızca bir karakter içerip içermediğini kontrol edebilirsiniz -:

/ ^ $ / / ^ $ /. Test ("a") // ✅ / ^$/.Test ("ab") // ❌

Şablonun inversiyonu

Şablonun başlangıcındaki ^ sembolü, çizginin başlangıcına bağlar.

Aralığın içindeki bu sembolü kullanarak aralığı ters çevirir, böylece:

/ [I-ZA-Z0-9] /. Test ("A") // ❌ / [и ада-za-z0-9] /. Test ("1") // ❌ / [^ a-za - Z0-9] /. Test ("A") // ❌ / [и ада-za-z0-9] /. Test ("@") // ✅

Metakterler

• \\ D herhangi bir sayı eşdeğeri ile çakışıyor
• \\ D, [^ 0-9] 'e eşdeğer bir sayı olmayan herhangi bir sembolle çakışıyor
• \\ w herhangi bir alfasayısal sembol eşdeğeri ile çakışıyor
• \\ W [^ a-za-z0-9] 'na eşdeğer alfasayısal bir değer olmayan herhangi bir sembolle çakışır.
• Herhangi bir boşluk simgesiyle çakışır: boşluk, sekme, yeni bir satırın sembolü ve unicode
• Boş olmayan herhangi bir sembolle çakışıyor
• \\ 0 null ile çakışıyor
• \\ n, yeni bir satır sembolü ile çakışıyor
• Sekme sembolü ile çakışıyor
• \\ uxxxx, Unicode sembolü ile XXXX kodu (U bayrağı gerekli) ile çakışıyor
• . Yeni bir dize sembolü hariç herhangi bir sembolle çakışır (\\ n) (Bayrağını kullanmazsanız, daha sonra açıklayın)
• [^] Yeni bir dize sembolü de dahil olmak üzere herhangi bir sembolle çakışıyor. Çok satırlı dizelerle çalışırken kullanışlıdır

Düzenli ifadelerde seçim

Birini seçmek istiyorsan veya Diğer dize, operatörü kullanın | .

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

Nüsle

Dizeyi yalnızca bir rakamdan oluşacak şekilde kontrol eden düzenli bir ifadeye sahip olduğunuzu hayal edin:

kullanabilirsiniz nüsle ? Bu, bu sembolü isteğe bağlı yapacak. Bizim durumumuzda, rakam 0 veya 1 kez gerçekleşmelidir:

fakat normal ifadenin birkaç basamaklı olmasını istiyorsak?

+, *, (N) ve (n, m) kullanarak 4 yoldan yapabilirsiniz.

+

Bir veya daha fazla (\u003e \u003d 1) eleman ile çakışır:

/ ^ \\ D + $ / / / / / d + $ /. Test ("12) // ✅ / ^ \\ d + $ /. Test (" 14) // ✅ / ^ \\ d + $ /. Test ("144343") // ✅ / ^ \\ D + $ /. Test ("") // ❌ / ^ \\ d + $ /. Test ("1A") // ❌

*

0 veya daha fazla (\u003e \u003d 0) öğeleriyle çakışır:

/ ^ \\ d + $ / / / ^ \\ / \\ / тест ("12) // ✅ / ^ \\ d.7 / .test (" 14 ") // ✅ / ^ \\ D * $ /. Test (" 144343) ") // ✅ / ^ \\ d * $ /. Test (" ") // ✅ / ^ // ❌ Test (" ") // ❌

(N)

Tam element sayısıyla tam olarak çakışıyor:

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

(N, m)

N ila M elemanları arasındaki aralıkla çakışıyor:

/ ^ \\ D (3.5) $ / / ^ \\ D (3,5) $ /. Test ("123") // ✅ / ^ \\ D (3,5) $ /. Test ("21234") // ✅ / ^ \\ d (3,5) $ / /test("12345 ") // ✅ / ^ \\ d (3,5) $ /. Test (" 123456 ") // ❌

m ihmal edilebilir ve ikinci sınırı kısıtlamalar olmadan bırakılabilir, böylece minimum n öğesi vardır:

/ ^ \\ D (3,) $ / / ^ \\ D (3,) $ /. Test ("2) // ❌ / ^ \\ D (3,) $ /. Test (" 123) // ✅ / ^ \\ d (3.12345 ") // ✅ / ^ \\ D (3,) $ /. test (" 123456789 ") // ✅

İsteğe bağlı öğeler

Sonraki işareti öğesi? , isteğe bağlı yap:

/ ^ \\ D (3) \\ W? $ / / ^ \\ D (3) \\ W? $ //. Test ("123) // ✅ / ^ \\ D (3) \\ W? $ /. Test (" 123A ") // ✅ / ^ \\ D (3) \\ W? $ /. Test (" 123AB ") // ❌

Gruplar

Parantez kullanma, sembol grupları (...) oluşturabilirsiniz.

Aşağıdaki örnek, bir veya daha fazla alfasayısal karakter tarafından takip edilen 3 basamağın tam bir tesadüfini arıyor:

/ ^ (\\ D (3)) (\\ W +) $ / /) (\\ D (3)) (\\ W +) $ /. Test ("123) // ❌ / ^ (\\ D (3)) ( \\ w +) $ // test ("123s") // ✅ / ^ (\\ D (3)) (\\ W +) $ /. Test ("223Something") // ✅ / ^ (\\ D (3)) (\\ w +) $ /. test ("1234") // ✅

Kapanış grubundan sonra bulunan karakterleri tekrarlayan karakterler tüm gruba aittir:

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

Yakalama grubu

Şimdiye kadar çizgileri nasıl test edip belirli bir şablon içerip içermediklerini kontrol ettik.

Düzenli ifadelerin serin olasılığı Çizginin belirli bölümlerini yakalayın ve onları bir diziye koyun.

Grupların yardımıyla ya da daha doğrusu yakalama grubu.

Varsayılan olarak, gruplar yakalanır. Şimdi sadece mantıksal bir değer döndüren Regexp.test (string) kullanmak yerine, aşağıdaki yöntemlerden birini kullanacağız:

• String.match (regexp)
• Regexp.exec (string)

Onlar kesinlikle aynıdır ve her ikisi de birinci eleman olarak iletilen bir dize ve her grup için tesadüfin diğer unsurlarında bir diziyi döndürürler.

Eğer tesadüf yoksa, Boş'u döndürür.

"123s" .Match (/ ^ (\\ D (3)) (\\ W +) $ /) // dizi ["123s", "123", "123S"] / ^ (\\ D (3)) (\\ W +) $ /. Exec ("123s") // dizi ["123s", "123", "S"] "Hey" .Match (/ (hey | ho) /) // dizi ["Hey", "Hey"] /(hey|ho)/.exec ("hey") // dizi ["hey", "hey"] / (hey | ho) /. Exec ("ha!") // null

Grup birkaç kez eşleştiğinde, yalnızca son değer döndürülen diziye eklenecektir.

"123456789" .Match (/ (\\ d) + /) // dizi ["123456789", "9"]

İsteğe Bağlı Gruplar

Yakalama grupları (...) ile isteğe bağlı yapılabilir mi? . Hiçbir şey bulunmazsa, undefind undefind döndürülen diziye eklenecektir:

/ ^ (\\ D (3)))) () (\\ W +) $ /. Exec ("23 s") // dizi ["123 s", "123", "", "S"] / ^ ( \\ d (3)) (\\ s)? (\\ w +) $ /. Exec ("123s") // dizi ["123s", "123", tanımsız, "s"]

Bulunan gruba bağlantı

Her bulunan grubun bir numara atanır. 1 dolar, ilk öğeyi, ikinci ila ikinci, vb. Bu, çizginin bir kısmını değiştirmek hakkında konuşacağımızda yararlıdır.

Seçilen yakalama grubu

Bu yeni bir ES2018 özelliğidir.

Grup bir isim atanabilir ve iade dizisindeki sadece bir yuva değil:

Const Re \u003d / (? \\ D (4)) - (? \\ D (2)) - (? \\ D (2)) / const sonuç \u003d re.exec ("2015-01-02") // Sonuç. Grup.year \u003d\u003d\u003d "2015"; // sonuc.groups.month \u003d\u003d\u003d "01"; // sonuc.Groups.day \u003d\u003d\u003d "02";

Grupsuz Eşleşme ve Exec Kullanımı

Eşleşme ve Exec'i gruplar olmadan kullanırken bir fark vardır: İlk elemanın içinde, dizi tamamen bulunmaz, ancak doğrudan bir tesadüf:

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

Dudaklı gruplar

Varsayılan gruplar yakalandığından, iade edilen dizideki bazı grupları görmezden gelmenin bir yoluna ihtiyacımız var. Bu mümkündür kavurucu gruplarKim başlar (?: ...).

"123s" .Match (/ ^ (\\ D (3)) (?: \\ S) (\\ w +) $ /) // null "123 s" .Match (/ ^ (\\ D (3)) (? : \\ s) (\\ w +) $ /) // dizi ["123 s", "123", "S"]

Bayrak

Aşağıdaki bayrakları normal ifadelerde kullanabilirsiniz:

• g: Global olarak tesadüfler arıyor
• İ: Normal bir ifadeyi kaydolmaya duyarlı değil
• m: Çok satırlı mod içerir. Bu modda, ^ ve $ tüm satırın başlangıcı ve sonuna karşı çakışır. Bu bayrak olmadan, çok hatlı dizelerle, her satırın başlangıcı ve sonuna karşı çakışırlar.
• u: Unicode desteği içerir (ES6 / ES2015'e eklenir)
• s: (ES2018'de yeni) "tek satırdan" azaltılması, izin verir. Yeni bir çizginin sembolleriyle çakışmak

Bayraklar birleştirilebilir, aynı zamanda değişmez çizginin sonuna eklenebilirler:

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

veya Regexp nesne yapıcısındaki ikinci parametre tarafından iletilir:

Yeni Regexp ("Hey", "ig"). Test ("Hey") // ✅

Düzenli ifadelerin incelenmesi

Düzenli ifadelerin özelliklerini inceleyebilirsiniz:

• kaynak - şablonun satırı
• m bayrağının ayarlandığı takdirde çoklu - true alınır
• g bayrağının ayarlandığı takdirde global - gerçek değer kabul edilir
• ignorecase - Ayarlandığım bayrak ise değer doğrudur
• lastindex

/ ^ (\\ w (3)) $ / i.Source // "^ (\\\\ D (3)) (\\\\ W +) $" / ^ (\\ w (3)) $ / i.multiline // False / ^ (\\ w (3)) $ / i.lastindex // 0 / ^ (\\ w (3)) $ / i.ignorecase // true / d (\\ w (3)) $ / i.global / / yanlış

Koruyucu

Özel semboller:

Bunlar özel karakterlerdir çünkü düzenli ifadeleri çizerken kontrol karakterleridir, bu nedenle bunları şablonun içindeki tesadüfleri aramak için kullanmak istiyorsanız, onları ters eğik çizgi sembolünü kullanarak korumak gerekir:

/ ^ \\\\ $ / / ^ \\ ^ $ / // / ^ \\ ^ Testi ( "^ ") ✅ / ^ \\ $$ / // / ^ $ /. Testi (" $") ✅

Dize Kenarlıkları

\\ B ve \\ b, dizenin kelimenin başlangıcında veya sonunda olup olmadığını belirlemenizi bekler:

• Karakter kümesi kelimenin başlangıcında veya sonunda ise \\ b çakışır.
• \\ B Karakter kümesi kelimenin başlangıcında veya sonunda değilse çakışır.

"Ben bir Sakal Testere" .match (/ \\ BBEAR /) // Array [ "Ayı"] "Ben bir Sakal Testere" .match (/ \\ BBEAR /) // Array [ "Ayı"] "Ben bir ayı gördüm" .Match (/ \\ bbear \\ b /) // null "cool_bear" .Match (/ \\ BBEAR \\ B /) // null

Düzenli ifadelerle değiştirme

Şablonla eşleşecek hatları nasıl kontrol edeceğimizi çoktan gördük.

Şablona karşılık gelen satırların bir kısmının bir diziye nasıl çıkarılacağını da gördük.

Şimdi nasıl bakalım Çizginin bir kısmını değiştirin Şablona göre.

JavaScript'teki string nesnesi, için düzenli ifadeler olmadan kullanılabilecek bir forma () yöntemi bulunur. bir değiştirme Çizgide:

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

Bu yöntem ayrıca tartışma olarak düzenli bir ifade alabilir:

"Hello World!" Değiştirin (/ World /, "Dog") // Merhaba köpek!

G bayrağını kullanarak - bu tek yol Vanilya Javascript'teki satırdaki çeşitli olayları değiştirin:

"Benim Köpek İyi Köpek mi!". Değiştirin (/ Köpek / G, "Kedi") // My Cat IS A Good Kedi!

Gruplar daha tuhaf şeyler yapmamıza izin verir, satırların bölümlerini değiştirmemizi sağlar:

"Merhaba, dünya!". Değiştir (/ (\\ w +), (\\ w +)! /, "$ 2: 1 $ !!!") // "Dünya: Merhaba !!!"

Bir dize yerine, daha fazla ilginç şeyler yapmak için işlevi kullanabilirsiniz. Argümanların sayı sayısına bağlı olduğu, String.match (Regexp) veya regexp.exec (string) yöntemleri dönüşü gibi bir dizi argümana aktarılacaktır:

"Merhaba, Dünya!" Değiştir (/ (\\ w +), (\\ w +) / (Matchedstring, Birinci, İkinci) \u003d\u003e (console.log (İLK);.! Console.log (İkinci); Dönüş ` $ (second.touppercase ()): (ilk) $ !!! `)) // "DÜNYA: Merhaba !!!"

Açgözlülük

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

Bu ne anlama geliyor?

Örneğin, düzenli bir ifadedir:

/ \\ $ (. +) \\ s? /

Tutarı dolar cinsinden çıkarmamız gerektiği varsayılmaktadır:

/\\$(.+)'s?/.exec ("Bu 100 $ 'lık") // 0

peki ya numaradan sonra daha fazla kelimemiz varsa, dikkatini dağıtıyorsa,

/ \\ $ (. +)) \\ s? /. Exec ("Bu, 100 $ 'lık maliyetler ve 200 $' dan azdır) // 100 ve 200 dolardan az

Neden? Çünkü $ işaretinden sonra normal ifade, herhangi bir sembolle çakışıyor. + Ve çizginin sonuna ulaşana kadar durmaz. Sonra durur, çünkü \\ s? son boşluğu isteğe bağlı yapar.

Düzeltmek için, normal ifadenin olması gerektiğini belirlememiz gerekir. tembel Ve en küçük tesadüfleri bulun. Bunu sembolle yapabilir miyiz? Miktardan sonra:

/ \\$(.+?) /S/.exec ("Bu 100 $ 'a mal olur ve 200 $' dan az) // 100

Yani, sembol? pozisyonuna bağlı olarak farklı şeyler ifade edebilir, bu nedenle bir miktar ve gösterge olabilir tembel mod.

Önümüzde: Nasıl takip ettiğine bağlı olarak dize eşleştirme

Kullanma? \u003d Tanımlı bir alt çizgenin izlediği bir dizgedeki tesadüfleri aramak için

/ Roger (? \u003d Sular) / / Roger (? \u003d Sular) /. Test ("Roger benim köpeğim") // false / roger (? \u003d Suları) /. Test ("Roger köpeğim ve Roger sularım Ünlü müzisyen ") // true

Ters bir işlem gerçekleştirir ve içindeki string içindeki tesadüfler bulunur. değil Kesin bir substring izler:

/ Roger (?! Sular) / / Roger (?! Sular) /. Test ("Roger benim köpeğim") // True / Roger (?! Sular) /. Test ("Roger köpeğim ve Roger Waters'ım Ünlü müzisyen ") // false

Retrospektif: Ne'den önce olduğuna bağlı olarak eşleşen dize

Bu yeni bir ES2018 özelliğidir.

İleride bir sembol kullanır? \u003d. Retrospektif kullanır?<= :

/(?<=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

Retrospektiflerin inversiyonu kullanıyor musunuz?

/(?

Düzenli ifadeler ve unicode

Bu ilk 1.600 Unicode karakterleri dahil değildir astral düzlemlerde işlem hatları için gerekli olabilir, özellikle de Unicode telli çalışırken U bayrağı zorunludur.

Örneğin, emodi, ama sadece onlar.

/^.$/.test("a ") // ✅ / ^. $ /. Testi ("? ") // ❌ / ^. $ / U.Test ("? ") // ✅

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

Unicode ve sıradan karakterlerin yanı sıra, aralıkları işleyebilir:

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

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

Tarama özellikleri Unicode.

Yukarıda söylediğimiz gibi, düzenli bir ifade şablonunda, herhangi bir rakamda bir tesadüf bulmak için, bir alanın yanı sıra herhangi bir karakterde bir eşleşme bulmak için \\ d kullanabilirsiniz, herhangi bir alfasayısal sembolde vb. Bir tesadüf bulmak için.

unicode özellikleri perdeleme \\ p () ve \\ p () tüm unicode karakterleri üzerinde bu kavramı genişleterek ve ekleyerek, çok serin fonksiyonu ekler ES2018, olasılığıdır.

Herhangi bir Unicode sembolünün bir dizi özellik vardır. Örneğin, Senaryo Diller Aile tanımlayan ASCII mantıksal değerdir ASCII karakterleri, vb True olarak eşit Bu özelliği kıvırcık parantez içine koyabilirsiniz ve normal ifade değerinin doğru olduğunu doğrulayacaktır:

/ ^ / U_ascii) + $ /U.Test("abc ") // ✅ / ^ \\ p (ASCII) + $ / u.Test (" [E-posta Korumalı]") // ✅ / ^ \\ P (SCII) + $ /U.Test (" ABC? ") // ❌

ASCII_HEX_DIGIT kontrolleri dize tek geçerli yüksek alkali numaralarını içerip içermediğini başka mantıklı bir özelliktir:

/ ^ / p (scii_hex_digit) + $ / u.test ("0123456789abcde") // ✅ / ^ \\ p_ascii_hex_digit) + $ / u.Test ("H")

sadece büyük harf, küçük, White_Space, alfabetik, Emoji ve diğerleri dahil olmak üzere kıvırcık parantez içine kendi adını ekleyerek kontrol edebilirsiniz birçok başka mantık özellikleri vardır:

/ ^ /U.Test("h ") // ✅ / ^ \\ (p büyük) $ /U.Test("h") // ✅ / ^ \\ (p emojisi) + $ / U.Test ( "H ") // ❌ / ^ \\ p (emoji) + $ / u.test (" ?? ") // ✅

Bu ikili özelliklere ek olarak, belirli bir değere karşılık gelen Unicode sembolünün herhangi bir özelliğini kontrol edebilirsiniz. Aşağıdaki örnekte, Yunan veya Latin alfabesindeki dizenin kaydedilip kaydedilmediğini kontrol ediyorum:

/ ^ Cro_script \u003d Yunanca) + $ / u.Test ("ελληνικά") // ✅ / ^ \\ p (Script \u003d Latin) + $ / u.Test ("Hey") // ✅

Örnek

Bir numaranın bir dizgeden çıkarılması

Diyelim ki, kaldırılması gereken tek bir numara içeren bir dize var. / \\ d + / yapmalı:

"Test 123123329" .Match (/ \\ d + /) // dizi ["123123329"]

E-posta adreslerini ara:

En basit yaklaşım, @ işaretinden önce ve sonra inanılmaz karakterleri kontrol etmektir:

/ (\\ S +) @ (\\ S +) \\ ((\\ S +) / / (\\ s *) '(\\ s *). \\ (\\ S +) /. Exec (" [E-posta Korumalı]") //["[E-posta Korumalı]"," COPESC "," Gmail "," COM "]

Bununla birlikte, bu basitleştirilmiş bir örnektir, çünkü altındaki birçok geçerli e-posta adresi var.

Çift tırnak arasındaki metni yakalayın

Çift tırnak içinde metin mahkumları içeren bir dizginiz olduğunu ve bu metni çıkarmanız gerektiğini hayal edin.

Bunu yapmanın en iyi yolu kullanmaktır. yakalama grubuÇünkü tesadüfümüzün sembolüyle başlaması ve bitmesi gerektiğini biliyoruz, bu yüzden şablonu kolayca yapılandırabiliriz, ancak bu teklifleri sonuçtan kaldırmak istiyoruz.

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

Const Merhaba \u003d "Merhaba" güzel çiçek "" const sonuç \u003d / "([_" "*" /.eexec(hello) // dizi ["\\" Güzel çiçek \\ "", "güzel çiçek"]

HTML etiketinden içerik elde etme

Örneğin, içeriğini açıklık etiketinden alın, etiket için herhangi bir sayıda argümanlara izin verir:

/]*>(.*?)<\/span>/ /]*>(.*?)<\/span>/.exec ("Test") // null / ]*>(.*?)<\/span>/.exec ("Test") // ["Test", "Test"] / ]*>(.*?)<\/span>/.exec (" Ölçek") // ["Ölçek"," Ölçek "]

JavaScript'teki RegeXP sınıfı normal bir ifadedir - karakter şablonunu tanımlayan bir nesnedir. Normal ifade nesneler genellikle aşağıda değişmezleri özel sözdizimi kullanılarak oluşturulur, ancak aynı zamanda () yapıcısı RegExp tarafından oluşturulabilir.

Sözdizimi

// özel bir değişmez sözdizimi kullanma var regex \u003d / desen / bayraklar; // tasarımcı ile var regex \u003d yeni regexp ("desen", "bayraklar"); var regex \u003d yeni regexp (/ desen /, "bayraklar");

Parametre değerleri:

Düzenli ifadelerin bayrakları

Bayrak	Açıklama
g.	Tüm tesadüfleri bulmanızı ve ilk tesadüfin ardından durmamasını sağlar ( global maç bayrağı.).
bEN.	Kayıt olmadan karşılaştırmanıza olanak sağlar ( vaka bayrağını yoksay).
m.	Haritalama birkaç satırda yapılır. (^ Ve $) başlangıç \u200b\u200bve son karakter işlenmesi birkaç hatlarına göre yapılır, olduğu, eşleme her satırın başında veya sonunda (\\ N ya da \\ r ayırıcılar) meydana gelir ve sadece başlangıcı ile, ya da tüm çizginin sonu ( multiline bayrağı).
u	Şablon, Unicode Kod Noktası dizisi olarak kabul edilecektir ( unicode bayrağı).
y.	Haritalama, bu düzenli ekspresyonun lastIdlex'in özelliğini gösteren endeksde meydana gelirken, haritalama daha sonraki veya erken indeks yapılmaz () yapışkan bayrak.).

Sembol setleri

Metakterler

Sembol	Açıklama
.	Bir yeni dize sembolü dışında karakter veya dize sonu (\\ n \\ r \\ u2028 ya \\ u2029) bulmak için izin verir.
\\ D.	Temel Latin alfabesinde sayıların sembolünü bulmanızı sağlar. Eşdeğeri kullanın Karakter seti.
\\ D.	Temel Latin alfabesinde bir rakam olmayan herhangi bir karakter bulmanızı sağlar. Bir karakter kümesine eşdeğer [^ 0-9].
\\ S.	Tek bir boş sembol bulmanızı sağlar. Uzay sembolünün altında bir alan, tablo, sayfa çeviri, dizgenin çevirisi ve Unicod'un diğer küresel sembolleri olarak anlaşılmaktadır. Karakter [\\ f \\ n \\ r \\ t \\ v \\ u00a0 \\ u1680 \\ u180e \\ u2000 \\ u2001 \\ u2002 \\ u2003 \\ u2004 \\ u2005 \\ u2006 \\ u2007 \\ U2008 \\ u2009 \\ U2008 \\ u2009 \\ U2008 \\ bir dizi denk U2028 \\ U2029 \\ U202F \\ U205F \\ U3000].
\\ S.	Boş olmayan tek bir sembol bulmanızı sağlar. uzay sembolü altında, bir boşluk, tabulation, sayfa çevirmeyi, dize çeviri ve UNICOD diğer küresel semboller olarak anlaşılmaktadır. karakter [^ \\ f \\ n \\ r \\ t \\ v \\ u00a0 \\ u1680 \\ u180e \\ u2000 \\ u2001 \\ u2002 \\ u2003 \\ u2004 \\ u2005 \\ u2006 \\ u2007 \\ U2008 \\ u2009 \\ U2008 \\ u2009 \\ U2008 bir dizi denk \\ U2028 \\ u2029 \\ u202f \\ u205f \\ u3000].
[\\ b]	BACKSPACE sembolünü bulmanızı sağlar (Özel Sembol \\ B, U + 0008).
\0	Sembol 0 (sıfır) bulmanızı sağlar.
\\ N.	Yeni bir dize sembolü bulmanızı sağlar.
\\ F.	Sayfa çeviri sembolü bulmanızı sağlar.
\\ R.	Bir satır başı dönüşü sembolü bulmanızı sağlar.
\\ T	Yatay sekmesinin bir sembolünü bulmanızı sağlar.
\\ V.	Dikey sekmenin bir sembolünü bulmanızı sağlar.
\\ W.	Alt çizgi dahil olmak üzere, taban latin alfabesinin alfanümerik bir sembolünü bulmanızı sağlar. Bir karakter kümesine eşdeğer.
\\ W.	Temel Latin alfabesinden bir sembol olmayan herhangi bir karakter bulmanızı sağlar. Bir karakter grubuna eşdeğer [^ a-za-z0-9_].
\\ Cx.	String'de bir kontrol simgesi bulmanızı sağlar. X, A'dan Z'ye mektuptur. Örneğin, / \\ CM / CTRL-M sembolünü belirtir.
\\ Xhh.	HexadeMimal değeri kullanarak bir sembol bulmanıza olanak sağlar (HH iki basamaklı onaltılık bir değerdir).
\\ uhhhh	UTF-16 kodlaması (HHHH - dört basamaklı onaltılık değer) kullanarak bir sembol bulmanızı sağlar.
\\ U (hhhh) veya \\ U (hhhhh)	Unicode U + HHHH veya U + HHHHH (onaltılık) değeri ile bir sembol bulmanıza olanak sağlar. Sadece U bayrağı belirtildiğinde.
\	Bir sonraki karakterin özel olduğunu ve kelimenin tam anlamıyla yorumlanmamasını belirtir. Genellikle özel bir şekilde yorumlanan semboller için, bir sonraki karakterin özel olmadığını ve kelimenin tam anlamıyla yorumlanmasını gösterir.

Kısıtlamalar

Nüsle

Sembol	Açıklama
n *	Hareket, sembolün sıfır veya daha fazla oluşumunu içeren herhangi bir dize ile oluşur. n..
n +.	Biçme, en az bir karakter içeren herhangi bir dize ile oluşur n..
n?	Hareket önceki bir öğeyle herhangi bir dize ile oluşur n. Sıfır veya bir kez.
n (x)	Bir karakter dizisi içeren herhangi bir satıra karşılık gelir n. Belirli sayıda kez x.. X.
n (x,)	x. Önceki öğenin düzenlemeleri n.. X. Bütün pozitif bir sayı olmalıdır.
n (x, y)	En azından içeren herhangi bir satıra karşılık gelir x.ama daha fazla değil y. Yukarıdaki elementin girişleri n.. X. ve y. Tamsayı pozitif sayılar olmalıdır.
n *? N +? N ?? n (x)? n (x,)? n (x, y)?	Hareket, Quantifiers *, +, "ile analoji ile gerçekleşir. ve (...) Ancak, arama asgari olası karşılaştırmayı giderse de. Varsayılan "açgözlü" modu,? Niceleyin sonunda, karşılaştırmanın tekrarı'nın mümkün olan en az sayıda kez gerçekleştiği "Unjone" modunu belirlemenizi sağlar.
x (? \u003d y)	Karşılaştırmanızı sağlar x.sadece eğer x. takip et y..
x (?! Y)	Karşılaştırmanızı sağlar x.sadece eğer x. bunu yapma y..
x | y.	Karşılaştırma belirtilen alternatiflerden herhangi biriyle gerçekleşir.

Gruplandırma ve Backlinks

Sembol	Açıklama
(x)	Bir sembol bulmanıza izin verir x. ve karşılaştırmanın sonucunu hatırlayın ("heyecan verici parantez"). Bir karşılaştırıldığında alt dize elde edilen dizinin elemanları neden olabilir ..., [n], ya da ... $ 1 önceden Normal ifade nesnesinin özelliklerinden, 9 $.
(?: x)	Bir sembol bulmanıza izin verir x.Ancak karşılaştırmanın sonucunu ezberlemek için değil ("eksik olmayan parantez"). Derlenmiş alt dize elde edilen dizinin elemanları neden olamaz ..., [n], ya da ... önceden Normal ifade nesnesinin $ 1 özelliklerinden, 9 $.
\\ N.	NO-O ile çakışan son ikame ile karşı bağlantı, normal terimlerdeki parantez içindeki hesapta (parantezlerin numaralandırılması sağa doğru gider). n. Bütün pozitif bir sayı olmalıdır.

Düzenli ifadeler Ekstrakte etmek veya değiştirmek için metinlerdeki kelimeler ve ifadeler için esnek bir aramaya izin verin.

Sözdizimi:

// normal bir ifade oluşturma için ilk seçenek var var regexp \u003d yeni regexp ( şablon,değiştirici); // normal bir ifadenin oluşturulmasının ikinci versiyonu var regexp \u003d / şablon/değiştirici;

şablon Arama için karakter şablonunu ayarlamanızı sağlar.

değiştirici Arama davranışı yapılandırmanıza izin verin:

• bEN. - Harf durumuna kayıt olmadan arama;
• g. - Global arama (tüm tesadüfler belgede, sadece ilk değil);
• m. - Çok satırlı arama.

Kelimeleri ve ifadeleri ara

Düzenli ifadelerin en basit kullanımı, çeşitli metinlerde kelimeleri ve ifadeleri bulmaktır.

Ayarları kullanarak aramayı kullanma örneğini verelim:

// normal ifadeyi ayarlayın RV1 RV1 \u003d / Rusya /; // normal ifadeyi ayarlayın RV2 RV2 \u003d / Rusya / g; // normal ifadeyi ayarlayın RV3 RV3 \u003d / RUSYA / IG; // // ifadeleri kullanırken metinde tesadüfler bulunacak olan cesur bir font tahsis edilir. RV1: Rusya, dünyanın en büyük halidir. Rusya 18 ülkeye sahip sınırlar. Rusya, SSCB'nin devlet-sürekliliğidir. // Bir kalın yazı tipi // İfadeler RV2 kullanıldığında tesadüfler metinde bulunacaktır nerede, tahsis edilir: Rusya dünyanın en büyük devletidir. Rusya 18 ülkeye sahip sınırlar. Rusya, SSCB'nin devlet sürekliliğidir. "; // Yağ yazı tipi, // ifadeleri kullanırken metinde tespit edilen yağ yazı tipi: Rusya, dünyanın en büyük eyaletidir. Rusya 18 ülke ile sınırlar. Rusya devlet - SSCB'nin halefidir. ";

Özel semboller

Düzenli ifadedeki geleneksel karakterlere ek olarak, şablonlar kullanılabilir Özel semboller (Metacters). Açıklamaları olan özel karakterler aşağıdaki tabloda gösterilmiştir:

Özel sembol	Açıklama
.	Dize uç sembolü hariç herhangi bir sembolle çakışır.
\\ W.	Herhangi bir alfabetik sembolle çakışır.
\\ W.	Herhangi bir alfabetik sembolü ile çakışıyor.
\\ D.	Sayılar olan karakterlerle çakışıyor.
\\ D.	Sayılar olmayan karakterlerle çakışır.
\\ S.	Bıçak sembolleriyle çakışıyor.
\\ S.	Uzay sembolleri ile çakışıyor.
\\ B.	Tesadüfler, yalnızca kelimelerin sınırlarında aranacaktır (başlangıçta veya sonunda).
\\ B.	Tesadüfler sadece kelimelerin sınırlarında değil, bozulacak.
\\ N.	Bir satır çeviri sembolü ile çakışıyor.

/ * İfade Reg1, iki keyfi harfle başlayan ve "veteriner" ile biten tüm kelimeleri bulacaktır. teklifte kelimeler boşlukla ayrılır beri sonra başında ve sonunda biz specialsimol \\ lar) * / reg1 \u003d / \\ s..t katacak \\ s / g.; txt \u003d "Merhaba Covenant Velvetet Cloopet"; Belge.write (txt.match (reg1) + "
"); / * İfade REG2, üç keyfi harfle başlayan ve" veteriner "* * / reg2 \u003d / \\ s ... womb \\ s / g ile biten tüm kelimeleri bulacaktır. WOMB \\ S / G; DOKTORN.WRITE (txt.match (reg2) + "
"); Txt1 \u003d" AÇIK çalar OH YÜKSEK PREMIRT; ile "ile başlayan tüm kelimeleri bulabilirsiniz / * İfade REG3" * / var reg3 \u003d / ile \\ DVL / G" Vet "o halde 1 rakamı ve uç aşağıda" ; Belge gelirse yaz (TXT1.Match (REG3) + "
"); // Expression Reg4, VAR REG4 \u003d / \\ D / G; TXT2 \u003d" 5 yıllık çalışma, 3 yıllık yüzme, 9 yaşında bir çekim. "Document.write (txt2.match) metnin tüm numaralarını bulacaktır." Document.write (txt2.match) (Reg4) + "
");

Hızlı Görünüm

Köşeli parantez içinde semboller

Köşeli parantez kullanma [Kayu] Üretmeniz gereken bir karakter grubunu belirleyebilirsiniz.

Sembol ^ Kare parantez içinde bir karakter grubunun önünde [^ qg] Alfabenin tüm karakterlerini belirtilenler dışındaki tüm karakterleri aramanın gerekli olduğunu göstermektedir.

Kake parantez içindeki semboller arasındaki çizgiyi (-) kullanarak [AA] Üretmek istediğiniz karakter aralığını ayarlayabilirsiniz.

Kare parantez yardımıyla, numaraları da arayabilirsiniz.

// normal ekspresyonu ayarlayın REG1 REG1 \u003d / \\ SCO [TDM] \\ S / G; // TXT1 TXT1 \u003d "KATTIC KOD KOM KOMERSANT" metninin dizesini ayarlayın; // Düzenli ekspresyonu kullanarak üretin Reg1 txt1 belgesinde arama. Yazma hattı (txt1.match (reg1) + "
"); Reg2 \u003d / \\ slo [^ tg] / g; txt2 \u003d" Slot Slot Slogu "; Document.write (txt2.match (reg2) +"
"); Reg3 \u003d // g; txt3 \u003d" 5 yıllık çalışma, 3 yıllık yüzme, 9 yaşında çekim "; belge.write (txt3.match (reg3));

Hızlı Görünüm

Nüsle

Nüsle - Bu tasarım, ondan önce sembolün kaç kez veya bir karakter grubunun tesadüfinde buluşması gerektiğini belirlemenizi sağlar.

Sözdizimi:

// önceki sembol X - zamanlarla tanışmalı (x) // Önceki sembol X'den A'ya dahil olmalıdır (x, y) // Önceki sembol en az x defa karşılamalıdır (x,) //, önceki sembolün 0 veya daha fazla kez gerçekleşmesi gerektiğini belirtir. * //, önceki sembolün 1 veya daha fazla kez buluşması gerektiğini belirtir. + //, önceki sembolün 0 veya 1 kez gerçekleşmesi gerektiğini belirtir. ?

// normal ifadeyi ayarlayın RV1 RV1 \u003d / Co. (5) WAT / G // Normal ekspresyonu ayarlayın RV2 RV2 \u003d / KO (3,) Watder / g // Düzenli ifadeyi ayarlayın RV3 RV3 \u003d / Co. + Wat / G // Set düzenli ifade RV4 RV4 \u003d / ko SU / G // Seti tesadüfler // ifadeler RV1 kullanarak metin bulunacaktır düzenli ifade RV5 RV5 \u003d / KO * WATDER / G // kalın yazı tipi gösterileri: Nakit Kedi Cat: // İfadeler RV2 kullanırken metin metninde bulunacaktır Cushka Kedi Kooshka Kedi Antrenör Koooooh Co -oooooooooooooooooooooooo // kalın yazı tipi gösterileri koo -Opoo Coooookhop Coooooooookh CooooooOhokha // BOLD font, // ifadeleri kullanırken metinde nerede bulunacağını gösteriyor: Cushka kedi Kooshka Coooshop Coooookhoko KooooooOpoo Coooooooooohka // kullanırken metin metninde bulunacaktır Kalın yazı gösterileri // İfadeler RV4: Metin // RV5 ifadeler kullanarak metin içinde bulunacaktır Nakit Kedi Kooshop COOOOOKHOK COOOOOOKHOKA COOOO -OOOKHOP COOOOOOHKA // Kalın yazı gösterileri: nakit Kedi Kedi Kooshka Kooooooooo Coooooooooooooooooooooooooooooo

Not: Herhangi bir özel sembol kullanmak istiyorsanız (örneğin. * +? Veya ()) Numaranın önüne nasıl koymanız gerektiğini.

Yuvarlak parantez kullanma

Düzenli ifade şablonunun bir kısmını parantez içine girerek, şablonun bu kısmında bulunan tesadüfin hatırlanması için ifadeyi belirtirsiniz. Kayıtlı tesadüf kodunuzda daha sonra kullanılabilir.

Örneğin, düzenli ifade / (Dimitri) \\ Svasiliev / "Dimitri Vasilyev" satırını bulacak ve alt dize "Dmitry" hatırlayacaktır.

Aşağıdaki örnekte, metindeki kelime sırasını değiştirmek için Değiştir () yöntemini kullanırız. Kaydedilen tesadüflere hitap etmek için 1 ve 2 dolar kullanıyoruz.

Var regexp \u003d / (dmitry) \\ s (vasilyev) /; Var metin \u003d "Dmitry Vasilyev"; var newtext \u003d text.replace (regexp, $ 2 $ 1); Document.write (newtext);

Hızlı Görünüm

Yuvarlak dirsekler, karakterlerden önce karakterleri gruplandırmak için kullanılabilir.

Bazı insanlar bir problemle karşı karşıya, "Ah, ve normal ifadeler kullanıyorum." Şimdi onların iki problemi var.
Jamie Runovsky

Yuan-MA şöyle dedi: "Ahşap yapısındaki bir ağacı kesmek için çok fazla güç gerekiyor. Sorunun çöküşünü programlamak için birçok kod gereklidir.
Yuan-Ma'nın Ustası, "Programlama Kitabı"

Programlama araçları ve teknikleri, kaotik-evrimsel bir şekilde hayatta kalır ve dağıtılır. Bazen güzel ve ustaca değil yaşamaktadır ancak alanında oldukça iyi çalışanlar sadece bu - örneğin, bunlar başarılı bir teknolojiye entegre edilmiştir eğer.

Bu bölümde, bu aracı tartışacağız - düzenli ifadeler. Bu, dize verilerindeki şablonları tanımlamanın bir yoludur. Javascript'te ve diğer birçok dilde ve araçlara dahil olan küçük bir dil oluştururlar.

Düzenli düzenlilikler çok garip ve son derece faydalıdır. Sözdizimi gizemlidir ve JavaScript'teki program arayüzü sakardır. Ancak bu araştırma ve sıra işleme için güçlü bir araçtır. Onlarla anlaşılan, daha verimli bir programcı olacaksınız.

Düzenli ifade oluşturun

Düzenli, nesnenin türüdür. Regexp yapıcısını arayarak veya teçhizatlarla çevrili istenen deseni yazarak oluşturulabilir.

Var re1 \u003d yeni regexp ("ABC"); Var re2 \u003d / abc /;

Bu normal ifadelerin her ikisi de bir şablonu temsil eder: "A" sembolü, ardından "B" sembolü ve ardından "C" sembolü.

Regexp yapıcısını kullanırsanız, şablon normal bir dize olarak yazılır, bu nedenle tüm kurallar ters katmanlara göredir.

Şablonun eğik çizgiler arasında olduğu ikinci giriş, ters vuruşları farklı şekilde işler. Öncelikle, desen düz bir yolla bitiyor, o zaman şablonumuza dahil etmek istediğimiz doğrudan levha önünde bir ters yattı koymanız gerekir. Ayrıca, tip özel karakterler parçası olmayan ters vuruş \\ n kaydedilmiş (ve hatlarında olduğu gibi, göz ardı), ve şablon anlamını değiştirmek olacaktır. Böyle bir soru işareti ya da artı olarak bazı karakterler, normal düzenliliklerin özellikle önem taşımaktadır, ve böyle bir sembol bulmak gerekiyorsa, o da ters parçayı hazırlarken edilmelidir.

Var on sekizeenplus \u003d / onsekiz \\ + /;

Hangi karakterlerin bir eğikliği önlemeniz gerektiğini bilmek için, düzenli olarak tüm özel karakterlerin bir listesini öğrenmeniz gerekir. Gerçekçi olmasına rağmen, şüphe durumunda, sadece bir harf, sayı veya alan olmayan herhangi bir sembolün önüne ters yatarı koyun.

Tesadüf Kontrolü

Regülatörlerin çeşitli yöntemleri vardır. En basit - test. Bir dize verirseniz, Boolean değerini döndürür, hattın belirtilen şablonun girişini içerip içermediğini bildirir.

Console.log (/abc/.test ("abcde")); // → gerçek konsol.log (/abc/.test ("abxde")); // → yanlış.

Yalnızca özel olmayan karakterlerden oluşan düzenli olarak, bu karakterlerin sırasını temsil eder. ABC, kontrol ettiğimiz doğrultuda bir yerse (sadece başlangıçta değil), test doğru geri dönecektir.

Bir dizi karakter arıyoruz

ABC dizesinin içerip içermediğini öğrenmek için, Endeks dosyası ile mümkün olur. Düzenli olarak daha ileri gitmenize ve daha karmaşık kalıpları oluşturmanıza izin verin.

Herhangi bir sayı bulmamız gerektiğini varsayalım. Karakter kümesini normal parantez içinde ayarlarken, bu, bu, ekspresyonun bu kısmının, parantez içindeki karakterlerden herhangi biriyle çakıştığı anlamına gelir.

Her iki ifadenin de rakamı içeren satırlarda.

Console.log (//. Test ("1992'de")); // → Gerçek konsol.log (//. Test ("1992'de")); // → Doğru.

Kare parantez içinde, iki karakter arasındaki çizgi, sıranın Unicode kodlamaya ayarlandığı karakter aralığını belirtmek için kullanılır. 0'dan 9'a kadar olan semboller sadece bir üst üste (48 ila 57 arasında kodlar) var, bu yüzden hepsini yakalar ve herhangi bir rakamla çakışır.

Birkaç karakter grubunun kendi yerleşik indirimleri var.

\\ D herhangi bir rakam
\\ w alfanümerik sembol
Battaniye sembolü (boşluk, sekme, satır çeviri vb.)
Bir rakam değil
\\ W alfasayısal bir sembol değil
Boş bir sembol değil
. Çeviri hattının hariç herhangi bir sembol

Bu şekilde, tarih ve saat biçimini 30-01-2003 15:20 gibi aşağıdaki ifadeyle sorabilirsiniz:

Var datetime \u003d / \\ d \\ d \\ d \\ d- \\ d \\ d \\ d \\ d \\ d \\ d: \\ d \\ d /; Konsol.log (datetime.test ("30-01-2003 15:20")); // → Gerçek konsol.log (datetime.test ("30-Jan-2003 15:20")); // → yanlış

Korkunç görünüyor, değil mi? Şablonu anlamayı zorlaştıran çok fazla ters katman. Daha sonra biraz iyileştireceğiz.

Kare parantezlerde ters vuruşlar da kullanılabilir. Örneğin, [\\ d] herhangi bir rakam veya nokta anlamına gelir. Kare parantez içindeki noktanın özel değerini kaybettiğini ve basitçe noktaya döndüğünü unutmayın. Aynısı diğer özel karakterler için de geçerlidir, +.

Bir dizi karakterleri ters çevirin - yani, setteki kişiler hariç, herhangi bir karakter bulmanız gerektiğini söylemek gerekir.

Var NOTBinary \u003d / [^ 01] /; Konsol.log (Notbinary.test ("1100100010100110")); // → Yanlış konsol.log (Notbinary.test ("1100100010200110")); // → Doğru.

Şablonun parçalarını tekrarlıyoruz

Bir rakamı nasıl bulacağız. Ve eğer tamamen sayısını bulmamız gerekiyorsa - bir veya daha fazla rakam dizisi?

Düzenli işaret + 'da bir şeyden sonra koyarsanız, bu elemanın bir kereden fazla tekrarlanabileceği anlamına gelecektir. / \\ d + / bir veya daha fazla rakam anlamına gelir.

Console.log (/ "\\ d +" /. Test ("" 123 "")); // → Gerçek konsol.log (/ "\\ D +" /. Test ("" ""))); // → Yanlış konsol.log (/ "\\ d *" /. Test ("" 123 "")); // → Gerçek konsol.log (/ "\\ d *" /. Test ("" ""))); // → Doğru.

Yıldızlarda * Değer neredeyse aynıdır, ancak şablonun sıfır zamana katılmasını sağlar. Bir şeyin yıldızları durursa, şablonun şablonun dizesinde bulmasını asla engellemez - bu sadece sıfır zaman var.

Soru işareti isteğe bağlı olan şablonun bir kısmını yapar, yani sıfır veya bir kez karşılayabilir. Aşağıdaki örnekte, U sembolü oluşabilir, ancak şablon olmadığında çakışır.

Var komşusu \u003d / komşu? R /; Konsol.log (komşu ("komşu")); // → Gerçek konsol.log (komşu ("Komşu")); // → Doğru.

Şablonun karşılaşması gereken tam sayıda ayarlamak için kıvırcık parantezler kullanılır. (4) Elemandan sonra 4 kez satırda buluşması gerektiği anlamına gelir. Ayrıca boşluğu ayarlayabilirsiniz: (2.4), elemanın en az 2 ve en az 4 kez buluşması gerektiği anlamına gelir.

Bir veya iki haneden gün, aylar ve saatlerin izin verilen tarih ve saat biçiminin bir başka versiyonu izin verilir. Ve o sadece daha okunaklı.

Var DateTime \u003d / \\ D (1,2) - \\ D (1,2) - \\ D (4) \\ D (1,2): \\ D (2) /; Konsol.log (datetime.test ("30-1-2003 8:45")); // → Doğru.

Aralıkları açık bir uçla kullanabilir, sayılardan birini indirebilirsiniz. (5) şablonun sıfırdan beş katı ve (5,) - beş veya daha fazla arasında buluşabileceği anlamına gelir.

Abonelik Gruplandırma

Derhal birden fazla öğeye * veya + operatörlerini kullanmak için parantez kullanabilirsiniz. Parantez içine alınan düzenli, düzenli, operatörler açısından bir eleman olarak kabul edilir.

Var cartooncrying \u003d / boo + (hoo +) + / i; Console.log (cartooncrying.test ("boohoooohoohooo")); // → Doğru.

Birinci ve ikinci avantajlar, BOO ve HOO sözleriyle ilgili yalnızca ikinci harfleri içerir. Üçüncü +, bir grubu (Hoo +), bir veya daha fazla diziyi bulur.

İfadenin sonunda I harfi, sembol kayıtlarına düzenli olarak duyarsız hale getirir - böylece B B ile çakışır.

Tesadımlar ve Gruplar

Test yöntemi, düzenleyicileri kontrol etmenin en kolay yöntemidir. Sadece bir tesadüf bulunup bulunmadığını bildirdi. Düzenleyicilerin hiçbir şey bulunamadığı takdirde null dönecek başka bir Exec yöntemine sahiptir ve aksi takdirde nesne tesadüf hakkında bilgi verecektir.

Var maçı \u003d / \\d +/.exec ("bir iki 100); Console.log (eşleşme); // → ["100"] konsol.log (maç.index); // → 8.

İade edilen bir Exec nesnesi, tesadüfin gerçekleştiği karakter numarasını içeren bir dizin özelliğine sahiptir. Genel olarak, nesne birinci elemanın tesadüf yapıldığı bir dize olduğu bir dizgiye benziyor. Örneğimizde, aradığımız rakamların sırası olacaktır.

Dizelerin aynı şekilde çalıştığı bir maç yöntemi var.

Konsol.log ("bir iki 100" .Match (/ \\ d + /)); // → ["100"]

Düzenli olarak yuvarlak parantezler tarafından gruplanan bir başvuru içerdiğinde, bu gruplarla çakışan metin de dizide görünecektir. İlk unsur her zaman bütün bir tesadüf. İkincisi, birinci gruba (her şeyden önce yuvarlak parantez yiyen), sonra ikinci grupla ve benzeri bir parçasıdır.

Var quotedtext \u003d / "([^"] *) "/; console.log (quotedtext.exec (" "dedi" Merhaba "")); // → ["Merhaba", "Merhaba"]

Grup hiç bulunmadığında (örneğin, soru işareti arkasında ise), dizideki konumu tanımsız içermektedir. Grup birkaç kez çakışırsa, o zaman dizide sadece son tesadüf olacaktır.

Console.log (/ kötü (ly)? /. Exec ("kötü")); // → ["kötü", undefined] konsol.log (/ (/ d) + /. Exec ("123")); // → ["123", "3"]

Gruplar, parça parçalarını çıkarmak için kullanışlıdır. Sadece tarih çizgisinin satırındayken olup olmadığını kontrol etmeniz ve tarihi temsil eden bir nesneyi oluşturmak için, parantez içine girebiliriz ve Exec'ten bir tarih seçebiliriz.

Ancak, JavaScript'te tarih ve saati depolamanın tercih ettiğini öğrendiğimiz hafif bir rakamla başlamak.

Tarih türü

Javascript, tarihler için standart bir nesne türüne sahiptir - ya da zamanında anlar. Bu tarih denir. Yeni bir tarih nesnesi oluşturursanız, mevcut tarih ve uygulamayı alacaksınız.

Konsol.log (yeni tarih ()); // → Güneş Kasım 09 2014 00:07:57 GMT + 0300 (CET)

Belirtilen süreyi içeren bir nesne de oluşturabilirsiniz.

Konsol.log (yeni tarih (2015, 9, 21)); // → Çarşamba 21 2015 00:00:00 GMT + 0300 (CET) konsol.log (Yeni Tarih (2009, 11, 9, 12, 59, 59, 999)); // → Çarşamba 09 2009 2009 12:59:59 GMT + 0300 (CET)

Javascript, sayıların çizilmeyle başladığı bir anlaşma kullanır ve ünitedeki gün sayısı. Bu aptalca ve saçma. Yukarı git.

Son dört argüman (saat, dakika, saniye ve milisaniye) isteğe bağlıdır ve sıfıra eşit olmamalıdır.

Zaman etiketleri, 1970'lerin başından bu yana geçen milisaniye sayısı olarak saklanır. 1970'e kadar olan zaman için, negatif sayılar kullanılıyor (bu, şu anda oluşturulan UNIX zaman anlaşmasından kaynaklanıyor). Tarih nesnesinin GETMIME yöntemi bu numarayı döndürür. Doğal olarak büyük.
Konsol.log (yeni tarih (2013, 11, 19) .gettime ()); // → 1387407600000 konsol.log (Yeni Tarih (1387407600000)); // → THU Aralık 19 2013 00:00:00 GMT + 0100 (CET)

Bir tartışma tasarımı belirlerseniz, bir dizi milisaniye olarak algılanır. Geçerli milisaniye değerini, tarih nesnesini oluşturarak ve GetMeTime yöntemini çağırarak veya tarihi arayarak veya tarihi arayarak alabilirsiniz.

Bileşenlerini çıkarmak için tarih nesnesi Getfullyear, getmmonth, getdate, gethours, getminutes ve getseconds'a sahiptir. Ayrıca, adil bir şekilde işe yaramaz iki basamaklı kodu, 93 veya 14'ü döndüren bir GetYear yöntemi de vardır.

Şablonun gerekli parçalarını parantez içine çıkararak, doğrudan dizgeden bir tarih nesnesi oluşturabiliriz.

Fonksiyon finddate (string) (var dateTime \u003d / (\\ d (1,2)) - (\\ D (1,2)) - (\\ d (4)) /; var maçı \u003d datetime.exec (string); geri dönüş Yeni tarih (sayı (eşleşme), sayı (eşleşme) - 1, sayı (eşleşme));) konsol.log (Find ("30-1-2003")); // → Thu 30 Ocak 2003 00:00:00 GMT + 0100 (CET)

Kelimenin ve satırın sınırları

Ne yazık ki, FindDate ayrıca "100-1-30000" hattından 00-1-3000 anlamsız bir tarihi sevinçle kaldırır. Tesadüf hattın herhangi bir yerinde olabilir, bu nedenle bu durumda sadece ikinci sembolden başlayacak ve sonuna kadar başlayacak.

Bütünün tamamını almak için bir tesadüf zorlamamız gerekirse, etiketleri ^ ve $ kullanıyoruz. ^ Çizginin başlangıcıyla ve sonuna kadar $ ile çakışıyor. Bu nedenle, / ^ \\ D + $ / sadece bir veya daha fazla rakamdan oluşan bir dize ile çakışıyor, / ^! Çizgi x olamaz).

Öte yandan, sadece tarihin başladığından ve kelimenin kenarında bittiğinden emin olmalıyız, \\ b etiketini kullanıyoruz. Sınır kelimesi, dizenin başlangıcı veya sonu olabilir veya hattın herhangi bir yerini, bir yandan alfanümerik-dijital sembol \\ W ve diğer - alfanümerik değildir.

Console.log (/cat/.test ("Concatenate")); // → Gerçek konsol.log (/ \\ bcat \\ b / .test ("Concatenate")); // → yanlış.

Sınır etiketinin bir sembol olmadığını unutmayın. Sadece belirli bir durum yapıldığında tesadüfin gerçekleştiğini belirten bir sınırlamadır.

Seçenekler ile şablonlar

Metnin sadece bir sayı olmadığını ve ardından domuz, inek veya tavuğun tek veya çok sayıda numaraya sahip olup olmadığını öğrenmenin gerekli olduğunu varsayalım.

Üç düzenli olarak yazmak ve onları kontrol etmek mümkün olacaktır, ancak daha iyi bir yol var. Sembol | Soldaki şablonlar arasındaki seçimini ve sağında gösterir. Ve aşağıdakileri söyleyebiliriz:

Var bir animalcount \u003d / \\ b \\ d + (domuz | inek | tavuk) s? \\ B /; Console.log (animalcount.test ("15 domuz")); // → Gerçek konsol.log (Animalcount.Test (15 Pigchickens)); // → yanlış.

Parantez parçaları, şablonun bölümünü sınırlandırın. Ve ikiden fazla seçeneğin seçimini belirlemek için bu tür bu operatörleri birbirinizle birlikte koyabilirsiniz.

Arama Mekanizması

Düzenli ifadeler akış şemaları olarak kabul edilebilir. Aşağıdaki şema son hayvan kodunu açıklar.

Grafiğin sol tarafından sağa giden yolu bulabilirseniz, ifade dizgeyle çakışır. Sıradaki geçerli konumu hatırlıyoruz ve her seferinde bir dikdörtgeni geçtikten sonra, çizginin hemen arkasındaki kısmının dikdörtgen içeriğiyle çakışıyor.

Öyleyse, blok diyagramından geçerken "3 domuz" hattındaki düzenli düzenlememizin tesadüfini kontrol etmek şöyle görünüyor:

4 pozisyonunda, kelimenin bir sınırı var ve ilk dikdörtgeni geçiyoruz
- 4 pozisyondan başlayarak bir rakam buluruz ve ikinci dikdörtgeni geçiyoruz
- 5 pozisyonunda, bir yolu ikinci dikdörtgenin önünde geri kapanır ve ikincisi bir boşlukla dikdörtgene geri döner. Bir rakam yok, bir rakam yok ve ikinci yolu seçiyoruz.
- Şimdi 6 konumdayız, "domuzların" başlangıcında ve yolların üçlü dalında. "İnek" ya da "tavuk" çizgisi yoktur, ancak bir "domuz" var, bu yüzden bu yolu seçiyoruz.
- 9 pozisyonunda, üçlü bir dallanma, bir yoldan sonra "S" yazar ve Sınır kelimesiyle son dikdörtgene başlar ve ikinci geçer "S". Biz "s" var, bu yüzden oraya gidiyoruz.
- 10 pozisyonda, hattın sonunda ve tesadüf sadece kelimenin sınırını yapabiliriz. Çizginin sonu sınır olarak kabul edilir ve son dikdörtgenden geçiyoruz. Ve bu yüzden başarıyla şablonumuzu bulduk.

Prensip olarak, düzenli ifadeler aşağıdaki gibi çalışır: Algoritma hattın başlangıcında başlar ve orada bir tesadüf bulmaya çalışır. Bizim durumumuzda, kelimenin bir sınırı vardır, bu yüzden ilk dikdörtgeni geçer - ancak sayı yok, bu yüzden ikinci dikdörtgenin üzerinde tökezler. Sonra satırdaki ikinci sembole taşınır ve orada bir tesadüf bulmaya çalışıyor ... vb. Bir tesadüf bulana kadar ya da hattın sonuna ulaşmaz, bu durumda tesadüf bulunur.

Kickbacks

Normal / \\ B (+ B | \\ D + | [\\ da-f] h) \\ B / [\\ da-f] h) \\ b / bir ikili sayı ile ve ardından veya sonek veya onaltılık olmayan bir ondalık sayı ile örtüşüyor (0 ila 9'dan 9'dan 9'dan veya semboller) A ila H), ardından H. İlgili diyagram:

Tesadüf aramasında, algoritmanın, hatta böyle bir sayı olmasa bile üst yol boyunca (ikili sayı) boyunca geçtiği olabilir. Örneğin bir "103" dize varsa, örneğin, yalnızca Şekil 3 algoritmasına ulaşmanın yanlış yolda olduğunu anlayabileceği açıktır. Genel olarak, hat, bu dalda değil, düzenli ile çakışıyor.

Sonra algoritma bir geri dönüş yapar. Çatalda, şu anki pozisyonu hatırlar (bizim durumumuzda, hemen kelimeden hemen sonra çizginin başlangıcıdır) geri dönebilir ve seçilen çalışmazsa başka bir yol deneyin. İlk üç ile buluştuktan sonra "103" dizesi için, ondalık sayılar için yoldan geçmeye çalışır. Çalışacak, bu yüzden tesadüf bulunacak.

Tam tesadüf bulaşmaz algoritma durur. Bu, birkaç seçeneğin yaklaşabilseler olsa bile, bunlardan sadece bir tanesi kullanılır (normalde göründükleri sırayla).

Rulolar + ve * gibi tekrarlama operatörleri kullanırken ortaya çıkar. İsterseniz / ^ *. * / Abcxe String'de, düzenli bir parçası. * Tüm çizgiyi emmeye çalışır. Algoritma daha sonra "x" de gerekli olduğunu anlayacaktır. Satırın bitiminden sonra hiçbir "x" olmadığından, algoritma bir tesadüf aramaya çalışacak, bir karaktere atmaya çalışır. Abcx'ten sonra da hiçbir X yok, daha sonra zaten ABC alt dizisine geri döndü. Ve çizginin ardından, x'i, 0'dan 4'e kadar pozisyonlarda başarılı bir tesadüfle ilgili raporlar bulur.

Düzenli olarak yazabilirsiniz; bu, birden fazla geri alımlara yol açacaktır. Böyle bir sorun, şablon, farklı yöntemlerin giriş veri kümesiyle çakıştığında oluşur. Örneğin, ikili sayılar için düzenli olarak yazarken bir hata yaparsak, yanlışlıkla (+) + B / benzeri bir şeyler yazabiliriz.

Algoritma, "B" nin sonunda içermeyen uzun bir sıra olmayan nonol ve birimlerde böyle bir şablonu arayacaksa, önce sayıları bitene kadar içsel döngüden önce geçer. Sonunda "B" olmadığını fark edecek, bir pozisyon için bir geri alma yapacağını fark edecektir, dış döngüde gerçekleşecek, yine pes edecek, yine pes edecek, iç döngü üzerinde başka bir pozisyona geri dönmeyi deneyin .. . Ve her iki menteşe de bisiklete binme yolunu arayacak. Yani, her satır sembolü olan iş miktarı iki katına çıkar. Birkaç düzine karakter için bile, tesadüf arama çok uzun zaman alacaktır.

Yöntemi değiştir

Dizeler, başka bir dizgenin çizgisinin yerini alabilen bir değiştirme yöntemi vardır.

Console.log ("Baba" .replace ("p", "m")); // → MAPA

İlk argüman düzenli olabilir, bu durumda, dizideki normal düzenlemenin ilk girişi ile değiştirilir. "G" seçeneği (Global, Universal) düzenli olarak eklendiğinde, tüm girişler değiştirilir ve sadece ilk değil

Console.log ("borobudur" .replace (//, "a")); // → Barobudur konsol.log ("borobudur" .Replace (// g, "a")); // → Barabadar

"Tümünü Değiştir" seçeneğini ayrı bir argümanla veya ayrı bir değiştirme yöntemiyle iletmek mantıklı olur. Fakat ne yazık ki, seçenek düzenli olarak kendisiyle iletilir.

Tüm güç düzenleyicileri, grup dizesinde düzenli olarak ayarlananlara referansları kullandığımızda açıklanmaktadır. Örneğin, insanların isimlerini içeren bir dize, hatta bir isim, "soyadı, isim" biçiminde. Eğer onları yerlerde değiştirmemiz ve virgülleri çıkarmamız gerekirse, ismin adının "isim" olması durumunda, aşağıdakileri yazıyoruz:

Konsol.log ("hazne, lütuf \\ nmccarthy, john \\ nritchie, dennis" .Replace (/ ([[\\ w] +), ([[\\ w] /) / g, "2 $ 1")); // → Grace Hopper // John McCarthy // Dennis Ritchie

Değiştirme hattında 1 ve 2 dolar, parantez içine alınmış karakter gruplarına bakın. 1 $, birinci grupla çakışan metnin değiştirilmesi, 2 $ - ikinci grupla - 9 dolara kadar. Tesadüfin tamamı $ 'da yer almaktadır.

Ayrıca ikinci bir argümanı ikinci bir argüman olarak da aktarabilirsiniz. Her yerine, bir fonksiyona neden olur, bunların argümanları, (ve tüm çizginin tüm tesadüfleri) bulunan argümanlar ve sonucu yeni bir dizgeye yerleştirilecektir.

Basit Örnek:

Var s \u003d "CIA ve FBI"; Konsol.log (/ \\ b (/ \\ b (FBI | CIA) \\ b / g, işlevi (dönüş str.Touppercase ())))); // → CIA ve FBI

Ama daha ilginç:

Var stock \u003d "1 limon, 2 lahana ve 101 yumurta"; İşlev Minuson (Maç, Miktar, Birim) (Tutar \u003d Numara (Miktar) - 1; eğer (Tutar \u003d\u003d 1) // sadece bir tane kaldı, ünitenin sonundaki "s" silmesi \u003d ünite.slice (0, birim) .Length - 1); eğer (miktar \u003d\u003d 0) tutarı \u003d "hayır"; dönüş tutarı + "" + birim;) konsol.log (stok. (/ (/ (\\ D +) (\\ W +) / g , eksi bir)); // → limon yok, 1 lahana ve 100 yumurta

Kod dizeyi alır, sayıların tüm girişini bulur, ardından kelime izler ve her sayının bir tarafından azaltıldığı satırı döndürür.

Grup (\\ D +), A (\\ W +) - birimde A (\\ W +) tutarında düşer. İşlev miktarı sayıya dönüştürür - ve her zaman çalışır, çünkü şablonumuz sadece \\ d +. Ve sonra sadece 1 öğenin kalması durumunda kelimede değişiklik yapar.

Açgözlülük

Tüm yorumları JavaScript kodundan kaldıran bir fonksiyon yazmak için kolaydır. İşte ilk girişim:

Fonksiyon Stripments (Kod) (Dönüş kodu.replace (/ \\ / \\ / ** | \\ / \\ * [^] * \\ * \\ // g, "");) konsol.log (Stripchings ("1 + / * 2 * / 3 ")); // → 1 + 3 konsol.log (strip şirketler ("x \u003d 10; // on!")); // → x \u003d 10; Konsol.log (Stripments ("1 / * a * / + / * b * / 1")); // → 1 1

Operatörün önündeki kısım "veya" iki eğik çizgi ile çakışmaktadır, ardından satır çevirisinin sembolü hariç, herhangi bir sayıda karakter izlemiştir. Çok satırlı yorumları kaldıran bir parça daha karmaşıktır. [^], Yani kullanıyoruz. Herhangi bir karakter bulmanın bir yolu kadar boş olmayan herhangi bir karakter. Noktayı kullanamıyoruz, çünkü blok yorumları yeni çizgiye devam ediyor ve çizgi çeviri sembolü nokta eşleşmiyor.

Ancak önceki örneğin çıktısı yanlıştır. Neden?

Parça [^] * İlk önce olabildiğince çok karakter yapmayı deneyin. Eğer bu nedenle, düzenli olarak bir sonraki kısmı tesadüfleri bulamıyorsa, bir karaktere geri döner ve tekrar deneyin. Örnekte, algoritma tüm dizgiyi yakalamaya çalışır ve ardından geri alır. 4 karakterden düşen, hatta bulacak * / - ve bu ne elde ettiğimiz şey değil. Sadece bir yorum yapmak istiyorduk ve hatta geçmemek ve son yorumu bulmak istedik.

Bu nedenle, operatörlerin (+, *,? Ve ()) açgözlü olduğunu, yani, ilk önce ne kadar yapabileceklerini yakaladıklarını ve sonra geri döndüklerini söylüyoruz. Böyle bir operatörden sonra bir soru koyursanız (+?, *?, (), ()?), Haksız yere dönüşeceklerdir ve mümkün olan en küçük girişleri bulmaya başlarlar.

Ve bu ihtiyacımız olan şey bu. Yıldızları, mümkün olan en düşük dikiş sembolünde tesadüfleri bulmaya zorlamak için, sadece bir yorum bloğunu emiyoruz ve başka bir şey yok.

Fonksiyon Stripments (Kod) (Dönüş Kodu.replace (/ \\ //.** | \\ / \\ * [^] *? \\ * \\ // g, "");) konsol.log (Stripchings ("1 / *) A * / + / * b * / 1 ")); // → 1 + 1

Açgözlü operatörleri itiraz yerine kullanırken birçok hata oluşur. Tekrarlanan operatörü kullanırken, önce her zaman bir unjudene operatörünün seçeneğini düşünün.

Dinamik regexp nesneleri oluşturma

Bazı durumlarda, kod yazarken tam şablon bilinmemektedir. Örneğin, metindeki kullanıcı adını aramanız ve bir vurgua girmeniz gerekir. Yalnızca programı başlattıktan sonra öğreneceğiniz için, kaydı istiflenmiş olarak kullanamazsınız.

Ancak bir dize oluşturabilir ve regexp yapıcısını kullanabilirsiniz. İşte bir örnek:

Var ad \u003d "harry"; Var text \u003d "ve alnına harry."; var regexp \u003d yeni regexp ("\\ \\ b (" + isim + ") \\\\ b", "gi"); konsol.log (metin. (Regexp, "$ 1_")); // → ve _garry_ alnın izinde.

Sınırları oluştururken, kelime çift katman kullanmak zorundadır, çünkü onları normal bir çizgide yazıyoruz ve düz merdivenlerle düzenli olarak yazıyoruz. Regexp için ikinci argüman, regülatörler için seçenekleri içerir - bizim durumumuzda "GI", yani. Küresel ve Kayıtlı-Bağımsız.

Ancak, adı "DEA + HLRD" ise (kullanıcımız Kulkhazker ise)? Sonuç olarak, tesadüf hattında bulamayacak olan düzenli olarak anlamsız bir düzenli alacağız.

Sevmediğimiz herhangi bir sembole boşluk ekleyebiliriz. Harflerin önünde ters vuruş ekleyemiyoruz, çünkü \\ b veya \\ n özel bir karışımdır. Ancak, herhangi bir alfabetik olarak dijital sembollerin önündeki sıkışmış ekleyebilirsiniz.

Var adı \u003d "DEA + HLRD"; Var metin \u003d "Bu Dea + Hlrd herkese vardı."; var kaçtı \u003d isim.replace (/ [^ \\ w \\ s] / g, "\\\\ $ &"); var regexp \u003d yeni regexp ("\\ '\\ b (" + kaçtı + ") \\\\ b", "gi"); konsol.log (metin. (Regexp, "$ 1_")); // → Bu _Dea + Hlrd_ Herkesi var.

Arama yöntemi

Endeks yöntemi düzenli olarak kullanılamaz. Ancak sadece düzenli olarak bekleyen bir arama yöntemi var. Endeksi gibi, ilk girişin dizinini veya olmasaydı -1'i döndürür.

Konsol.log ("kelime" .Search (/ s /)); // → 2 konsol.log (". .Search (/ s /)); // → -1.

Ne yazık ki, belirli bir ofsetten başlayarak (indexof ile yapıldığı gibi), bir tesadüf arama yöntemini ayarlamak imkansızdır. Yararlı olurdu.

Mülkiyet Littionlex

Exec yöntemi, dizideki belirli bir konumdan aramaya başlamanın uygun bir yoluna izin vermez. Ancak rahatsız edici bir yol verir.

Nesne düzenleyicilerinin özellikleri var. Bunlardan biri bir dize içeren bir kaynaktır. Bir diğeri, bir sonraki aramanın başlayacağı bazı koşullarda, bazı koşullarda kontrol eden LastIddex'tir.

Bu koşullar, Global G seçeneğinin varlığına olan ihtiyacı ve Aramanın Exec yöntemini kullanması gerektiği gerçeğini içerir. Daha makul bir çözümün, ek bir argümanın icra gösterilmesine izin vermesine izin verilecek, ancak rasyonellik JavaScript Regülatörleri arayüzünde temel bir özellik değildir.

Var paterni \u003d / y / g; Pattern.lastindex \u003d 3; Var maçı \u003d pattern.exec ("xyzzy"); Console.log (maç.index); // → 4 konsol.log (pattern.lastindex); // → 5.

Arama başarılı olsaydı, Exec Call, LastIdIndex özelliğini günceller, böylece bulunan girişten sonra bir pozisyon gösterir. Başarı yoksa, LastIndex sıfıra monte edilir - sadece oluşturulan nesnede LastIndex.

Global değişkenleri düzenli ve birden fazla yürütme çağrısını kullanırken, bu otomatik lintionx güncellemeleri sorunlara yol açabilir. Düzenli olarak, önceki aramadan kalan konumdan bir arama başlatabilirsiniz.

Var digit \u003d / \\ d / g; Console.log (digit.exec ("burada burada: 1")); // → ["1"] konsol.log (digit.exec ("ve şimdi: 1")); // → null

G seçeneğinin bir başka ilginç etkisi, maç yönteminin çalışmasını değiştirmesidir. Bu seçenekle çağrıldığında, bir diziyi iade etmek yerine, Exec Work sonucuna benzer şekilde, şablonun dize girmesini bulur ve bulunan tüm alt diziden bir diziyi döndürür.

Console.log ("muz" .Match (/ en / g)); // → ["bir", "bir"]

Küresel değişkenlerle çok dikkatlice. İhtiyaç duydukları durumlarda - çağırır - değişiklikler, özellikle de uygulanabilecekleri tüm durumlar - belki de uygulanması gereken tüm durumlar.

Girerek döngüler

Tipik bir görev, LastIndex ve Exec'ü kullanarak Döngü gövdesinde eşleşme nesnesine erişime sahip olacak şekilde, şablonun tüm girişlerini dizideki tüm girişlerini geçmektir.

Var girişi \u003d "3 sayı ile dikiş ... 42 ve 88."; var numarası \u003d / \\ b (\\ d +) \\ b / g; Var maçı; İken (maç \u003d number.exec (giriş)) konsol.log ("bulundu", maç, "Açık", maç.index); // → 3 ila 14 // bulundu 42 ila 33 // bulundu 88 - 40

Değer atamasının değere atanması. Maçın kullanılması \u003d RE.EXEC (giriş) tasarımı, iken bir durum olarak, her yinelemenin başında bir arama üretiyoruz, sonucu bir değişkende kaydettik ve tüm tesadüfler bulunduğunda döngüyü bitiririz.

Ini dosyalarını işitme

Bölümün sonuçlanmasında, regülatörleri kullanarak görevi düşünün. Otomatik modda internet üzerinden düşmanlarımız hakkında bilgi toplayan bir program yazdığımızı hayal edin. (Tüm programı yazmayacağım, sadece dosyayı ayarlarıyla okuyan kısım. Üzgünüm.) Dosya şöyle görünür:

SearchEwine \u003d http: //www.google.com/search? Q \u003d 1 $ kindarlık \u003d 9.7; Yorumlardan önce, nokta yerleştirilir; Her bölüm ayrı bir düşman tam için geçerlidir \u003d Larry Doe Type \u003d Anaokulu web sitesinden \u003d http: //www.geocities.com/capecanaVeral/11451 fullname \u003d Gargamel Type \u003d Angry Wizard Outddir \u003d / Ana Sayfa / Marijn / Düşmanlar / Gargamel

Kesin dosya formatı (oldukça yaygın olarak kullanılan ve genellikle INI olarak adlandırılır), aşağıdakiler:

Bir noktalı virgülle başlayan boş dizeler ve satırlar göz ardı edilir
- Kare parantez içine alınan satırlar yeni bir bölüm başlatır
- Alfanümerik tanımlayıcıyı içeren satırlar, ardından bu bölümde ayarlar ekleyin.

Her şey yanlış veri.

Görevimiz, böyle bir dizgiyi, her biri ad özelliğine ve ayar dizisini içeren bir diziyi bir diziyi dönüştürmektir. Her bölüm için, dosyanın üstündeki genel ayarlar için bir nesneye ve bir nesneye ihtiyacınız var.

Dosya demonte edilmemesi gerektiğinden, dosyayı dize kırılmasıyla başlamak fena değildir. Bunu yapmak için, Bölüm 6'da, String.Split ("\\ n") kullandık. Bazı işlemler çizgiyi bir karakter değil \\ n ve iki - \\ r \\ n değil aktarmak için kullanılır. Bölünmüş yöntemi bir argüman olarak düzenli olarak aldığından, satırı satırlar arasında bir ekspresyon / \\ r? \\ N /, izin veren ve tek bir \\ n ve \\ r \\ n kullanarak bölünebilir miyiz.

Fonksiyon parseini (string) (// üst düzey ayarlar içeren bir nesneden başla) Var Currentsection \u003d (İsim: , alanlar :); var sertifikalar \u003d; string.split (/ \\ r? \\ N /). Foreach (fonksiyon ( Çizgi) (var maçı; eğer (/ \\ ^ / s * (;;. *)? $ /. Test (satır)) (iade;) Başka ise (maç \u003d satır. $$ /)) (Kıvrımlar \u003d (Adı: Maç, Alanlar :); Kategoriler.Push (Kıvrım);) Diğerse (Match \u003d Line.match (/ ^ (\\ W +) \u003d (. *) $ /) ) (Kıvrımlar. Fields.PUSS ((Adı: Maç, Değer: Maç));) Başka (yeni hata atın ("dikiş" + satır + "" yanlış veri içerir. ");))); Dönüş kategorileri;)

Kod, geçerli bölüm "geçerli bölüm" olarak güncelleyerek tüm satırları geçer. İlk başta, Düzenli / \\ ^ (;; *) yardımı ile çizgiyi görmezden gelmenin mümkün olup olmadığını kontrol eder. Nasıl çalıştığını düşünün? Parantez arasındaki kısmı yorumlarla çakışıyor, eh? Bu düzenli olarak bazı boşluklardan oluşan çizgilerle çakışıyor mu?

Dize bir yorum değilse, kod yeni bir bölüm başlatılıp başlamadığını kontrol eder. Evet ise, sonraki ayarların eklendiği geçerli bölüm için yeni bir nesne oluşturur.

Son anlamlı özellik bir satırdır normal bir kurulumdur ve bu durumda mevcut nesneye eklenir.

Hiçbir seçenek çalışmadıysa, işlev bir hata verir.

Ne sıklıkta kullanımın ne kadar sık \u200b\u200bkullandığına dikkat edin ^ ve $, ekspresyonun bütünün tüm dizgiyle çakıştığını ve bir bölümle olmadığı gerçeğini umursadılar. Onları kullanmamak gerekirse, bir bütün olarak kod çalışacaktır, ancak bazen garip sonuçlar olacak ve bu hatanın izlenmesi zor olacaktır.

IF tasarım (maç \u003d string.match (...)), atamayı istifa ederken bir durum olarak kullanan bir numaraya benzer. Genellikle, eşleşme aramanın başarılı olacağını bilmiyorsunuz, böylece ortaya çıkan nesneye sadece kontrol eden bloğun içinde erişebilirsiniz. Bu yüzden güzel bir şekilde kırmamak için, kontrol zinciri ise, değişkenin arama sonucunu atarız ve bu ödevi hemen bir çek olarak kullanırız.

Uluslararası semboller

Başlangıçta basit bir şekilde basit bir şekilde uygulanması ve ardından "Granit" uygulamasının daha sonra fiksasyonu nedeniyle, JavaScript, İngilizce olarak gerçekleşmeyen sembollerle düzenli olarak aptalca. Örneğin, JavaScript düzenleyicilerinin bakış açısına göre "harflerin" sembolü, İngilizce alfabesinin 26 harfinden biri olabilir ve bir nedenden ötürü vurgu yapılabilir. Tip É veya β harflerinin harfleri, benzersiz bir şekilde harflerle, \\ W ile çakışmaz (ve \\ W ile çakışmaz).

Garip bir tesadüfe göre, tarihsel olarak \\ s (boşluk), vazgeçilmez bir alan veya bir Moğol ünlü ayırıcısı gibi şeyler de dahil olmak üzere, glible olarak kabul edilen tüm karakterlerle çakışıyor.

Bazı uygulamalarda, diğer dillerde düzenleyiciler, "tüm önemli harfler", "tüm noktalama işaretleri" veya "kontrol karakterleri" gibi özel Unicode karakter kategorilerini aramak için özel bir sözdizimi vardır. Javascript'te bu tür kategorileri eklemenin planları var, ancak yakında uygulanıyor gibi görünüyorlar.

Sonuç

Düzenli düzenlilikler, satırlardaki arama modellerini temsil eden nesnelerdir. Bu şablonları ifade etmek için sözdizimini kullanırlar.

/ ABC / Sembol Sırası
// listeden herhangi bir sembol
/ [^ ABC] / Listeden karakterler hariç herhangi bir karakter
// GAP'ın herhangi bir sembolü
/ x + / şablonun bir veya daha fazla oluşumu x
/ x +? / bir veya daha fazla olay, ölümsüz
/ x * / sıfır veya daha fazla oluşum
/ x? / sıfır veya bir meydana gelir
/ x (2.4) / iki ila dört olaydan
/ (ABC) / Grup
/ A | B | C / Birkaç Şablondan herhangi biri
/ \\ D / Herhangi bir rakam
/ \\ w / Herhangi bir alfanümerik sembol ("harf")
/ \\ S / Herhangi bir boş sembol
/./ çeviri satırı hariç herhangi bir sembol
/ \\ B / Kelime sınırı
/ ^ / Start çizgisi
/ $ / Bitiş çizgisi

Düzenli bir test yöntemi vardır, bir dizgede bir desen olup olmadığını kontrol etmek için. Tüm bulunan grupları içeren bir dizi döndüren bir Exec yöntemi var. Masif, tesadüfin olduğu karakter numarasının olduğu bir endeks özelliğine sahiptir.

Dizeler, şablonları aramak için bir maç yöntemine ve yalnızca girişin ilk konumunu döndüren arama yöntemine sahiptir. Değiştirme yöntemi şablonun girişini başka bir dizeye değiştirebilir. Ek olarak, fonksiyonu, şablona göre bir yedek hat oluşturacak ve bulunacak grupları oluşturacak şekilde iletebilirsiniz.

Regülatörlerin bir kapanıştaki eğik çizgiden sonra yazılmış ayarlara sahiptir. Ben seçeneği normal bir vaka bağımlısı yapar ve G seçeneği g, diğer şeylerin yanı sıra, tüm bulunan şeyleri değiştirmelerine neden olan diğer şeylerin yerine geçmesine neden olan Global'ı yönetir.

RegeXP Tasarımcısı normal satırlar oluşturmak için kullanılabilir.

Düzenli - Rahatsız bir tutamağa sahip keskin bir araç. Bazı görevleri büyük ölçüde basitleştirirler ve diğer karmaşık işleri çözmede kontrol edilemez hale gelebilirler. Düzenli düzenlilik kullanabilme yeteneğinin bir kısmı, günaha, amaçlanmadıkları görevi onlara doldurmalarına karşı koyabilmektir.

Egzersizler

Kaçınılmaz olarak, görevleri çözerken, anlaşılmaz durumlara sahip olacaksınız ve bazen bazı düzenleyicilerin öngörülemeyen davranışlarını görerek bazen umutsuzluğa sahip olabilirsiniz. Bazen, görselleştirmeyi görebileceğiniz ve istenen efektle karşılaştırabileceğiniz Debuggex.com'un çevrimiçi hizmeti ile düzenli olarak davranışlarını keşfetmeye yardımcı olur.

Düzenli golf

Koddaki "Golf", belirli bir programı asgari sayıda karakterle ifade etmeniz gereken oyun denir. Düzenli Golf, belirli bir şablonu aramak için mümkün olan en küçük regülatörlerin yazılması konusunda pratik bir egzersizdir.

Sübvansiyonların her biri için, sıraya göre kontrol etmek için düzenli olarak yazın. Düzenli olarak bu belirtilen alt çizelgeyi bulmalıdır. Özellikle söz edilmemişse, kelimelerin sınırları hakkında endişelenmeyin. Düzenli bir şekilde çalıştığınızda, azaltmaya çalışın.

Araba ve kedi.
- Pop ve Prop
- Ferret, Feribot ve Ferrari
- iOS ile biten herhangi bir kelime
- boşluk, ardından bir nokta, virgül, kolon veya virgül noktası.
- Kelime uzunluğu altı harf
- harfler olmadan kelime e

// Normal Vermiy (/.../, ["Arabam", "Kötü Kediler"], ["Camper", "Yüksek Sanat"]); doğrulayın (/.../, ["pop kültürü", "MAD PROTS"], ["PLOP"]); Doğrulayın (/.../, ["Ferret", "feribot", "Ferrari"], ["Ferrum", "A Transfer"]); doğrulayın (/.../, ["ne kadar lezzetli", "geniş oda"], ["yıkıcı", "bilinç"]); Doğrulayın (/.../, ["Kötü noktalama işaretleri."], ["NOKTA Kaçış"]); Doğrunuza (/.../, ["hottentotentialtenen"], ["hayır", "hotten tenten tenten"]); Doğrulayın (/.../, ["Kırmızı Platypus", "Wobbling Nest"], ["Toprak Yatağı", "Öğrenme APE"]); İşlev doğrulamak (regexp, evet, no) (// eğer regexp.source \u003d\u003d "") geri dönüşü; Evet.Fireach (işlev (ler) (eğer (! Regexp.test (s)) konsolu .log ("Bulunamadı" "+ S +" "");)))) ..ForeCheach (fonksiyon (lar) (fonksiyon (lar) (function (lar) ("Beklenmeyen giriş" + S + "" ") ;));)

Metinde alıntılar

Diyelim ki bir hikaye yazdığınızı ve her yerde diyalogların belirlenmesi için tek tırnak çalındı. Artık diyalogların alıntılarını iki katına çıkarmak istiyorsunuz ve türün kısaltmalarında tek ayrılmamaktadır.

Bu alıntıların ikisini ayıran ve değiştiren Değiştir Yöntemi'ne bir çağrı yazan bir şablonla gelin.

Tekrar numaralar

Numaraların dizileri, basit normal / \\ D + /.

Sadece JavaScript stilinde kaydedilen numaraları bulan bir ifade yazın. Sayı, ondalık nokta ve üstel 5E-3 veya 1E10 üstel kayıttan önce olası bir eksi veya artı, tekrar olası bir artı veya eksi ile tutmalıdır. Ayrıca, otan önce veya sonra, numaranın sayıları dayanmadığına dikkat edin, ancak sayı bir noktadan oluşamaz. Yani, .5 veya 5. - izin verilen sayılar ve tek başına bir nokta - hayır.

// Düzenli düzenli girin. var numarası \u003d / \u003d ... $ /; // testler: ["1", "-1", "+15", "1.55", ".5", "5.", "1.3E2", "1E-4", "1E + 12"] .FireACH (işlev (ler) (eğer (! Number.test (s)) konsol.log ("" + s + "");))); ["1A", "+ -1", "1.2.3", "1 + 1", "1E4.5", ".5.", "1F5", "."]. Foreach (fonksiyonlar (lar) (Eğer (number.test (s)) konsol.log ("yanlış kabul edildi" "+ s +" ")));));