No sé lo que está haciendo cuando tenemos esta situación:

Foo::Bar

Se ve como un camino.

InformationsquelleAutor ben | 2010-05-25

5 Comentarios

  1. 40

    Que (en general) para acceder a un método estático o de una propiedad en una clase. Se llama el operador de resolución de ámbito, o Paamayim Nekudotayim (lo que lleva a algunos increíblemente confuso mensajes de error!). Ver http://www.php.net/manual/en/language.oop5.paamayim-nekudotayim.php.

    • Se me pegaba a él 😉 Quita mi respuesta como duplicar post.
    • +1 los mensajes de error siempre me han de mirar dos veces
    • Como el manual de PHP de la página por encima de las notas, que significa «dos puntos» en hebreo. Wikipedia menciona, también. en.wikipedia.org/wiki/Scope_resolution_operator#PHP
    • Creo que me quedo con el llamamiento es el doble de colon.
  2. 52

    La ::, el operador es el operador de resolución de ámbito. Se utiliza para el acceso constantes de clase o propiedades y métodos estáticos, ya sea desde fuera de la clase:

    ClassName::CONSTANT_VALUE
    ClassName::staticMethod()

    O dentro de un método de clase para hacer referencia a la misma o un padre de familia de clase utilizando self y parent:

    self::CONSTANT_VALUE
    self::staticMethod()
    parent::CONSTANT_VALUE
    parent::staticMethod()
    • Fantástica respuesta! Muy claro
    • y estáticos:: podemos utilizar
  3. 4

    El Operador de Resolución de Ámbito(::)el doble de colon, es un símbolo que permite el acceso a estática, constante, y reemplaza a propiedades o métodos de una clase.

    <?php
    class A {
    
    public static $B = '1'; # Static class variable.
    
    const B = '2'; # Class constant.
    
    public static function B() { # Static class function.
        return '3';
    }
    
    }
    
    echo A::$B . A::B . A::B(); # Outputs: 123
    ?>
  4. 0

    uso del Operador de Resolución de Ámbito

    Una constante de la clase, de propiedad de la clase (estáticos), función de la clase (estáticos)
    todos pueden compartir el mismo nombre y se puede acceder usando el doble de colon

    class B{
        public static $par = "par";
    }
    class A extends B{
        const B = "constant";
        public static $sel = "self";
    
        public static $b = "static property";
        public static function b(){
            echo "static function";
        }
        public static function c(){
            return parent::$par;
        }
        public static function d(){
            return self::$sel;
        }
         public static function e(){
            return self::$par;
        }
    }
    
    echo A::B.PHP_EOL;
    echo A::$b.PHP_EOL;
    echo A::b().PHP_EOL;
    echo A::c().PHP_EOL;
    echo A::d().PHP_EOL;
  5. 0

    Para complementar las respuestas con respecto a PHP el uso de dos puntos como su «operador de resolución de ámbito»:

    Además, una doble dos puntos se utilizan:

    1. Para resolver un incompetente, calificado, o con un alias de nombre de clase completamente calificado forma, y

    2. Para invocar una clase de «__callStatic método arbitrario, no declarado con anterioridad nombre de método.

    Para resolver un nombre de clase completamente calificado forma añadiendo «::clase»

    Dos signos de dos puntos seguido por la «clase» de la palabra clave, se coloca después del nombre de una clase, establece que clase de nombre totalmente calificado como una cadena. I. e., «Nombreclase::clase», resuelve el nombre completo de «ClassName». Ver: (A) Manual: Clases y Objetos: conceptos Básicos, (B) Manual: Clases y Objetos: Constantes de Clase., y (C) Manual: Referencia Del Lenguaje: Constantes

    La sintaxis se adoptó en PHP 5.5. Ver: (A) RFC y (B) PHP 5.5 Nuevas Características

    El «::clase de sintaxis» es útil dentro de un espacio de nombres para obtener el nombre completo de una clase de su sin salvedades o calificada formulario, o de un alias de su nombre.

    El «::clase de sintaxis» parece trabajar para resolver los nombres de interfaz así como los nombres de clase, a pesar de que no parece ser documentado por las fuentes vinculado anteriormente.

    Dentro de una clase, la sintaxis también funciona con «self::clase», como lo menciona el «::clase» RFC vinculado anteriormente.

    Un par de ejemplos:

    <?php
    
    namespace MyNamespace;
    
    use MyNamespace\YourInterface as HerInterface;    
    use MyNamespace\YourClass as HerClass;
    use MyNamespace\TheirClass as OurClass;
    
    interface MyInterface { }
    
    interface YourInterface { }
    
    class MyClass { }
    
    class YourClass { }
    
    class TheirClass
    {
        public function fullName()
        {
            echo self::class;
        }
    }
    
    $ourClassInstance = new OurClass;
    
    echo MyClass::class, PHP_EOL;
    //outputs: MyNamespace\MyClass
    
    echo HerClass::class, PHP_EOL;
    //outputs: MyNamespace\YourClass
    
    echo MyInterface::class, PHP_EOL;
    //outputs: MyNamespace\MyInterface
    
    echo HerInterface::class, PHP_EOL;
    //outputs: MyNamespace\YourInterface
    
    echo $ourClassInstance->fullName(), PHP_EOL;
    //outputs: MyNamespace\TheirClass

    Invocar «__callStatic» con un no declarado nombre de método

    Dos signos de dos puntos pueden ser utilizados para «llamar» a un método estático nombre que una clase no ha declarado. E. g., «Nombreclase::arbitraryMethodName()». Hacerlo invoca a la clase «__callStatic» método, si la clase ha declarado uno. También pasa a __callStatic el nombre de los no declarados método y los argumentos pasados a la no declarados método. El __callStatic método a continuación puede «dinámicamente» elegir cómo manejar la llamada. PHP se refiere a esto como «sobrecarga» con el __callStatic «método mágico».

    Ver más StackOverflow discusión

    Ejemplo:

    <?php
    
    namespace OurCompany\Orders;
    
    class Intake
    {
        public static function __callStatic($name, $arguments)
        {
            $item = substr($name, 5); //trims "order" prefix
    
            $specialistClass = "\OurCompany\Specialists\" . $item;
    
            if (class_exists($specialistClass)) {
                $specialist = new $specialistClass;
                return $specialist->handleOrder($arguments);
            }
    
            return "I'm sorry, we can't help you with " .
                lcfirst($item) . ".";
        }
    }
    
    namespace OurCompany\Specialists;
    
    class Car
    {
        public function handleOrder($arguments)
        {
            return "May I help you with a $arguments[0] car?";
        }
    }
    
    class Truck
    {
        public function handleOrder($arguments)
        {
            return "May I help you with a $arguments[0] truck?";
        }
    }
    
    use OurCompany\Orders\Intake;
    
    echo Intake::orderCar("red"), PHP_EOL;
    //outputs: May I help you with a red car?
    
    echo Intake::orderTruck("pickup"), PHP_EOL;
    //outputs: May I help you with a pickup truck?
    
    echo Intake::orderShoes("suede"), PHP_EOL;
    //outputs: I'm sorry, we can't help you with shoes.

Dejar respuesta

Please enter your comment!
Please enter your name here