type - PHP tipo-alusión a los valores primitivos?

varchar php

Question

Me gustaría saber si uno puede teclear-insinuar un método para esperar tipos primitivos.

Algo como esto:

public function someMethod(string $str)
                         //^^^^^^

O:

private function anotherMethod(int $num)
                             //^^^

de la misma manera que lo harías:

private function otherMethod(Person $rambo)
                           //^^^^^^

¿Es eso posible en php?

Answer 1

Aquí hay una sintaxis breve para forzar un valor booleano de un parámetro pasado. Si $state es verdadero, entonces $this->is_active se establece en verdadero. Para todos los demás tipos de valores, se establece en falso.

function set_active ( $state ) {
    $this->is_active = true === $state;
}

Answer 2

En PHP 7 agregaron lo siguiente:

Las declaraciones de tipo permiten que las funciones requieran que los parámetros sean de un cierto tipo en la hora de la llamada. Si el valor dado es del tipo incorrecto, se genera un error: en PHP 5, este será un error fatal recuperable, mientras que PHP 7 emitirá una excepción TypeError.

Referencia: http://php.net/manual/en/functions.arguments.php#functions.arguments.type-declaration

Cuando se formuló esta respuesta, PHP 5 fue la última y dijo lo siguiente:

PHP 5 introduce sugerencias tipo. Las funciones ahora pueden obligar a los parámetros a ser objetos (especificando el nombre de la clase en el prototipo de función), interfaces, matrices (desde PHP 5.1) o invocables (desde PHP 5.4) . Sin embargo, si NULL se usa como valor de parámetro predeterminado, se permitirá como argumento para cualquier llamada posterior.

Si la clase o interfaz se especifica como sugerencia de tipo, también se permiten todos sus elementos secundarios o implementaciones.

Las sugerencias de tipo no se pueden usar con tipos escalares como int o string. Los recursos y los rasgos tampoco están permitidos.

Referencia: php.net/manual/en/language.oop5.typehinting.php

Answer 3

Nop. No puede escribir sugerencias para primitivas porque PHP tiene conversiones automáticas para primitivas. Ver http://bugs.php.net/bug.php?id=29508 . Esto nunca cambiará, a menos que el equipo de PHP tenga un repentino cambio de opinión (lo cual es dudoso, son bastante obstinados).

Answer 4

Sí, ahora es posible. Después de una larga discusión, una propuesta para implementar sugerencias de tipo para los parámetros de funciones escalares y los valores de retorno fue aprobada con el conteo de votos más alto hasta el momento, verifique los detalles:

La sugerencia de tipo escalar consiste en declarar los tipos de parámetros de funciones y valores de retorno que pueden ser de los tipos int, float, string y bool. Esto permite que el motor de tiempo de ejecución de PHP compruebe si los tipos de valores pasados ​​a funciones de parámetros y valores devueltos son los tipos esperados para detectar eventuales errores de programación. La sugerencia de tipo para objetos, matrices y callables ya estaba permitida en versiones anteriores de PHP. La implementación actual introduce cinco nuevas palabras reservadas: int, float, bool, string y numeric. Estos no fueron reservados previamente, porque el casting es un caso especial en el lexer.

Example :
function test(float $a) {
    var_dump($a); 
}

test(1); // float(1)
test("1"); // float(1)
test(1.0); // float(1)
test("1a"); // E_RECOVERABLE_ERROR
test("a"); // E_RECOVERABLE_ERROR
test(""); // E_RECOVERABLE_ERROR
test(1.5); // float(1.5)
test(array()); // E_RECOVERABLE_ERROR
test(new StdClass); // E_RECOVERABLE_ERROR

También tiene la opción de declarar en el archivo de origen donde puede permitir la sugerencia del tipo Scaler. Debe ser la primera línea de su script de configuración y no puede declararse en ningún otro lugar en el mismo archivo.

Like : declare(strict_types=1);

En tiempo de ejecución, cuando el motor de PHP intenta devolver un valor, comprobará si no coincide con lo declarado emitirá un error fatal como, Error fatal: el argumento 1 pasado a incremente () debe ser del tipo entero, cadena dada

