login  Naam:   Wachtwoord: 
Registreer je!
 Scripts:

Scripts > PHP > Handige scripts > List voor PHP

List voor PHP

Auteur: Abbas - 01 februari 2010 - 23:46 - Gekeurd door: Koen - Hits: 2599 - Aantal punten: 5.00 (1 stem)





In .NET heb je de generische klasse List met eigenlijk héél veel mogelijkheden zoals Queryable en IEnumerable methodes enz... Dus ik dacht, waarom niet eens een gelijkaardige klasse maken voor PHP. Uiteraard met minder mogelijkheden dan de .NET-variant maar met alle basisfunctionaliteiten.

Bij de declaratie moet je meegeven wat voor type van List je wil en dan kan je de functies die erin staan allemaal gebruiken. Als er geen type wordt meegegeven wordt het type standaard "string". Je kan geen elementen van een ander type toevoegen dan die van het type dat is meegegeven bij de construct. Het is ook mogelijk om een lijst te maken van objecten. Dus als je bijvoorbeeld een lijst van het type Person wil werkt dit ook perfect.

Code:
  1. <?php
  2.  
  3. class MyList implements Countable, ArrayAccess
  4. {
  5. //class-variabelen
  6. //- type van de elementen
  7. //- lijst van elementen
  8. private $listType;
  9. private $innerList = array();
  10.  
  11. //default constructor
  12. public function __construct($type = "string")
  13. {
  14. $this->listType = $type;
  15. }
  16.  
  17. //item toevoegen als het type juist is
  18. public function Add($item)
  19. {
  20. if($this->IsType($item))
  21. $this->innerList[] = $item;
  22. }
  23.  
  24. //collectie van items toevoegen als het een array is
  25. public function AddRange($collection)
  26. {
  27. if($this->IsArray($collection))
  28. foreach($collection as $item)
  29. $this->Add($item);
  30. }
  31.  
  32. //lijst leegmaken
  33. public function Clear()
  34. {
  35. unset($this->innerList);
  36. }
  37.  
  38. //controleren of de lijst een item bevat
  39. public function Contains($item)
  40. {
  41. if($this->IsType($item))
  42. {
  43. foreach($this->innerList as $innerItem)
  44. if($item == $innerItem)
  45. return true;
  46. return false;
  47. }
  48. }
  49.  
  50. //aantal elementen in de lijst tellen
  51. public function Count()
  52. {
  53. return count($this->innerList);
  54. }
  55.  
  56. //index van een bepaald element weergeven
  57. //-1 wordt teruggestuurd als het niet bestaat in de lijst
  58. public function IndexOf($item)
  59. {
  60. if($this->IsType($item))
  61. {
  62. $i = 0;
  63. foreach($this->innerList as $innerItem)
  64. {
  65. if($item == $innerItem)
  66. return $i;
  67. else
  68. $i++;
  69. }
  70. return -1;
  71. }
  72. }
  73.  
  74. //element op een bepaalde index invoegen
  75. public function Insert($index, $item)
  76. {
  77. if($this->IsValidIndex($index) && $this->IsType($item))
  78. {
  79. $temp1 = array_slice($this->innerList, 0, $index);
  80. $temp2 = array_slice($this->innerList, $index);
  81.  
  82. array_push($temp1, $item);
  83. $this->innerList = array_merge($temp1, $temp2);
  84. }
  85. }
  86.  
  87. //collectie van elementen op een bepaalde index invoegen
  88. public function InsertRange($index, $collection)
  89. {
  90. if($this->IsValidIndex($index) && $this->IsArray($collection))
  91. {
  92. $collection = array_reverse($collection);
  93. foreach($collection as $item)
  94. if($this->IsType($item))
  95. $this->Insert($index, $item);
  96. }
  97. }
  98.  
  99. //de laatste index van een element geven
  100. public function LastIndexOf($item)
  101. {
  102. if($this->IsType($item))
  103. {
  104. for($i = count($this->innerList)-1; $i >= 0; $i--)
  105. if($this->innerList[$i] == $item)
  106. return $i;
  107. return -1;
  108. }
  109. }
  110.  
  111. //een bepaald item uit de lijst verwijderen
  112. public function Remove($item)
  113. {
  114. if($this->IsType($item))
  115. $this->RemoveAt($this->IndexOf($item));
  116. }
  117.  
  118. //een item op basis van index verwijderen
  119. public function RemoveAt($index)
  120. {
  121. if($this->IsValidIndex($index))
  122. array_splice($this->innerList, $index, 1);
  123. }
  124.  
  125. //een collectie van items verwijderen
  126. public function RemoveRange($index = 0, $count)
  127. {
  128. if($this->IsValidRange($index, $count))
  129. for($i = 0; $i < $count; $i++)
  130. $this->RemoveAt($index);
  131. }
  132.  
  133. //de volgorde van de elementen van de lijst omdraaien
  134. public function Reverse()
  135. {
  136. $this->innerList = array_reverse($this->innerList);
  137. }
  138.  
  139. //een sublijst maken van de huidge en terugsturen
  140. public function SubList($index, $count)
  141. {
  142. $returnList = new MyList($this->listType);
  143. if($this->IsValidRange($index, $count))
  144. $returnList->AddRange(array_slice($this->innerList, $index, $count));
  145. return $returnList;
  146. }
  147.  
  148. //maakt een standaard array van de elementen van de lijst
  149. public function ToArray()
  150. {
  151. return array_slice($this->innerList, 0);
  152. }
  153.  
  154. //deze functie zorgt ervoor dat je de foreach-loop
  155. //kan gebruiken om door de elementen van de lijst te gaan
  156. public function GetIterator()
  157. {
  158. return new ArrayIterator($this->innerList);
  159. }
  160.  
  161. //vanzelfsprekend
  162. private function IsInteger($input)
  163. {
  164. return is_int($input);
  165. }
  166.  
  167. //vanzelfsprekend
  168. private function IsArray($item)
  169. {
  170. return is_array($item);
  171. }
  172.  
  173. //deze functie kijkt na of het opgegeven type gelijk
  174. //is aan het type dat verwacht wordt voor de lijst
  175. private function IsType($item)
  176. {
  177. $itemType = gettype($item) == "object" ? get_class($item) : gettype($item);
  178. return $this->listType == $itemType;
  179. }
  180.  
  181. //nakijken of de opgegeven index wel valid is
  182. private function IsValidIndex($index)
  183. {
  184. if(!$this->IsInteger($index))
  185. return false;
  186. return ($index >= 0 && $index < count($this->innerList));
  187. }
  188.  
  189. //kijken of de range van elementen vanaf de index
  190. //tot het aantal elementen wel 'mag'
  191. //->dus dat die range niet buiten de lijst ligt
  192. private function IsValidRange($index, $count)
  193. {
  194. if($index < 0 || $count < 1)
  195. return false;
  196. if($count > $this->Count())
  197. return false;
  198. if(($index + $count)-1 > $this->Count()-1)
  199. return false;
  200. return true;
  201. }
  202.  
  203. //private functie zodat je $var = $myList[$index] kan gebruiken
  204. private function GetItem($index)
  205. {
  206. if($this->IsValidIndex($index))
  207. return $this->innerList[$index];
  208. }
  209.  
  210. //private functie zodat je $myList[$index] = $value kan gebruiken
  211. private function SetItem($index, $item)
  212. {
  213. if($this->IsValidIndex($index) && $this->IsType($item))
  214. $this->innerList[$index] = $item;
  215. }
  216.  
  217. //wordt niet direct gebruikt maar moet neergeschreven worden
  218. //omdat deze klasse de interface ArrayAcces implementeert
  219. public function offsetExists($index)
  220. {
  221. return $this->Contains($index);
  222. }
  223.  
  224. //functie vanuit de interface ArrayAccess die het resultaat van GetItem() terugstuurt
  225. //$var = myList[$index];
  226. public function offsetGet($index)
  227. {
  228. return $this->GetItem($index);
  229. }
  230.  
  231. //functie die SetItem() aanroept
  232. //myList[$index] = $value;
  233. public function offsetSet($index, $item)
  234. {
  235. $this->SetItem($index, $item);
  236. }
  237.  
  238. //zelfde hier als met offsetExsists
  239. public function offsetUnset($index)
  240. {
  241. $this->RemoveAt($index);
  242. }
  243. }
  244.  
  245. ?>

