Utilisation de soi ou $ ceci en php

Le soi mot-clé et $ ceci les variables sont utilisées à deux fins différentes dans la programmation orientée objet PHP. Ceux-ci sont principalement utilisés pour représenter les membres de la classe d'une classe particulière. Le soi Le mot-clé est utilisé pour représenter les membres actuels et statiques de la classe. Le $ ceci La variable est utilisée pour représenter l'objet actuel et les membres non statiques de la classe. Les fonctionnalités et les utilisations des mots-clés et $ cette variable en classe PHP sont expliqués dans ce tutoriel.

Mots-clés autonomes:

Caractéristiques:
Les fonctionnalités de ce mot-clé sont mentionnées ci-dessous:

• Aucun symbole spécial n'est nécessaire pour utiliser ce mot-clé.
• Il est utilisé avec l'opérateur de résolution de portée (: :) de PHP.
• Il ne fait référence à aucune instance de la classe.
• Il représente les membres statiques de la classe qui sont utilisés par toutes les instances de classe.
• Il ne nécessite pas d'initier un objet.

Syntaxe:
self :: $ static_member

Exemple 1: Utilisation du mot-clé et appelez la fonction statique à l'aide de l'objet

L'exemple suivant montre l'utilisation du soi mot-clé pour accéder aux membres statiques de n'importe quelle classe. Créez un fichier PHP avec le code suivant qui contient une classe nommée «Visiteur», avec une variable statique et une fonction. Lorsqu'un objet de cette classe crée, la valeur initiale de la variable statique sera imprimée. Le incrément_counter () La fonction incrémentera la valeur de la variable statique de 1. Le soi Le mot-clé est utilisé dans le script pour lire et incrémenter la valeur de la variable statique.

Classe Visiteur
// définir un membre statique
COMPRESSION STATIQUE PRIVÉE = 1;
// définir le constructeur à la valeur du membre statique
fonction __construct ()
Echo "La valeur initiale est:".Self :: $ compteur."
"

/ * Définir une fonction pour incrémenter la valeur du membre statique
et renvoyez la valeur à l'appelant * /
Fonction statique publique incrément_counter ()
self :: $ Counter ++;
Retour "La valeur actuelle est:".self :: $ compteur;


// Créer un objet de la classe
$ object = new Visitor ();
// appelle la fonction statique
echo $ object-> incrément_counter ()."
"
?>

Sortir:
La sortie suivante apparaîtra après l'exécution du script. La valeur initiale de $ compteur est 1, qui devient 2 après l'augmentation.

Exemple-2: Utilisation du mot-clé et appelez directement la fonction statique

Dans l'exemple suivant, le livre La classe contient trois variables statiques et lorsque l'objet de cette classe est créé, ces variables seront initialisées avec trois valeurs en utilisant le soi mot-clé. Lorsque la méthode addbook () appellera à l'aide de l'objet, la méthode statique, afficher(), appellera en utilisant le soi mot-clé.

Comment les membres statiques de la classe sont accessibles sans créer d'objet est également affiché dans ce tutoriel.

livre de classe

// déclare un membre statique
Public Static $ id;
Public Static $ bookname;
public statique $ Stock_qty;
// Déclarer le constructeur
Fonction publique __construct ($ id, $ bookname, $ Stock_qyt)

self :: $ id = $ id;
self :: $ bookName = $ bookName;
self :: $ Stock_qty = $ stocke_qty;

// Déclarer la méthode régulière
Addbook de la fonction publique ($ QTY)

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

// Déclarer la méthode statique
affichage de fonction statique publique ()

Echo "ID de livre:".self :: $ id."
"
Echo "Nom du livre:".self :: $ bookname."
"
Echo "Stock actuel:".self :: $ Stock_qty."
"


// initialise les variables statiques à l'aide du constructeur
$ bookObject = nouveau livre ('123', 'Learning Php', 120);
// appelle la méthode statique en utilisant
$ bookObject-> Addbook (30);
écho "------------------------------
"
// appelle directement la méthode statique
Book :: Display ();
?>

Sortir:
La sortie suivante apparaîtra après l'exécution du script. La méthode affichage () est appelée deux fois ici. Il est appelé en utilisant le mot de même auto-clé et directement avec le nom de la classe.

$ cette variable:

$ ceci La variable est principalement utilisée dans la programmation orientée objet pour définir une référence à l'objet actuel de la classe. Il est utilisé pour se référer au membre non statique et à la fonction de la classe uniquement, sinon il générera une erreur. Les utilisations de cette variable sont présentées dans la partie suivante de ce tutoriel.

Exemple-3: utilisation de la $ cette variable pour accéder au membre de la classe privée

Dans l'exemple suivant, le consommateur La classe est créée avec deux membres privés, un constructeur et une méthode. Les membres privés de la classe sont accessibles à l'intérieur de la classe uniquement. Le $ ceci La variable est utilisée ici pour définir et obtenir les valeurs des membres privés. Lorsque l'objet de la classe est créé, les membres de la classe seront initialisés à l'intérieur du constructeur. Quand le nom et prénom() la méthode sera appelée, alors les valeurs des membres privés seront imprimées à l'aide du $ ceci variable.

classe Client
// Déclarer un membre privé
Private $ FirstName;
Privé $ LastName;
// Déclarer l'instructeur
fonction publique __construct ($ fn, $ ln)

$ this-> FirstName = $ fn;
$ this-> lastName = $ ln;

// imprime le nom complet du client
fonction publique fullName ()
Echo "Le nom du client est:".$ this-> FirstName."".$ this-> LastName;


// Créer un objet
$ client = nouveau client («mohammed», «rafiq»);
// appelle la fonction publique fullname ()
$ client-> fullName ();
?>

Sortir:
La sortie suivante apparaîtra après l'exécution du script.

Exemple-4: utilisation à la fois du mot-clé et $ cette variable

L'exemple suivant montre l'utilisation des deux le soi mot-clé et $ ceci variable. L'employé La classe contient un membre statique et privé. Le soi Le mot-clé est utilisé pour accéder au membre statique et le $ ceci La variable est utilisée pour accéder au membre non statique dans le script.

Employé de classe
// déclare un membre statique
Nom $ statique public;
// déclare un membre privé
salaire privé $;
// Déclarer le constructeur
fonction publique __construct ($ name, $ salaire)

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

// imprime le nom complet du client
Détails de la fonction publique ()
Echo "Nom de l'employé:".self :: $ name."
"
Echo "Salaire:".$ this-> salaire;


// Créer un objet
$ emp = nouvel employé («Mir Sabbir», 500000);
// appelle la fonction publique fullname ()
$ emp-> Détails ();
?>

Sortir:
La sortie suivante apparaîtra après l'exécution du script. Ici, le nom de l'employé est imprimé en utilisant le soi mot-clé, et le salaire est imprimé en utilisant le $ ceci variable.

Didacticiel vidéo

Conclusion:

Le soi mot-clé et $ ceci les variables sont utilisées à différentes fins à l'intérieur de la classe. Les deux sont utilisés pour accéder aux membres de la classe. Les utilisations du soi mot-clé et $ ceci Les variables sont présentées en utilisant quatre exemples différents dans ce tutoriel, pour aider le lecteur à connaître l'utilisation du soi mot-clé et $ ceci variable, ainsi que les appliquer correctement dans leur script PHP.