Con estas nuevas características de declaración, puede escribir aplicaciones más robustas al detectar errores tempranos de programación causados ​​por pasar valores de los tipos incorrectos a las funciones.

También pueden ocurrir cambios automáticos de tipos. Por ejemplo, los tipos int se pueden cambiar automáticamente a parámetros de tipo flotante,

function test(float $x){
    var_dump($x);
}
test(10); // works fine

Declarando el tipo de devolución

Podemos declarar los tipos de devolución agregando dos puntos seguidos por el tipo esperado entre el último paréntesis y el primer paréntesis en la declaración de la función.

Para las funciones que no devuelven ningún valor, no se debe agregar nada en la sección de declaración de tipo de devolución.

function mustReturnInt(): int { ... }
function mustReturnString(): string { ... }
function mustReturnBool(): bool { ... }
function mustReturnFloat(): float { ... }
function doesNotReturnAnything() { ... }

Un poco más complejo ejemplo

declare(strict_types=1);  
class StrictTypesTestingClass {  
public function returnSameInt(int $value): int {   return $value;  }   
public function returnSameFloat(float $value): float {   return $value;  }  
public function returnSameString(string $value): string {   return $value;  }   
public function returnSameBool(bool $value): bool {   return $value;  } }  
$check = new StrictTypesTestingClass();  // calls that work  print $check->returnSameInt(10); 
print $check->returnSameFloat(10.0); 
print $check->returnSameString("test"); 
print $check->returnSameBool(true) ? ''true'' : ''false'';  // calls that throw exceptions 
print $check->returnSameInt("10"); 
print $check->returnSameFloat("10.0"); 
print $check->returnSameString(10);
print $check->returnSameBool("true");

Comportamiento de comprobación de tipos débiles y conversión de tipos: El modo de comprobación de tipos débiles se puede utilizar con la declaración declare (strict_types = 0); o la ausencia de la declaración de tipos estrictos. Hay algunos puntos a tener en cuenta: llamadas marcadas de tipo débil a una extensión o función PHP incorporada tienen el mismo comportamiento que en versiones anteriores de PHP. Las reglas de comprobación de tipo débil para nuevas declaraciones de tipo escalar son en general las mismas que las de extensión o funciones integradas de PHP. NULL es un caso especial para ser coherente con las declaraciones de tipos actuales para clases, callables y matrices. NULL no se acepta por defecto, a menos que sea un parámetro y se le dé explícitamente un valor predeterminado de NULL, por ejemplo: function sample (int $ a = NULL);

Hay muchas ventajas en este enfoque. Obtienes seguridad de tipo. ¡Lo que significa que finalmente puedes analizar estáticamente el código! Puede detectar errores donde accidentalmente toma una cadena de una función y la pasa como un número entero a otro. Para mí, un desarrollador que usa PHP diariamente y ve Java como una referencia para lenguajes OOP, este es un gran progreso para PHP .

Answer 5

Sí, es posible.

http://ru2.php.net/manual/ru/language.oop5.typehinting.php#83442

Advertencia: hay un error tipográfico en el manual original: resolución en lugar de resolución

La gente suele preguntar acerca de las tipografías escalares / básicas. Aquí hay una caída en la clase que utilizo en mi framework MVC que habilitará las tipografías mediante el uso de un manejador de error personalizado.

Nota: Debe incluir este código sobre el resto del código en sus encabezados de inclusión y si usa la función set_error_handler (), debe tener en cuenta que esto también lo usa. Puede que necesite encadenar su set_error_handlers ()

¿Por qué?

1. Porque las personas están hartas de usar las funciones is_ * para validar los parámetros.
2. Reducción de la codificación redundante para codificadores defensivos.
3. Las funciones / métodos son autodefinidos / documentados en cuanto a la entrada requerida.

Además ... Siga la discusión sobre las tipografías en PHP 6.0 en las placas PHP Internals.

<?php

define(''TYPEHINT_PCRE'', ''/^Argument (/d)+ passed to (?:(/w+)::)?(/w+)/(/) must be an instance of (/w+), (/w+) given/'');

class Typehint
{

    private static $Typehints = array(
        ''boolean''   => ''is_bool'',
        ''integer''   => ''is_int'',
        ''float''     => ''is_float'',
        ''string''    => ''is_string'',
        ''resource''  => ''is_resource''
    );

    private function __Constrct() {}

    public static function initializeHandler()
    {

        set_error_handler(''Typehint::handleTypehint'');

        return TRUE;
    }

    private static function getTypehintedArgument($ThBackTrace, $ThFunction, $ThArgIndex, &$ThArgValue)
    {

        foreach ($ThBackTrace as $ThTrace)
        {

            // Match the function; Note we could do more defensive error checking.
            if (isset($ThTrace[''function'']) && $ThTrace[''function''] == $ThFunction)
            {

                $ThArgValue = $ThTrace[''args''][$ThArgIndex - 1];

                return TRUE;
            }
        }

        return FALSE;
    }

    public static function handleTypehint($ErrLevel, $ErrMessage)
    {

        if ($ErrLevel == E_RECOVERABLE_ERROR)
        {

            if (preg_match(TYPEHINT_PCRE, $ErrMessage, $ErrMatches))
            {

                list($ErrMatch, $ThArgIndex, $ThClass, $ThFunction, $ThHint, $ThType) = $ErrMatches;

                if (isset(self::$Typehints[$ThHint]))
                {

                    $ThBacktrace = debug_backtrace();
                    $ThArgValue  = NULL;

                    if (self::getTypehintedArgument($ThBacktrace, $ThFunction, $ThArgIndex, $ThArgValue))
                    {

                        if (call_user_func(self::$Typehints[$ThHint], $ThArgValue))
                        {

                            return TRUE;
                        }
                    }
                }
            }
        }

        return FALSE;
    }
}

Typehint::initializeHandler();

?>

An are some examples of the class in use:

<?php

function teststring(string $string) { echo $string; }
function testinteger(integer $integer) { echo $integer; }
function testfloat(float $float) { echo $float; }

// This will work for class methods as well.

?>

Te dan la imagen..

Answer 6

Supongo que no necesitas sugerencias tipo para PHP porque te dan funciones de verificación de tipo como is_bool (), is_string (), etc., para que puedas comprobar lo que trates de poner en un argumento en contra de estas funciones antes de hacerlo realmente un argumento, aunque el método que utilizan para verificar la matriz y los tipos de objetos sería mucho más limpio.

Answer 7

Todo el mundo ya lo dijo, no se puede hacer una sugerencia de tipo para primitivos porque PHP no lo admite. La razón detrás de esto no solo está relacionada con las conversiones automáticas sino también con la reacción de la comunidad.

Hasta el momento, puedo recordar que en mayo de 2010 se agregó soporte para sugerencias de tipo escalar al tronco de PHP. Pero debido a la respuesta de la comunidad, esta característica no llegó a la versión 5.4.

Hubo un poco de controversia sobre esto. Los que se opusieron al cambio argumentaron que este apoyo iría en contra de los diseños fundamentales de PHP. PHP se considera un lenguaje débilmente tipado. En esencia, esto significa que PHP no requiere que declares tipos de datos. Las variables todavía tienen tipos de datos asociados, pero puede hacer cosas radicales como agregar una cadena a un entero sin que se produzca un error.

En mi humilde opinión: la insinuación de tipo escalar debe agregarse a PHP lo antes posible, es una característica que todos necesitamos, realmente respeto que PHP sea un lenguaje débilmente tipado, pero para el desarrollo y producción de alto nivel, especialmente en contextos de OO, es necesario tener una indicación de tipo escalar. Podemos tener ambas alternativas en PHP, como procedural y OO.

Answer 8

php.net/manual/en/language.oop5.typehinting.php type hinting no es compatible con tipos primitivos.

Sin embargo, es compatible con clases e interfaces.

Editar: Olvidé mencionar que también es compatible con matrices.