პოსტები ტეგით “RegExp”

STL: Simple Template Language Preview

დეკ 02 2009

დიდი ხნის პაუზის შემდეგ მინდა წარმოგიდგინოთ ერთი ახალი პროექტი რომელზეც გარკვეული პერიოდია ვმუშაობ. ჯერჯერობით ეს არის პრივიუ რელიზი რომელიც მალე საბოლოო ფაზაში შევა და სრულ დოკუმენტაციასა და მაგალითებს შესაბამისად წარმოგიდგენთ. მანამდე კი მისი ნახვა და გადმოწერა შეგიძლიათ შემდეგი მისამართიდან: STL Library.

რა არის STL? როგორც სათაურმა მიგანიშნათ ეს არის PHP – ზე დაწერილი მარტივი და მოქნილი შაბლონების ენა და ამ ენის პროცესორი. STL არის მარტივად გამოყენებადი შაბლონების ენა რომელიც არის საკმაოდ მარტივად ასათვისებელი თუ თქვენ გაგაჩნიათ ნებისმიერ მსგავს შაბლონების ენასთან სულ მცირედი მუშაობის გამოცდილებაც კი. მისი სინტაქსი წააგავს Django, Jinja2, Smarty და სხვა მსგავსი შაბნოლენბის ენებს.

ბიბლიოთეკას არ აქვს არანაირი დამოკიდებულება სხვა გარე ბიბლიოთეკებზე და PHP – ს სპეციფიურ მოდულებზე. კი არის სრულად ე.წ. standalone და მისი გამოყენება შეგიძლიათ ნებისმიერ PHP პროექტში. სრულად »

ტეგები: , , ,

38 კომენტარი »

JavaScript: String.replace()

სექ 16 2009

რამდენიმე წლის წინ დავწერე პოსტი JavaScript – ით DOM ელემენტის სტილებთან მუშაობის შესახებ. ბრაუზერებს შორის სხვაობიდან გამომდინარე(კერძოდ კი IE – ს განსხვავებული მიდგომის გამო) პრობლემის გვერდის ასავლელად დავწერე ქვემოთ ნაჩვენები კოდი:

1
2
3
4
5
6
7
8
9
10
function getCamelCase(string) {
    var tokens = string.split('-');
    if (tokens.length > 1) {
        for (var i = 1; i < tokens.length; i++) {
            tokens[i] = tokens[i].substring(0, 1).toUpperCase() + tokens[i].substring(1).toLowerCase();
        }
        string = tokens.join('');
    }
    return string;
}

კოდის ერთადერთი დანიშნულებაა ტირეებიანი CSS ატრიბუტების მაგ. border-left-color, background-color გადაყვანა ე.წ. Camel Case ფორმატში ანუ borderLeftColor, backgroundColor და ა.შ.

დღეს კოდის წერისას იგივე პრობლემა მექანიკურად გადავჭერი სხვა უფრო მოხდენილი და რაც მთავარია გაცილებით მცირე ზომის კოდის მეშვეობით:

1
2
3
4
5
6
7
8
var str = "some-test-string";
str.replace(/-([w])/gi, function(a1, a2) {
    return a2.toUpperCase();
});

//კოდის შესრულების შემდეგ
//სტრიქონი "some-test-string"
//გარდაიქმნება შემდეგნაირად: "someTestString"

დამეთანხმებით რომ თვალსაჩინო სხვაობაა :D როგორ მუშაობს ეს კოდი? პირველ რიგში შეგახსენებთ თავად String ობიექტის replace() მეთოდის სიგნატურას:

str.replace(regexp|substr, newSubStr|function[, Non-standard flags]);

ანუ replace() მეთოდს მეორე პარამეტრად ახალი, ჩასანაცვლებელი სტრიქონის ნაცვლად შეგვიძლია გადავცეთ ქოლბექ ფუნქცია რომელიც დააბრუნებს დამუშავებულ სტრიქონს, ხოლო ეს დაბრუნებული სტრიქონი თავის მხრივ გამოყენებული იქნება რეგულარული გამოსახულების მიერ ნაპოვნი შესატყვისის ჩასანაცვლებლად.