Mogelijk voorbeeld van gebruik:

  1. require_once "List.php";
  2.  
  3. $lst = new MyList("string");
  4. $values = array("een", "twee", "drie");
  5. $lst->AddRange($values);
  6. //$lst = een, twee, drie
  7.  
  8. $lst->Remove("een");
  9. //$lst = twee, drie
  10.  
  11. $lst[1] = "vier";
  12. //$lst = twee, vier
  13.  
  14. $lst->RemoveAt(0);
  15. //$lst = vier
  16.  
  17. $lst->AddRange($values);
  18. $lst->Reverse()
  19. //$lst = drie, twee, een, vier
  20.  
  21. $sub = $lst->SubList(1, 2);
  22. //$sub = twee, een

Voorbeeld met object:

  1. require_once "List.php";
  2. require_once "Person.php";
  3.  
  4. $lst = new MyList("Person");
  5.  
  6. $user = new Person();
  7. $user->Naam = "abbas";
  8. $user->Geboortejaar = 1985;
  9.  
  10. $lst->Add($user);
  11.  
  12. $newUser = $lst[0];
  13. //$newUser = $user
  14. $strNaam = $lst[0]->Naam;
  15. //$strNaam = abbas
  16. //Alle andere functies zijn ook toepasbaar
Download code! Download code (.txt)

 Stemmen
Niet ingelogd.

 Reacties
Post een reactie
Lees de reacties (3)
© 2002-2024 Sitemasters.be - Regels - Laadtijd: 0.057s