Code.ge Blog » Design Patterns

Registry პატერნი, array_map და ტექსტში შაბლონით ძებნა

იოსები — Fri, 19 Oct 2007 14:35:54 +0000

ამ დღეებში ვატარებდი მცირე ექსპერიმენტებს ტექსტში შაბლონებით ძიებაზე, და მცირე სასარგებლო აღმოჩენები გავაკეთე. ჩემი ამოცანა მდგომარეობდა იმაში რომ ტექსტში მომეძებნა გარკვეული ფრაგმენტები და შემდეგ ჩამენაცვლებინა ისინი სხვა მნიშვნელობებით, ეს მნიშვნელობები კი სისტემის გლობალური ცვლადები იყო. ფრაგმენტებს ტრადიციული სახე მივეცი რადგან შაბლონებით ძიება მარტივი ყოფილიყო, ანუ რაღაც ამის მსგავსი {var:encoding}, ყველასათვის ცნობილი და მიღებული ფორმით…

როგორ გადავწყვიტე საბოლოოდ ეს ამოცანა? პირველ რიგში მინდა ავღნიშნო რომ არ მიყვარს ე.წ. გლობალური ცვლადების გამოყენება და ამის თავიდან ასარიდებლად ყოველთვის ვიყენებ Registry პატერნს, რომლის მეშვეობითაც იოლად ვირიდებ თავიდან გლობალურ ცვლადებთან მუშაობის არასასიამოვნო დეტალებს.

პატერნის რეალიზაცია PHP5 – ისთვის გამოიყურება შემდეგნაირად(დეტალური ახსნა თუ რანაირად მუშაობს ეს პატერნი იხილეთ ზემოთ მითითებულ ბმულზე):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Registry {

private static $stack = array();

public static function add($key, $value) {
self::$stack[$key] = $value;
}

public static function get($key) {
if (isset(self::$stack[$key])) {
return self::$stack[$key];
}
}

public static function has($key) {
return isset(self::$stack[$key]);
}

}

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

1
2
3
4
5
6
7
8
9

//მონაცემების დამატება
Registry::add('encoding', 'UTF-8');
Registry::add('url', 'http://www.code.ge');
Registry::add('test', 'testvar');

//მონაცემების წაკითხვა
Registry::get('encoding');
Registry::get('url');
Registry::get('test');

როგორც ხედავთ ყველაფერი ძალიან მარტივია, და რაც მთავარია არ ვიყენებთ საშინელ $GLOBALS მასივს…

რაც შეეხება თავად ტექსტს, და მასში ძიებას, პირველ რიგში განვიხილოთ მსგავსი ტექსტი:


     {var:encoding} 
     {var:url} 
     {var:test} 
     {var:fake_variable}

ეს არის ჩვეულებრივი HTML კოდი რომელშიც ჩასმული გვაქვს ე.წ. ცვლადები, შემდეგი სახით: {var:encoding}, {var:url} და ა.შ. ასეთი ტექსტისათვის რეგულარული გამოსახულების შაბლონის დაწერა ძალიან მარტივია /\{(?:var:)(\w+)}/, მისი მეშვეობით შეგვიძლია მოვძებნოთ ყველა საჭირო ფრაგმენტი ტექსტში:

1
2
3
4
5

if (preg_match_all('/\{(?:var:)(\w+)}/', $template, $vars)) {
echo '

';

    print_r($vars);

    echo '

';
}

კოდის შესრულების შედეგად ვღებულობთ მასივს, რომლის პირველი ელემენტი შეიცავს ყველა მოძებნილი ფრაგმენტის მასივს, ხოლო მეორე ელემენტი შეიცავს უშუალოდ ამ ფრაგმენტებიდან ამოღებულ ცვლადების სახელებს:

Array
(
    [0] => Array
        (
            [0] => {var:encoding}
            [1] => {var:url}
            [2] => {var:test}
            [3] => {var:fake_variable}
        )

    [1] => Array
        (
            [0] => encoding
            [1] => url
            [2] => test
            [3] => fake_variable
        )

)

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

1
2
3
4
5

if (preg_match_all('/\{(?:var:)(\w+)}/', $template, $vars)) {
$values = array_map(array('Registry', 'get'), $vars[1]);
$template = str_replace($vars[0], $values, $template);
}
echo $template;

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


     UTF-8 
     http://www.code.ge 
     Test Variable

როგორ მუშაობს ეს კოდი:

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

