Key Takeaways

• Php 5.6 führte die F?higkeit ein, typisierte Arrays mit dem… Token zu erstellen, was darauf hinweist, dass eine Funktion oder Methode eine variable Argumente akzeptiert. Diese Funktion kann mit Typ -Hinweisen kombiniert werden, um sicherzustellen, dass nur bestimmte Arten von Objekten in einem Array akzeptiert werden.
• Eine Einschr?nkung dieses Merkmals besteht darin, dass nur ein typisiertes Array pro Methode definiert werden kann. Um dies zu überwinden, k?nnen typisierte Arrays in ?Sammelklassen“ injiziert werden, was auch spezifischere Rückgabetypen als ?Array“ bei GET -Methoden erm?glicht.
• Wertobjekte k?nnen zur benutzerdefinierten Validierung verwendet werden. Beispielsweise k?nnte ein Bewertungswertobjekt mit Einschr?nkungen erstellt werden, um sicherzustellen, dass eine Bewertung immer zwischen 0 und 5 liegt. Dies bietet eine zus?tzliche Validierung einzelner Sammlungsmitglieder, ohne jedes injizierte Objekt überschleifen zu müssen.
• streng typisierte Arrays und Sammlungen haben mehrere Vorteile. Sie bieten eine einfache Typvalidierung an einem Ort, stellen sicher, dass die Werte beim Bauwesen immer validiert wurden, die Hinzufügung einer benutzerdefinierten Logik pro Sammlung erm?glichen und die Wahrscheinlichkeit, Argumente in Methodensignaturen zu vermischen
W?hrend es m?glich ist, Methoden hinzuzufügen, um ?nderungen zu den Werten von Sammlungen und Wertobjekten nach der ersten Konstruktion zu erleichtern, ist es effizienter, sie unver?nderlich zu halten und sie in ihre primitiven Typen umzuwandeln, wenn ?nderungen vorgenommen werden müssen. Nach ?nderungen k?nnen die Sammlungen oder Wertobjekte mit den aktualisierten Werten rekonstruiert werden, die dann erneut validiert werden.

Dieser Beitrag erschien zum ersten Mal auf Medium und wurde hier mit Erlaubnis des Autors erneut ver?ffentlicht. Wir ermutigen Sie, Bert auf Medium zu folgen und ihm dort einige Vorlieben zu geben!

---

Eine der in Php 5.6 angekündigten Sprachmerkmale war die Hinzufügung des ... Tokens, um zu bezeichnen, dass eine Funktion oder Methode eine variable L?nge von Argumenten akzeptiert.

etwas, das ich selten erw?hnt habe, ist, dass es m?glich ist, diese Funktion mit Typ -Tipps zu kombinieren, um im Wesentlichen typisierte Arrays zu erstellen.

Zum Beispiel k?nnten wir eine Filmklasse mit einer Methode haben, um ein Array von Luftdaten festzulegen, die nur DateTimeMimmable -Objekte akzeptieren:

<span><span><?php
</span></span><span>
</span><span><span>class Movie {  
</span></span><span>  <span>private $dates = [];
</span></span><span>
</span><span>  <span>public function setAirDates(\DateTimeImmutable ...$dates) {
</span></span><span>    <span>$this->dates = $dates;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getAirDates() {
</span></span><span>    <span>return $this->dates;
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

Wir k?nnen jetzt eine variable Anzahl separater DateTimeMimmable -Objekte an die Methode setAirdates () übergeben:

<span><span><?php
</span></span><span>
</span><span><span>$movie = new Movie();
</span></span><span>
</span><span><span>$movie->setAirDates(
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-01-28'),
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-02-22')
</span></span><span><span>);
</span></span>

Wenn wir etwas anderes als eine datetimeimmimmige übergeben würden, würde beispielsweise ein fataler Fehler geworfen:

Wenn wir stattdessen bereits eine Reihe von DateTimeMimmable -Objekten hatten, die wir an setArdates () übergeben wollten, konnten wir das ... Token erneut verwenden, aber dieses Mal, um sie auszupacken:

<span><span><?php
</span></span><span>
</span><span><span>$dates = [
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-01-28'),
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-02-22'),
</span></span><span><span>];
</span></span><span>
</span><span><span>$movie = new Movie();
</span></span><span><span>$movie->setAirDates(...$dates);
</span></span>

Wenn das Array einen Wert enthalten würde, der nicht vom erwarteten Typ ist, würden wir immer noch den zuvor genannten t?dlichen Fehler erhalten.

Zus?tzlich k?nnen wir Skalartypen ab Php 7 verwenden. Zum Beispiel k?nnen wir eine Methode hinzufügen, um eine Liste von Bewertungen als Floats in unserer Filmklasse festzulegen:

<span><span><?php
</span></span><span>
</span><span><span>class Movie {  
</span></span><span>  <span>private $dates = [];
</span></span><span>
</span><span>  <span>public function setAirDates(\DateTimeImmutable ...$dates) {
</span></span><span>    <span>$this->dates = $dates;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getAirDates() {
</span></span><span>    <span>return $this->dates;
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

Dies stellt erneut sicher, dass die Bewertungseigenschaft immer Schwimmer enth?lt, ohne dass wir alle Inhalte überschreiten müssen, um sie zu validieren. Jetzt k?nnen wir also leicht einige mathematische Operationen bei Getaveragering () durchführen, ohne sich um ungültige Typen sorgen zu müssen.

Probleme mit dieser Art von typisierten Arrays

Einer der Nachteile der Verwendung dieser Funktion als typisierte Arrays ist, dass wir nur ein solches Array pro Methode definieren k?nnen. Angenommen, wir wollten eine Filmklasse, die eine Liste von Luftdaten zusammen mit einer Liste von Bewertungen im Konstruktor erwartet, anstatt sie sp?ter über optionale Methoden festzulegen. Dies w?re mit der oben verwendeten Methode unm?glich.

Ein weiteres Problem ist, dass bei der Verwendung von Php 7 die Rückgabetypen unserer Get () -Methoden immer noch ?Array“ sein müssten, was oft zu generisch ist.

L?sung: Sammlungsklassen

Um beide Probleme zu beheben, k?nnen wir einfach unsere typisierten Arrays in sogenannte ?Sammlungsklassen“ injizieren. Dies verbessert auch unsere Bedenken Trennung, da wir nun die Berechnungsmethode für die durchschnittliche Bewertung auf die relevante Sammelklasse verschieben k?nnen:

<span><span><?php
</span></span><span>
</span><span><span>$movie = new Movie();
</span></span><span>
</span><span><span>$movie->setAirDates(
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-01-28'),
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-02-22')
</span></span><span><span>);
</span></span>

Beachten Sie, wie wir noch eine Liste typisierter Argumente mit einer variablen L?nge in unserem Konstruktor verwenden, was uns die Mühe spart, über jede Bewertung zu schleifen, um ihren Typ zu überprüfen.

Wenn wir die M?glichkeit haben m?chten, diese Sammelklasse in Foreach -Loops zu verwenden, müssten wir einfach die Iteratoraggregate -Schnittstelle implementieren:

<span><span><?php
</span></span><span>
</span><span><span>$dates = [
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-01-28'),
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-02-22'),
</span></span><span><span>];
</span></span><span>
</span><span><span>$movie = new Movie();
</span></span><span><span>$movie->setAirDates(...$dates);
</span></span>

Wenn wir weitermachen, k?nnen wir auch eine Sammlung für unsere Liste der Luftdaten erstellen:

<span><span><?php
</span></span><span>
</span><span><span>declare(strict_types=1);
</span></span><span>
</span><span><span>class Movie {
</span></span><span>  <span>private $dates = [];
</span></span><span>  <span>private $ratings = [];
</span></span><span>
</span><span>  <span>public function setAirDates(\DateTimeImmutable ...$dates) { /* ... */ }
</span></span><span>  <span>public function getAirDates() : array { /* ... */ }
</span></span><span>
</span><span>  <span>public function setRatings(float ...$ratings) {
</span></span><span>    <span>$this->ratings = $ratings;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getAverageRating() : float {
</span></span><span>    <span>if (empty($this->ratings)) {
</span></span><span>      <span>return 0;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>$total = 0;
</span></span><span>
</span><span>    <span>foreach ($this->ratings as $rating) {
</span></span><span>      <span>$total += $rating;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>return $total / count($this->ratings);
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

Wenn wir alle Teile des Puzzles in der Filmklasse zusammenfügen, k?nnen wir jetzt zwei separat typisierte Sammlungen in unserem Konstruktor injizieren. Zus?tzlich k?nnen wir spezifischere Rückgabetypen als ?Array“ bei unseren GET -Methoden definieren:

<span><span><?php
</span></span><span>
</span><span><span>declare(strict_types=1);
</span></span><span>
</span><span><span>class Ratings {
</span></span><span>  <span>private $ratings;
</span></span><span>
</span><span>  <span>public function __construct(float ...$ratings) {
</span></span><span>    <span>$this->ratings = $ratings;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getAverage() : float {
</span></span><span>    <span>if (empty($this->ratings)) {
</span></span><span>      <span>return 0;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>$total = 0;
</span></span><span>
</span><span>    <span>foreach ($this->ratings as $rating) {
</span></span><span>      <span>$total += $rating;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>return $total / count($this->ratings);
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

Verwenden von Wertobjekten für die benutzerdefinierte Validierung

Wenn wir unseren Bewertungen zus?tzliche Validierung hinzufügen wollten, k?nnten wir noch einen Schritt weiter gehen und ein Bewertungswertobjekt mit einigen benutzerdefinierten Einschr?nkungen definieren. Zum Beispiel k?nnte eine Bewertung zwischen 0 und 5 begrenzt sein:

<span><span><?php
</span></span><span>
</span><span><span>declare(strict_types=1);
</span></span><span>
</span><span><span>class Ratings implements IteratorAggregate {
</span></span><span>  <span>private $ratings;
</span></span><span>
</span><span>  <span>public function __construct(float ...$ratings) {
</span></span><span>    <span>$this->ratings = $ratings;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getAverage() : float { /* ... */ }
</span></span><span>
</span><span>  <span>public function getIterator() {
</span></span><span>     <span>return new ArrayIterator($this->ratings);
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

Zurück in unserer Kennzeichnungsklasse müssten wir nur einige geringfügige ?nderungen vornehmen, um diese Wertobjekte anstelle von Floats zu verwenden:

<span><span><?php
</span></span><span>
</span><span><span>class AirDates implements IteratorAggregate {
</span></span><span>  <span>private $dates;
</span></span><span>
</span><span>  <span>public function __construct(\DateTimeImmutable ...$dates) {
</span></span><span>    <span>$this->dates = $dates;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getIterator() {
</span></span><span>     <span>return new ArrayIterator($this->airdates);
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

Auf diese Weise erhalten wir eine zus?tzliche Validierung einzelner Sammlungsmitglieder, ohne dass wir jedes injizierte Objekt überschreiten müssen.

Vorteile

tippen diese separaten Sammelklassen und das Wertobjekt wie viele Arbeiten, aber sie haben mehrere Vorteile gegenüber generischen Arrays und Skalarwerten:

• Einfache Typ Validierung an einem Ort. Wir müssen nie manuell über ein Array schauen, um die Arten unserer Sammlungsmitglieder zu validieren.

• Wo immer wir diese Sammlungen und Wertobjekte in unserer Anwendung verwenden, wissen wir, dass ihre Werte bei der Konstruktion immer validiert wurden. Zum Beispiel wird jede Bewertung immer zwischen 0 und 5 sein;

• Wir k?nnen einfach benutzerdefinierte Logik pro Sammlung und/oder Wertobjekt hinzufügen. Zum Beispiel die Methode von GetAverage (), die wir w?hrend unserer gesamten Anwendung wiederverwenden k?nnen;

• Wir erhalten die M?glichkeit, mehrere typisierte Listen in eine einzelne Funktion oder Methode zu injizieren.

Es gibt signifikant reduzierte Wahrscheinlichkeit, Argumente in Methodensignaturen zu vermischen. Wenn wir beispielsweise sowohl eine Liste von Bewertungen als auch eine Liste von Luftdaten injizieren m?chten, k?nnen sich die beiden bei der Verwendung von generischen Arrays durch einen Unfall durcheinander verwechseln.
Was ist mit ?nderungen?

Inzwischen fragen Sie sich vielleicht, wie Sie nach der ersten Konstruktion ?nderungen an den Werten Ihrer Sammlungen und Wertobjekte vornehmen k?nnen.

W?hrend wir Methoden hinzufügen konnten, um ?nderungen zu erleichtern, würde dies schnell umst?ndlich werden, da wir die meisten Methoden auf jeder Sammlung duplizieren müssten, um den Vorteil der Typ -Hinweise zu erhalten. Beispielsweise sollte eine add () -Methode für Bewertungen nur ein Bewertungsobjekt akzeptieren, w?hrend eine add () -Methode auf Airdates nur ein datetimeMimmable -Objekt akzeptieren sollte. Dies macht die Schnittstelle und/oder die Wiederverwendung dieser Methoden sehr schwierig.

Stattdessen konnten wir einfach unsere Sammlungen und Wertobjekte unver?nderlich halten und sie in ihre primitiven Typen umwandeln, wenn wir ?nderungen vornehmen müssen. Nachdem wir ?nderungen vorgenommen haben, k?nnen wir die erforderlichen Sammlungen oder Wertobjekte mit den aktualisierten Werten einfach neu konstruieren. Beim (re) Bauen werden alle Typen erneut validiert, zusammen mit einer zus?tzlichen Validierung, die wir m?glicherweise definiert haben.

Zum Beispiel k?nnten wir unseren Sammlungen eine einfache Methode für there () hinzufügen und ?nderungen wie folgt vornehmen:

Auf diese Weise k?nnen wir auch vorhandene Array-Funktionen wie Array_filter () wiederverwenden.

<span><span><?php
</span></span><span>
</span><span><span>class Movie {  
</span></span><span>  <span>private $dates = [];
</span></span><span>
</span><span>  <span>public function setAirDates(\DateTimeImmutable ...$dates) {
</span></span><span>    <span>$this->dates = $dates;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getAirDates() {
</span></span><span>    <span>return $this->dates;
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

Wenn wir wirklich ?nderungen an den Sammlungsobjekten selbst vornehmen mussten, k?nnen wir die erforderlichen Methoden auf der Grundlage von Bedarf hinzufügen, wo immer sie erforderlich sind. Denken Sie jedoch daran, dass die meisten dieser auch die Validierung der angegebenen Argumente durchführen müssen. Daher ist es schwierig, sie in allen verschiedenen Sammelklassen wiederzuverwenden.

generische Methoden wiederverwenden

Wie Sie vielleicht bemerkt haben, erhalten wir in unseren Sammelklassen immer noch eine Code -Duplikation in unseren Sammelklassen, indem wir sowohl toArray () als auch Getiterator () auf allen implementieren. Zum Glück sind diese Methoden generisch genug, um zu einer generischen Elternklasse zu wechseln, da beide einfach das injizierte Array zurückgeben:

Alles, was wir in unserer Sammelklasse übrig bleiben würden, w?re die Typ -Validierung im Konstruktor und jede optionale zus?tzliche Logik, die für diese Sammlung spezifisch ist, wie folgt:

<span><span><?php
</span></span><span>
</span><span><span>$movie = new Movie();
</span></span><span>
</span><span><span>$movie->setAirDates(
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-01-28'),
</span></span><span>  <span><span>\DateTimeImmutable</span>::createFromFormat('Y-m-d', '2017-02-22')
</span></span><span><span>);
</span></span>

<span><span><?php
</span></span><span>
</span><span><span>class Movie {  
</span></span><span>  <span>private $dates = [];
</span></span><span>
</span><span>  <span>public function setAirDates(\DateTimeImmutable ...$dates) {
</span></span><span>    <span>$this->dates = $dates;
</span></span><span>  <span>}
</span></span><span>
</span><span>  <span>public function getAirDates() {
</span></span><span>    <span>return $this->dates;
</span></span><span>  <span>}
</span></span><span><span>}
</span></span>

optional k?nnten wir unsere Sammlung endgültig machen, um zu verhindern, dass Kinderklassen mit der Eigenschaft der Werte auf eine Weise durcheinander bringen, die unsere Typ -Validierung rückg?ngig macht.

Schlussfolgerung

Obwohl es immer noch alles andere als perfekt ist, wurde es stetig einfacher, mit Typ Validierung in Sammlungen und Wertobjekten mit den jüngsten Ver?ffentlichungen von PHP zu arbeiten.

Idealerweise würden wir in einer zukünftigen Version von PHP eine Form von Generika erhalten, um die Erstellung wiederverwendbarer Sammlungsklassen weiter zu erleichtern.

Eine Funktion, die die Verwendung von Wertungsobjekten erheblich verbessern würde, w?re die F?higkeit, ein Objekt zus?tzlich zur String ein Objekt an verschiedene primitive Typen zu geben. Dies k?nnte leicht implementiert werden, indem zus?tzliche magische Methoden hinzugefügt werden, die mit __tostring () wie __toint (), __tofloat () usw. vergleichbar sind, usw.

Zum Glück gibt es einige RFCs, um m?glicherweise beide Funktionen in sp?teren Versionen zu implementieren, sodass die Daumen gekreuzt sind! ?

• Generika: https://wiki.php.net/rfc/generics

• Generische Arrays: https://wiki.php.net/rfc/generic-arrays

• Casting -Objekt in Scalar: https://wiki.php.net/rfc/class_casting_to_scalar

---

Wenn Sie dieses Tutorial hilfreich gefunden haben, besuchen Sie bitte den Originalbeitrag auf Medium und geben Sie ihm einige ??. Wenn Sie Feedback, Fragen oder Kommentare haben, lassen Sie sie bitte unten oder als Antwort auf den ursprünglichen Beitrag.

h?ufig gestellte Fragen (FAQs) zum Erstellen von streng getippten Arrays und Sammlungen in PHP

Wie hoch sind die Vorteile der Verwendung von streng getippten Arrays in PHP? Dies kann besonders in gr??eren, komplexeren Anwendungen nützlich sein, bei denen die Datenkonsistenz von entscheidender Bedeutung ist. Durch die Durchsetzung eines bestimmten Typs für alle Elemente in einem Array k?nnen Sie potenzielle Fehler und Fehler verhindern, die aufgrund unerwarteter Datentypen auftreten k?nnen. Es macht Ihren Code auch vorhersehbarer und einfacher zu debuggen, da Sie immer die Art der Daten kennen, mit denen Sie arbeiten. unterstützt nicht streng typisierte Arrays. Sie k?nnen jedoch eine Klasse erstellen, die die Typ -überprüfung der dem Array hinzugefügten Elemente erzwingt. Diese Klasse h?tte Methoden zum Hinzufügen und Abrufen von Elementen, und diese Methoden würden den Typ des Elements überprüfen, bevor die Operation durchgeführt wird. Wenn der Typ des Elements nicht mit dem erwarteten Typ übereinstimmt, würde ein Fehler geworfen. Sie k?nnen angeben, dass eine Funktion oder Methode ein Array als Argument erwartet, indem Sie ?Array“ vor dem Argumentnamen in der Funktion oder Methodeerkl?rung hinzufügen. Dies stellt jedoch nur sicher, dass das Argument ein Array ist, nicht dass alle Elemente im Array von einem bestimmten Typ sind.

Was ist der Unterschied zwischen locker typisierten und streng typisierten Arrays? In einem streng getippten Array müssen alle Elemente von einem bestimmten Typ sein. Wenn Sie versuchen, einem streng getippten Array ein Element eines anderen Typs hinzuzufügen, wird ein Fehler geworfen. PHP unter Verwendung der "deklar (strict_types = 1)"; Richtlinie zu Beginn Ihrer PHP -Datei. Dadurch wird die strenge Typ -überprüfung aller Funktionsaufrufe und Rückgabeberechnungen in der Datei erzwingen. von Objekten in PHP durch Erstellen einer Klasse, die die dem Array hinzugefügten Objekte die Typ -überprüfung erzwingt. Die Klasse hat Methoden zum Hinzufügen und Abrufen von Objekten, und diese Methoden würden den Typ des Objekts überprüfen, bevor die Operation durchgeführt wird. Die Hauptbeschr?nkung von streng typisierten Arrays in PHP besteht darin, dass sie zus?tzlichen Code ben?tigen, da PHP sie nicht nativ unterstützt. Dadurch kann Ihr Code komplexer und zu warten. Darüber hinaus k?nnen streng getippte Arrays weniger flexibel sein als locker getippte Arrays, da sie keine Elemente verschiedener Typen zulassen. Sie k?nnen den Typ verwenden, der bei mehrdimensionalen Arrays in PHP angedeutet wird. Der Typ von PHP ist jedoch nur sicher, dass das Argument ein Array ist, nicht dass alle Elemente im Array (oder Sub-Arrays) von einem bestimmten Typ sind. PHP?

Wenn Sie streng eingegebene Arrays in PHP verwenden, k?nnen Sie Fehler mithilfe von Try-Catch-Bl?cken verarbeiten. Wenn beim Hinzufügen eines Elements zum Array ein Fehler auftritt (z. B. wenn das Element vom falschen Typ ist), wird eine Ausnahme ausgel?st. Sie k?nnen diese Ausnahme fangen und angemessen umgehen. Funktionen. Sie müssen jedoch vorsichtig sein, da diese Funktionen die Typ -überprüfung nicht erzwingen. Wenn Sie eine Funktion verwenden, die das Array ?ndert und ein Element des falschen Typs hinzufügt, kann dies zu Fehlern führen.

Das obige ist der detaillierte Inhalt vonErstellen von streng typisierten Arrays und Sammlungen in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!