Code.ge Blog » RegExp http://www.code.ge ბლოგი ვებ პროგრამირებისა და ტექნოლოგიების შესახებ Mon, 03 May 2010 14:38:57 +0000 en hourly 1 http://wordpress.org/?v=3.0 STL: Simple Template Language Preview http://www.code.ge/posts/stl-simple-template-language-preview http://www.code.ge/posts/stl-simple-template-language-preview#comments Wed, 02 Dec 2009 08:41:15 +0000 იოსები http://www.code.ge/?p=428 დიდი ხნის პაუზის შემდეგ მინდა წარმოგიდგინოთ ერთი ახალი პროექტი რომელზეც გარკვეული პერიოდია ვმუშაობ. ჯერჯერობით ეს არის პრივიუ რელიზი რომელიც მალე საბოლოო ფაზაში შევა და სრულ დოკუმენტაციასა და მაგალითებს შესაბამისად წარმოგიდგენთ. მანამდე კი მისი ნახვა და გადმოწერა შეგიძლიათ შემდეგი მისამართიდან: STL Library.

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

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

რა არის საჭირო მისი გამოყენებისთვის? სულ მცირედი: 1) თქვენს პროექტში უნდა ჩატვირთოთ stl.lib.php რომლის გადაწერაც შეგიძლიათ ზემოთ მითითებული მისამართიდან; 2) შექმნათ შაბლონი ნებისმიერ ტექსტურ ფორმატში(html, txt, xml და ა.შ); 3) შექმნათ STL_template კლასის ობიექტი, გადასცეთ მას საჭირო ტექსტური შაბლონი და კონტესტური ცვლადები და შეასრულოთ. სულ ეს არის და ეს. როგორ? მაგალითი იხილეთ ქვემოთ:

HTML შაბლონი – test.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{if students}
  <h1>This is students list</h1>
  <ul>
  {for student in students}
    <li>
      <h2>{fn:ucfirst(strtolower(%student.name%))}</h2>
      <ul>
      {for friend in student.friends}
        <li>%friend.name%</li>
      {/for}
      </ul>
    </li>
  {/for}
  </ul>
{else}
  <h1>The students list is empty :(</h1>
{/if}

ნაჩვენები შაბლონის მეშვეობით ხდება სტუდენტებისა და შესაბამისად ცალკეული სტუდენტის მეგობრების სიის გამობეჭდვა. ქვემოთ ნაჩვენებია შაბლონის ინიციალიზაციის კოდი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//შაბლონის ობიექტის შექმნა
$tpl = new STL_template('test.html', true);

//შაბლონში მონაცემების დამატება
$tpl->put('students', array(
  array(
    'name' => 'John',
    'friends' => array(
      array(
        'name' => 'Ann'
      ),
      array(
        'name' => 'Suzan'
      ),
      array(
        'name' => 'Tom'
      )
    )
  ),
  array(
    'name' => 'Tom',
    'friends' => array(
      array(
        'name' => 'David'
      ),
      array(
        'name' => 'Mary'
      )
    )
  )
));

//შაბლონის პროცესინგი, შესრულება და გამობეჭდვა
echo $tpl->process();

ნაჩვენები კოდის შესრულების შედეგად მიიღებთ სურათზე ნაჩვენებ შედეგს:

Picture 28

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

if/elseif/else ოპერატორი
ეს არის ერთერთი ყველაზე ხშირად გამოყენებადი ოპერატორი და შესაბამისად მაქსიმუმი გავაკეთე იმისთვის რომ მისი გამოყენება მაქსიმალურად ეფექტურად იყოს შესაძლებელი. მაგალითში ნაჩვენები კოდის ფრაგმენტი “{if students}” უბრალოდ ამოწმებს არის თუ არა აღწერილი ცვლადი სახელით “students” და აქვს თუ არა მას მინიჭებული საწყისი მნიშვნელობა. თუმცა პირობა შესაძლებელია იყოს გაცილებით უფრო კომპლექსური. ქვემოთ ნაჩვენებია ამ ოპერატორის გამოყენების ნიმუშები:

1
2
3
4
5
6
7
{if students && someOtherVariable=="some test value" || testValue in someCollection}
Do something
{elseif !students && !someOtherVariable}
Do something else
{else}
UPS :D
{/if}

გარდა if/elseif/else ოპერატორისა ასევე შეგიძლიათ პოპულარული და უმნიშვნელოვანი foreach ოპერატორის გამოყენება, მაგ:

1
2
3
{for student in students}
%student.name%
{/for}

ნაჩვენებ მაგალითში მოხდება “students” კოლექციის იტერაცია ხოლო ყოველი მომდევნო ელემენტის ახალ “student” ცვლადზე მინიჭება. მოგვიანებით კი შეგიძლიათ ახალი “student” ობიექტისა და მისი თვისებების გამოყენება.

ცვლადების გამობეჭდვა ხდება სპეციალური ფორმატის მეშვეობით, კერძოდ კი ცვლადი უნდა განათავსოთ პროცენტის(%) სიმბოლოებში.

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

1
{fn:ucfirst(strtolower(%student.name%))}

ფრაგმენტიდან ჩანს რომ ხდება ორი ფუნქციის გამოძახება: 1) strtolower() PHP ფუნქცია რომელიც მნიშვნელობას გადაიყვანს ქვედა რეგისტრის სიმბოლოებში; 2) ucfirst PHP ფუნქცია რომელიც სტრიქონის პირველ სიმბოლოს გადაიყვანს ზედა რეგისტრის სიმბოლოში.

