[Beispiel] Block System

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • [Beispiel] Block System

      Hallo liebes MCore Team,
      wie schon angedroht werde ich versuchen den Webcoding Bereich etwas aufleben zu lassen.

      Da ich gestern von einem Kollegen gefragt wurde wie man ein Blocksystem in PHP realisieren könnte welches dynamisch auf eventuelle Gegebenheiten reagiert.

      Lange Rede kurze Sinn. Ich habe es mit Ihm zusammen gebaut und wollte es euch nicht vorenthalten.

      Was ist ein Block System?

      Das Block System wird benötigt, um aus einem Controller oder wo auch immer, diverse Parameter oder ganze Programmteile nachzuladen.

      Das ganze System ist natürlich weder ausgereift, noch out of box nutzbar. Es ging für meinen Kollegen viel mehr darum einen Anhaltspunkt zuhaben und zu verstehen wie man eine Klasse bauen kann, welche ohne komplett definierte Methoden, dennoch dynamisch benutzt werden kann.

      Was bedeutet ohne definierte Methoden?

      Ohne fefinierte Methoden bedeutet, das wir die PHP eigene Magic Methode

      Quellcode

      1. __callStatic
      benutzen werden.

      Wie wird die Klasse benutzt?

      Die Klasse kann man ganz einfach in ein bestehendes System integrieren und muss noch eine Anpassung bezüglich der Verarbeitung der Blöcke machen.

      Code der Klasse

      PHP-Quellcode

      1. <?php
      3. class Block {
      5. /**
      6. * Beinhaltete alle Sections
      7. *
      8. * @var array
      9. */
      10. private static $sections=array();
      12. /**
      13. * Dynamischer Aufruf von nicht definierten Methodennamen
      14. *
      15. * @param string $method
      16. * @param array $args
      17. * @return void
      18. */
      19. public static function __callStatic($method, $args=array())
      20. {
      21. array_set(static::$sections, $method, array());
      22. foreach($args as $k => $v)
      23. {
      24. if(is_array($v))
      25. {
      26. foreach($v as $key => $value)
      27. {
      28. array_set(static::$sections[$method], $key, $value);
      29. }
      30. }
      31. }
      32. }
      34. /**
      35. * Aufruf einer Section egal in welcher Tiefe
      36. *
      37. * @param string $section
      38. * @param string $default
      39. * @return string|array
      40. */
      41. public static function get($section=false, $default=null)
      42. {
      43. if(!$section)
      44. {
      45. return static::$sections;
      46. }
      47. else
      48. {
      49. return array_get(static::$sections, $section, $default);
      50. }
      51. }
      52. }
      Alles anzeigen


      Beispiel Implementation

      PHP-Quellcode

      1. <?php
      3. require 'helpers.php';
      4. require 'blocks.php';
      6. Block::sidebar(array(
      7. array('social.facebook' => 'social/facebook'),
      8. array('social.twitter' => 'social/twitter')
      9. ));
      11. // Wenn man nun einen Block Segment auslesen will, dann reicht es wenn man das Array mit der Dot Syntax durchläuft
      12. Block::get(); // Gibt alle definierten Blöcke als Array aus
      13. Block::get('sidebar'); // Gibt alle Blöcke der Sidebar Kategorie aus als Array wenn es mehrere sind
      14. Block::get('sidebar.social'); // Alle Blöcke der Kategorie Sidebar und Unterkategorie Social als Array wenn es mehrere sind
      15. Block::get('sidebar.social.facebook'); // Gibt alle Blöcke der Kategorie Sidebar, Social, Facebook aus
      17. // Ich hoffe ich konnte mit dieser Erklärung alles klarstellen
      Alles anzeigen


      Helfer Datei damit die Array Dot Syntax funktioniert, diese wurde aus dem Laravel Framework übernommen

      PHP-Quellcode

      1. <?php
      3. /**
      4. * Get an item from an array using "dot" notation.
      5. *
      6. * <code>
      7. * // Get the $array['user]['name] value from the array
      8. * $name=array_get($array, 'user.name');
      9. *
      10. * // Return a default from if the specified item doesn't exist
      11. * $name=array_get($array, 'user.name', 'Taylor');
      12. * </code>
      13. *
      14. * @param array $array
      15. * @param string $key
      16. * @param mixed $default
      17. * @return mixed
      18. */
      19. function array_get($array, $key, $default=null)
      20. {
      21. if (is_null($key)) return $array;
      23. // To retrieve the array item using dot syntax, we'll iterate through
      24. // each segment in the key and look for that value. If it exists, we
      25. // will return it, otherwise we will set the depth of the array and
      26. // look for the next segment.
      27. foreach (explode('.', $key) as $segment)
      28. {
      29. if ( ! is_array($array) or ! array_key_exists($segment, $array))
      30. {
      31. return value($default);
      32. }
      34. $array=$array[$segment];
      35. }
      37. return $array;
      38. }
      40. /**
      41. * Set an array item to a given value using "dot" notation.
      42. *
      43. * If no key is given to the method, the entire array will be replaced.
      44. *
      45. * <code>
      46. * // Set the $array['user]['name] value on the array
      47. * array_set($array, 'user.name', 'Taylor');
      48. *
      49. * // Set the $array['user]['name]['first] value on the array
      50. * array_set($array, 'user.name.first', 'Michael');
      51. * </code>
      52. *
      53. * @param array $array
      54. * @param string $key
      55. * @param mixed $value
      56. * @return void
      57. */
      58. function array_set(&$array, $key, $value)
      59. {
      60. if (is_null($key)) return $array=$value;
      62. $keys=explode('.', $key);
      64. // This loop allows us to dig down into the array to a dynamic depth by
      65. // setting the array value for each level that we dig into. Once there
      66. // is one key left, we can fall out of the loop and set the value as
      67. // we should be at the proper depth.
      68. while (count($keys) > 1)
      69. {
      70. $key=array_shift($keys);
      72. // If the key doesn't exist at this depth, we will just create an
      73. // empty array to hold the next value, allowing us to create the
      74. // arrays to hold the final value.
      75. if ( ! isset($array[$key]) or ! is_array($array[$key]))
      76. {
      77. $array[$key]=array();
      78. }
      80. $array =& $array[$key];
      81. }
      83. $array[array_shift($keys)]=$value;
      84. }
      86. /**
      87. * Remove an array item from a given array using "dot" notation.
      88. *
      89. * <code>
      90. * // Remove the $array['user]['name] item from the array
      91. * array_forget($array, 'user.name');
      92. *
      93. * // Remove the $array['user]['name]['first] item from the array
      94. * array_forget($array, 'user.name.first');
      95. * </code>
      96. *
      97. * @param array $array
      98. * @param string $key
      99. * @return void
      100. */
      101. function array_forget(&$array, $key)
      102. {
      103. $keys=explode('.', $key);
      105. // This loop functions very similarly to the loop in the "set" method.
      106. // We will iterate over the keys, setting the array value to the new
      107. // depth at each iteration. Once there is only one key left, we will
      108. // be at the proper depth in the array.
      109. while (count($keys) > 1)
      110. {
      111. $key=array_shift($keys);
      113. // Since this method is supposed to remove a value from the array,
      114. // if a value higher up in the chain doesn't exist, there is no
      115. // need to keep digging into the array, since it is impossible
      116. // for the final value to even exist.
      117. if ( ! isset($array[$key]) or ! is_array($array[$key]))
      118. {
      119. return;
      120. }
      122. $array =& $array[$key];
      123. }
      125. unset($array[array_shift($keys)]);
      126. }
      129. /**
      130. * Return the first element in an array which passes a given truth test.
      131. *
      132. * <code>
      133. * // Return the first array element that equals "Taylor"
      134. * $value=array_first($array, function($k, $v) {return $v == 'Taylor';});
      135. *
      136. * // Return a default value if no matching element is found
      137. * $value=array_first($array, function($k, $v) {return $v == 'Taylor'}, 'Default');
      138. * </code>
      139. *
      140. * @param array $array
      141. * @param Closure $callback
      142. * @param mixed $default
      143. * @return mixed
      144. */
      145. function array_first($array, $callback, $default=null)
      146. {
      147. foreach ($array as $key => $value)
      148. {
      149. if (call_user_func($callback, $key, $value)) return $value;
      150. }
      152. return value($default);
      153. }
      155. /**
      156. * Recursively remove slashes from array keys and values.
      157. *
      158. * @param array $array
      159. * @return array
      160. */
      161. function array_strip_slashes($array)
      162. {
      163. $result=array();
      165. foreach($array as $key => $value)
      166. {
      167. $key=stripslashes($key);
      169. // If the value is an array, we will just recurse back into the
      170. // function to keep stripping the slashes out of the array,
      171. // otherwise we will set the stripped value.
      172. if (is_array($value))
      173. {
      174. $result[$key]=array_strip_slashes($value);
      175. }
      176. else
      177. {
      178. $result[$key]=stripslashes($value);
      179. }
      180. }
      182. return $result;
      183. }
      185. /**
      186. * Divide an array into two arrays. One with keys and the other with values.
      187. *
      188. * @param array $array
      189. * @return array
      190. */
      191. function array_divide($array)
      192. {
      193. return array(array_keys($array), array_values($array));
      194. }
      196. /**
      197. * Return the value of the given item.
      198. *
      199. * If the given item is a Closure the result of the Closure will be returned.
      200. *
      201. * @param mixed $value
      202. * @return mixed
      203. */
      204. function value($value)
      205. {
      206. return ($value instanceof Closure) ? call_user_func($value) : $value;
      207. }
      Alles anzeigen


      Ich hoffe ich kann damit dem ein oder anderen helfen. Bei Frage und konstruktiver Kritik, einfach hier im Thread posten.

      Bitte bedenkt das es nur eine Beispiel Verwendung ist und natürlich ausgebaut werden muss/kann.

    • Werbung zur Unterstützung des Forums ( Bitte AddBlocker deaktivieren )