ამ ფუნქცის პირველი პარამეტრი არის ე.წ. callback ტიპის. თავისთავად callback PHP – ში წარმოადგენს რთულ ტიპს, ნებისმიერი ფუნქცია რომელიც ღებულობს ამ ტიპის პარამეტრს, შეგვიძლია გადავცეთ ნებისმიერი ფუნქციის სახელი, მაგ: array_map(‘trim’). მასივის მეშვეობით შეგვიძლია გადავცეთ კლასის სახელი და კლასის მეთოდი, მაგ: array_map(array(‘Registry’, ‘get’)) სადაც Registry არის კლასის სახელი, ხოლო get სტატიკური მეთოდის სახელი, და ასევე შეგვიძლია მასივის მეშვეობით გადავცეთ ნებისმიერი კლასის ობიექტი და მეთოდის სახელი, მაგ: array_map(array(new MyClass, ‘myMethod’)).

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

სწორედ ამ ფუნქციის მეშვეობით ვიღებთ Registry კლასიდან ჩვენთვის საჭირო მნიშვნელობებს (რამდენადაც get მეთოდს გადაეცემა $vars მასივის პირველი ელემენტის სათითაო ელემენტი იგი დაგვიბრუნებს შესაბამის მნიშვნელობას ამ key – სთვის, თუ ასეთი არსებობს) და ვანიჭებთ მის მიერ დაბრუნებულ მასივს $values ცვლადს.
str_replace ფუნქციის მეშვეობით ვახორციელებთ საჭირო ფრაგმენტების ჩანაცვლებას მოპოვებული მნიშვნელობებით. ამ ფუნქციას პირველ პარამეტრად გადავცემთ ჩასანაცვლებელი ფრაგმენტების მასივს ($vars[0] მასივი) და მეორე პარამეტრად გადავცმეთ საბოლოო მნიშვნელობებს (array_map – ის მეშვეობით მოვპოვებული $values მასივი), ხოლო მესამე პარამეტრად დაუმუშავებელ შაბლონს, შედეგად ვღებულობთ უკვე დამუშავებულ ტექსტს.

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

Registry პატერნი – php4

იოსები — Fri, 23 Feb 2007 22:18:53 +0000

Registry პატერნი გამოიყენება გლობალურ მონაცემებთან სამუშაოდ (გლობალური ცვლადები). ამ პატერნის მეშვეობით შესაძლებელია ორგანიზება გავუკეთოთ ნებისმიერ გლობალურ მონაცემს და შედმგომში ადვილად გამოვიყენოთ ეს მონაცემები. ნაცვლად იმისა რომ გლობალური მონაცემები შევინახოთ PHP-ს გლობალურ $GLOBAL მასივში (რომლის გამოყენებაც აპლიკაციის წერისას არცთუ სასიამოვნო პროცესია), ბევრად ეფექტური იქნება თუ ასეთ მონაცემებთან სამუშაოდ გვექნება რაიმე ჩამოყალიბებული და მოქნილი მექანიზმი. სწორედ ასეთ მექანიზმს წარმოადგენს Registry პატერნი.

PHP-ში გლობალურ მონაცემებთან ორი გზით არის შესაძლებელი:

global – საკვანძო სიტყვის გამოყენებით
$GLOBALS – PHP-ს უკვე არსებული მასივი რომელზეც წვდომა შესაძლებელია კოდის ნებისმიერ ადგილიდან

მაგალითში ნაჩვენებია ორივე მეთოდის გამოყენება:

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

$myVar = "sample text";

/*$myVar ცვლადი ამ შემთხვევაში ფუნქციის
ლოკალური ცვლადია და არაფერი საერთო არ გააჩნია
ფუნქციის გარეთ აღწერილ იგივე ცვლადთან
*/
function printMyVar() {
echo $myVar;
}

/*ამ ფუნქციაში $myVar ცვლადზე წვდომა ხორციელდება
global-ის გამოყენებით. ფუნქციის შიდა ცვლადი და მის
გარეთ აღწერილი ცვლადი ერთი და იგივეა
*/
function printMyVar() {
global $myVar;
echo $myVar;
}

/*ამ შემთხვევაში $myVar ცვლადს მივმართავთ $GLOBALS
მასივის მეშვეობით
*/
function printMyVar() {
$myVar = &$GLOBALS['myVar'];
echo $myVar;
}

/*პირდაპირ გამოიყენება $GLOBALS['myVar']*/
function printMyVar() {
echo $GLOBALS['myVar'];
}

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

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

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

