Warum typecasting ist nicht eine option in der PHP-Funktion Parameter

Mag dies wie eine dumme Frage für viele von Euch, aber es hält mich Fragen, warum PHP nicht erlauben typecasting in seiner Funktion Parameter. Viele Menschen verwenden diese Methode, zu werfen in den Parametern:

private function dummy($id,$string){
    echo (int)$id." ".(string)$string
}

Oder

private function dummy($id,$string){
    $number=(int)$id;
    $name=(string)$string;
    echo $number." ".$name;
}

Aber mit Blick auf die vielen anderen Programmiersprachen, Sie akzeptieren typecasting in Ihrer Funktion Parameter. Aber dies zu tun, in PHP kann zu Fehlern führen.

private function dummy((int)$id,(string)$string){
    echo $id." ".$string;
}

Parse error: syntax error, unexpected T_INT_CAST, in der Erwartung, '&' or T_VARIABLE

Oder

private function dummy(intval($id),strval($string)){
    echo $id." ".$string;
}

Parse error: syntax error, unexpected '(', expecting '&' or T_VARIABLE

Will nur wissen, warum dies nicht funktioniert, und wenn es einen Weg gibt. Wenn es keinen Weg gibt, dann werde der reguläre Weg ist okay für mich:

private function dummy($id,$string){
    echo (int)$id." ".(string)$string;
}

InformationsquelleAutor Death.System | 2012-07-13

10

PHP hat eine rudimentäre type-hinting-Fähigkeit für arrays und Objekte, aber es funktioniert nicht auf Skalare Typen.

PHP 5 führt Typbestimmung. Funktionen sind jetzt in der Lage zu zwingen, die Parameter der Objekte (durch Angabe der Namen der Klasse in der Funktion Prototyp), Schnittstellen, arrays (ab PHP 5.1) oder callable (ab PHP 5.4). Jedoch, wenn der Wert NULL ist als Standardwert für den parameter, wird es sein darf als ein argument, bei einem späteren Anruf.

Wenn eine Klasse oder Schnittstelle angegeben als type-hint, dann werden alle Ihre Kinder oder Implementierungen zulassen>ed zu.

Geben Hinweise können nicht verwendet werden, die mit skalaren Typen wie int oder string. Züge sind nicht erlaubt.

Array hinting Beispiel:
```
public function needs_array(array $arr) {
    var_dump($arr);
}
```
Objekt hinweisenden Beispiel
```
public function needs_myClass(myClass $obj) {
    var_dump($obj);
}
```
Wenn Sie brauchen, um die Durchsetzung einer skalaren Typ, müssen Sie es tun, durch Typisierung oder für die überprüfung der Art, in der die Funktion und die Rettung oder dementsprechend handeln, wenn es erhält den falschen Typ.

Werfen Ausnahmen, wenn Sie die falsche Art
```
public function needs_int_and_string($int, $str) {
   if (!ctype_digit(strval($int)) {
     throw new Exception('$int must be an int');
   }
   if (strval($str) !== $str) {
     throw new Exception('$str must be a string');
   }
}
```
Nur schweigend festgelegten params
```
public function needs_int_and_string($int, $str) {
   $int = intval($int);
   $str = strval($str);
}
```
Update: PHP 7 Fügt der Skalaren Type Hints

PHP 7 eingeführt hat Skalare type-Deklarationen mit strikten und nicht-strikten-Modi. Es ist nun möglich zu werfen, ein TypeError im strict-Modus, wenn eine Funktion argument-variable nicht genau dem deklarierten Typ oder zu zwingen, die Art, die im nicht-strict-Modus.
```
declare(strict_types=1);

function int_only(int $i) {
   //echo $i;
}

$input_string = "123"; //string
int_only($input);
// TypeError: Argument 1 passed to int_only() must be of the type integer, string given
```
- PHP 5.5 wird wahrscheinlich fügen Sie einige verschiedene Skalare typehinting: nikic.github.com/2012/07/10/What-PHP-5-5-might-look-like.html
- Ich werde noch einmal zu Lesen, dass. NikiC ist ein bekannter Mitwirkender hier.
- Also, Objekt-hinting nennt so etwas von einer anderen Klasse?
- Fordern nicht von anderen Klassen, aber wenn die parameter, die er empfängt, nicht eine Instanz der Klasse in der Spur, es führt zu einem schwerwiegenden Fehler.
- Also in meinem Beispiel oben, wenn $obj ist nicht eine Instanz von myClass, schwerwiegender Fehler.
InformationsquelleAutor Michael Berkowski
3

PHP erlauben dies nur für Objekttypen, und ich vermute, es ist, weil die Sprache ist so schwach typisierten sonst. Bedenken Sie:
```
<?php
class Foo {

    public function dummy(int $id, string $string){
        echo $id." ".$string;
    }

}

$foo = new Foo();
$foo->dummy(1, "me");
```
Dieser code ist syntaktisch okay (d.h. kompiliert), aber es ist ein Laufzeit Fehler:

Abfangbaren fatal error: Argument 1 passed to Foo::dummy() muss eine Instanz von int, integer, gegeben, genannt, /Users/christrahey/tes.php in Zeile 11 definiert /Users/christrahey/tes.php auf der Linie 4

Beachten Sie, dass es auf der Suche nach einem Instanz einer Klasse namens int.

InformationsquelleAutor Chris Trahey

Für alle Besucher hier von Google, werden Sie wahrscheinlich wissen, dass Sie jetzt, mit php 7.x, können Sie erklären, alle parameter-Typen, einschließlich skalaren:

<?php
declare(strict_types=1);
function foo(int $i){
    echo $i;
}

foo(20);
//foo('abvc'); //Fatal error: Uncaught TypeError: Argument 1 passed to foo() must be of the type integer, string given
foo('12');//this will be OK, *unless* we enable strict types at the first line

Array hinting Beispiel:

Objekt hinweisenden Beispiel

Werfen Ausnahmen, wenn Sie die falsche Art

Nur schweigend festgelegten params

Update: PHP 7 Fügt der Skalaren Type Hints