საინტერესოა ასევე თუ რა პარამეტრებს გადასცემს replace() მეთოდი ქოლბექ ფუნქციას. გადასაცემი პარამეტრების რაოდენობა ცვალებადია და დამოკიდებულია მთელ რიგ ფაქტორებზე. მაგალითად ჩემს მიერ ნაჩვენებ მაგალითში ფუნქციას გადაეცემა ოთხი პარამეტრი, კერძოდ კი ფუნქცია გამოიძახება ორჯერ შემდეგი პარამეტრებით:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//პიველი დამთხვევისათვის ანუ "-t"
function(
  "-t",  //რეგულარული გამოსახულების მიერ ნაპოვნი სტრიქონი სრულად
  "t",    //დამაჯგუფებელ ფრჩხილებში მოთავსებული შედეგი
  4,     //პოზიცია რომელზეც მოხდა პირველი დამთხვევა
  "some-test-string" //სრული სტრიქონი
);

//მეორე დამთხვევისათვის ანუ "-s"
function(
  "-s",  //რეგულარული გამოსახულების მიერ ნაპოვნი სტრიქონი სრულად
  "s",    //დამაჯგუფებელ ფრჩხილებში მოთავსებული შედეგი
  9,     //პოზიცია რომელზეც მოხდა პირველი დამთხვევა
  "some-test-string" //სრული სტრიქონი
);

ნაჩვენები კოდიდან თვალსაჩინოა სავარაუდო პარამეტრების რაოდენობა, თუმცა მნიშვნელოვანია შემდეგი დეტალების გათვალისწინება, ქოლბექ ფუნქციას:

  • პირველ პარამეტრად ყოველთვის გადაეცემა რეგულარული გამოსახულების მიერ ნაპოვნი სრული შესატყვისი;
  • ბოლო პარამეტრად ყოველთვის გადაეცემა სრული სტრიქონი რომლშიც განხორციელდა გარკვეული შესატყვისის ძიება;
  • ბოლოდან მეორე(ბოლოს წინა) პარამეტრად ყოველთვის გადაეცემა ნაპოვნი შესატყვისის პოზიცია.
  • თუ რამდენი პარამეტრის გადაცემა მოხდება პირველსა და ბოლო ორ პარამეტრს შორის დამოკიდებულია რეგულარულ გამოსახულებაში გამოყენებული დამაჯგუფებელი ფრჩხილების რაოდენობაზე(ჩემს მიერ ნაჩვენებ მაგალითში ასეთი პარამეტრი ერთია რადგან მხოლოდ ერთი დამაჯგუფება მაქვს გამოყენებული);
  • replace() მეთოდი გამოიძახებს ერთხელ თუ რეგულარული გამოსახულების ბოლოს არ გვაქვს მითითებული “g” ანუ გლობალური მოდიფიკატორი, ან გამოიძახებს იმდენჯერ რამდენი დამთხვევაც მოხდება კონკრეტული შესატყვისისათვის(ნაჩვენებ მაგალითში გამოძახება მოხდება ორჯერ).

enjoy B-)

ტეგები: ,

8 კომენტარი »

JavaScript: Regex and Multi-line Mode

აპრ 21 2009

დღეს აღმოვაჩინე რომ JavaScript – ის Regex იმპლემენტაციას გარდა სხვა ნაკლოვანებებისა ასევე არ გააჩნია ე.წ. “multi-line match mode”. ამ შემთხვევაში ლაპარაკი არ მაქვს რეგულარული გამოსახულების “m” მოდიფიკატორის მხარდაჭერაზე, ლაპარაკი მაქვს “s” მოდიფიკატორზე რომელიც “.“(წერტილი) სიმბოლოს აიძულებს გარდა სხვა სიმბოლოებისა(ნაგულისხმევად “.” ნიშნავს “ნებისმიერი სიმბოლო გარდა ახალი სტრიქონის სიმბოლოსი”) ასევე მოძებნოს ახალი სტრიქონის სიმბოლო.