/**
*@access public
*@package util
*/
class Registry {

/** @ignore */
var $stack;

/**
*Default private constructor
*@access private
*/
function Registry() {
$this->stack = array();
}

/**
*@access public
*@param string a string specifying object's key
*@param mixed an item to be stored during the request
*/
function add($key, &$item) {
$reg = &Registry::getInstance();
$reg->stack[$key] = &$item;
}

/**
*@param string a string specifying object's key
*@return mixed an object if it exists in the object stack or null
*/
function &get($key) {
$reg = &Registry::getInstance();
return $reg->stack[$key];
}

/**
*@param string a string specifying object's key
*@return boolean true if an object exists in the object stack or false
*/
function has($key) {
$reg = &Registry::getInstance();
return !is_null($reg->get($key));
}

/**
*@return Registry the Registry instance
*/
function &getInstance() {
static $registry = array();
if (!$registry) {
$registry[0] = &new Registry();
}
return $registry[0];
}

}

კოდი შედგება ოთხი მეთოდისგან ესენია:

add – მეთოდი მონაცემების მასივში ამატებს ახალ ობიექტს მითითებული სახელით
get – მეთოდი დააბრუნებს ობიექტს მითითებული სახელით, თუ მსგავსი ინახება ობიექტების მასივში
has – მეთოდი ამოწმებს არსებობს თუ არა ობიექტი მითითებული სახელით ობიექტების მასივში
getInstance – მეთოდი აბრუნებს უკვე არსებულ Registry კლასის ობიექტს (თუ იგი არ არსებობს წინასწარ ქმნის მასე, ასე რომ ამ მეთოდის პირველი გამოყენების თანავე Registry კლასის ობიექტი იქმნება ერთხელ და ინახება $registry სტატიკურ(static) ცვლადში რაც იძლევე იმის გარანტიას რომ ამ მეთოდის ხელმეორე გამოყენების შემთხვევაში $registry ცვლადი ხელმეორედ აღარ შეიქმნება)

Registry კლასის რეალიზაციაში ცხადად ჩანს რომ იგი რეალიზებულია Singleton პატერნის მეშვეობით.

ამ კლასის გამოყენების მაგალითები მოყვანილია ქვემოთ:

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
35

class Test {
var $testData;
function Test() {
$this->testData = "this is my test data";
}
}

$test = &new Test();
Registry::add('test', $test);

function useTest() {
$test = &Registry::get('test');
echo $test->testData;
}

class DatabaseConnection() {
var $connection;

function DatabaseConnection($host, $user, $pass) {
$this->connection = mysql_connect($host, $user, $pass);
}

function getConnection() {
return $this->connection;
}

}

$dbConn = &new DatabaseConnection();
Registry::add('db', $dbConn);

function useDbConnection() {
$db = Registry::get('db');
//$db->getConnection();
}

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

Singleton პატერნი – PHP4 და PHP5

იოსები — Fri, 23 Feb 2007 03:01:53 +0000

შესაძლებელია თუ არა ამ საჭირო პატერნის რეალიზაცია PHP4 – ში? მიუხედავად იმისა რომ უმრავი რამ არის ნათქვამი PHP-ს ამ ვერსიის არასრულფასოვან ობიექტზე ორიენტირებულ შესაძლებლობებზე – ეს შესაძლებელია თუმცა გარკვეულწილად ეს არის ხელოვნური და შედარებით რთული გზა ვიდრე PHP5-სა და Java-ში. (დეტალურად ამ პატერნის შესახებ შეგიძლიათ წაიკითხოთ ამ პოსტში).

რითია ეს სირთულე გამოწვეული ეს სირთულე PHP4 – ში? ამის რამდენიმე მიზეზია რომელსაც ჩამოვთვლილია ქვევით:

არ არსებობს წვდომის მოდიფიკატორები(public, protected, private) კლასის ცვლადებისა და მეთოდებისათვის.
არ არსებობს სტატიკური (static) კლასის ცვლადები.

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

განვიხილოთ მაგალითი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Singleton {

//private constructor
function Singleton() {}

function &getInstance() {

static $singleton = array();

if (!$singleton) {
$singleton[0] = &new Singleton();
}

return $singleton[0];

}

}

თუმცა PH5 – სთვის საქმე გაცილებით უკეთ არის და მისი რეალიზაცია თითქმის იდენტურია Java-ს რეალიზაციისა.

მაგალითი PHP5 – სთვის:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Singleton {

static private $instance = null;

//private constructor
private function __construct() { }

public static function getInstance() {
if (self::$instance == null) {
self::$instance = new Singleton();
}
return self::$instance;
}

}

მოცემულ კოდში განსხვავებით პირველი მაგალითისგან თვალში გხვდება რამოდენიმე ახალი საკვანძო სიტყვა:

static – გამოიყენება როგორც კლასის ცვლადის ასევე კლასის მეთოდთან.
public, private – წვდომის მოდიფიკატორები რომლებიც მანამდე არ არსებობდა PHP – ში.
_counstruct - PHP5 – ში კონსტრუქტორის სახელი (კლასის სახელი გამოყენება წინა ვერსიაში ავტომატურად გულისხმობდა რომე ეს ფუნქცია იყო კონსტრუქტორი)
self – ეს საკვანძო სიტყვა გულისხმობს მიმდინარე კლასს, მხოლოდ სტატიკურ კონტექსტში.

Singleton პატერნი – Java

იოსები — Fri, 23 Feb 2007 02:16:49 +0000

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

ამ პატერნის გამოყენებით შესაძლებელია კონკრეტული ტიპის(კლასის) ერთი და მხოლოდ ერთი ობიექტის (ეგზემპლარის) შექმნა რომელიც გამოყენებული იქნება გლობალურად გარკვეულ კონტექსტში. ზოგიერთ პროგრამირების ენაში (მაგ. C, PHP) არსებობს ე.წ. გლობალური ცვლადის ცნება, რომლის ინიციალიზაციაც ხდება ფუნქციებისა და კლასების კონტექსტ მიღმა და მისი გამოყენება შესაძლებელია ნებისმიერ ფუნქციასა თუ კლასში. მიუხედავად იმისა რომ Java არ არის აღჭურვილი მსგავსი შესაძლებლობით Singleton პატერნის მეშვეობით შესაძლებელია მივიღოთ იგივე(თუმცა უფრო დახვეწილი და მოქნილი) შედეგი რაც მიიღება გლობალური ცვლადებით სხვა ენებში.

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Singleton {

private static Singleton singleton = null; //private static variable to store reference to the singleton instance

private Singleton() {} //private constructor

public static Singleton getInstance() {

if (singleton == null) {
singleton = new Singleton();
}

return singleton; //return the reference

}

}

მთავარი დეტალი ამ პატერნის გამოყენებისას არის ის რომ კლიენტს(პროგრამის სხვა კოდი რომელიც იყენებს ამ კლასს) არ უნდა შეეძლოს ამ კლასის ობიექტის ცხადად შექმნა (new-ს გამოყენებით) რაც მიიღწევა ამ კლასის კონსტრუქტორის როგორც private წევრად აღწერით. ერთი შეხედვით შეიძლება უცნაურად(და სულელურად) გეჩვენოთ private კონსტრუქტორი კლასში, მაგრამ გარდა იმისა რომ ეს სავსებით დასაშვებია Java-ში ასევე არის ერთადერთი გზა რათა კლიენტს შევუზუდოთ ამ კლასის ობიექტების შექმნა.

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

ნაცვლად Singleton კლასის ობიექტის ცხადად შექმნის შესაძლებლობისა კლიენტს უნდა შევთავაზოთ მეთოდი(მეთოდები) რომლებიც იზრუნებენ ამ კლასის ობიექტის შექმნასა და მის დაბრუნებაზე. ზემოთ აღწერილ მაგალითში ასეთი მეთოდია getInstance() რომელიც არის public და ასევე static რაც გულისხმობს იმას რომ ამ მეთოდზე წვდომა შესაძლებელია მისი კლასის ობიექტის არსებობის გარეშე.

თავისთავად მეთოდი მარტივია და აკეთებს ორ ძირითად რამეს:

ამოწმებს არსებობს თუ არა Singleton კლასის ობიექტი, თუ არ არსებობს ქმნის მას.
აბრუნებს უკვე არსებულ ობიექტს.

ასევე აღსანიშნავია ლოკალური singleton ცვლადი რომელიც არის private და static რაც თავისთავად გულისხმობს რომ მასთან წვდომა გააჩნიათ მხოლოდ იგივე კლასის სხვა წევრებს და მისი ინიციალიზაციისათვის არ არის აუცილებელი კლასის ობიექტის შექმნა.