¿Qué significa la variable $ this en PHP?

Veo la variable $thisen PHP todo el tiempo y no tengo idea para qué se usa. Nunca lo he usado personalmente.

¿Alguien puede decirme cómo funciona la variable $thisen PHP?

Es una referencia al objeto actual, se usa más comúnmente en código orientado a objetos.

• Referencia: http://www.php.net/manual/en/language.oop5.basic.php
• Cartilla: http://www.phpro.org/tutorials/Object-Oriented-Programming-with-PHP.html

Ejemplo:

<?php
class Person {
    public $name;

    function __construct( $name ) {
        $this->name = $name;
    }
};

$jack = new Person('Jack');
echo $jack->name;

Esto almacena la cadena 'Jack' como una propiedad del objeto creado.

La mejor manera de aprender sobre la $thisvariable en PHP es probarla con el intérprete en varios contextos:

print isset($this);              //true,   $this exists
print gettype($this);            //Object, $this is an object 
print is_array($this);           //false,  $this isn't an array
print get_object_vars($this);    //true,   $this's variables are an array
print is_object($this);          //true,   $this is still an object
print get_class($this);          //YourProject\YourFile\YourClass
print get_parent_class($this);   //YourBundle\YourStuff\YourParentClass
print gettype($this->container); //object
print_r($this);                  //delicious data dump of $this
print $this->yourvariable        //access $this variable with ->

Entonces, la $thispseudovariable tiene las propiedades y el método del objeto actual. Esto es útil porque le permite acceder a todas las variables miembro y métodos miembros dentro de la clase. Por ejemplo:

Class Dog{
    public $my_member_variable;                             //member variable

    function normal_method_inside_Dog() {                   //member method

        //Assign data to member variable from inside the member method
        $this->my_member_variable = "whatever";

        //Get data from member variable from inside the member method.
        print $this->my_member_variable;
    }
}

$thises una referencia a un PHP Objectque fue creado por el intérprete para usted, que contiene una matriz de variables.

Si llama $thisdentro de un método normal en una clase normal, $thisdevuelve el Objeto (la clase) a la que pertenece ese método.

Es posible $thisque no esté definido si el contexto no tiene un objeto padre.

php.net tiene una gran página que habla sobre la programación orientada a objetos PHP y cómo se $thiscomporta según el contexto. https://www.php.net/manual/en/language.oop5.basic.php

Sé su vieja pregunta, de todos modos otra explicación exacta sobre $ this . $ esto se usa principalmente para referir propiedades de una clase.

Ejemplo:

Class A
{
   public $myname;    //this is a member variable of this class

function callme() {
    $myname = 'function variable';
    $this->myname = 'Member variable';
    echo $myname;                  //prints function variable
    echo $this->myname;              //prints member variable
   }
}

salida:

function variable

member variable

Es la forma de hacer referencia a una instancia de una clase desde dentro de sí misma, al igual que muchos otros lenguajes orientados a objetos.

De los documentos de PHP :

La pseudovariable $ this está disponible cuando se llama a un método desde el contexto de un objeto. $ esta es una referencia al objeto que llama (generalmente el objeto al que pertenece el método, pero posiblemente otro objeto, si el método se llama estáticamente desde el contexto de un objeto secundario).

Veamos qué sucede si no usamos $ this e intentamos tener variables de instancia y argumentos de constructor con el mismo nombre con el siguiente fragmento de código

<?php

class Student {
    public $name;

    function __construct( $name ) {
        $name = $name;
    }
};

$tom = new Student('Tom');
echo $tom->name;

?>

No hace eco nada más que

<?php

class Student {
    public $name;

    function __construct( $name ) {
        $this->name = $name; // Using 'this' to access the student's name
    }
};

$tom = new Student('Tom');
echo $tom->name;

?>

esto se hace eco de 'Tom'

cuando crea una clase, tiene (en muchos casos) variables de instancia y métodos (también conocidos como funciones). $ this accede a esas variables de instancia para que sus funciones puedan tomar esas variables y hacer lo que necesitan para hacer lo que quiera con ellas.

otra versión del ejemplo de Meder:

class Person {

    protected $name;  //can't be accessed from outside the class

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}
// this line creates an instance of the class Person setting "Jack" as $name.  
// __construct() gets executed when you declare it within the class.
$jack = new Person("Jack"); 

echo $jack->getName();

Output:

Jack

$thises una referencia al objeto de llamada (normalmente el objeto al que pertenece el método, pero posiblemente otro objeto, si el método se llama estáticamente desde el contexto de un objeto secundario).

$ esta es una variable especial y se refiere al mismo objeto, es decir. sí mismo.

en realidad se refiere a la instancia de la clase actual

aquí hay un ejemplo que aclarará la declaración anterior

<?php
 class Books {
  /* Member variables */
  var $price;
  var $title;

  /* Member functions */
  function setPrice($par){
     $this->price = $par;
  }

  function getPrice(){
     echo $this->price ."<br/>";
  }

  function setTitle($par){
     $this->title = $par;
  }

  function getTitle(){
     echo $this->title ." <br/>";
  }
}
?> 

Esta es una explicación larga y detallada. Espero que esto ayude a los principiantes. Lo haré muy simple.

Primero, creemos una clase

<?php 

class Class1
{
    
}

Puede omitir la etiqueta de cierre de php ?>si solo usa código php.

Ahora agreguemos propiedades y un método dentro Class1.

<?php 

class Class1
{
    public $property1 = "I am property 1";
    public $property2 = "I am property 2";

    public function Method1()
    {
        return "I am Method 1";
    }
}

La propiedad es solo una variable simple, pero le damos el nombre de propiedad porque está dentro de una clase.

El método es solo una función simple, pero decimos método porque también está dentro de una clase.

los public palabra clave significa que se puede acceder al método o propiedad en cualquier parte del script.

Ahora, ¿cómo podemos usar las propiedades y el método dentro Class1 ?

La respuesta es crear una instancia o un objeto, piense en un objeto como una copia de la clase.

<?php 

class Class1
{
    public $property1 = "I am property 1";
    public $property2 = "I am property 2";

    public function Method1()
    {
        return "I am Method 1";
    }
}

$object1 = new Class1;
var_dump($object1);

Creamos un objeto, que es $object1, que es una copia de Class1con todo su contenido. Y tiramos todo el contenido de $object1usarvar_dump() .

Esto te dará

object(Class1)#1 (2) { ["property1"]=> string(15) "I am property 1" ["property2"]=> string(15) "I am property 2" }

Así que todos los contenidos de Class1están $object1incluidos, exceptoMethod1 , no sé por qué los métodos no se muestran al volcar objetos.

Ahora, ¿qué pasa si queremos acceder $property1solo. Es simple, lo hacemos var_dump($object1->property1);, acabamos de agregar->property1 , lo señalamos.

también podemos acceder Method1(), lo hacemosvar_dump($object1->Method1()); .

Ahora suponga que quiero acceder $property1desde adentro Method1(), haré esto

<?php 

class Class1
{
    public $property1 = "I am property 1";
    public $property2 = "I am property 2";

    public function Method1()
    {   
        $object2 = new Class1;
        return $object2->property1;
    }
}

$object1 = new Class1;
var_dump($object1->Method1()); 

creamos $object2 = new Class1;que es una nueva copia de Class1o podemos decir una instancia. Luego señalamos property1desde$object2

return $object2->property1;

Esto se imprimirá string(15) "I am property 1"en el navegador.

Ahora en lugar de hacer esto por dentro Method1()

$object2 = new Class1;
return $object2->property1;

Nosotros hacemos esto

return $this->property1;

El $thisobjeto se usa dentro de la clase para referirse a la propia clase.

Es una alternativa para crear un nuevo objeto y luego devolverlo así

$object2 = new Class1;
return $object2->property1;

Otro ejemplo

<?php 

class Class1
{
    public $property1 = 119;
    public $property2 = 666;
    public $result;

    public function Method1()
    {   
        $this->result = $this->property1 + $this->property2;
        return $this->result;
    }
}

$object1 = new Class1;
var_dump($object1->Method1());

Creamos 2 propiedades que contienen números enteros y luego las agregamos y ponemos el resultado en $this->result.

No olvides eso

$this->property1= $property1=119

tienen el mismo valor .. etc.

Espero que eso explique la idea.

Esta serie de videos te ayudará mucho en OOP

https://www.youtube.com/playlist?list=PLe30vg_FG4OSEHH6bRF8FrA7wmoAMUZLv

Se refiere a la instancia de la clase actual, como dijo Meder .

Consulte los documentos de PHP . Se explica en el primer ejemplo.