ასევე STL – ს აქვს მოდულების მხარდაჭერა თუმცა ამაზე ოდნავ მოგვიანებით შეგატყობინებთ პროექტის დარელიზების შემდეგ.

ამ მომენტისათვის სულ ეს არის, დოკუმენტაციასა და უფრო ვრცელ მაგალითებს შემოგთავაზებთ სულ მალე :)

]]> http://www.code.ge/posts/stl-simple-template-language-preview/feed 38 JavaScript: String.replace() http://www.code.ge/posts/javascript-string-replace http://www.code.ge/posts/javascript-string-replace#comments Wed, 16 Sep 2009 20:27:52 +0000 იოსები http://www.code.ge/?p=332 რამდენიმე წლის წინ დავწერე პოსტი 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-)

]]> http://www.code.ge/posts/javascript-string-replace/feed 8 JavaScript: Regex and Multi-line Mode http://www.code.ge/posts/javascript-regex-and-multi-line-mode http://www.code.ge/posts/javascript-regex-and-multi-line-mode#comments Tue, 21 Apr 2009 09:43:27 +0000 იოსები http://www.code.ge/?p=233 დღეს აღმოვაჩინე რომ 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
[\s\S]

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

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

1
/{code\s+lang="(\w+)"}([\s\S]*){\/code}/

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

]]> http://www.code.ge/posts/javascript-regex-and-multi-line-mode/feed 2 PHP: nl2p(aragraph) vs nl2br http://www.code.ge/posts/php-nl2paragraph-vs-nl2br http://www.code.ge/posts/php-nl2paragraph-vs-nl2br#comments Fri, 18 Jul 2008 15:51:49 +0000 იოსები http://www.code.ge/?p=131 როგორ იქცევით ისეთ შემთხვევაში, როდესაც საჭიროა HTML textarea ელემენტიდან მიღებული ტექსტის, HTML დოკუმენტში უცვლელად გამობეჭვდაა საჭირო ანუ ტექსტის ფორმატირების გათვალისწინებით?

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

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

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

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

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

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

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

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

1
2
3
function nl2p($input) {
    return preg_replace('~^\s*(.*?)\s*$~smx', '<p>$1</p>', $input);
}

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

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

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

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

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

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

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

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

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

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

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

]]> http://www.code.ge/posts/php-nl2paragraph-vs-nl2br/feed 6