جاوا میں باقاعدہ اظہار

باقاعدہ اظہار ایک ایسا موضوع ہے جسے پروگرامرز، یہاں تک کہ تجربہ کار بھی، اکثر بعد میں ملتوی کر دیتے ہیں۔ لیکن جلد یا بدیر، زیادہ تر جاوا ڈویلپرز کو متنی معلومات پر کارروائی کرنی پڑتی ہے۔ اکثر، اس کا مطلب ہے متن کی تلاش اور ترمیم کرنا۔ باقاعدہ اظہار کے بغیر، موثر اور کمپیکٹ ٹیکسٹ پروسیسنگ کوڈ کا تصور بھی نہیں کیا جا سکتا۔ لہذا تاخیر کرنا چھوڑ دیں، آئیے ابھی ریگولر ایکسپریشنز سے نمٹیں۔ یہ اتنا مشکل نہیں ہے۔

ریگولر ایکسپریشن (regex) کیا ہے؟

درحقیقت، ریگولر ایکسپریشن ٹیکسٹ میں سٹرنگ تلاش کرنے کا ایک نمونہ ہے۔ جاوا میں، اس پیٹرن کی اصل نمائندگی ہمیشہ ایک سٹرنگ ہوتی ہے، یعنی Stringکلاس کی ایک چیز۔ تاہم، یہ کوئی بھی تار نہیں ہے جسے باقاعدہ اظہار میں مرتب کیا جا سکتا ہے — صرف وہ تاریں جو ریگولر ایکسپریشن بنانے کے اصولوں کے مطابق ہوں۔ نحو کی وضاحت زبان کی تصریح میں کی گئی ہے۔ ریگولر ایکسپریشنز کو حروف اور نمبروں کے ساتھ ساتھ میٹا کریکٹرز کا استعمال کرتے ہوئے لکھا جاتا ہے، جو کہ وہ حروف ہیں جو ریگولر ایکسپریشن نحو میں خاص معنی رکھتے ہیں۔ مثال کے طور پر:

String regex = "java"; // The pattern is "java";
String regex = "\\d{3}"; // The pattern is three digits;

جاوا میں ریگولر ایکسپریشنز بنانا

جاوا میں باقاعدہ اظہار بنانے میں دو آسان اقدامات شامل ہیں:

1. اسے ایک سٹرنگ کے طور پر لکھیں جو ریگولر ایکسپریشن نحو کے مطابق ہو۔
2. سٹرنگ کو باقاعدہ اظہار میں مرتب کریں؛

Patternجاوا کے کسی بھی پروگرام میں، ہم ایک آبجیکٹ بنا کر ریگولر ایکسپریشنز کے ساتھ کام شروع کرتے ہیں ۔ ایسا کرنے کے لیے، ہمیں کلاس کے دو جامد طریقوں میں سے ایک کو کال کرنا ہوگا: compile۔ پہلا طریقہ ایک دلیل لیتا ہے - ایک سٹرنگ لٹریل جس میں باقاعدہ اظہار ہوتا ہے، جب کہ دوسرا ایک اضافی دلیل لیتا ہے جو پیٹرن سے مماثل ترتیبات کا تعین کرتا ہے:

public static Pattern compile (String literal)
public static Pattern compile (String literal, int flags)

پیرامیٹر کی ممکنہ قدروں کی فہرست کلاس flagsمیں بیان کی گئی ہے Patternاور ہمارے لیے جامد کلاس متغیرات کے طور پر دستیاب ہے۔ مثال کے طور پر:

Pattern pattern = Pattern.compile("java", Pattern.CASE_INSENSITIVE); // Pattern-matching will be case insensitive.

بنیادی طور پر، Patternکلاس باقاعدہ اظہار کے لیے ایک کنسٹرکٹر ہے۔ ہڈ کے نیچے، طریقہ کلاس کے پرائیویٹ کنسٹرکٹر کو ایک مرتب کردہ نمائندگی بنانے کے لیے compileکال کرتا ہے ۔ Patternیہ آبجیکٹ تخلیق کرنے کا طریقہ کار اس طرح لاگو کیا جاتا ہے تاکہ ناقابل تغیر اشیاء کو تخلیق کیا جا سکے۔ جب ریگولر ایکسپریشن بنتا ہے تو اس کا نحو چیک کیا جاتا ہے۔ اگر سٹرنگ میں غلطیاں ہیں، تو ایک PatternSyntaxExceptionپیدا ہوتا ہے۔

