Cuando se deben usar más de $esto?

En PHP 5, ¿cuál es la diferencia entre el uso de self y $this?

Cuando es apropiada?

InformationsquelleAutor Casey Watson | 2008-09-30

22 Kommentare

  1. 1677

    Respuesta Corta

    Uso $this para referirse a la actual
    objeto. Uso self para referirse a la
    clase actual. En otras palabras, el uso
    $this->member para los miembros no estáticos,
    uso self::$member para los miembros estáticos.

    Respuesta Completa

    Aquí es un ejemplo de correcta uso de $this y self para no estático y estático de las variables miembro:

    <?php
    class X {
        private $non_static_member = 1;
        private static $static_member = 2;
    
        function __construct() {
            echo $this->non_static_member . ' '
               . self::$static_member;
        }
    }
    
    new X();
    ?>

    Aquí es un ejemplo de incorrecto uso de $this y self para no estático y estático de las variables miembro:

    <?php
    class X {
        private $non_static_member = 1;
        private static $static_member = 2;
    
        function __construct() {
            echo self::$non_static_member . ' '
               . $this->static_member;
        }
    }
    
    new X();
    ?>

    Aquí es un ejemplo de polimorfismo con $this funciones miembro:

    <?php
    class X {
        function foo() {
            echo 'X::foo()';
        }
    
        function bar() {
            $this->foo();
        }
    }
    
    class Y extends X {
        function foo() {
            echo 'Y::foo()';
        }
    }
    
    $x = new Y();
    $x->bar();
    ?>

    Aquí es un ejemplo de la supresión de polimórficos comportamiento mediante self funciones miembro:

    <?php
    class X {
        function foo() {
            echo 'X::foo()';
        }
    
        function bar() {
            self::foo();
        }
    }
    
    class Y extends X {
        function foo() {
            echo 'Y::foo()';
        }
    }
    
    $x = new Y();
    $x->bar();
    ?>

    La idea es que $this->foo() llama a la foo() función de miembro de cualquiera que sea el tipo exacto del objeto actual. Si el objeto es de type X, así se llama X::foo(). Si el objeto es de type Y, llama Y::foo(). Pero con self::foo(), X::foo() siempre se llama.

    De http://www.phpbuilder.com/board/showthread.php?t=10354489:

    Por http://board.phpbuilder.com/member.php?145249-laserlight

    • Esta respuesta es demasiado simplista. Como se ha señalado en otras respuestas, self se utiliza con el operador de resolución de ámbito :: para hacer referencia a la clase actual; esto se puede hacer tanto en estáticos y no estáticos contextos. Además, es perfectamente legal el uso de $this llamar a métodos estáticos (pero no a los campos de referencia).
    • También considere el uso de static:: en lugar de ::auto si eres 5.3+. Puede causar incontables dolores de cabeza de lo contrario, véase mi respuesta a continuación el por qué.
    • -1. Esta respuesta es engañosa, leer las otras respuestas para obtener más información.
    • Puede ser excesivamente simplificado, pero no respondió a mi nivel básico pregunta sin hacer que mi cabeza explote. Me hizo tener un poco más de información que he encontrado útil más abajo, pero por ahora yo sólo estaba tratando de averiguar por qué me tocó a mi los atributos de la clase con $this->attrib y las constantes de clase con self::constante. Esto me ayudó a entender que mejor
    • ¿Qué acerca de $this::?
    • Esa es la manera de llamar a un método estático. Como staticclass::parse(). Pero, como la suya, teniendo us $ en el nombre de la clase no es válido.
    • ADVERTENCIA: «usar $this->miembro de los miembros no estáticos» esto no se aplica a const MYCONST = 1 definido en la no-estático de clases. Llamar $this->MYCONST activará una undefined property aviso. La única manera de obtener un valor declarado en el interior de un no-static (estático) de la clase es el uso de self::MYCONST.

  2. 735

    La palabra clave auto no NO se refieren únicamente a la ‘clase’, al menos no de una manera que restringe a los miembros estáticos. En el contexto de un miembro no estática, self también proporciona una manera de pasar por alto la vtable (ver wiki en la vtable) para el objeto actual. Así como usted puede utilizar parent::methodName() para llamar a los padres de la versión de una función, así que usted puede llamar self::methodName() llamar al corriente de las clases de la implementación de un método.

    class Person {
        private $name;
    
        public function __construct($name) {
            $this->name = $name;
        }
    
        public function getName() {
            return $this->name;
        }
    
        public function getTitle() {
            return $this->getName()." the person";
        }
    
        public function sayHello() {
            echo "Hello, I'm ".$this->getTitle()."<br/>";
        }
    
        public function sayGoodbye() {
            echo "Goodbye from ".self::getTitle()."<br/>";
        }
    }
    
    class Geek extends Person {
        public function __construct($name) {
            parent::__construct($name);
        }
    
        public function getTitle() {
            return $this->getName()." the geek";
        }
    }
    
    $geekObj = new Geek("Ludwig");
    $geekObj->sayHello();
    $geekObj->sayGoodbye();

    Esta es la salida:

    Hola, soy Ludwig el geek

    Adiós desde Ludwig la persona

    sayHello() utiliza el $this puntero, por lo que la vtable se invoca a la llamada Geek::getTitle().
    sayGoodbye() utiliza self::getTitle(), por lo que la vtable no se utiliza, y Person::getTitle() se llama. En ambos casos, se trata con el método de una instancia de un objeto, y tiene acceso a la $this puntero dentro de las funciones llamadas.

    • Esta respuesta sería aún mejor si usted comenzó con una regla general y no la excepción. Es una cuestión de estilo, no de conocimientos técnicos. Este es el mejor ejemplo que he visto de la diferencia entre el self:: y $this->, pero es una vergüenza para ocultar que por refutar una idea en primer lugar.
    • ¿Por qué es malo el estilo? No es elevar la conciencia si la expectativa (tesis) de la OP es la primera rechazado (antítesis) y, a continuación, la explicación es dada como síntesis?
    • Me parece de corriente «class» muy problemático. Como que la combinación de palabras puede ser entendido como «la clase donde self se encuentra»/»la definición de la clase es una parte literal de» así como «la clase del objeto» (que en realidad sería static).
    • ¿Qué acerca de $this::?
    • no hay ninguna buena razón para usar $this::; todos los casos posibles, ya están cubiertos por más comúnmente utilizados para la sintaxis. Dependiendo de lo que quieres decir, utilizar $this->, self::, o static::.
    • Justo lo suficiente. Sólo me preguntaba si no era un buen caso de uso, o simplemente otro sentido algo en PHP con demasiado margen de maniobra, etc. Es confuso al principio, pero sin duda significa la auto debido a los dos puntos.

  3. 451

    NO UTILICE self::, uso static::

    Hay otro aspecto de auto:: que es digno de mención. Molesto self:: se refiere al ámbito en el punto de la definición y no en el punto de ejecución. Considere la posibilidad de esta clase simple con dos métodos:

    class Person
    {
    
        public static function status()
        {
            self::getStatus();
        }
    
        protected static function getStatus()
        {
            echo "Person is alive";
        }
    
    }

    Si llamamos Person::status() vamos a ver «la Persona está viva» . Ahora consideremos lo que sucede cuando hacemos una clase que hereda de esta:

    class Deceased extends Person
    {
    
        protected static function getStatus()
        {
            echo "Person is deceased";
        }
    
    }

    Llamar Deceased::status() podemos esperar ver «Persona está muerta», sin embargo lo que vemos es «la Persona está viva» como el ámbito de aplicación contiene el original de la definición de método cuando llame a self::getStatus() estaba definido.

    PHP 5.3 tiene una solución. el static:: operador de resolución de implementos «a finales de la estática de unión», que es una manera elegante de decir que es muy probable que el alcance de la llamada clase. Cambiar la línea en status() a static::getStatus() y los resultados son lo que cabría esperar. En versiones anteriores de PHP, usted tendrá que encontrar un parche para ello.

    Ver Documentación de PHP

    Así que para responder a la pregunta, no se como le …

    $this-> se refiere al objeto actual (una instancia de una clase), mientras que static:: se refiere a una clase

    • ¿Qué acerca de constantes de clase?
    • Supongo que el mismo va
    • «Llamar Fallecido::status() podemos esperar ver «Persona está muerta»». No. Esta es una función estática de la llamada así que no hay polimorfismo de los involucrados.
    • De todos PHP defectos, yo no creo que esto es de locos a todos. ¿De qué otra manera habría que permiten a los programadores para designar a los métodos de la clase actual (en contraposición a la búsqueda de ellos en la vtable)? Si hubieran llamado de otra manera (tal vez con los principales caracteres de subrayado), a continuación, las personas que quieren esta característica lo critican por ser feo. Otra cosa, lo que sea cuerdo nombre con el que se podría usar esto parece siempre ser fácilmente confundido a la gente que critique por ser «loco» de la conducta, probablemente ajeno a cómo método de envío, incluso obras.
    • El ejemplo parece confuso para mí: veo getStatus método como uno que yo llamaría para una instancia de una clase, no de una clase.
    • Por favor, considere la posibilidad de editar la respuesta como php -r "class X { private const X = 1; public static function show() { echo static::X; }} class Y extends X {} Y::show();" va a tirar undefined class constant X ya que la constante no existe en Y. en este caso, self::X es necesario (en lugar de hacer const protected que uno podría tristemente hacer si ellos consideran que self:: como prohibido).
    • diciendo: «NO USE self::, el uso de static::» es un extraño punto de hacer – esos son deliberadamente no es la misma operación. Creo que el punto de que están haciendo realmente es «es más clara si se utiliza el nombre de clase real ‘Miclase::’ en lugar de ‘self::’. Es decir, si usted quiere que el comportamiento de self::, usted puede conseguir eso, menos confusamente, por usar el nombre de la clase, por ejemplo,MyClass::.

  4. 242

    Entender realmente de qué estamos hablando cuando hablamos de self frente a $this, necesitamos profundizar en lo que se va a conceptual y lo práctico. La verdad no siento ninguna de las respuestas hacerlo apropiadamente, así que aquí está mi intento.

    Vamos a empezar hablando de lo que es un clase y un objeto es.

    Clases Y Objetos, Conceptualmente

    Así que, ¿qué es un clase? Una gran cantidad de personas lo definen como un plan o un plantilla de un objeto. De hecho, usted puede leer más Acerca de las Clases En PHP Aquí. Y en cierta medida eso es lo que realmente es. Echemos un vistazo a una clase:

    class Person {
        public $name = 'my name';
        public function sayHello() {
            echo "Hello";
        }
    }

    Como usted puede decir, no es una propiedad de la clase llamada $name y un método (función) llamado sayHello().

    Es muy importante tener en cuenta que la clase es una estructura estática. Lo que significa que la clase Person, una vez definido, es siempre el mismo en todas partes usted mira.

    Un objeto por otro lado es lo que se llama un instancia de una Clase. Lo que significa es que debemos tener el «plan» de la clase, y usarlo para hacer una copia dinámico. Esta copia es ahora especialmente vinculado a la variable que se almacenan en. Por lo tanto, cualquier cambio en una instancia es local a esa instancia.

    $bob = new Person;
    $adam = new Person;
    $bob->name = 'Bob';
    echo $adam->name; //"my name"

    Crear nuevos instancias de una clase utilizando la new operador.

    Por lo tanto, podemos decir que una Clase es una estructura global, y un Objeto es una estructura local. No te preocupes que gracioso -> sintaxis, vamos a entrar en eso en un poco.

    Otra cosa en la que tenemos que hablar, es que podemos de verificación si una instancia es una instanceof una clase particular: $bob instanceof Person que devuelve un valor booleano si el $bob instancia se hizo con el Person clase, o un niño de Person.

    La Definición De Estado

    Así que vamos a profundizar un poco en qué clase de realidad contiene. Hay 5 tipos de «cosas» que una clase contiene:

    1. Propiedades – Pensar en ellos como variables que cada instancia contiene.

      class Foo {
          public $bar = 1;
      }
    2. Propiedades estáticas – Creo que de estos, ya que las variables son compartidos a nivel de la clase. Lo que significa que nunca son copiados por cada instancia.

      class Foo {
          public static $bar = 1;
      }
    3. Métodos – Estas son las funciones que cada instancia contiene (y que funcionen en las instancias).

      class Foo {
          public function bar() {}
      }
    4. Métodos estáticos – Estas son funciones que son compartidos a través de toda la clase. Que hacer no operar en las instancias, pero en cambio en las propiedades estáticas sólo.

      class Foo {
          public static function bar() {}
      }
    5. Constantes Clase resuelto constantes. No va más profundo aquí, pero la adición de la integridad:

      class Foo {
          const BAR = 1;
      }

    Así que, básicamente, estamos almacenar información sobre la clase y el objeto contenedor el uso de «pistas» acerca de estática que identificar si la información es compartida (y por lo tanto estática) o no (y por lo tanto dinámico).

    Estado y de los Métodos

    Dentro de un método, la instancia de un objeto es representado por el $this variable. El estado actual de que el objeto está ahí, y la mutación (cambio) de cualquier propiedad que se traducirá en un cambio en la instancia (pero no otros).

    Si se llama a un método de forma estática, la $this variable no está definido. Esto es debido a que no hay ninguna instancia asociada con una llamada estática.

    Lo interesante aquí es cómo estática de llamadas realizadas. Así que vamos a hablar acerca de cómo podemos acceder al estado:

    Acceder Estado

    Así que ahora que hemos almacenado ese estado, tenemos que acceder a ella. Esto puede ser un poco complicado (o manera más que un poco), así que vamos a dividir esto en dos puntos de vista: desde el exterior de una instancia de la clase (digamos de una función normal de la llamada, o desde el ámbito global), y dentro de una instancia de la clase (desde dentro de un método en el objeto).

    Desde Fuera De Una Instancia De La Clase

    Desde el exterior de una instancia de la clase, las reglas son bastante simples y predecibles. Tenemos dos operadores, y cada uno nos dice inmediatamente si estamos tratando con una instancia o una clase estática:

    • ->objeto-operador – Esto se utiliza siempre cuando estamos accediendo a una instancia.

      $bob = new Person;
      echo $bob->name;

      Es importante tener en cuenta que llamar a Person->foo no tiene sentido (ya que Person es una clase, no de una instancia). Por lo tanto, es un error de análisis.

    • ::ámbito de resolución-operador – Esto siempre es utilizado para acceder a una Clase estática de la propiedad o método.

      echo Foo::bar()

      Además, podemos llamar a un método estático en un objeto de la misma manera:

      echo $foo::bar()

      Es extremadamente importante tener en cuenta que cuando hacemos esto desde fuera, la instancia del objeto está oculto de la bar() método. Lo que significa que es exactamente igual a ejecutar:

      $class = get_class($foo);
      $class::bar();

    Por lo tanto, $this no está definido en la llamada estática.

    Desde El Interior De Una Instancia De La Clase

    Las cosas cambian un poco aquí. Los mismos operadores se utilizan, pero su significado se vuelve significativamente borrosa.

    La objeto-operador -> todavía se utiliza para hacer llamadas a la instancia del objeto de estado.

    class Foo {
        public $a = 1;
        public function bar() {
            return $this->a;
        }
    }

    Llamar a la bar() método en $foo (una instancia de Foo) utilizando el objeto-operador: $foo->bar() resultará en la instancia de la versión de $a.

    Así que eso es lo que esperamos.

    El significado de la :: operador a pesar de los cambios. Depende del contexto de la llamada a la función actual:

    • Dentro de un contexto estático

      Dentro de un contexto estático, las llamadas realizadas utilizando :: también será estática. Veamos un ejemplo:

      class Foo {
          public function bar() {
              return Foo::baz();
          }
          public function baz() {
              return isset($this);
          }
      }

      Llamar Foo::bar() va a llamar a la baz() método de forma estática, y por lo tanto $this se no ser pobladas. Vale la pena señalar que en las últimas versiones de PHP (5.3+) esto desencadenará una E_STRICT error, porque estamos llamando a métodos no estáticos de forma estática.

    • Dentro de una instancia de contexto

      Dentro de una instancia de contexto por otro lado, las llamadas realizadas utilizando :: dependen del receptor de la llamada (el método que estamos llamando). Si el método se define como static, a continuación, utilizará una llamada estática. Si no, se enviará la información de la instancia.

      De este modo, en el código anterior, llamando $foo->bar() volverá true, ya que la «estática» de la llamada que ocurre en el interior de una instancia de contexto.

    Sentido? No lo creo. Es confuso.

    Corto-Corte De Palabras Clave

    Debido a atar todo junto el uso de nombres de clase es sucio, PHP dispone de 3 basic «acceso directo» palabras clave para que alcance la resolución más fácil.

    • self – Esto se refiere a la actual nombre de la clase. Así self::baz() es el mismo que Foo::baz() dentro de la Foo clase (cualquier método).

    • parent – Esto se refiere a la madre de la actual clase.

    • static – Esto se refiere a la llamada clase. Gracias a la herencia, el niño de las clases puede reemplazar los métodos y las propiedades estáticas. Por lo que llamar a ellos mediante static en lugar de un nombre de clase nos permite resolver donde la llamada provenía, más que el nivel actual.

    Ejemplos

    La manera más fácil de entender esto es para empezar a buscar algunos ejemplos. Vamos a elegir una clase:

    class Person {
        public static $number = 0;
        public $id = 0;
        public function __construct() {
            self::$number++;
            $this->id = self::$number;
        }
        public $name = "";
        public function getName() {
            return $this->name;
        }
        public function getId() {
            return $this->id;
        }
    }
    
    class Child extends Person {
        public $age = 0;
        public function __construct($age) {
            $this->age = $age;
            parent::__construct();
        }
        public function getName() {
            return 'child: ' . parent::getName();
        }
    }

    Ahora, también estamos viendo la herencia de aquí. Ignorar por un momento que esto es un mal modelo de objetos, pero veamos lo que pasa cuando se juega con esto:

    $bob = new Person;
    $bob->name = "Bob";
    $adam = new Person;
    $adam->name = "Adam";
    $billy = new Child;
    $billy->name = "Billy";
    var_dump($bob->getId()); //1
    var_dump($adam->getId()); //2
    var_dump($billy->getId()); //3

    Por lo que el contador de ID es compartido a través de ambas instancias y los niños (porque estamos usando self para acceder a ella. Si hemos utilizado static, se podría reemplazar en un niño de la clase).

    var_dump($bob->getName()); //Bob
    var_dump($adam->getName()); //Adam
    var_dump($billy->getName()); //child: Billy

    Nota que estamos ejecutando el Person::getName() instancia método cada vez. Pero estamos usando el parent::getName() hacerlo en uno de los casos (en el caso del niño). Esto es lo que hace que este enfoque poderoso.

    Palabra De Precaución #1

    Tenga en cuenta que el contexto de llamada es lo que determina si una instancia es utilizado. Por lo tanto:

    class Foo {
        public function isFoo() {
            return $this instanceof Foo;
        }
    }

    No es siempre verdadero.

    class Bar {
        public function doSomething() {
            return Foo::isFoo();
        }
    }
    $b = new Bar;
    var_dump($b->doSomething()); //bool(false)

    Ahora es realmente extraño aquí. Estamos llamando a una clase diferente, pero la $this que se pasa a la Foo::isFoo() método es la instancia de $bar.

    Esto puede causar todo tipo de errores y conceptual de la WTF-ery. Así que te recomiendo evitar el :: operador dentro de los métodos de instancia en nada, a excepción de los tres virtual «atajo» de las palabras clave (static, self, y parent).

    Palabra De Advertencia #2

    Nota que los métodos estáticos y propiedades son compartidas por todos. Que hace, básicamente, las variables globales. Con todos los problemas que vienen con las globales. Así que me sería muy vacilantes a la hora de almacenar la información en los métodos estáticos/propiedades a menos que usted esté cómodo con él que es verdaderamente global.

    Palabra De Precaución #3

    En general, usted querrá usar lo que se conoce como Tarde-Estática de Unión mediante static en lugar de self. Pero tenga en cuenta que no son la misma cosa, de modo que diciendo «siempre uso static en lugar de self es muy corto de miras. En su lugar, detenerse y pensar acerca de la llamada que desea hacer y pensar si quieres clases hijas para ser capaz de reemplazar el que estática resuelto llamada.

    TL/DR

    Muy mal, volver atrás y leer. Puede que sea demasiado largo, pero que mucho tiempo, porque este es un tema complejo

    TL/DR #2

    Ok, está bien. En resumen, self se utiliza para hacer referencia a el actual nombre de la clase dentro de una clase, donde como $this se refiere al objeto actual instancia. Tenga en cuenta que self es un copiar/pegar de atajo. De forma segura puede reemplazar con el nombre de su clase, y va a funcionar bien. Pero $this es una variable dinámica que no puede ser determinado de antemano (y puede incluso no ser de su clase).

    TL/DR #3

    Si el objeto-operador se utiliza (->), entonces usted siempre sabe que usted está tratando con un ejemplo. Si el alcance de la resolución operador se utiliza (::), usted necesita más información sobre el contexto (estamos en un objeto-contexto ya? Estamos fuera de un objeto? etc).

    • Palabra de advertencia #1: $esto no va a ser definido cuando se llama a un método estático: 3v4l.org/9kr0e
    • Bueno… $this no se define si sigue «Normas Estrictas» y no llame a los métodos de la estática que no están definidos como estática. Veo el resultado que se explica aquí: 3v4l.org/WeHVM de acuerdo, muy raro.
    • Sólo si es declarado estática. Cual fue el punto que estaba tratando de hacer: que es difícil de saber y ver lo que está pasando sin cavar a través del código de…
    • Después de leer la descripción larga por completo, me sentía perezoso para desplazarse arriba upvote. Bromeando, me hizo upvote :D. Gracias esto es muy útil.
    • sería bueno añadir una explicación clara acerca de la diferencia entre el self::$propiedad y self::propiedad; yo creo que eso es bastante confuso demasiado
    • Esta es la respuesta que debe ser aceptada.
    • La comisión de la mujer#1 se comporta de forma diferente desde PHP 7. Como Foo::isFoo() se llama de forma estática, $this no se define. Que es más intuitivo comportamiento en mi opinión. – Otra de las resultados si Bar se extienden desde Foo. A continuación, la llamada Foo::isFoo() sería estar dentro de la instancia de contexto (no específico para PHP7).

  5. 115

    self (no $self) se refiere a la tipo de clase, donde como $this se refiere a la actual instancia de la clase. self es para uso en las funciones miembro estáticas para permitir el acceso a variables de miembro estático. $this se utiliza en la no-funciones miembro estáticas, y es una referencia a la instancia de la clase en la que el miembro de la función fue llamada.

    Porque this es un objeto, se utiliza como: $this->member

    Porque self no es un objeto, que es básicamente un tipo que automáticamente se refiere a la clase actual, se utiliza como: self::member

  6. 96

    $this-> se utiliza para referirse a una instancia específica de una clase de variables (variables miembro) o los métodos.

    Example: 
    $derek = new Person();

    $derek es ahora una instancia específica de la Persona.
    Cada Persona tiene un nombre y un apellido, pero $derek tiene un determinado nombre y apellidos (Derek Martin). Dentro de los $derek ejemplo, podemos referirnos a ellos como $this->el nombre y $this->apellidos

    Nombreclase:: se utiliza para referirse a ese tipo de clase, y sus variables estáticas, métodos estáticos. Si le ayuda, usted mentalmente puede sustituir la palabra «static» con «compartida». Debido a que son compartidos, que no puede referirse a $esta, que hace referencia a una instancia específica (no compartido). Las Variables estáticas (es decir, estática $db_connection) puede ser compartida entre todas las instancias de un tipo de objeto. Por ejemplo, todos los objetos de base de datos compartir una única conexión (estático $conexión).

    Variables Estáticas Ejemplo:
    Suponer que tenemos una clase de base de datos con un solo miembro de la variable: static $num_connections;
    Ahora, poner esto en el constructor:

    function __construct()
    {
        if(!isset $num_connections || $num_connections==null)
        {
            $num_connections=0;
        }
        else
        {
            $num_connections++;
        }
    }

    Sólo como objetos de constructores, también tienen destructores, que se ejecuta cuando el objeto muere o es unset:

    function __destruct()
    {
        $num_connections--;
    }

    Cada vez que creamos una nueva instancia, va a aumentar nuestra conexión a contador por uno. Cada vez que destruir o detener el uso de una instancia, se reducirá la conexión de contador por uno. De esta manera, podemos controlar el número de instancias de la base de datos de objetos que tenemos en uso con:

    echo DB::num_connections;

    Porque $num_connections es estáticos (compartidos), se refleja el número total de activos objetos de base de datos. Usted puede haber visto esta técnica se utiliza para compartir conexiones de base de datos entre todas las instancias de una clase de base de datos. Esto se hace debido a que la creación de la conexión de base de datos toma mucho tiempo, así que lo mejor es crear uno solo, y compartir (esto se llama un Patrón Singleton).

    Métodos estáticos (es decir, public static Vista::format_phone_number($dígitos)) puede ser utilizado SIN antes crear instancias de uno de esos objetos (es decir, Que no internamente se refieren a $esta).

    Método Estático Ejemplo:

    public static function prettyName($first_name, $last_name)
    {
        echo ucfirst($first_name).' '.ucfirst($last_name);
    }
    
    echo Person::prettyName($derek->first_name, $derek->last_name);

    Como se puede ver, public static function prettyName no sabe nada sobre el objeto. Es sólo trabajar con los parámetros que pasar, como una función normal que no parte de un objeto. ¿Por qué molestarse, entonces, si sólo pudiéramos tener no como parte del objeto?

    1. Primera, adjuntando funciones a los objetos ayuda a mantener las cosas organizadas, para que usted sepa dónde encontrarlos.
    2. Segundo, evita los conflictos de nombres. En un proyecto grande, es probable que usted tenga dos desarrolladores crear getName() funciones. Si uno crea un ClassName1::getName(), y el otro crea ClassName2::getName(), no es ningún problema en absoluto. No hay conflicto. Yay métodos estáticos!

    SELF::
    Si la codificación de fuera el objeto que tiene el método estático que desea consultar, debe llamar utilizando el nombre del objeto View::format_phone_number($número_teléfono);
    Si la codificación de dentro de el objeto que tiene el método estático que desea consultar, puede ya sea utilizar el nombre del objeto View::format_phone_number($pn), O puede utilizar el self::format_phone_number($pn) acceso directo

    Lo mismo ocurre para las variables estáticas:
    Ejemplo: Vista::templates_path frente a self::templates_path

    Dentro de la DB de la clase, si se refiere a un método estático de algún otro objeto, debemos utilizar el nombre del objeto:
    Ejemplo: Sesión::getUsersOnline();

    Pero si el DB clase quiso referirse a su propia variable estática, que acaba de decir el auto:
    Ejemplo: self::conexión;

    Espero que ayude a aclarar las cosas 🙂

    • Gran respuesta. Sólo quiero señalar, cuando se refiere a un atributo estático, es necesario utilizar un $ signo. Por ejemplo self::$templates_path
  7. 29

    De este blog:

    • self hace referencia a la clase actual
    • self puede ser utilizado para llamar a las funciones estáticas y de referencia variables de miembro estático
    • self puede ser utilizado dentro de las funciones estáticas
    • self también puede desactivar el comportamiento polimórfico, pasando por alto la vtable
    • $this se refiere al objeto actual
    • $this puede ser utilizado para llamar a las funciones estáticas
    • $this no debe ser utilizado para llamar a los miembros estáticos variables. Uso self lugar.
    • $this no puede ser utilizado dentro de las funciones estáticas
  8. 25

    En PHP, utiliza el auto de palabras clave para acceder a propiedades y métodos estáticos.

    El problema es que puede reemplazar $this->method() con self::method()en cualquier lugar, sin importar si method() se declara estática o no. Así que uno debe utilizar?

    Considerar este código:

    class ParentClass {
        function test() {
            self::who();    //will output 'parent'
            $this->who();   //will output 'child'
        }
    
        function who() {
            echo 'parent';
        }
    }
    
    class ChildClass extends ParentClass {
        function who() {
            echo 'child';
        }
    }
    
    $obj = new ChildClass();
    $obj->test();

    En este ejemplo, self::who() siempre la salida de ‘padre de familia’, mientras que $this->who() dependerá de qué clase de objeto.

    Ahora podemos ver que el auto se refiere a la clase en la que está llamado, mientras $this se refiere a la de la clase del objeto actual.

    Así, usted debe usar sólo cuando $this no está disponible, o cuando usted no desea permitir que los descendientes de las clases para sobrescribir el método actual.

  9. 21

    Dentro de una definición de clase, $this se refiere al objeto actual, mientras que self hace referencia a la clase actual.

    Es necesario referirse a un elemento de clase utilizando self, y se refieren a un objeto elemento mediante $this.

    self::STAT //refer to a constant value
    self::$stat //static variable
    $this->stat //refer to an object variable  
  10. 20

    Aquí hay un ejemplo de uso correcto de $esto y yo para no estático
    y variables de miembro estático:

    <?php
    class X {
        private $non_static_member = 1;
        private static $static_member = 2;
    
        function __construct() {
            echo $this->non_static_member . ' '
               . self::$static_member;
        }
    }
    
    new X();
    ?> 
  11. 20

    Según http://www.php.net/manual/en/language.oop5.static.php no hay $self. Sólo hay $this, que hace referencia a la instancia actual de la clase (objeto), y el auto, que puede ser usado para referirse a los miembros estáticos de una clase. La diferencia entre una instancia de un objeto y una clase entra en juego aquí.

    • Sugerencia: Lea esta respuesta al disparo en el ácido.
  12. 15

    Creo que la cuestión no era si se puede llamar el miembro estático de la clase llamando ClassName::staticMember. La pregunta fue ¿cuál es la diferencia entre el uso de self::classmember y $this->classmember.

    Por ejemplo, ambos de los siguientes ejemplos de trabajo sin ningún tipo de errores, ya sea que utilice self:: o $this->

    class Person{
        private $name;
        private $address;
    
        public function __construct($new_name,$new_address){
            $this->name = $new_name;
            $this->address = $new_address;
        }
    }
    
    class Person{
        private $name;
        private $address;
        public function __construct($new_name,$new_address){
            self::$name = $new_name;
            self::$address = $new_address;
        }
    }
    • Es especialmente divertido que inicia su respuesta con «yo creo que la pregunta no era si se puede llamar el miembro estático de la clase llamando Nombreclase::staticMember. La pregunta fue ¿cuál es la diferencia entre el uso de auto::classmember y $this->classmember» y, a continuación, proceder a mostrar ninguna diferencia en absoluto. De hecho, muestran una instancia de donde las dos opciones funcionan de forma idéntica. -1
    • Sin embargo útil. El ámbito de aplicación es sobre la resolución y esta parte no es clara en el manual de php. Todavía me resulta útil
    • Fatal error: Access to undeclared static property: Person::$name in D:\LAMP\www\test.php on line 16
  13. 15

    self se refiere clase actual(en el que se llama),

    $this se refiere objeto actual.
    Usted puede utilizar estática en lugar de sí mismo.
    Véase el ejemplo:

        class ParentClass {
                function test() {
                        self::which();  //output 'parent'
                        $this->which(); //output 'child'
                }
    
                function which() {
                        echo 'parent';
                }
        }
    
        class ChildClass extends ParentClass {
                function which() {
                        echo 'child';
                }
        }
    
        $obj = new ChildClass();
        $obj->test();

    De salida:
    los padres
    niño

  14. 14

    Como aquí nadie habló acerca de las actuaciones, aquí hay una pequeña referencia que hice (5.6):

     Name     | Time    | Percent  
    ---------- | --------- | ---------  
     $this->  | 0.99163 | 106.23%  
     self::   | 0.96912 | 103.82%  
     static:: | 0.93348 | 100%

    Esos son los resultados de los 2 000 000 de carreras, y aquí está el código que he usado:

    <?php
    
    require '../vendor/autoload.php';
    
    //My small class to do benchmarks
    //All it does is looping over every test x times and record the
    //  time it takes using `microtime(true)`
    //Then, the percentage is calculated, with 100% being the quickest
    //Times are being rouned for outputting only, not to calculate the percentages
    $b = new Tleb\Benchmark\Benchmark(2000000);
    
    class Foo
    {
        public function calling_this()
        {
            $this->called();
        }
    
        public function calling_self()
        {
            self::called();
        }
    
        public function calling_static()
        {
            static::called();
        }
    
        public static function called()
        {
        }
    }
    
    $b->add('$this->',  function () { $foo = new Foo; $foo->calling_this(); });
    $b->add('self::',   function () { $foo = new Foo; $foo->calling_self(); });
    $b->add('static::', function () { $foo = new Foo; $foo->calling_static(); });
    
    $b->run();
    • Llamar no-op función de 2 000 000 de veces dura 1s. Tengo el amor de PHP.
    • Bueno viejo PHP. 🙂 Pero una llamada = 0.001 ms. Es eso malo?
    • Creo que este (y cosas similares) es el por qué de las cosas tales como Orm sentirse lento, a menos que la caché de cosas, y sitio estático generadores son una cosa.
    • Teóricamente no debería de tomar procesador de 1 ciclo de reloj, lo que hace que alrededor de 1 / 2e9 s = 0.5 ns estos días
    • Acabo de volver a leer mi respuesta. Cuidado: es crea la clase demasiado. No sé por qué yo no uso el use palabra clave tbh, pero no tengo PHP ya que rehacer un punto de referencia, y la verdad no me siento como volver a instalarlo.
  15. 14
    • El puntero de objeto $this que se refiere al objeto actual.
    • El valor de la clase de static se refiere al objeto actual.
    • El valor de la clase de self se refiere a la exactitud de la clase fue definido en.
    • El valor de la clase de parent refiere al padre de la exacta clase fue definido en.

    Ver el siguiente ejemplo que muestra la sobrecarga.

    <?php
    
    class A {
    
        public static function newStaticClass()
        {
            return new static;
        }
    
        public static function newSelfClass()
        {
            return new self;
        }
    
        public function newThisClass()
        {
            return new $this;
        }
    }
    
    class B extends A
    {
        public function newParentClass()
        {
            return new parent;
        }
    }
    
    
    $b = new B;
    
    var_dump($b::newStaticClass()); //B
    var_dump($b::newSelfClass()); //A because self belongs to "A"
    var_dump($b->newThisClass()); //B
    var_dump($b->newParentClass()); //A
    
    
    class C extends B
    {
        public static function newSelfClass()
        {
            return new self;
        }
    }
    
    
    $c = new C;
    
    var_dump($c::newStaticClass()); //C
    var_dump($c::newSelfClass()); //C because self now points to "C" class
    var_dump($c->newThisClass()); //C
    var_dump($b->newParentClass()); //A because parent was defined *way back* in class "B"

    La mayoría del tiempo que se desea hacer referencia a la clase actual, que es por qué utilizar static o $this. Sin embargo, hay veces cuando usted necesidad self porque desea que la clase original, independientemente de lo que la extiende. (Muy, Muy rara vez)

  16. 13

    Cuando self se utiliza con el :: operador se hace referencia a la clase actual, que puede realizarse tanto en estáticos y no estáticos contextos. $this se refiere al objeto en sí mismo. Además, es perfectamente legal el uso de $this llamar a métodos estáticos (pero no para referirse a los campos).

  17. 7

    $this hace referencia a la clase actual de objeto, self hace referencia a la clase actual (No objeto). La clase es el modelo del objeto. Para definir una clase, sino de construir objetos.

    Entonces, en otras palabras, el uso self for static y this for none-static members or methods.

    también en los niños/padres escenario self /parent es principalmente utilizado para identificar a niños y padres de familia miembros de la clase y los métodos.

  18. 7

    Además desde $this:: no se ha discutido todavía.

    Sólo para fines informativos, a partir de PHP 5.3 cuando se trata con instancias de objetos para obtener la corriente alcance el valor, en oposición al uso de static::, se puede utilizar como alternativa $this:: como así.

    http://ideone.com/7etRHy

    class Foo
    {
        const NAME = 'Foo';
    
        //Always Foo::NAME (Foo) due to self
        protected static $staticName = self::NAME;
    
        public function __construct()
        {
            echo $this::NAME;
        }
    
        public function getStaticName()
        {
           echo $this::$staticName;
        }
    }
    
    class Bar extends Foo
    {
        const NAME = 'FooBar';
    
        /**
         * override getStaticName to output Bar::NAME
         */
        public function getStaticName()
        {
            $this::$staticName = $this::NAME;
            parent::getStaticName();
        }
    }
    
    $foo = new Foo; //outputs Foo
    $bar = new Bar; //outputs FooBar
    $foo->getStaticName(); //outputs Foo
    $bar->getStaticName(); //outputs FooBar
    $foo->getStaticName(); //outputs FooBar

    Utilizando el código anterior no es habitual o una práctica recomendada, pero es simplemente para ilustrar su uso, y es la de actuar como un «¿sabes?», en referencia a la publicación original que se trate.

    También representa el uso de $object::CONSTANT por ejemplo echo $foo::NAME; frente a $this::NAME;

  19. 7

    Me encontré con la misma pregunta y la respuesta es simple:

    • $this requiere una instancia de la clase
    • self:: no

    Cuando usted está utilizando métodos estáticos o estática atributos y quieres llamar a ellos sin tener un objeto de la clase instanciada necesita utilizar self: de llamar, porque $this siempre se requiere en el objeto a ser creado.

  20. 5

    Uso self si desea llamar a un método de una clase sin la creación de un objeto o instancia de esa clase, con el consiguiente ahorro RAM (a veces uso el auto para ese propósito). En otras palabras, es en realidad una llamada a un método de forma estática. Uso this por objeto perspectiva.

  21. 2

    Caso 1: el Uso de self puede ser utilizado para las constantes de clase

     clase classA { 
    const FIXED_NUMBER = 4; 
    self::POUNDS_TO_KILOGRAMS 
    } 
    

    Si quieres llamarlo fuera de la clase, el uso de classA::POUNDS_TO_KILOGRAMS para tener acceso a las constantes

    Caso 2: Para las propiedades estáticas

    clase classC { 
    public function __construct() { 
    self::$_counter++; $this->num = self::$_counter; 
    } 
    } 
    
  22. 1

    De acuerdo a php.net hay tres palabras clave especiales en este contexto: self, parent y static. Se utilizan para acceder a las propiedades o métodos de dentro de la definición de clase.

    $this, por otro lado, se utiliza para llamar a una instancia y métodos de cualquier clase, mientras que la clase es accesible.

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea