Uzun zmandır kullandığım ama birtürlü yayınlanabilir sürümünü yazamadığım ribbonu dün yazdım  (:   şuan için ribbon menünün her özelliğini taşımasa da başlangıc adına yeterli düzeye geldi . sınıf phpclassesta onaylanınca adresini buraya yazacağım. şimdilik bir görüntü ile kaynak kodları vereyimm.

Örnek Kullanım :

0
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
include 'd3ribbon.php';
 
/ Ribbon objesi create işlemi
    $ribbon=new d3ribbon();
 
    // stil klasorunun adı
    $ribbon->stlye='blue';
 
    // Ana Kategori
    $main_cat = $ribbon->add_category('D3 Ribbon Main Cat','index.php?component=main_component','main_component');
    // Ana Kategori Grupları
    $grp  = $ribbon->add_group($main_cat,'Group Name',250,'grpid');
    $grp2 = $ribbon->add_group($main_cat,'Group Name 2',250,'grp2');
    // Gruplar içine Butonlar
    $ribbon->add_button($grp,'Users','index.php?component='.$main_cat.'&module=users','image yok','users');
    $ribbon->add_button($grp,'Empooleys','index.php?component='.$main_cat.'&module=employees','image yok','employees');
 
    /**
    * Seçili Kategori ve Butonu işaretleyelim
    */
    $ribbon->selected_category_id = isset($_GET['component']) ? $_GET['component'] :'main_component' ;
    $ribbon->selected_button_id = isset($_GET['module']) ? $_GET['module'] : null;
 
  //ribbon menüyü ekrana basalım
 
$ribbon->build(false);

ribbon menünün tüm özelliklerini ve görselliğini kazandırabilmek için yardımcı olabilecek arkadaşlar olursa memnun olurum.
kaynak kodlar :
D3Ribbon PHP

      Merhaba arkadaşlar, nasıl ihtiyacım oldu ben de bilmiyorum ama bir css kalıtım sınıfı hazırladım. css doğru kullanıldığında zaten object oriented bir dildir. fakat bunu css kodlarken değil css i uygularken yapmak zorundaydık bu da her eleman için kalıtımı tekrar yazmamızı gerektiriyor. Bu da bizim alıştığımız object oriented yapısından farklı  hatta kimi programcı css’in object oriented olduğunu bile bilmez.  kalıtım sadece propertyler için  bu da sahip objenin stilinden gelir.  color:inherit;  gibi bir açıklamayla içerisinne konulan elemanın rengini alabiliyor.

Css de bir selector için yazdığınız stilden bir stil daha türettiniz mi hiç ?

Elbette bu css’te mümkün değil . ama linq’den beridir bişeyler parse ededudurken aklıma csste kalıtım geldi. ve bunun için de ufak bir sınıf yazdım. stilden stil türetme + cache mekanizması bizi hem fazla css kodlardan  kurtarıyor hem de karşıya sıkıştırılmış olarak göndermemizi sağlıyor. örnek bir inheritance örneği veremek istersek

0
1
2
3
4
.tablo
{
   font-size:12px;
   color:yellow;
}

şimdi bu sınıftaki propertyleri tekrar içermesini istediğimiz stili yazalım

0
1
2
3
4
5
6
7
8
9
10
11
.turetilmis-tablo
{
   based-on:'.tablo';  /* bu satırda .tablo stilinden türediğimiz belirttik */
   font-size:13px; /*  overriding (: */
   background-color:blue;  /*  diğer propertylere ek olarak bir de background-color ekledik*/
}
.turetilmis-diger-tablo
{
   based-on:'.turetilmis-tablo';  /* turetilmis-tablo stilinin tüm elemanlarını getirdik */
   background-color:red;  /*background-color değerini override edip polimorphizm sağladık(: */
   border:1px solid;  /*ek bir ozellik daha */
}

bu işlemlerden anladığımız gibi. ilk önce sarı yazı rengi olan bir stil yaptık ve burdan kalıtımın onemli hususlarını işledik. şimdi cıktımıza bakalım.

0
1
2
3
4
5
6
7
8
9
10
11
12
.turetilmis-tablo
{
   color:yellow;
   font-size:13px;
   background-color:blue;
}
.turetilmis-diger-tablo
{
   color:yellow;
   font-size:13px;
   background-color:red;
   border:1px solid;
}

kalıtım uygulanmış değil mi? (:

şimdi sınıfımızın kullanımıı gosterelim. dosyamızın adı inheritance.css olsun

0
1
2
3
4
5
6
<?php
    include 'D3Css.php';
    header("Content-Type: text/plain");
    $css = new D3Css('inheritance.css',true,'.');
    $css->compressed=false; 
    echo $css;
?>

bizim için iişlenecek inheitance.css ve sıkıştırılmadan ( compressed=fase ) saklanacak. artık yorumlama ile uğraşmayacağız.

sınıf henüz onaylanmamış. yayınlandığında buraya link vereceğim. şimdilik kodları veriyorum,

0
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
<?php
    /**
    * @name D3Css Css Inheritance and compressor.
    * @version 1.1
    * @author Tufan Baris YILDIRIM
    * @link http://www.tufyta.com/css-inheritance
    * ---------------------------------------------------
    * v1.1
    * -----
    *  -  cache mechanism added.
    *       - class can run without original file if output is cached.
    * v1.0
    * -----
    * This class can rewrite your css files and evulate inheritance.
    */
    class D3Css
    {
        /**
        * output will be one-line if compressed is true
        *
        * @var mixed
        */
        public  $compressed = true;
        /**
        * set cache folder for  write css output.
        *
        * @var mixed;
        */
        public  $cache_folder;
 
        /**
        * Cache file name
        *
        * @var mixed
        */
        public  $cache_file;
        /**
        * css file
        *
        * @var mixed
        */
        public $file;
        /**
        * Selector with properties.
        *
        * @var mixed
        */
        private $blocks = array();
        /**
        * Keep Selector Referances
        *
        * @var mixed
        */
        private $referances = array();
 
        /**
        * constructor method
        * Create an D3Css object by given file url or css string
        *
        * @param mixed $file_or_css_string
        * @param mixed $file
        * @return D3Css
        */
        public function __construct($file_or_css_string,$file=false,$cache_folder=null)
        {
 
            if ($file)
            {
                (is_file($file_or_css_string) || is_file($this->cache_file = $cache_folder.'/'.md5($file_or_css_string).'.css')) || trigger_error($file_or_css_string.' file not found.!');
                $this->file = $file_or_css_string;
            }
 
            if (isset($cache_folder))
            {
                if (!is_dir($cache_folder))
                    trigger_error($cache_folder.' is not a dir. ',E_USER_ERROR);
                else
                    $this->cache_folder = $cache_folder;
            }
            else
            {
                // get file conent if file is true else parse given string directly
                $this->parse_blocks($file ? file_get_contents($file_or_css_string) : $file_or_css_string);
            }
        }
 
        /**
        * @name Css Cleaner
        * @since 1.0
        * Remove
        *   - Multiline Comments
        *   - Single line comments
        *   - redudent characters,spaces and newlines.
        * @param mixed $css
        * @return mixed
        */
        private function clean_css($css)
        {
            // remove comments
            $css = preg_replace('/(\/\*.*?\*\/|\n|\t|\/\/.*?\n)/sim','', $css);
 
            // remove redudent characters and newlines.
            $css = preg_replace('/\s?(,|{|:){1}\s?/sim','\\1', $css);
 
            return $css;
        }
 
        /**
        * @name Main Parser Method
        * @since 1.0
        * Parce blocks , generate $blocks and $referances array.
        * @param mixed $string
        */
        private function parse_blocks($string)
        {
            preg_match_all('/(?<selectors>[^\{\}]+)\{(?<declerations>[^\{\}]+)\}/im',$this->clean_css($string),$matches);
 
            // delete unnecessary elements
            $matches = array('selectors' => $matches['selectors'],'declerations' => $matches['declerations']);
 
            // delete css string
            unset($string);
 
            $blocks = array();
 
            foreach( $matches['selectors'] as $index => $selector )
            {
                // $blocks[$selector=trim($selector)] =  $matches['declerations'][$index];
                preg_match_all('/(?<properties>[^:]+)(\s*):(?<values>[^;]+);?/im',$matches['declerations'][$index],$submatches);
 
                $blocks[$selector=trim($selector)] = array_combine(
                $properties = array_values(array_map('trim',$submatches['properties'])),
                array_values(array_map('trim',$submatches['values']))
                );
 
                // Referances avaliabilty.
                if(in_array('based-on',$properties))
                {
                    if(!in_array($base_class_name = str_replace("'",'',$blocks[$selector]['based-on']),$avaliable_classes = array_keys($blocks))
                    && !in_array($base_class_name,$avaliable_referances = array_keys($referances))) // checking referances for full inheritance yeah.
 
                        trigger_error('classes can not be declared before their base classes (may be Circular Referance)',E_USER_ERROR);
 
                    elseif (is_array($base_class=$blocks[$base_class_name]) || is_array($base_class = $referances[$base_class_name]))
                    {
                        // evulating inheritance  and overriting
                        $blocks[$selector] = array_merge($base_class,$blocks[$selector]);
                    }
 
                    // delete based-on property from class
                    unset($blocks[$selector]['based-on']);
                }
 
                // Delete submatches after use.
                unset($submatches);
 
                // Extract Referances. ex:  [&amp;body] and [&amp;td] will be referanced to  [body,td]
                if(count($selectors=explode(',',$selector))>1)
                {
                    foreach ( $selectors as $subselector )
                    {
                        $referances[trim($subselector)] = &$blocks[$selector];
                    }
                }
 
                // unset element after parse
                unset( $matches['selectors'][$index] ,$matches['declerations'][$index]);
            }
 
            $this->blocks=$blocks;
            $this->referances=$referances;
        }
 
        /**
        * @name Property Imploder.
        * @since 1.0
        * @param mixed $value
        * @param mixed $property
        */
        private function implode_properties(&$value,$property)
        {
            // Implote properties add tab if compressed false.
            $value = ($this->compressed ? '':"\t") . $property . ':' . $value . ';';
        }
 
        /**
        * Block Imploder
        * @since 1.0
        * @param mixed $properties
        * @param mixed $block_name
        */
        private function implode_blocks(&$properties,$block_name)
        {
            $concanated = "";
 
            if(is_array($properties))
            {
                // Implode all properties as  property_name : value;
                array_walk($properties,array(&$this,'implode_properties'));
                // Implode blocks after their properties imploded
                $concanated = implode(!$this->compressed ? "\r\n" : '',$properties);
            }
 
            // add newlines if compressed false.
            if ($this->compressed)
                $properties = $block_name . '{' . $concanated . '}';
            else
                $properties = $block_name . " {\r\n" . $concanated . "\r\n}\r\n";
        }
 
        /**
        * @name Output writer
        * @since 1.0
        * Write or return output css code blocks
        * @param mixed $return
        * @return string
        */
        public function output($return=false)
        {
            if (!isset($this->cache_folder))
            {
                $blocks = $this->blocks;
                if (array_walk($blocks,array(&$this,'implode_blocks')))
                {
                    $output = implode($this->compressed ? ' ':"\r\n",$blocks);
                }
                else
                {
                    trigger_error('output failed.!',E_USER_ERROR);
                }
                unset($blocks);
            }
            else
            {
                if(is_file($this->cache_file))
                {
                    $output = file_get_contents($this->cache_file);
                }
                elseif(is_file($this->file))
                {
                    $this->__construct($this->file,true);
 
                    $cf = $this->cache_folder;
                    $this->cache_folder=null;
                    file_put_contents($this->cache_file,$output = $this->output(true));
                    $this->cache_folder = $cf;
 
                }
                else
                {
                    trigger_error('Cache cannot be created.',E_USER_ERROR);
                }
            }
 
            if ($return)
                return $output;
            else
                echo $output;
        }
 
        /**
        * @name String Caster.
        * @since 1.0
        */
        public function __toString()
        {
            return $this->output(true);
        }
 
        /**
        * @name Destructor
        * @since 1.0
        * Unset used vars
        */
        public function __descructor()
        {
            unset($this->blocks,$this->referances);
        }
 
    }
?>

Reflection Nedir ?

Reflection (Yansıma) kısaca açıklanabilecek bir konu olmasa da olabildiğinde örneksel anlatmaya çalışacağım. Reflection bize çalışma anında hiç bilmediğimiz bir yerden gelebilecek bir objeyi ,bir sınıfı veya sınıf elemanını inceleyip hakkında bilgi sahibi olabilme olanağı tanıyor.

Nerde İhtiyaç Duyarız ?

Reflection bize Plugin tabanlı bir sistem hazırlama konusunda çok faydalı olabilir. Modül ve ya Plugin sistemlerinde kullanıcılardan istediğimiz sabit şeyler olabilir.

  • Modülün adı ne ?
  • Nerde çalışmalı ?
  • Hangi şartlarda çalışmalı ?

Bu bilgileri bize modülün kendisi verilmeli değil mi ? verdiği taktirde biz de bunu formatımıza uygun olarak modülün istediği gibi işleyebiliriz. Elimizde modülün kendisine özel sınıflarından birinden türetilmiş bir nesne olduğunu düşünelim. Bu elemanın “name” adında bir propertysi var mı ? “calistir()” adinda bir metodu var mı? Hataları yapımcıya gösterebilmek ve ya Modülü çalıştırabilmek için bunlara ihtiyacımız var . Reflection olayını kısaca kafamızda oluşturmuş olduk.

PHP, 5 ten sonra Reflection adına pek çok yenilik yaptı ve 5.3 ile Reflection gerçek adını aldı (Namespace ile beraber ihtiyaç duyuldu diye tahmin ediyorum.)

PHP’de (script dillerinin genelinde) Reflection olayı özel bir çaba (ekstra sınıflar) gerektirmeden yapılabiliyor. Bunu en iyi yapan script dili tahminimce PHP . Fakat bu olayı adlandırmak ve bir sınıfa toplamak güzel olmuş. İlk önce PHP ‘nin bize Reflector sınıflardan önce Reflection adına sunduğu ve daha önce Lambda konusunda kısaca değindim fonksiyonları incelemek istiyorum.

get_included_files();
get_defined_constants();
get_defined_functions();
get_defined_vars();
get_declared_classes();
get_declared_interfaces();
gettype();
get_called_class();
get_class_methods();
get_class_vars();
get_parent_class();
get_object_vars();
get_extension_funcs();
get_loaded_extensions();

Reflection sınıfı olmadan da bu metotlarla Reflector sınıfımızı yazıp tek tek ReflectionObject ten tutun Reflection sınıfına kadar yazabiliriz.

PHP Reflection sınıfına neden ihtiyaç duydu ?

Bu soruyu kendimize sormamız doğal. Hem bunların hepsini yapabildiğimizi söyledik hem de PHP nin 5.3 ten sonra Reflection olayına isim verdiğini söyledik. Bu işi kendi başımıza halledebiliyorsak neden bize reflection sınıfı yazıldı ? Bunun cevabını yine 5.3 ile beraber gelen özelliklerde aramalıydık ki bu analiz sonucunda çıkarabileceğimiz tek sonuç Namespaces

Namespaceler ile çalışınca sınıflarımıza reflekte olaylarında belki metot belki property hatta bu modifier incelemesi bile yapabiliriz ancak namespace incelemesi yapamayacağımızı verdiğim fonksiyonların isimlerinden bile anlayabiliriz.

Reflection Classes.

The Reflector interface

0
1
2
3
4
Reflector {                abstract public static string export ( void )
 
                abstract public string __toString ( void )
 
}

Tüm export edilebilir Reflection sınıfları bu arayüze sahip olmalıdır. Olmasa dahi sınıflarımız için reflekte işlemleri yapabilirz (Bir daha bu cümleyi kurmamaya özen göstereceğim fakat unutmayın ki Reflection olayını zaten yapabiliyorduk ). Fakat bu arayüz sayesinde diğer reflection sınıfları içinde kullanabileceğimiz objeler oluşturabilir hatasız işlem yapabiliriz.

Reflection sınıflarının 2 temel metodu da parametre almıyor __toString sihirbazını tanıtma fırsatım olmasa da bunları OOP magics sayfasından öğrenebilirsiniz. Export aslında __toString işlevi görüyor diyebiliriz. Fakat biz __toString metodunu sınıfın kendisini explain etmek için kullanırdık Reflecion sınıflarında da exportu Reflekte edilmesi istenen sınıfı explain etmek için kullanacağız.

Kısaca __toString() Sihirbazı

Örnek üzerinden acıklamak istiyorum öncelikle bir sınıfımız olsun.

0
1
2
3
4
class Yazilimci{
 
            public  $name,$surname;
 
 } 

Örnek bir de kullanım yapalım

0
1
2
    $tufan=new Yazilimci();    $tufan->name="Tufan Barış";
 
    $tufan->surname="YILDIRIM";<strong> 

bunu biz “Tufan Barış YILDIRIM” şeklinde yazdırmak istediğimizde

0
   Echo     $tufan->name.” ”. $tufan->surname;<strong> 

Bu kullanım bize ad soyadı verir. Ancak. Buna bir metot hazırlamak istediğimizi varsayaraksak

0
1
2
3
4
5
6
7
8
9
10
class Yazilimci{
 
            public  $name,$surname;
 
            public function  isimYaz()
           {
 
                  return     $tufan->name.” ”. $tufan->surname;
           }
 
    } 

Şimdiki kullanımı ve bu metodun bize sağladığı yararı inceleyelim

0
  Echo  $tufan->isimYaz();

Evet metot bize isimyaz dediğmizde cok güzel bir şekilde ad ve soyadı yazdırıyor .

Peki objeye string gibi davranıp ekrana yazmaya kalkarsak ne olur ?

0
  Echo   $tufan;

Catchable fatal error: Object of class Yazilimci could not be converted to string

Yazilimci türündeki bir obje string e dönüştürülemedi. $tufan değişkeni bizim için bu sınıfın verilerini tutan bloğun işaretçisini (Pointer) tutuyor değil mi ? O zaman bunu ekrana basabilmek için bu bloğun bir string olması gerekiyor ama değil. Şimdi __toString() sihirbazının yaptığı işi görmek için sınıfı tekrar yazalım.

0
1
2
3
4
5
6
7
8
9
10
class Yazilimci{
 
            public  $name,$surname;
 
            public  function  __toString()
           {
 
                  return      $tufan->name.” ”. $tufan->surname;
           }
 
    } 

Şimdi, hata aldığımız kullanımı tekrar denediğimizde ekrana cıkan sonuç “Tufan Barış YILDIRIM” obje stringe dönüştürülmek istendiğinde tetiklenen metodumuz. String dönüştürme ya da string gibi kullanmaya kalkmaya birkaç örnek verelim.

0
1
2
3
4
5
6
Echo  $tufan;<strong>Print  $tufan;
 
Echo  “Yazanın adı :. $tufan;
 
$tamadi=(string)$tufan;
 
 

Bunlara bir örnek daha ekleyebiliriz. String parametre isteyen bir fonksiyona direk bu objeyi vermek gibi. Fakat fonksiyon içerisine girene kadar bu obje olarak kalacaktır. İçerikdei kullanım yine bunlardan biri olacağı için örnek verme gereği duymadım , değinmeden de geçmek istemedim.

The ReflectionProperty class

0
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
 Class ReflectionProperty implements Reflector{
 
/* Constants */
 
const integer ReflectionProperty::IS_STATIC = 1 ;
 
const integer ReflectionProperty::IS_PUBLIC = 256 ;
 
const integer ReflectionProperty::IS_PROTECTED = 512 ;
 
const integer ReflectionProperty::IS_PRIVATE = 1024 ;
 
/* Properties */
 
public $name ;
 
public $class ;
 
/* Methods */
 
final private void __clone ( void )
 
__construct ( mixed $class , string $name )
 
public static string export ( mixed $class , string $name [, bool $return ] )
 
public ReflectionClass getDeclaringClass ( void )
 
public string getDocComment ( void )
 
public int getModifiers ( void )
 
public string getName ( void )
 
public mixed getValue ([ string $object ] )
 
public bool isDefault ( void )
 
public bool isPrivate ( void )
 
public bool isProtected ( void )
 
public bool isPublic ( void )
 
public bool isStatic ( void )
 
public void setAccessible ( bool $accessible )
 
public void setValue ( object $object , mixed $value )
 
public string __toString ( void )
 
} 

ReflectionProperty sınıfı Reflection işlemlerinde elde ettiğimiz her property nin türüdür. Elemanlarını bir bir incelersek ;

Öncelikle üzerinde örneklendirme yapacağımız sınıfımızı tekrar yazalım

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Yazilimci implements Reflector     {
 
         public $name, $surname;
 
         private $girlFriend;
 
         public function __toString()
 
         {
 
             return $this->name." ".$this->surname;
 
         }
 
         public static function export($class,$name,$return=false)
 
         {
 
                return 'Requested Property Name is <b>'.$name.'</b> and Value is <b>'.$class->$name.'</b>';
 
         }
 
     }

$name – Property nin adı . örneğin Yazilimci türünden bir öğemiz olsaydı $surname propertysi için alacağımız değer “ surname “ olacaktı.

$class- Property iyesi sınıfın adına denktir.Yine elimizdeki sınıf için incelersek bunun karşılığı “Yazilimci” olacaktı.

Metotlar

0
public static string export ( mixed $class , string $name [, bool $return ] ) 

Abstract interface (override edilmesi zorunlu) metodlardan biri olan bu metod bize reflector bir sınıf yazrken cıktıyı verebilecek metoddur. Private propertylere ulaşmamızı da sağlamış olacak ve reflection adına bize kolaylık sağlamış olacaktır.

Ilk parametresi export etmek istediğimiz sınıf türünden bir obje name parametresi üzerinde işlem yapmak istediğimiz propertynin adı ve son return parametresi de cıktının geri döneceğini ya da ekrana direk basılacağını belirler.

0
public string __toString ( void )

__toString() elemanını zorunlu kılması belki de Reflection sınıfıın içerde kendisi için yaptığı bir kolaylıktır bilemiyorum. Lakin “Reflection::export” metodunun kullandığı da budur. Bize sadece Export metodunu sadece __toString() gorevi yapmak zorunda olmama ve __toString() i de yine amacı dışında kullanabilme şansı tanımışlar.

Açıklamasını yaptığımız kullanımlara sınıfımız üzerinde bir örnek göstermeden önce ReflectionCLass i tanıyalım:

The ReflectionClass class

ReflectionClass Sınıf reflekte edebileceğimiz yine Reflector kökenli bir sınıf. Propertyleri

0
1
2
3
4
5
6
7
8
9
10
     $reflectMember=new Yazilimci();     $reflectMember->name="Tufan Barış";
 
     $reflectMember->surname="YILDIRIM";
 
     echo '<pre>';
 
     echo Reflection::export($reflectMember);
 
     echo Yazilimci::export($reflectMember,'name');
 
     echo  new ReflectionClass($reflectMember);<strong> 

İlk echo bloğumuzda export() ‘un __toString() i çalıştırdığını tekrar görüyoruz ekrana Tufan Barış YILDIRIM yazıyor. İkincisinde Yazilimci için özelleştirilen export metodundaki kod bloğunu çalıştıracaktır doğal olarak ve bizim sınıf, yazdığımız “Requested Property Name is… ” ile başlayan cümleyi verecektir. Son Blokta ise ReflectionClass oluşturup __toString() metodunun tetiklenmesini sağladık işte genel cıktı

Tufan Barış YILDIRIMRequested Property Name is <b>girlFriend</b> and Value is <b></b>Class [ <user> class Yazilimci implements Reflector ] {

@@ C:\AppServ\www\test\enc.php 2-17

– Constants [0] {

}

– Static properties [0] {

}

– Static methods [1] {

Method [ <user, prototype Reflector> static public method export ] {

@@ C:\AppServ\www\test\enc.php 12 – 16

– Parameters [3] {

Parameter #0 [ <required> $class ]

Parameter #1 [ <required> $name ]

Parameter #2 [ <optional> $return = false ]

}

}

}

– Properties [3] {

Property [ <default> public $name ]

Property [ <default> public $surname ]

Property [ <default> private $girlFriend ]

}

– Methods [1] {

Method [ <user, prototype Reflector> public method __toString ] {

@@ C:\AppServ\www\test\enc.php 7 – 10

}

}

}

Bu cıktı incelenerek oluşan obje hakkında bilgi edinilebilir. Objenin türetildiği sınıfın tanımlandığı dosyanın satır ve sütun numarası dahi var. Metot ve property listesi de modifierlarıyla beraber listeleniyor. Reflection sınıfını bu şekilde ekrana basmak için kullanmayacağız tabi ki. Programda veri niteliği taşıyabilmesi için New ReflectionClass ı bir değişkene atayıp istediğimiz gibi kullanacağız.

Not :

Reflection Sınıfları sadece derleme sırasında (Compile Time) oluşan reflekte bilgisini dikkate alır. Çalışma zamanında (Runtime) oluşan property ve ya metotlar için Reflekte işlemi yapılamaz.

Notunumuzu bir örnekle açıklayacak olursak

0
1
2
3
4
5
6
7
8
9
10
11
12
Class  Reflekte{
 
                public function Reflekte()
 
                {
 
                      $this->yeniProperty=”Yeni değer”
 
                }
 
}
 
 

Böyle bir sınıfımız olduğunu varsayarsak.” yeniProperty “ adındaki propertymiz Constructor içinde oluşmuş olacak ve değer ataması yapılacak . Fakat reflekte işlemine geldiğimizde

0
1
2
3
4
  $reflekte=new Reflekte();
 
 $Reflection=new ReflectionProperty($reflekte,’yeniProperty’); // Hata Fırlatır.
 
 

Reflection Sınıfları

Reflector sınıflarının temeki aynı olduğu için Sadece ReflectionProperty ve ReflectionClass üzerinde durduk. Diğer sınıflarımızda temel aynı sadece kullanım alanı farklı.

Reflector (Interface) – Sınıflarımız reflekte edilebilmesi için bu arayüze sahip olmalıdır.
ReflectionClass – Class Reflekte etmek için tasarlanmış Reflector.
ReflectionExtension – Extension reflekte etkmek için tasarlanmış Reflector.
ReflectionFunction – Fonksiyon reflekte etmek için tasarlanmış Reflector.
ReflectionFunctionAbstract- ReflectionFunction için yazılmış base Reflector.
ReflectionMethod –Metot reflekte etmek için tasarlanmış Reflector.
ReflectionObject – Object Reflekte etmek için tasarlanmış Reflector.
ReflectionParameter –ReflectionFunction içinden ayrıştırılmış Parametreleri reflekte etmek için tasarlanmış Reflector.
ReflectionProperty – ReflectionClass içinden ayrıştırılmış Propertyleri reflekte etmek için tasarlanmıştır aynı zamanda kendi başına da oluşturulup 1 property üzerinde çalışılabilir.

Yazının PDF Versiyonunu Buradan indirebilirsiniz.

PHP – Reflection.pdf

globu test ederken burdan pek bir fark cıkmayacağını tahmin etmiştim.   test ortamım tabi ki değişmedi

PHP  Versiyonu  : 5.3.2
Apache Versiyonu : 2.2
İşlemci : AMD Turion 64 X2 2.20 GHZ
Ram    : 4 GB

test ettiğim dizinin eleman sayısı : 150.000  az da olsa fark görülebilsin diye büyük dizii oluşturmaya çalıştım – ki bu kadar büyük bir dizi ile işimiz olmayacaktır muhtemelen.

dizimizi oluşturalım

0
1
2
3
4
 $myArray=array();
    for($i=0;$i<150000;$i++)
    {
        $myArray[]=uniqid(md5(microtime()));
    }

kullanım şekillerimiz:

0
1
2
3
for($i=0;$i<count($myArray);$i++)
    {
        $a="some actions";
    }

0.143 saniye sürdü

count u forun karar blogundan cıkaralım

0
1
2
3
4
$cnt= count($myArray);
    for($i=0;$i<$cnt;$i++)
    {
        $a="some actions";
    }

0.054 saniye sürdü

gördüğünüz gibi 150 binde yarım saniye fark var. kasıntıya gerek yok daha gerekli yerlerde optimizasyonla uğraşarak sciriptlerimize daha faydalı olabilriz (: ama siz yine de elinizi alıştırmayın

iyi çalışmalar.

© 2012 Tufan Suffusion theme by Sayontan Sinha