ჩემი მარტივი ამოცანის გადასაჭრელად საჭირო იყო მოცემულ ტექსტში მეპოვა შემდეგი ტიპის მონაკვეთი:

1
2
3
function myFunction($param1, $param2) {
      return array($param1, $param2);
}

ხოლო ნაპოვნი მონაკვეთიდან ამომეღო {code}{/code} ტაგებს შორის მოქცეული ტექსტი. თუმცა ეს გასაგები მიზეზების გამო არ გამომივიდა.

ნებისმიერ PCRE – სთან თავსებად იმპლემენტაციას გააჩნია “s” მოდიფიკატორი რომლის მეშვეობითაც მსგავსი ამოცანა წყდება ძალიან მარტივად. მაგალითად PHP – ში რეგულარულ გამოსახულებას ჩავწერდით შემდეგნაირად:

1
2
3
//ყურადღება მიაქციეთ გამოსახულების ბოლოში
//მიწერილ "s" სიმბოლოს
$regex = '/{code lang="(w+)"}(.*?){/code}/s'

სამწუხაროდ ასეთ გამოსახულებას JavaScript – ში ვერ დავწერთ. თუმცა, ცოტაოდენი კვლევაძიებისა და ექსპერიმენტების შემდგომ მივაგენი გამოსავალს რაც გამოიხატება სპეციფიური ე.წ. character class – ის გამოყენებაში. ამისათვის საჭიროა “s” და “S” მეტა სიმბოლოების დაჯგუფება character class – ში. შედეგად მივიღებთ შემდეგ გამოსახულებას:

1
[sS]

სადაც “s” შეესაბამება ნებისმიერ უხილავ სიმბოლოს, ხოლო “S” შეესაბამება ნებისმიერ არა უხილავ სიმბოლოს.

შედეგად მივიღე ასეთი JavaScript – ის რეგულარული გამოსახულება:

1
/{codes+lang="(w+)"}([sS]*){/code}/

ეს გამოსახულება მუშაობს ანალოგიურად PCRE – სთან თავსებადი გამოსახულებისა რომელიც იყენებს “s” მოდიფიკატორს.

ტეგები: ,

2 კომენტარი »

PHP: nl2p(aragraph) vs nl2br

ივლ 18 2008

როგორ იქცევით ისეთ შემთხვევაში, როდესაც საჭიროა HTML textarea ელემენტიდან მიღებული ტექსტის, HTML დოკუმენტში უცვლელად გამობეჭვდაა საჭირო ანუ ტექსტის ფორმატირების გათვალისწინებით?

ამ შემთხვევაში, ტექსტის აბზაცებად ფორმატირებას ვგულისხმობ, სადაც აბზაცების გამოყოფად იგულისხმება ახალი სტრიქონის სიმბოლო.

მაგალითად ასეთი ტექსტი:

ეს არის ჩვეულებრივი აბზაცი.

ეს არის შემდეგი აბზაცი...

და კიდევ ერთი აბზაცი..

ამ შემთხვევაში ტექსტის გამოსაბეჭდად გამოვიყენე <pre> ტეგი, რომელიც ტექსტს ახალი სტრიქონის სიმბოლოების გათვალისწინებით ბეჭდავს და არ უკარგავს მას ფორმატირებას. თუმცა, <pre> სრულიად გამოუსადეგარია ბლოგ პოსტის ან ამ ბლოგის მომხმარებლების მიერ დაპოსტილი კომენტარების გამოსატანად.

PHP – ს გააჩნია ფუნქცია სახელად nl2br რომელსაც ყოველი ახალი სტრიქონის სიმბოლო გადაჰყავს <br /> ტეგში, თუმცა არც ეს არის დიდი ხეირი რადგან,
როგორც HTML სპეციფიკაცია გვეუბნება, აბზაცების ფორმატირებისათვის უნდა გამოვიყენოთ <p> ტეგი, თუმცა PHP – ს ასეთი ფუნქცია არ გააჩნია.

მარტივი რეგულარული გამოსახულების დახმარებით მივიღე ასეთი ფუნქცია, რომელიც აღწერილ პრობლემას მარტივად და სწრაფად აგვარებს:

[php]
function nl2p($input) {
return preg_replace(‘~^s*(.*?)s*$~smx’, ‘

$1

‘, $input);
}
[/php]

თუ ამ ფუნქციას გამოვიყენებთ ზემოთ მოყვანილი ტექსტის დასამუშავებლად, მივიღებთ ასეთ შედეგს:

<p>ეს არის ჩვეულებრივი აბზაცი.</p>
<p>ეს არის შემდეგი აბზაცი...</p>
<p>და კიდევ ერთი აბზაცი..</p>

აღსანიშნავია რომ, ეს ფუნქცია იგნორირებას უკეთებს ერთმანეთის მიყოლებით აკრეფილ ახალი სტრიქონის სიმბოლოებს.

როგორ მუშაობს თავად რეგულარული გამოსახულება:

$regex = '~
    ^            # 1) შევამოწმოთ სტრიქონის დასაწყისი
    s*          # 2) ნებისმიერი რაოდენობის უხილავი სიმბოლო
    (.*?)        # 3) ნებისმიერი რაოდენობის ნებისმიერი სიმბოლო
    s*          # 4) ნებისმიერი რაოდენობის უხილავი სიმბოლო
    $            # 5) შევამოწმოთ სტრიქონის დასასრული
~smx'            # 6) smx - გამოსახულების მოდიფიკატორები

ბრჩხილებში მოქცეული გამოსახულების მესამე პუნქტის მეშვეობით ვინახავთ ჩვენთვის საჭირო ტექსტს, იმისათვის რომ მოგვიანებით შევძლოთ მისი გამოყენება, გამოსახულების დანარჩენი ნაწილი კი უბრალოდ ტექსტის შემოწმებისათვის არის საჭირო.

თავად გამოსახულებაზე უფრო საინტერესო მოცემულ შემთხვევაში არის, გამოყენებული რეგულარული გამოსახულების მოდიფიკატორები s და m.

. – წერტილი, რეგულარულ გამოსახულებაში ნიშნავს ნებისმიერ სიმბოლოს ახალი სტრიქონის სიმბოლოს გარდა. ხოლო s მოდიფიკატორი გამოსახულების ბოლოს წერტილს უცვლის მნიშვნელობას და იგი უკვე სხვა ნებისმიერ სიმბოლოსთან ერთად ახალი სტრიქონის სიმბოლოებსაც მოიცავს.

m მოდიფიკატორი თავის მხრივ ცვლის ტექსტის დასაწყისისა(^) და ტექსტის დასასრულის($) სიმბოლოების ქცევას. რაც ნიშნავს იმას, რომ, ეს სიმბოლოები მიუთითებენ არა მთლიანი ტექსტის დასაწყისსა და დასასრულს არამედ ახალი ხაზის სიმბოლოთი გამოყოფილ სტრიქონის დასაწყისსა და დასასრულს.

გამოსახულებაში ასევე მნიშვნელოვანია მეორე და მეოთხე პუნქტები. გამოსახულება უბრალოდ აღნიშნავს ნებისმიერი რაოდენობის უხილავ სიმბოლოს(უხილავ სიმბოლოებს განეკუთვნება ახალი სტრიქონის სიმბოლოც). გამოსახულების ეს ნაწილია საჭიროა იმისათვის რომ ტექსტში არსებულ ერთზე მეტ ახალი სტრიქონის სიმბოლოებს გავუკეთოთ იგნორეირება რათა არ მივიღოთ ცარიელი <p>p</p> ტეგების კომბინაცია.

სულ ეს არის და ეს :)

ტეგები: ,

6 კომენტარი »