JavaScript regex'te yakalama grupları adlandırıldı mı?

Bildiğim kadarıyla JavaScript'te yakalama grupları olarak adlandırılan bir şey yok. Benzer işlevselliği elde etmenin alternatif yolu nedir?

ECMAScript 2018 , JavaScript regexes adlı adlandırılmış yakalama gruplarını tanıttı .

Misal:

  const auth = 'Bearer AUTHORIZATION_TOKEN'
  const { groups: { token } } = /Bearer (?<token>[^ $]*)/.exec(auth)
  console.log(token) // "Prints AUTHORIZATION_TOKEN"

Daha eski tarayıcıları desteklemeniz gerekiyorsa, adlandırılmış yakalama gruplarıyla yapabileceğiniz normal (numaralandırılmış) yakalama gruplarıyla her şeyi yapabilirsiniz, sadece sayıları takip etmeniz gerekir; normal ifade değişiklikleri.

Düşünebildiğim yakalama gruplarının yalnızca iki "yapısal" avantajı vardır:

1. Bazı normal ifade tatlarında (bildiğim kadarıyla .NET ve JGSoft), normal ifadenizdeki farklı gruplar için aynı adı kullanabilirsiniz ( bunun önemli olduğu bir örnek için buraya bakın ). Ancak çoğu normal ifade aroması bu işlevselliği yine de desteklemez.

2. Rakamlarla çevrili bir durumda numaralandırılmış yakalama gruplarına başvurmanız gerekiyorsa, bir sorunla karşılaşabilirsiniz. Let Diyelim ki bir rakam olarak bir sıfır eklemek istediğiniz ve bu nedenle değiştirmek istiyor demek (\d)olan $10. JavaScript'te bu işe yarayacaktır (normal ifadenizde 10'dan az yakalama grubuna sahip olduğunuz sürece), ancak Perl sayı 10yerine geri başvuru numarası aradığınızı düşünecektir 1ve ardından a 0. Perl'de ${1}0bu durumda kullanabilirsiniz .

Bunun dışında, adı geçen yakalama grupları sadece "sözdizimsel şeker" dir. Yakalama gruplarını yalnızca gerçekten ihtiyacınız olduğunda kullanmanıza ve yakalamayan grupları (?:...)diğer tüm koşullarda kullanmanıza yardımcı olur .

JavaScript ile ilgili daha büyük sorun, okunabilir, karmaşık düzenli ifadelerin oluşturulmasını çok daha kolay hale getirecek ayrıntılı regex'leri desteklememesidir.

Steve Levithan'ın XRegExp kütüphanesi bu sorunları çözer.

Ek sözdizimi, bayraklar ve yöntemler için destek de dahil olmak üzere düzenli ifadelerin artırılmış, genişletilebilir, tarayıcılar arası uygulaması olan XRegExp'yi kullanabilirsiniz :

• Adlandırılmış yakalama için kapsamlı destek dahil olmak üzere yeni normal ifade ve yedek metin sözdizimi ekler .
• İki yeni normal ifade bayrağı ekler:, snoktanın tüm karakterlerle eşleşmesini sağlamak için (diğer adıyla dotall veya tek satır modu) ve xserbest aralık ve yorumlar için (genişletilmiş mod olarak da bilinir).
• Karmaşık normal regex işlemeyi bir esinti haline getiren bir dizi işlev ve yöntem sunar.
• Normal ifade davranışı ve sözdiziminde en sık karşılaşılan tarayıcılar arası tutarsızlıkları otomatik olarak giderir.
• XRegExp'in normal ifade diline yeni sözdizimi ve bayraklar ekleyen eklentileri kolayca oluşturmanızı ve kullanmanızı sağlar.

Başka bir olası çözüm: grup adlarını ve dizinleri içeren bir nesne oluşturun.

var regex = new RegExp("(.*) (.*)");
var regexGroups = { FirstName: 1, LastName: 2 };

Ardından, gruplara başvuruda bulunmak için nesne anahtarlarını kullanın:

var m = regex.exec("John Smith");
var f = m[regexGroups.FirstName];

Bu, normal ifadenin sonuçlarını kullanarak kodun okunabilirliğini / kalitesini geliştirir, ancak normal ifadenin kendisinin okunabilirliğini geliştirmez.

