Special Arguments

Special Arguments

Special Arguments
Special Arguments

Chciałem wam przedstawić dość ciekawą klasę, z mojego punktu widzenia, która może rozwiązać problem przekazywania argumentów poprzez konstruktor. Jeżeli nie wiemy ile parametrów będziemy przekazywać do konstruktora możemy to zrobić w ten sposób. Nie musimy ingerować w samą klasę za każdym razem kiedy dopisujemy kolejny parametr. Załóżmy że mamy samochód w którym nie wiemy ile osób będzie podróżować, a chcemy przekazać do konstruktora, za każdym razem inną ilość osób.

Masz problem z argumentami w konstruktorze

Special Arguments jest właśnie do ciebie.

Zobacz na przykładzie wywołania zwykłego przekazywania argumentów do konstruktora o zmiennej ilości wejścia o zasadności jego stosowania.

Prostota w swoim wykonaniu a jaka świetna

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class special_arguments
{
  public $person = array();
    public function __construct()
    {
      if($arg = func_num_args()>0)
      {
         $this->person = func_get_args();
      }
    }
    public function car()
    {
        return $this->person;
    }
 }

a tutaj samo wywołanie, nie musimy zmieniać za każdym razem konstruktora w samej klasie tylko przypisujemy tyle argumentów ile chcemy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$adam = "1 person";
 $ginter = "2 person";
 $bodzio = "3 person";
 $endriu = "4 person";
 $bandzo = "5 person";
 
 $test = new special_arguments($adam, $ginter, $bodzio, $endriu, $bandzo);
// &
 $test1 = new special_arguments($adam, $bandzo);
 
 $a = $test->car();
 foreach($a as $person)
 {
  echo $person."--";
 }

 $a = $test1->car();
 foreach($a as $person)
 {
  echo $person."--";
 }

niezłe co? 🙂

A teraz bardziej skomplikowane trochę namieszam z klasami abstrakcji, a funkcje będą statyczne, to nam ułatwi przekazywanie ich jako argumentów do samego konstruktora Special Arguments co wy na to?

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
abstract class person1
{
 public static function person11()
 {
   return "person 1";
 }
}
 
 abstract class person2
 {
  public static function person22()
  {
   return "person 2";
  }
}
 
abstract class person3
{
 public static function person33()
 {
  return "person 3";
 }
}
 
abstract class person4
{
 public static function person44(){
 return "person 4";
 }
}
 
 abstract class person5
 {
 public static function person55()
 {
 return "person 5";
 }
}
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
class special_arguments
{
 
 public $person = array();
 
 public function __construct()
 {
  if($arg = func_num_args()>0)
  {
   $this->person = func_get_args();
  }
 }
 
 public function person1()
 {
  return $this->person["a"];
 }
 
 public function person2()
 {
  return $this->person["b"];
 }
 
 public function person3()
 {
  return $this->person["c"];
 }
 
 public function person4()
 {
   return $this->person["d"];
 }
 
 public function person5()
 {
  return $this->person["e"];
 }
}

Tutaj następuje wywołanie takich klas, to jest to co wcześniej pisałem przekazujemy je jako statyczne, zobaczcie jak prosta klasa powoduje ogromne możliwości jakie otrzymujemy w zamian.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// ## Special Arguments ##
 
 // ## Możemy dowolnie zmieniać na te klasy które chcemy ##
 
$test = new special_arguments(array("a"=>person1::person11(),
"b"=>person2::person22(), "c"=>person3::person33(),
 "d"=>person4::person44(), "e"=>person5::person55()));
 
// ## albo ##
 
$test = new special_arguments(array( "b"=>person2::person22(),
 "d"=>person4::person44(), "e"=>person5::person55()));
 
// ## albo ##
 
 $test = new special_arguments(array("a"=>person1::person11(),
 "e"=>person5::person55()));
 
 foreach($test->person[0] as $person)
 {
  echo $person."--";
 }

No a teraz zademonstruję kosmos klasa Special Arguments jest tak elastyczna, że podajemy jeden argument do konstruktor Specjal Arguments z danej klasy i za pomocą magii 🙂 możemy odczytać wszystkie metody z klasy sprawdzanej, to jest niesamowite jakie to daje możliwości programiście do manewru w każdym kierunku, a co najważniejsze trafia dokładnie do tej metody w klasie Special Arguments gdzie sobie tego życzymy.

Dam wszystkie klasy wprowadzane do konstruktora Special Arguments do jednego bloku a następnie Special Arguments i następnie wywołanie myślę że tak będzie bardziej przejrzyści niż każdą klasę osobno.

A tu wspomniany magiczny kosmos

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
class Person
{
 
 public function person11()
 {
  return "Person pozycja 1";
 }

 public function person12()
 {
   return "Person pozycja 2";
 }
 
  public function person13()
 {
   return "Person pozycja 3";
 }
}
 
class Person2
{
 public function person22()
 {
 return "person 2";
 }
}
 
 class Person3
 {
  public function person33()
  {
   return "person 3";
  }
 }
 
 class Person4
 {
  public function person44()
  {
   return "person 4";
  }
 }
 
class Person5
{
  public function person11()
 {
   return "Person5 pozycja 1";
 }
  public function person12()
 {
   return "Person 5 pozycja 2";
 }
  public function person13()
 {
   return "Person 5 pozycja 3";
 }
   public function person14()
 {
   return "Person 5 pozycja 2";
 }
  public function person14()
 {
   return "Person 5 pozycja 3";
 }
}
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
class special_arguments
{
  public $person = array();
 
  public function __construct()
  {
   if($arg = func_num_args()>0)
   {
     $this->person = func_get_args();
   }
 }
 
 public function person1()
 {
  return $this->person[0]["a"];  
 }
 
 public function person2()
 {
  return $this->person[0]["b"];
 }
 
 public function person3()
 {  
  return $this->person[0]["c"];
 }
 
 public function person4()
 {
  return $this->person[0]["d"];
 }
 
 public function person5()
 {
  return $this->person[0]["e"];
 }
}
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
 ## Special Arguments ##

 ## Możemy dowolnie zmieniać na te klasy które chcemy ##

 //$test = new special_arguments(array("a"=>new person11(),
                // "b"=>new person22(), "c"=>new person33(),
                // "d"=>new person44(), "e"=>new person55()));
 
 ## albo ##

 //$test = new special_arguments(array( "b"=>new person22(),
         // "d"=>new person44(), "e"=>new person55()));
 
 ## albo ##

 $test = new special_arguments(array("a"=>new Person(),
                         "e"=>new Person5()));
 
 echo $test->person1()->person11();
 echo "---";
 echo $test->gt;person1()->person12();
 echo "---";
 echo $test->person1()->person13();
 echo "---";
 echo $test->person5()->person11();
 echo "---";
 echo $test->person5()->person12();
 echo "---";
 echo $test->person5()->person13();
 echo "---";
 echo $test->person5()->person14();
 echo "---";
 echo $test->person5()->person15();

Uważam, że taki system może być według mnie nazywany nowym wzorcem projektowym w PHP dajcie znać jeżeli macie jakieś zdanie na ten temat.

A wszystko można sprawdzić pobierają klasę i wywołać ją sobie w różnych ustawieniach

Powodzenia

Download github: Download Special Arguments

Add a Comment