Uso di sé o $ questo in PHP

IL se stesso parola chiave e $ questo La variabile viene utilizzata per due scopi diversi nella programmazione orientata agli oggetti PHP. Questi sono usati principalmente per rappresentare i membri della classe di una particolare classe. IL se stesso La parola chiave viene utilizzata per rappresentare i membri attuali e statici della classe. IL $ questo La variabile viene utilizzata per rappresentare l'oggetto corrente e i membri non statici della classe. Le caratteristiche e gli usi delle parole chiave e $ questa variabile nella classe PHP sono spiegate in questo tutorial.

Parole chiave di sé:

Caratteristiche:
Le caratteristiche di questa parola chiave sono menzionate di seguito:

• Non è necessario un simbolo speciale per utilizzare questa parola chiave.
• Viene utilizzato con l'operatore di risoluzione dell'ambito (: :) di PHP.
• Non si riferisce a nessun istanza della classe.
• Rappresenta i membri statici della classe utilizzati da tutte le istanze di classe.
• Non richiede di avviare un oggetto.

Sintassi:
Self :: $ static_member

Esempio 1: utilizzare la parola chiave di sé e chiamare la funzione statica usando l'oggetto

L'esempio seguente mostra l'uso del se stesso Parole chiave per accedere ai membri statici di qualsiasi classe. Crea un file PHP con il seguente codice che contiene una classe denominata "visitatore", con una variabile statica e una funzione. Quando si crea qualsiasi oggetto di questa classe, verrà stampato il valore iniziale della variabile statica. IL increment_counter () La funzione increverà il valore della variabile statica di 1. IL se stesso La parola chiave viene utilizzata nello script per leggere e incrementare il valore della variabile statica.

Visitatore di classe
// Definisci un membro statico
statico privato $ counter = 1;
// Definire il costruttore al valore del membro statico
funzione __construct ()
echo "Il valore iniziale è:".Self :: $ Counter."
";

/*Definire una funzione per incrementare il valore del membro statico
e restituire il valore al chiamante*/
Funzione statica pubblica Increment_Counter ()
Self :: $ Counter ++;
restituire "Il valore corrente è:".Self :: $ Counter;


// Crea oggetto della classe
$ object = new Visitor ();
// Chiama la funzione statica
Echo $ Object-> increment_counter ()."
";
?>

Produzione:
Il seguente output apparirà dopo aver eseguito lo script. Il valore iniziale di $ contatore è 1, che diventa 2 dopo l'incremento.

Esempio 2: utilizzare la parola chiave di sé e chiamare direttamente la funzione statica

Nel seguente esempio, il libro La classe contiene tre variabili statiche e quando viene creato l'oggetto di questa classe, queste variabili verranno inizializzate con tre valori utilizzando il sé parola chiave. Quando il metodo AddBook () chiamerà usando l'oggetto, il metodo statico, Schermo(), chiamerà usando il file se stesso parola chiave.

In questo tutorial è mostrato anche come i membri statici della classe senza creare alcun oggetto.

libro di classe

// dichiara membri statici
statico pubblico $ id;
Public Static $ Bookname;
pubblico statico $ stock_qty;
// dichiara costruttore
Funzione pubblica __Construct ($ id, $ bookname, $ stock_qyt)

self :: $ id = $ id;
self :: $ bookname = $ bookname;
self :: $ stock_qty = $ stock_qty;

// dichiara metodo regolare
Funzione pubblica AddBook ($ QTY)

self :: $ stock_qty += $ qty;
self :: display ();

// dichiara metodo statico
Display di funzioni statiche pubbliche ()

Echo "ID libro:".Self :: $ id."
";
Echo "Nome libro:".self :: $ bookname."
";
Echo "Stock corrente:".Self :: $ stock_qty."
";


// Inizializza le variabili statiche usando il costruttore
$ bookObject = new Book ('123', 'Learning php', 120);
// chiama il metodo statico usando la parola chiave
$ bookobject-> addBook (30);
eco "------------------------------
";
// chiama il metodo statico direttamente
Libro :: display ();
?>

Produzione:
Il seguente output apparirà dopo aver eseguito lo script. Il metodo Display () è chiamato due volte qui. Viene chiamato usando la parola chiave di sé e direttamente con il nome della classe.

$ questa variabile:

$ questo La variabile viene utilizzata principalmente nella programmazione orientata agli oggetti per impostare un riferimento all'oggetto corrente della classe. Viene utilizzato per fare riferimento al membro non statico e alla funzione della classe solo altrimenti genererà un errore. Gli usi di questa variabile sono mostrati nella parte successiva di questo tutorial.

Esempio-3: utilizzo di $ questa variabile per accedere al membro della classe privata

Nel seguente esempio, il cliente La classe è creata con due membri privati, un costruttore e un metodo. I membri privati ​​della classe sono accessibili solo all'interno della classe. IL $ questo La variabile viene utilizzata qui per impostare e ottenere i valori dei membri privati. Quando viene creato l'oggetto della classe, i membri della classe verranno inizializzati all'interno del costruttore. Quando il nome e cognome() verrà chiamato il metodo, quindi i valori dei membri privati ​​verranno stampati utilizzando il $ questo variabile.

Cliente di classe
// dichiara membro privato
privato $ firstname;
privato $ lastname;
// dichiara istruttore
funzione pubblica __construct ($ fn, $ ln)

$ this-> firstName = $ fn;
$ this-> lastname = $ ln;

// Stampa il nome full del cliente
funzione pubblica fullName ()
echo "Il nome del cliente è:".$ this-> firstname."".$ this-> lastname;


// Crea oggetto
$ customer = new Customer ('Mohammed', 'Rafiq');
// Chiama la funzione pubblica fullName ()
$ customer-> fullname ();
?>

Produzione:
Il seguente output apparirà dopo aver eseguito lo script.

Esempio-4: uso sia della parola chiave e $ questa variabile

L'esempio seguente mostra l'uso di entrambi il sé parola chiave e $ questo variabile. Il dipendente La classe contiene un membro statico e privato. IL se stesso La parola chiave viene utilizzata per accedere al membro statico e $ questo La variabile viene utilizzata per accedere al membro non statico nello script.

dipendente di classe
// dichiara un membro statico
Public Static $ Nome;
// dichiara un membro privato
Stipendio privato $;
// dichiara il costruttore
funzione pubblica __construct ($ nome, $ stipendio)

self :: $ name = $ name;
$ this-> stipendio = $ stipendio;

// Stampa il nome full del cliente
dettagli della funzione pubblica ()
Echo "Nome dipendente:".Self :: $ Nome."
";
Echo "Stipendio:".$ this-> stipendio;


// Crea oggetto
$ emp = new dipendente ('mir sabbir', 500000);
// Chiama la funzione pubblica fullName ()
$ emp-> dettagli ();
?>

Produzione:
Il seguente output apparirà dopo aver eseguito lo script. Qui, il nome del dipendente è stampato utilizzando il sé parola chiave e lo stipendio viene stampato utilizzando il $ questo variabile.

Tutorial video

Conclusione:

Il sé parola chiave e $ questo La variabile viene utilizzata per scopi diversi all'interno della classe. Entrambi sono usati per accedere ai membri della classe. Gli usi del se stesso parola chiave e $ questo Le variabili sono mostrate utilizzando quattro diversi esempi in questo tutorial, per aiutare il lettore a conoscere l'uso del se stesso parola chiave e $ questo variabile, oltre ad applicarli correttamente nel loro script PHP.