باقاعدہ اظہار نحو

باقاعدہ اظہار کا نحو <([{\^-=$!|]})?*+.>حروف پر انحصار کرتا ہے، جنہیں حروف کے ساتھ ملایا جا سکتا ہے۔ ان کے کردار پر منحصر ہے، وہ کئی گروہوں میں تقسیم کیا جا سکتا ہے: 1. لکیروں یا متن کی حدود کو ملانے کے لیے میٹا حروف 2. پہلے سے طے شدہ کریکٹر کلاسز کے ملاپ کے لیے میٹا کریکٹرز 3. مماثل کنٹرول حروف کے لیے میٹا کریکٹرز 4. کریکٹر کلاسز کے لیے میٹا کریکٹرز 5. حروف کی تعداد (کوانٹیفائر) کی نشاندہی کرنے کے لیے میٹا حروف۔ ایک کوانٹیفائر ہمیشہ ایک کریکٹر یا کریکٹر گروپ سے پہلے ہوتا ہے۔

لالچی quantifiers

ایک چیز جو آپ کو کوانٹیفائرز کے بارے میں جاننی چاہئے وہ یہ ہے کہ وہ تین مختلف اقسام میں آتے ہیں: لالچی، ملکیتی، اور ہچکچاہٹ۔ +آپ کوانٹیفائر کے بعد ایک " " حرف شامل کرکے کوانٹیفائر کو possessive بناتے ہیں ۔ ?آپ اسے " " شامل کرکے ہچکچاتے ہیں ۔ مثال کے طور پر:

"A.+a" // greedy
"A.++a" // possessive
"A.+?a" // reluctant

آئیے یہ سمجھنے کے لیے اس پیٹرن کو استعمال کرنے کی کوشش کریں کہ مختلف قسم کے کوانٹیفائر کیسے کام کرتے ہیں۔ پہلے سے طے شدہ طور پر، کوانٹیفائر لالچی ہوتے ہیں۔ اس کا مطلب ہے کہ وہ تار میں سب سے طویل میچ تلاش کرتے ہیں۔ اگر ہم درج ذیل کوڈ کو چلاتے ہیں:

public static void main(String[] args) {
    String text = "Fred Anna Alexander";
    Pattern pattern = Pattern.compile("A.+a");
    Matcher matcher = pattern.matcher(text);
    while (matcher.find()) {
        System.out.println(text.substring(matcher.start(), matcher.end()));
    }
}

ہمیں یہ آؤٹ پٹ ملتا ہے:

Anna Alexa

ریگولر ایکسپریشن " A.+a" کے لیے، پیٹرن میچنگ اس طرح کی جاتی ہے:

1. مخصوص پیٹرن میں پہلا حرف لاطینی حرف ہے A۔ Matcherانڈیکس صفر سے شروع ہو کر متن کے ہر حرف سے اس کا موازنہ کرتا ہے۔ کریکٹر Fہمارے متن میں انڈیکس صفر پر ہے، اس لیے Matcherحروف کے ذریعے اس وقت تک دہرایا جاتا ہے جب تک کہ یہ پیٹرن سے مماثل نہ ہو۔ ہماری مثال میں، یہ کردار انڈیکس 5 میں پایا جاتا ہے۔

2. پیٹرن کے پہلے حرف کے ساتھ مماثلت ملنے کے بعد، Matcherاس کے دوسرے کریکٹر کے ساتھ مماثلت تلاش کرتا ہے۔ ہمارے معاملے میں، یہ " ." کردار ہے، جو کسی بھی کردار کے لیے کھڑا ہے۔

   کردار nچھٹے نمبر پر ہے۔ یہ یقینی طور پر "کسی بھی کردار" کے میچ کے طور پر اہل ہے۔

