Cosa significa la variabile $ this in PHP?

Vedo la variabile $thisin PHP tutto il tempo e non ho idea di cosa sia usata. Non l'ho mai usato personalmente.

Qualcuno può dirmi come funziona la variabile $thisin PHP?

È un riferimento all'oggetto corrente, è più comunemente usato nel codice orientato agli oggetti.

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

Esempio:

<?php
class Person {
    public $name;

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

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

Memorizza la stringa "Jack" come proprietà dell'oggetto creato.

Il modo migliore per conoscere la $thisvariabile in PHP è provarla con l'interprete in vari contesti:

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 ->

Quindi la $thispseudo-variabile ha il metodo e le proprietà dell'oggetto corrente. Una cosa del genere è utile perché ti consente di accedere a tutte le variabili membro e ai metodi membro all'interno della classe. Per esempio:

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;
    }
}

$thisè un riferimento a un PHP Objectche è stato creato dall'interprete per te, che contiene un array di variabili.

Se chiami $thisall'interno di un metodo normale in una classe normale, $thisrestituisce l'Oggetto (la classe) a cui appartiene quel metodo.

È possibile $thische non sia definito se il contesto non ha un oggetto genitore.

php.net ha una grande pagina che parla della programmazione PHP orientata agli oggetti e di come $thissi comporta a seconda del contesto. https://www.php.net/manual/en/language.oop5.basic.php

Conosco la sua vecchia domanda, comunque un'altra spiegazione esatta su $ questo . $ viene utilizzato principalmente per fare riferimento alle proprietà di una classe.

Esempio:

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
   }
}

produzione:

function variable

member variable

È il modo per fare riferimento a un'istanza di una classe dall'interno di se stessa, come molti altri linguaggi orientati agli oggetti.

Dai documenti PHP :

La pseudo-variabile $ this è disponibile quando un metodo viene chiamato dall'interno di un contesto di oggetto. $ questo è un riferimento all'oggetto chiamante (di solito l'oggetto a cui appartiene il metodo, ma forse un altro oggetto, se il metodo viene chiamato staticamente dal contesto di un oggetto secondario).

Vediamo cosa succede se non usiamo $ this e proviamo ad avere variabili di istanza e argomenti del costruttore con lo stesso nome con il seguente frammento di codice

<?php

class Student {
    public $name;

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

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

?>

Non fa eco a niente ma

<?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;

?>

questo fa eco 'Tom'

quando crei una classe hai (in molti casi) variabili e metodi di istanza (ovvero funzioni). $ this accede a quelle variabili di istanza in modo che le tue funzioni possano prendere quelle variabili e fare ciò di cui hanno bisogno per fare quello che vuoi con loro.

un'altra versione dell'esempio di 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

$thisè un riferimento all'oggetto chiamante (di solito l'oggetto a cui appartiene il metodo, ma forse un altro oggetto, se il metodo viene chiamato staticamente dal contesto di un oggetto secondario).

$ questa è una variabile speciale e si riferisce allo stesso oggetto, ad es. si.

in realtà fa riferimento all'istanza della classe corrente

ecco un esempio che cancellerà l'affermazione di cui sopra

<?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/>";
  }
}
?> 

Questa è una spiegazione lunga e dettagliata. Spero che questo possa aiutare i principianti. Lo renderò molto semplice.

Per prima cosa, creiamo una classe

<?php 

class Class1
{
    
}

Puoi omettere il tag di chiusura php ?>se stai usando solo codice php.

Ora aggiungiamo proprietà e un metodo all'interno 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 proprietà è solo una semplice variabile, ma le diamo il nome proprietà perché è all'interno di una classe.

Il metodo è solo una semplice funzione, ma diciamo metodo perché è anche all'interno di una classe.

La publicparola chiave significa che è possibile accedere al metodo oa una proprietà in qualsiasi punto dello script.

Ora, come possiamo usare le proprietà e il metodo all'interno Class1?

La risposta è creare un'istanza o un oggetto, pensare a un oggetto come una copia della classe.

<?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);

Abbiamo creato un oggetto, che è $object1, che è una copia di Class1con tutto il suo contenuto. E abbiamo scaricato tutti i contenuti $object1dell'utilizzo var_dump().

Questo ti darà

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

Quindi tutti i contenuti di Class1sono in $object1, tranne Method1, non so perché i metodi non vengono visualizzati durante il dumping degli oggetti.

E se volessimo $property1solo accedere . È semplice, lo facciamo var_dump($object1->property1);, abbiamo appena aggiunto ->property1, l'abbiamo indicato.

possiamo anche accedere Method1(), lo facciamo var_dump($object1->Method1());.

Supponiamo ora che io voglia accedere $property1dall'interno Method1(), lo farò

<?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()); 

abbiamo creato $object2 = new Class1;che è una nuova copia di Class1o possiamo dire un'istanza. Quindi abbiamo indicato property1da$object2

return $object2->property1;

Questo verrà stampato string(15) "I am property 1"nel browser.

Ora invece di farlo dentro Method1()

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

Lo facciamo

return $this->property1;

L' $thisoggetto viene utilizzato all'interno della classe per fare riferimento alla classe stessa.

È un'alternativa per creare un nuovo oggetto e poi restituirlo in questo modo

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

Un altro esempio

<?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());

Abbiamo creato 2 proprietà contenenti numeri interi e poi le abbiamo aggiunte e inserito il risultato $this->result.

Non dimenticare quello

$this->property1= $property1=119

hanno lo stesso valore .. ecc

Spero che questo spieghi l'idea.

Questa serie di video ti aiuterà molto in OOP

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

Si riferisce all'istanza della classe corrente, come ha detto meder .

Vedi la documentazione PHP . È spiegato sotto il primo esempio.