Google+

Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Clasă pentru crearea unor funcții dinamice
#1
Prin intermediul clasei de mai jos, intitulată MakeFunctions puteți crea și apela funcții dinamice, cu posibilitatea preluării datelor din baze de date.
Codul sursă al clasei îl găsiți mai jos :

PHP Code:
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
/*
 * @author : Surdeanu Mihai
 * @date : 12.09.2011
 * @copyright : All rights reserved.
 */
class MakeFunctions 
{  
    // variabilele clasei  
    private $prefix;
    private $funcs_list = array();
    private $funcs_make = array();
    // constructorul clasei
    function __construct($prefix = "rolang_funcs") 
    {  
        // este setat prefixul de lucru
        $this->prefix = $prefix;
    }
    // metoda clasei ce adauga un vector de functii cu numele format din $prefix + cheia unei valori din vector
    public function add($functions = array()) 
    {
        foreach ($functions as $key => $value) {
            // se adauga functia in lista
            $this->funcs_list[$key] = $value;
        }
    }
    // metoda clasei ce sterge un vector de functii din lista
    public function remove($functions = array()) 
    {
        foreach ($functions as $function) {
            // o functie este stearsa doar daca ea exista in lista noastra
            if (array_key_exists($this->prefix."_".$function, $this->funcs_list)) {
                unset($this->funcs_list[$this->prefix."_".$function]);
            }
        }
    }
    // metoda clasei ce creaza toate functiile din lista
    public function make($these = false)
    {
        if (!$these) {
            foreach ($this->funcs_list as $key => $value) {
                $args = isset($value['args']) ? $value['args'] : "";
                $code = isset($value['code']) ? $value['code'] : "";
                // se creaza functia
                $this->funcs_make[$this->prefix."_".$key] = create_function($args, $code);
            }
        }
        else {
            if (is_array($these)) {
                // doar functiile specificate in vector vor fi create
                foreach ($these as $key => $value) {
                    $args = isset($value['args']) ? $value['args'] : "";
                    $code = isset($value['code']) ? $value['code'] : "";
                    // se creaza functia
                    $this->funcs_make[$this->prefix."_".$key] = create_function($args, $code);
                }                
            }
        }
    }
    // apelarea unei functii cu parametri dati
    public function call($function, $args = array())
    {
        $function = $this->prefix."_".$function;
        // functia este rulata doar in cazul in care exista
        if(function_exists($this->funcs_make[$function])) {
            return call_user_func_array($this->funcs_make[$function], $args); 
        }
        else {
            // daca nu exista se returneaza fals
            return false;
        }
    }
    // intoarce lista cu functiile create sau cu cele in curs de creare
    public function get($maked = true, $only = false)
    {
        $var = ($maked) ? "funcs_make" : "funcs_list";
        if (!$only) {
            // atunci se intoarce o lista ca toate functiile create
            return array_keys($this->{$var});
        }
        else {
            // este vector?
            if (is_array($only)) {
                $only = array_map(array($this, 'concat'), $only);
                // se returneaza doar functiile specificate de utilizator
                return array_intersect(array_keys($this->{$var}), array_values($only));
            }
            else {
                // daca nu este vector atunci se returneaza fals
                return false;
            }
        } 
    }    
    // functie de concatenare a doua string-uri 
    private function concat($string) {
        return $this->prefix."_".$string;
    }
}  

Constructor :
- El vă permite setarea unui prefix pentru fiecare funcție din lista definită cu ajutorul metodelor de mai jos.
Metode :
- add : adaugă un vector de funcții în lista de prelucrare. Forma vectorului trebuie să fie asemănătoare cu cea din exemplul de mia jos. De asemenea dacă nu definiți o valoare pentru cheia "args" înseamnă că funcția nou-creată nu va dispune de parametri, iar în cazul în care nu definiți o valoare pentru cheia "code" înseamnă că funcția nu va face nimic.
- remove : șterge o serie de funcții adăugate prin intermediul metodei "add". Vectorul trimis ca și parametru va cuprinde numele funcțiilor pe care doriți să le scoateți din listă.
- make : aceasta vă permite crearea propriu-zisă a funcțiilor adăugate în listă. De asemenea puteți folosi parametrul $these ca și parametru opțional în vederea creării doar a unor funcții din listă, a căror nume se regăsește în acest vector.
- call : metoda vă dă posiblitatea de a apela o funcție creată de această clasă. Metoda are un parametru obligatoriu și anume numele funcției care se dorește a fi apelată și unul opțional, un vector cu argumentele acesteia. Acest ultim parametru este opțional, pentru că se poate ca funcția apelată să nu necesite primirea unor parametri și atunci nu aveți de ce să definiți un astfel de vector.
- get : vă permite să vedeți lista cu funcțiile din listă create și aflate în curs de creare. Primul parametru vă întreabă dacă doriți să listați funcțiile aflate în curs de creare sau create deja. Cel de-al doilea parametru al metodei este opțional și cu ajutorul său puteți selecta afișa doar a unor funcții dacă acestea există în listă.
Exemplu :

PHP Code:
1
2
3
4
5
6
7
8
9
10
11
12
$make = new MakeFunctions();
// se adauga doua functii in lista cu numele "functia1" si "functia2"
// - prima functie afiseaza textul primit ca si parametru, iar a doua afiseaza un numar aleator intre 1 si 5.
$make->add(array(
                "functia1" => array("args" => "\$v", "code" => "echo \$v;"),
                "functia2" => array("code" => "echo rand(1,5);")
           ));
// se creaza functiile
$make->make();
// se afiseaza functiile create
print_r($make->get(), false);
$make->call("functia1", array("Doar un test"));

Rezultatul rulării exemplului de mai sus :

PHP Code:
Array ( [0] => rolang_funcs_functia1 [1] => rolang_funcs_functia2 ) Doar un test

Users : collective term for those who use computers. Users are divided into three types : novice, intermediate and expert.
Novice users : people who are afraid that simply pressing a key might break their computer.
Intermediate users : people who don`t know how to fix their computer after they`ve just pressed a key that broke it.
Expert users : people who break other people`s computers.
Reply


Forum Jump:


Users browsing this thread: 1 Guest(s)