3. Matcherپیٹرن کے اگلے کردار کو چیک کرنے کے لیے آگے بڑھتا ہے۔ ہمارے پیٹرن میں، یہ کوانٹیفائر میں شامل کیا گیا ہے جو پچھلے حرف پر لاگو ہوتا ہے: " .+"۔ چونکہ ہمارے پیٹرن میں "کسی بھی کریکٹر" کی تکرار کی تعداد ایک یا زیادہ بار ہے، Matcherبار بار سٹرنگ سے اگلا کریکٹر لیتا ہے اور اسے پیٹرن کے خلاف چیک کرتا ہے جب تک کہ یہ "کسی بھی کریکٹر" سے میل کھاتا ہے۔ ہماری مثال میں - سٹرنگ کے اختتام تک (انڈیکس 7 سے انڈیکس 18 تک)۔

   بنیادی طور پر، Matcherتار کو آخر تک لے جاتا ہے — یہ بالکل وہی ہے جو "لالچی" سے مراد ہے۔

4. جب میچر متن کے آخر تک پہنچ جاتا ہے اور پیٹرن کے " " حصے کی جانچ پڑتال مکمل کرتا ہے A.+، تو یہ باقی پیٹرن کی جانچ کرنا شروع کر دیتا ہے: a۔ آگے کوئی متن نہیں ہے، لہذا چیک "بیک آف" کے ذریعے آگے بڑھتا ہے، آخری کردار سے شروع ہوتا ہے:

5. Matcher.+پیٹرن کے " " حصے میں تکرار کی تعداد کو "یاد رکھتا ہے" ۔ اس مقام پر، یہ تکرار کی تعداد کو ایک سے کم کرتا ہے اور متن کے خلاف بڑے پیٹرن کو چیک کرتا ہے جب تک کہ کوئی مماثلت نہ مل جائے:

حامل کوانٹیفائر

ملکیتی کوانٹیفائر بہت زیادہ لالچی کی طرح ہوتے ہیں۔ فرق یہ ہے کہ جب متن کو سٹرنگ کے آخر تک پکڑ لیا جاتا ہے، تو "بیکنگ آف" کے دوران کوئی پیٹرن میچنگ نہیں ہوتی ہے۔ دوسرے لفظوں میں، پہلے تین مراحل وہی ہیں جیسے لالچی کوانٹیفائر کے لیے۔ پوری سٹرنگ کیپچر کرنے کے بعد، میچر باقی پیٹرن کو اس میں شامل کرتا ہے جس پر وہ غور کر رہا ہے اور اس کا موازنہ کیپچر کی گئی سٹرنگ سے کرتا ہے۔ ہماری مثال میں، ریگولر ایکسپریشن " A.++a" کا استعمال کرتے ہوئے، بنیادی طریقہ سے کوئی مماثلت نہیں ملتی۔

ہچکچاہٹ کوانٹیفائر

1. ان کوانٹیفائرز کے لیے، جیسا کہ لالچی قسم کے ساتھ، کوڈ پیٹرن کے پہلے کردار کی بنیاد پر ایک میچ تلاش کرتا ہے:

2. پھر یہ پیٹرن کے اگلے کردار (کوئی بھی کردار) کے ساتھ میچ تلاش کرتا ہے:

3. لالچی پیٹرن میچنگ کے برعکس، ہچکچاہٹ والے پیٹرن میچنگ میں مختصر ترین میچ تلاش کیا جاتا ہے۔ اس کا مطلب یہ ہے کہ پیٹرن کے دوسرے کریکٹر سے مماثلت تلاش کرنے کے بعد (ایک مدت، جو متن میں پوزیشن 6 پر موجود کریکٹر سے مماثل ہے، Matcherچیک کرتا ہے کہ آیا متن باقی پیٹرن سے میل کھاتا ہے - حرف " a"

4. متن پیٹرن سے مماثل نہیں ہے (یعنی یہ انڈیکس 7 پر " " حرف پر مشتمل ہے n)، اس لیے Matcherمزید ایک "کوئی بھی حرف" کا اضافہ کرتا ہے، کیونکہ کوانٹیفائر ایک یا زیادہ کی نشاندہی کرتا ہے۔ اس کے بعد یہ دوبارہ 5 سے 8 پوزیشنوں میں متن کے ساتھ پیٹرن کا موازنہ کرتا ہے:

ہمارے معاملے میں، ایک میچ پایا جاتا ہے، لیکن ہم ابھی تک متن کے اختتام تک نہیں پہنچے ہیں۔ لہٰذا، پیٹرن کی مماثلت پوزیشن 9 سے دوبارہ شروع ہوتی ہے، یعنی پیٹرن کے پہلے کردار کو اسی طرح کے الگورتھم استعمال کرنے کے لیے دیکھا جاتا ہے اور یہ متن کے اختتام تک دہرایا جاتا ہے۔

اس کے مطابق، mainپیٹرن " A.+?a" کا استعمال کرتے وقت طریقہ درج ذیل نتیجہ حاصل کرتا ہے: Anna Alexa جیسا کہ آپ ہماری مثال سے دیکھ سکتے ہیں، مختلف قسم کے کوانٹیفائر ایک ہی پیٹرن کے لیے مختلف نتائج پیدا کرتے ہیں۔ لہذا اس کو ذہن میں رکھیں اور آپ جس چیز کی تلاش کر رہے ہیں اس کی بنیاد پر صحیح قسم کا انتخاب کریں۔

ریگولر ایکسپریشنز میں کرداروں سے فرار

چونکہ جاوا میں ایک باقاعدہ اظہار، یا اس کے بجائے، اس کی اصل نمائندگی، ایک سٹرنگ لٹریل ہے، ہمیں اسٹرنگ لٹریلز کے حوالے سے جاوا کے قوانین کا حساب دینا ہوگا۔ \خاص طور پر، جاوا سورس کوڈ میں سٹرنگ لٹریلز میں بیک سلیش کریکٹر " " کو ایک کنٹرول کریکٹر کے طور پر سمجھا جاتا ہے جو کمپائلر کو بتاتا ہے کہ اگلا کریکٹر خاص ہے اور اس کی تشریح ایک خاص طریقے سے ہونی چاہیے۔ مثال کے طور پر:

String s = "The root directory is \nWindows"; // Move "Windows" to a new line
String s = "The root directory is \u00A7Windows"; // Insert a paragraph symbol before "Windows"

اس کا مطلب یہ ہے کہ سٹرنگ لٹریلز جو ریگولر ایکسپریشنز کو بیان کرتے ہیں اور " \" حروف کا استعمال کرتے ہیں (یعنی میٹا کریکٹرز کی نشاندہی کرنے کے لیے) کو بیک سلیش کو دہرانا چاہیے تاکہ یہ یقینی بنایا جا سکے کہ جاوا بائیک کوڈ کمپائلر سٹرنگ کی غلط تشریح نہ کرے۔ مثال کے طور پر:

String regex = "\\s"; // Pattern for matching a whitespace character
String regex = "\"Windows\"";  // Pattern for matching "Windows"

خاص حروف سے بچنے کے لیے ڈبل بیک سلیش کا بھی استعمال کیا جانا چاہیے جنہیں ہم "عام" حروف کے طور پر استعمال کرنا چاہتے ہیں۔ مثال کے طور پر:

String regex = "How\\?";  // Pattern for matching "How?"

پیٹرن کلاس کے طریقے

کلاس Patternکے پاس ریگولر ایکسپریشنز کے ساتھ کام کرنے کے دوسرے طریقے ہیں:

• String pattern()‒ آبجیکٹ بنانے کے لیے استعمال ہونے والی ریگولر ایکسپریشن کی اصل سٹرنگ کی نمائندگی کو لوٹاتا ہے Pattern:

  Pattern pattern = Pattern.compile("abc");
  System.out.println(pattern.pattern()); // "abc"

• static boolean matches(String regex, CharSequence input)- آپ کو ریگولر ایکسپریشن کو چیک کرنے دیتا ہے جو بطور پاس کردہ متن کے خلاف regex کے طور پر پاس کیا گیا ہے input۔ واپسی:

  صحیح - اگر متن پیٹرن سے میل کھاتا ہے؛
  غلط - اگر ایسا نہیں ہوتا ہے؛

  مثال کے طور پر:

  System.out.println(Pattern.matches("A.+a","Anna")); // true
  System.out.println(Pattern.matches("A.+a","Fred Anna Alexander")); // false

• int flags()‒ پیٹرن کے پیرامیٹر سیٹ کی قدر واپس کرتا ہے flagsجب پیٹرن بنایا گیا تھا یا 0 اگر پیرامیٹر سیٹ نہیں کیا گیا تھا۔ مثال کے طور پر:

  Pattern pattern = Pattern.compile("abc");
  System.out.println(pattern.flags()); // 0
  Pattern pattern = Pattern.compile("abc",Pattern.CASE_INSENSITIVE);
  System.out.println(pattern.flags()); // 2

• String[] split(CharSequence text, int limit)- پاس شدہ متن کو ایک Stringصف میں تقسیم کرتا ہے۔ پیرامیٹر limitمتن میں تلاش کیے گئے میچوں کی زیادہ سے زیادہ تعداد کی نشاندہی کرتا ہے:

  • اگر limit > 0- limit-1مماثل ہے؛
  • اگر limit < 0- متن میں تمام مماثل ہیں۔
  • اگر limit = 0- متن میں تمام مماثلتیں، صف کے آخر میں خالی تاروں کو مسترد کر دیا جاتا ہے؛

  مثال کے طور پر:

  public static void main(String[] args) {
      String text = "Fred Anna Alexa";
      Pattern pattern = Pattern.compile("\\s");
      String[] strings = pattern.split(text,2);
      for (String s : strings) {
          System.out.println(s);
      }
      System.out.println("---------");
      String[] strings1 = pattern.split(text);
      for (String s : strings1) {
          System.out.println(s);
      }
  }

  کنسول آؤٹ پٹ:

  
  Fred
  Anna Alexa
  ---------
  Fred
  Anna
  Alexa

  ذیل میں ہم کلاس کے ایک اور طریقے پر غور کریں گے جو Matcherآبجیکٹ بنانے کے لیے استعمال ہوتا ہے۔

میچر کلاس کے طریقے

کلاس کی مثالیں Matcherپیٹرن میچنگ انجام دینے کے لیے بنائی جاتی ہیں۔ Matcherباقاعدہ اظہار کے لیے "سرچ انجن" ہے۔ تلاش کرنے کے لیے، ہمیں اسے دو چیزیں دینے کی ضرورت ہے: ایک پیٹرن اور ایک ابتدائی اشاریہ۔ Matcherایک آبجیکٹ بنانے کے لیے ، Patternکلاس مندرجہ ذیل طریقہ فراہم کرتی ہے: рublic Matcher matcher(CharSequence input) طریقہ ایک کردار کی ترتیب لیتا ہے، جسے تلاش کیا جائے گا۔ یہ ایک کلاس کی مثال ہے جو CharSequenceانٹرفیس کو نافذ کرتی ہے۔ آپ نہ صرف a Stringبلکہ a StringBuffer, StringBuilder, Segment, یا کو بھی پاس کرسکتے ہیں CharBuffer۔ پیٹرن ایک Patternایسی چیز ہے جس پر matcherطریقہ کہا جاتا ہے. میچر بنانے کی مثال:

Pattern p = Pattern.compile("a*b"); // Create a compiled representation of the regular expression
Matcher m = p.matcher("aaaaab"); // Create a "search engine" to search the text "aaaaab" for the pattern "a*b"

اب ہم اپنے "سرچ انجن" کا استعمال مماثلتوں کو تلاش کرنے، متن میں مماثلت کی پوزیشن حاصل کرنے، اور کلاس کے طریقوں کا استعمال کرتے ہوئے متن کو تبدیل کرنے کے لیے استعمال کر سکتے ہیں۔ طریقہ boolean find()متن میں اگلے میچ کی تلاش کرتا ہے۔ ہم ایونٹ ماڈل کے حصے کے طور پر پورے متن کا تجزیہ کرنے کے لیے یہ طریقہ اور لوپ اسٹیٹمنٹ استعمال کر سکتے ہیں۔ دوسرے لفظوں میں، جب کوئی واقعہ پیش آتا ہے، یعنی جب ہمیں متن میں کوئی مماثلت ملتی ہے تو ہم ضروری کارروائیاں کر سکتے ہیں۔ مثال کے طور پر، ہم متن میں میچ کی پوزیشن کا تعین کرنے کے لیے اس کلاس int start()اور طریقوں کا استعمال کر سکتے ہیں۔ int end()اور ہم متبادل پیرامیٹر کی قدر کے ساتھ میچوں کو تبدیل کرنے کے لیے String replaceFirst(String replacement)اور طریقے استعمال کر سکتے ہیں۔ String replaceAll(String replacement)مثال کے طور پر:

public static void main(String[] args) {
    String text = "Fred Anna Alexa";
    Pattern pattern = Pattern.compile("A.+?a");

    Matcher matcher = pattern.matcher(text);
    while (matcher.find()) {
        int start=matcher.start();
        int end=matcher.end();
        System.out.println("Match found: " + text.substring(start, end) + " from index "+ start + " through " + (end-1));
    }
    System.out.println(matcher.replaceFirst("Ira"));
    System.out.println(matcher.replaceAll("Mary"));
    System.out.println(text);
}

آؤٹ پٹ:

Match found: Anna from index 5 through 8
Match found: Alexa from index 10 through 14
Fred Ira Alexa
Fred Mary Mary
Fred Anna Alexa

مثال سے یہ واضح ہوتا ہے کہ replaceFirstاور replaceAllطریقے ایک نئی Stringآبجیکٹ بناتے ہیں — ایک سٹرنگ جس میں اصل متن میں پیٹرن کے مماثلت کو دلیل کے طور پر طریقہ کو بھیجے گئے متن سے بدل دیا جاتا ہے۔ مزید برآں، replaceFirstطریقہ صرف پہلے میچ کی جگہ لے لیتا ہے، لیکن replaceAllطریقہ متن میں موجود تمام میچوں کی جگہ لے لیتا ہے۔ اصل متن میں کوئی تبدیلی نہیں ہے۔ اور کلاسز کے اکثر ریجیکس آپریشن بالکل کلاس میں بنائے Patternجاتے ہیں۔ یہ طریقے ہیں جیسے , , , اور . لیکن ہڈ کے نیچے، یہ طریقے اور کلاسز کا استعمال کرتے ہیں۔ لہذا اگر آپ کسی پروگرام میں بغیر کسی اضافی کوڈ کے متن کو تبدیل کرنا چاہتے ہیں یا اسٹرنگ کا موازنہ کرنا چاہتے ہیں تو کلاس کے طریقے استعمال کریں۔ اگر آپ کو مزید جدید خصوصیات کی ضرورت ہے تو، اور کلاسز کو یاد رکھیں۔ MatcherStringsplitmatchesreplaceFirstreplaceAllPatternMatcherStringPatternMatcher

نتیجہ

جاوا پروگرام میں، ایک ریگولر ایکسپریشن کی تعریف ایک سٹرنگ کے ذریعے کی جاتی ہے جو مخصوص پیٹرن سے مماثل قوانین کی پابندی کرتی ہے۔ کوڈ پر عمل کرتے وقت، جاوا مشین اس سٹرنگ کو ایک Patternآبجیکٹ میں مرتب کرتی ہے اور Matcherمتن میں مماثلتیں تلاش کرنے کے لیے ایک آبجیکٹ کا استعمال کرتی ہے۔ جیسا کہ میں نے شروع میں کہا تھا، لوگ اکثر ان کو ایک مشکل موضوع سمجھتے ہوئے بعد کے لیے باقاعدہ اظہار کو روک دیتے ہیں۔ لیکن اگر آپ بنیادی نحو، میٹا کریکٹرز، اور کردار سے فرار کو سمجھتے ہیں، اور ریگولر ایکسپریشنز کی مثالوں کا مطالعہ کرتے ہیں، تو آپ دیکھیں گے کہ وہ پہلی نظر میں ظاہر ہونے سے کہیں زیادہ آسان ہیں۔