ES6'da gruplarınızı yakalamak için dizi yok etmeyi kullanabilirsiniz:

let text = '27 months';
let regex = /(\d+)\s*(days?|months?|years?)/;
let [, count, unit] = regex.exec(text) || [];

// count === '27'
// unit === 'months'

Farkına varmak:

• sondaki ilk virgül, leteşleşen dizinin ilk değerini atlar; bu, eşleşen dizenin tamamıdır
• || []sonra .exec()eşleşme (çünkü varken bir kurucuların hatayı engelleyecektir .exec()dönecektir null)

Güncelleme: Sonunda JavaScript'e dönüştürdü (ECMAScript 2018)!

Adlandırılmış yakalama grupları çok yakında JavaScript'e girebilir.
Bunun için teklif zaten 3. aşamada.

Bir yakalama grubuna, (?<name>...)herhangi bir tanımlayıcı adı için sözdizimi kullanılarak köşeli parantezler içinde bir ad verilebilir . Bir tarihin normal ifadesi olarak yazılabilir /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u. Her ad benzersiz olmalı ve ECMAScript IdentifierName dilbilgisini izlemelidir .

Adlandırılmış gruplara, normal ifade sonucunun groups özelliğinin özelliklerinden erişilebilir. Aynı adlandırılmamış gruplarda olduğu gibi gruplara numaralandırılmış başvurular da oluşturulur. Örneğin:

let re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;
let result = re.exec('2015-01-02');
// result.groups.year === '2015';
// result.groups.month === '01';
// result.groups.day === '02';

// result[0] === '2015-01-02';
// result[1] === '2015';
// result[2] === '01';
// result[3] === '02';

Yakalanan grupları adlandırmak bir şey sağlar: karmaşık düzenli ifadelerle daha az karışıklık.

Bu gerçekten sizin kullanım durumunuza bağlıdır, ancak belki de regex'inizin güzel yazdırılması yardımcı olabilir.

Veya yakalanan gruplarınıza başvurmak için sabitleri tanımlamayı deneyebilirsiniz.

Yorumlar daha sonra kodunuzu okuyan diğer kullanıcılara ne yaptığınızı göstermeye de yardımcı olabilir.

Geri kalanı için Tims cevabını kabul etmeliyim.

Node.js projelerinizde kullanabileceğiniz adlı -degegepp adlı bir node.js kütüphanesi vardır (tarayıcıda kütüphaneyi browserify veya diğer paketleme komut dosyalarıyla paketleyerek). Ancak, kütüphane, adlandırılmamış yakalama grupları içeren normal ifadelerle kullanılamaz.

Normal ifadenizdeki açılış yakalama parantezlerini sayarsanız, adlandırılmış yakalama grupları ile normal ifadenizdeki numaralandırılmış yakalama grupları arasında bir eşleme oluşturabilir ve serbestçe karışıp eşleştirebilirsiniz. Normal ifadeyi kullanmadan önce grup adlarını kaldırmanız yeterlidir. Bunu gösteren üç işlev yazdım. Bu özete bakın: https://gist.github.com/gbirke/2cc2370135b665eee3ef

As Tim Pietzcker ECMAScript 2018 tanıtır JavaScript regexes içine yakalama gruplarını adında söyledi. Ancak yukarıdaki cevaplarda bulamadığım şey , regex'in kendisinde adlandırılan yakalanan grubun nasıl kullanılacağıydı .

Bu sözdizimi ile adlandırılmış yakalanan grup kullanabilirsiniz: \k<name>. Örneğin

var regexObj = /(?<year>\d{4})-(?<day>\d{2})-(?<month>\d{2}) year is \k<year>/

ve Forivin'in söylediği gibi, yakalanan grubu nesne sonucunda aşağıdaki gibi kullanabilirsiniz:

let result = regexObj.exec('2019-28-06 year is 2019');
// result.groups.year === '2019';
// result.groups.month === '06';
// result.groups.day === '28';

  var regexObj = /(?<year>\d{4})-(?<day>\d{2})-(?<month>\d{2}) year is \k<year>/mgi;

function check(){
    var inp = document.getElementById("tinput").value;
    let result = regexObj.exec(inp);
    document.getElementById("year").innerHTML = result.groups.year;
    document.getElementById("month").innerHTML = result.groups.month;
    document.getElementById("day").innerHTML = result.groups.day;
}

