Mga Regular na Ekspresyon sa Java, Bahagi 4

Nagpapakita kami sa iyong atensyon ng pagsasalin ng maikling gabay sa mga regular na expression sa Java, na isinulat ni Jeff Friesen para sa website ng javaworld . Para sa kadalian ng pagbabasa, hinati namin ang artikulo sa ilang bahagi. Mga Regular na Ekspresyon sa Java, Bahagi 1 Mga Regular na Ekspresyon sa Java, Bahagi 2 Mga Regular na Ekspresyon sa Java, Bahagi 3

Mga pamamaraan para sa pakikipagtulungan sa mga nakunan na grupo

Ang application source code RegexDemoay may kasamang method call m.group(). Ang pamamaraan group()ay isa sa ilang mga pamamaraan ng klase Matcherna naglalayong magtrabaho kasama ang mga nakuhang grupo:

• Ibinabalik ng pamamaraan int groupCount()ang bilang ng mga nakuhang grupo sa pattern ng solver. Hindi isinasaalang-alang ng numerong ito ang espesyal na numero ng grupo ng pagkuha 0, na tumutugma sa pattern sa kabuuan.

• Ibinabalik ng pamamaraan String group()ang mga character ng nakaraang tugma na natagpuan. Upang mag-ulat ng matagumpay na paghahanap para sa isang walang laman na string, ang pamamaraang ito ay nagbabalik ng isang walang laman na string. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

• Ang pamamaraan String group(int group)ay katulad ng nakaraang pamamaraan, maliban na ibinabalik nito ang mga character ng nakaraang tugma, na nakuha ng numero ng pangkat na tinukoy ng parameter group. Tandaan na ito group(0)ay katumbas ng group(). Kung ang template ay walang nakuhang pangkat na may ibinigay na numero, ang pamamaraan ay naghagis ng eksepsiyon IndexOutOfBoundsException. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

• Ibinabalik ng pamamaraan String group(String name)ang mga character ng nakaraang tugma na natagpuan, na nakuha ng pangkat ng pangalan. Kung ang nakuhang pangalan ng pangkat ay wala sa template, isang pagbubukod ang itatapon IllegalArgumentException. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

Ang sumusunod na halimbawa ay nagpapakita ng paggamit ng groupCount()at mga pamamaraan group(int group):

Pattern p = Pattern.compile("(.(.(.)))");
Matcher m = p.matcher("abc");
m.find();
System.out.println(m.groupCount());
for (int i = 0; i <= m.groupCount(); i++)
System.out.println(i + ": " + m.group(i));

Mga resulta ng pagpapatupad:

3
0: abc
1: abc
2: bc
3: c

Mga pamamaraan para sa pagtukoy ng mga posisyon ng tugma

Ang klase Matcheray nagbibigay ng ilang mga pamamaraan na nagbabalik ng panimulang posisyon at pagtatapos ng isang tugma:

• Ibinabalik ng pamamaraan int start()ang panimulang posisyon ng nakaraang tugma na natagpuan. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

• Ang pamamaraan int start(int group)ay katulad ng nakaraang pamamaraan, ngunit ibinabalik ang panimulang posisyon ng nakaraang tugma na natagpuan para sa pangkat na ang numero ay tinukoy ng parameter group. Kung ang template ay walang nakuhang pangkat na may ibinigay na numero, ang pamamaraan ay naghagis ng eksepsiyon IndexOutOfBoundsException. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

• Ang pamamaraan int start(String name)ay katulad ng nakaraang pamamaraan, ngunit ibinabalik ang panimulang posisyon ng nakaraang tugma na natagpuan para sa pangkat na tinatawag na name. Kung ang nakuhang pangkat nameay wala sa template, isang pagbubukod ang itatapon IllegalArgumentException. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

• Ibinabalik ng pamamaraan int end()ang posisyon ng huling character ng nakaraang tugma na natagpuan plus 1. Kung ang matcher ay hindi pa nagsagawa ng isang tugma o ang nakaraang operasyon sa paghahanap ay nabigo, ang isang exception ay itinapon IllegalStateException.

• Ang pamamaraan int end(int group)ay katulad ng nakaraang pamamaraan, ngunit ibinabalik ang pangwakas na posisyon ng nakaraang tugma na natagpuan para sa pangkat na ang numero ay tinukoy ng parameter group. Kung ang template ay walang nakuhang pangkat na may ibinigay na numero, ang pamamaraan ay naghagis ng eksepsiyon IndexOutOfBoundsException. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

• Ang pamamaraan int end(String name)ay katulad ng nakaraang pamamaraan, ngunit ibinabalik ang pangwakas na posisyon ng nakaraang tugma na natagpuan para sa pangkat na tinatawag na name. Kung ang nakuhang pangkat nameay wala sa template, isang pagbubukod ang itatapon IllegalArgumentException. Kung hindi pa nagsagawa ng lookup ang solver o nabigo ang isang nakaraang operasyon sa paghahanap, itatapon ang isang exception IllegalStateException.

Ang sumusunod na halimbawa ay nagpapakita ng dalawang paraan ng lokasyon ng pagtutugma na naglalabas ng mga posisyon ng pagsisimula/pagtatapos ng pagtutugma para sa pagkuha ng pangkat na numero 2:

Pattern p = Pattern.compile("(.(.(.)))");
Matcher m = p.matcher("abcabcabc");
while (m.find())
{
   System.out.println("Найдено " + m.group(2));
   System.out.println("  начинается с позиции " + m.start(2) +
                      " и заканчивается на позиции " + (m.end(2) - 1));
   System.out.println();
}

Ang output ng halimbawang ito ay ang sumusunod:

Найдено bc
начинается с позиции 1 и заканчивается на позиции 2
Найдено bc
начинается с позиции 4 и заканчивается на позиции 5
Найдено bc
начинается с позиции 7 и заканчивается на позиции 8

Mga pamamaraan ng klase ng PatternSyntaxException

Ang isang halimbawa ng klase PatternSyntaxExceptionay naglalarawan ng isang error sa syntax sa regular na expression. Naghahagis ng gayong pagbubukod mula sa mga pamamaraan compile()at matches()klase Pattern, at nabuo sa pamamagitan ng sumusunod na konstruktor: PatternSyntaxException(String desc, String regex, int index) Iniimbak ng konstruktor na ito ang tinukoy na paglalarawan ( desc), regular na expression ( regex), at ang posisyon kung saan naganap ang error sa syntax. Kung hindi alam ang lokasyon ng error sa syntax, indexitatakda ang halaga sa -1. Malamang, hindi mo na kakailanganing gumawa ng mga pagkakataon ng PatternSyntaxException. Gayunpaman, kakailanganin mong kunin ang mga halaga sa itaas kapag lumilikha ng na-format na mensahe ng error. Upang gawin ito, maaari mong gamitin ang mga sumusunod na pamamaraan:

• Ang pamamaraan String getDescription()ay nagbabalik ng isang paglalarawan ng syntax error.
• Ibinabalik ng pamamaraan int getIndex()ang alinman sa posisyon kung saan nangyari ang error, o -1 kung hindi alam ang posisyon.
• Ang pamamaraan String getPattern()ay nagbabalik ng isang di-wastong regular na expression.

Bilang karagdagan, ang minanang pamamaraan String getMessage()ay nagbabalik ng isang multiline na string na may mga halaga na ibinalik mula sa mga nakaraang pamamaraan kasama ng isang visual na indikasyon kung saan naganap ang error sa syntax sa template. Ano ang isang syntax error? Narito ang isang halimbawa: java RegexDemo (?itree Treehouse Sa kasong ito, nakalimutan naming tukuyin ang closing parenthesis metacharacter ( )) sa nested flag expression. Ito ang output mula sa error na ito:

regex = (?itree
input = Treehouse
Неправильное регулярное выражение: Unknown inline modifier near index 3
(?itree
   ^
Описание: Unknown inline modifier
Позиция: 3
Неправильный шаблон: (?itree

Bumuo ng Mga Kapaki-pakinabang na Aplikasyon ng Regular Expression Gamit ang Regex API

Ang mga regular na expression ay nagbibigay-daan sa iyo upang lumikha ng makapangyarihang mga application sa pagpoproseso ng teksto. Sa seksyong ito, ipapakita namin sa iyo ang dalawang madaling gamitin na application na sana ay mahikayat ka na higit pang tuklasin ang mga klase at pamamaraan ng Regex API. Ipinakilala ng pangalawang apendiks ang Lexan: isang reusable code library para sa pagsasagawa ng lexical analysis.

Mga regular na expression at dokumentasyon

Ang dokumentasyon ay isa sa mga ipinag-uutos na gawain kapag bumubuo ng propesyonal na software. Sa kabutihang palad, ang mga regular na expression ay makakatulong sa iyo sa maraming aspeto ng paggawa ng dokumentasyon. Ang code sa Listing 1 ay kumukuha ng mga linyang naglalaman ng single-line at multiline na C-style na komento mula sa isang source file at isinusulat ang mga ito sa isa pang file. Para gumana ang code, dapat nasa parehong linya ang mga komento. Listahan 1. Pagkuha ng mga komento

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class ExtCmnt
{
   public static void main(String[] args)
   {
      if (args.length != 2)
      {
         System.err.println("Способ применения: java ExtCmnt infile outfile");
         return;
      }

      Pattern p;
      try
      {
         // Следующий шаблон определяет многострочные комментарии,
         // располагающиеся в одной строке (например, /* одна строка */)
            // и однострочные комментарии (например, // Howая-то строка).
            // Комментарий может располагаться в любом месте строки.

         p = Pattern.compile(".*/\\*.*\\*/|.*//.*$");
      }
      catch (PatternSyntaxException pse)
      {
         System.err.printf("Синтаксическая ошибка в регулярном выражении: %s%n", pse.getMessage());
         System.err.printf("Описание ошибки: %s%n", pse.getDescription());
         System.err.printf("Позиция ошибки: %s%n", pse.getIndex());
         System.err.printf("Ошибочный шаблон: %s%n", pse.getPattern());
         return;
      }

      try (FileReader fr = new FileReader(args[0]);
           BufferedReader br = new BufferedReader(fr);
           FileWriter fw = new FileWriter(args[1]);
           BufferedWriter bw = new BufferedWriter(fw))
      {
         Matcher m = p.matcher("");
         String line;
         while ((line = br.readLine()) != null)
         {
            m.reset(line);
            if (m.matches()) /* Должна соответствовать вся строка */
            {
               bw.write(line);
               bw.newLine();
            }
         }
      }
      catch (IOException ioe)
      {
         System.err.println(ioe.getMessage());
         return;
      }
   }
}

Ang pamamaraan main()sa Listing 1 ay unang sumusuri para sa tamang command-line syntax at pagkatapos ay nag-compile ng isang regular na expression na idinisenyo upang makita ang mga single- at multi-line na komento sa isang class object Pattern. Kung walang itinataas na exception PatternSyntaxException, bubuksan ng pamamaraan main()ang source file, gagawa ng target na file, kukuha ng matcher upang tumugma sa bawat linyang binasa laban sa pattern, at pagkatapos ay babasahin ang source file linya sa linya. Para sa bawat linya, itinutugma ito sa pattern ng komento. Kung matagumpay, isusulat ng pamamaraan main()ang string (sinusundan ng isang bagong linya) sa target na file (sasaklawin namin ang logic ng I/O ng file sa isang tutorial sa Java 101 sa hinaharap). I-compile ang Listahan 1 tulad ng sumusunod: javac ExtCmnt.java Patakbuhin ang application na may file ExtCmnt.javabilang input: java ExtCmnt ExtCmnt.java out Dapat mong makuha ang mga sumusunod na resulta sa file out:

// Следующий шаблон определяет многострочные комментарии,
 // располагающиеся в одной строке (например, /* одна строка */)
    // и однострочные комментарии (например, // Howая-то строка).
    // Комментарий может располагаться в любом месте строки.
p = Pattern.compile(".*/\\*.*\\*/|.*//.*$");
    if (m.matches()) /* Должна соответствовать вся строка */

Sa pattern string .*/\\*.*\\*/|.*//.*$, ang pipe metacharacter |ay gumaganap bilang isang lohikal na O operator, na nagsasaad na dapat gamitin ng matcher ang kaliwang operand ng ibinigay na regular na expression construct upang makahanap ng tugma sa texter ng matcher. Kung walang mga tugma, gagamitin ng matcher ang tamang operand mula sa ibinigay na regular na expression na construct para sa isa pang pagtatangka sa paghahanap (ang mga parenthesis metacharacter sa nakuhang pangkat ay bumubuo rin ng isang lohikal na operator). Mga Regular na Ekspresyon sa Java, Bahagi 5