td, th{
  border: solid 2px #ccc;
}

<input id="tinput" type="text" value="2019-28-06 year is 2019"/>
<br/>
<br/>
<span>Pattern: "(?<year>\d{4})-(?<day>\d{2})-(?<month>\d{2}) year is \k<year>";
<br/>
<br/>
<button onclick="check()">Check!</button>
<br/>
<br/>
<table>
  <thead>
    <tr>
      <th>
        <span>Year</span>
      </th>
      <th>
        <span>Month</span>
      </th>
      <th>
        <span>Day</span>
      </th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>
        <span id="year"></span>
      </td>
      <td>
        <span id="month"></span>
      </td>
      <td>
        <span id="day"></span>
      </td>
    </tr>
  </tbody>
</table>

Bunu vanilya JavaScript ile yapamazken, belki de sihir kullanarak dizinlenmiş eşleşmeleri adlandırılmış eşleşmelere dönüştürmek Array.prototypegibi bir işlev kullanabilirsiniz .Array.prototype.reduce

Açıkçası, aşağıdaki çözüm eşleşmelerin sırayla gerçekleşmesini gerektirecektir:

// @text Contains the text to match
// @regex A regular expression object (f.e. /.+/)
// @matchNames An array of literal strings where each item
//             is the name of each group
function namedRegexMatch(text, regex, matchNames) {
  var matches = regex.exec(text);

  return matches.reduce(function(result, match, index) {
    if (index > 0)
      // This substraction is required because we count 
      // match indexes from 1, because 0 is the entire matched string
      result[matchNames[index - 1]] = match;

    return result;
  }, {});
}

var myString = "Hello Alex, I am John";

var namedMatches = namedRegexMatch(
  myString,
  /Hello ([a-z]+), I am ([a-z]+)/i, 
  ["firstPersonName", "secondPersonName"]
);

alert(JSON.stringify(namedMatches));

ECMAScript 2018'iniz yok mu?

Amacım, adlandırılmış gruplarla alışkın olduğumuz şeye mümkün olduğunca benzer bir şekilde çalışmasını sağlamaktı. ECMAScript 2018'de ?<groupname>adlandırılmış bir grubu belirtmek için grubun içine yerleştirebilirsiniz, eski javascript çözümümde (?!=<groupname>)ise aynı şeyi yapmak için grubun içine yerleştirebilirsiniz. Yani ekstra bir parantez ve ekstra !=. Oldukça yakın!

Hepsini bir dize prototip işlevi içine sarılmış

Özellikleri

• eski javascript ile çalışır
• ekstra kod yok
• kullanımı oldukça basit
• Normal ifade hala çalışıyor
• gruplar normal ifade içinde belgelenir
• grup adlarında boşluk olabilir
• sonuç içeren nesneyi döndürür

Talimatlar

• (?!={groupname})adlandırmak istediğiniz her grubun içine yerleştirin
• grubun başına ()koyarak yakalamayan grupları yok etmeyi unutmayın ?:. Bunlar adlandırılmayacak.

arrays.js

// @@pattern - includes injections of (?!={groupname}) for each group
// @@returns - an object with a property for each group having the group's match as the value 
String.prototype.matchWithGroups = function (pattern) {
  var matches = this.match(pattern);
  return pattern
  // get the pattern as a string
  .toString()
  // suss out the groups
  .match(/<(.+?)>/g)
  // remove the braces
  .map(function(group) {
    return group.match(/<(.+)>/)[1];
  })
  // create an object with a property for each group having the group's match as the value 
  .reduce(function(acc, curr, index, arr) {
    acc[curr] = matches[index + 1];
    return acc;
  }, {});
};    

kullanım

function testRegGroups() {
  var s = '123 Main St';
  var pattern = /((?!=<house number>)\d+)\s((?!=<street name>)\w+)\s((?!=<street type>)\w+)/;
  var o = s.matchWithGroups(pattern); // {'house number':"123", 'street name':"Main", 'street type':"St"}
  var j = JSON.stringify(o);
  var housenum = o['house number']; // 123
}

o sonucu

{
  "house number": "123",
  "street name": "Main",
  "street type": "St"
}