16 modèles de conception PHP introduits
Cet article partage principalement avec vous une introduction à 16 modèles de conception PHP. L'article implique quelques diagrammes de classes UML. Pour une meilleure compréhension, vous pouvez d'abord lire les diagrammes de classes UML. J'espère que cela aide tout le monde.
1. Modèle d'usine
Le modèle d'usine peut être divisé en trois types de modèles : modèle d'usine simple, modèle de méthode d'usine, modèle d'usine abstrait
1.
Également connu sous le nom de modèle de méthode Static Factory, il appartient au modèle de création de classe. Dans le modèle d'usine simple, les instances de différentes classes peuvent être renvoyées en fonction de différents paramètres. Le modèle de fabrique simple définit spécifiquement une classe responsable de la création d'instances d'autres classes. Les instances créées ont généralement une classe parent commune.
Rôle :
Factory类：负责创建具体产品的实例 Product类：抽象产品类，定义产品子类的公共接口 ConcreteProduct 类：具体产品类，实现Product父类的接口功能，也可添加自定义的功能
Diagramme de classes UML : 
Exemple de code :
<?php //简单工厂模式class Cat{
function __construct()
{
echo "I am Cat class <br>";
}
}class Dog{
function __construct()
{
echo "I am Dog class <br>";
}
}class Factory{
public static function CreateAnimal($name){
if ($name == 'cat') { return new Cat();
} elseif ($name == 'dog') { return new Dog();
}
}
}$cat = Factory::CreateAnimal('cat');$dog = Factory::CreateAnimal('dog');Modèle d'usine simple le plus grand L'avantage est que la création d'objets et l'utilisation d'objets sont séparées, et la création d'objets est confiée à une classe d'usine spécialisée. Cependant, son plus grand inconvénient est que la classe d'usine n'est pas assez flexible. L'ajout de nouveaux produits spécifiques nécessite des modifications. le code logique de jugement de la classe d'usine, et lorsqu'il y a de nombreux produits, le code de méthode d'usine sera très complexe.
2. Modèle de méthode d'usine
Dans ce modèle, en définissant une classe d'usine de base abstraite et en définissant une interface pour créer des objets de produit, le travail de création d'instances de produit spécifiques est reporté à ses sous-classes d'usine. L'avantage de ceci est que la classe principale se concentre uniquement sur la définition de l'interface de la classe d'usine et que les instances de produit spécifiques sont laissées à la sous-classe d'usine spécifique pour la création. Lorsque le système doit ajouter un nouveau produit, il n'est pas nécessaire de modifier le code système existant. Il vous suffit d'ajouter une classe de produit spécifique et sa sous-classe d'usine correspondante. Cela rend le système plus évolutif et conforme au principe d'ouverture et de fermeture. de programmation orientée objet ;
Rôle :
Product：抽象产品类 ConcreteProduct：具体产品类 Factory：抽象工厂类 ConcreteFactory：具体工厂类
Diagramme de classes UML : 
Écrivez la description de l'image ici
Exemple de code :
<?php interface Animal{
public function run();
public function say();}class Cat implements Animal{
public function run(){
echo "I ran slowly <br>";
} public function say(){
echo "I am Cat class <br>";
}
}class Dog implements Animal{
public function run(){
echo "I'm running fast <br>";
} public function say(){
echo "I am Dog class <br>";
}
}abstract class Factory{
abstract static function createAnimal();}class CatFactory extends Factory{
public static function createAnimal()
{
return new Cat();
}
}class DogFactory extends Factory{
public static function createAnimal()
{
return new Dog();
}
}$cat = CatFactory::createAnimal();$cat->say();$cat->run();$dog = DogFactory::createAnimal();$dog->say();$dog->run();Factory Le modèle de méthode est une abstraction et une extension supplémentaires du modèle d'usine simple. Grâce à l'utilisation du polymorphisme orienté objet, le modèle de méthode d'usine conserve les avantages du modèle d'usine simple et surmonte ses inconvénients. Dans le modèle de méthode d'usine, la classe d'usine principale n'est plus responsable de la création de tous les produits, mais laisse le travail de création spécifique aux sous-classes. Cette classe principale est uniquement responsable de fournir l'interface qu'une usine spécifique doit implémenter et n'est pas responsable des détails de la façon dont la classe de produit est instanciée. Cela permet au modèle de méthode d'usine de permettre au système d'introduire de nouveaux produits sans modifier l'usine. rôle.
3. Abstract Factory Pattern
Fournit une interface pour créer une série d'objets liés ou interdépendants sans spécifier leurs classes spécifiques. Le modèle d'usine abstrait, également connu sous le nom de modèle Kit, est un modèle de création d'objets.
Ce modèle est une extension supplémentaire du modèle de méthode d'usine. Dans le modèle de méthode d'usine, une usine spécifique est responsable de la production d'un type spécifique de produit, c'est-à-dire une relation un-à-un. Cependant, si une usine spécifique doit produire plusieurs objets de produit, alors le modèle d'usine abstrait est nécessaire. à utiliser.
Afin de faciliter la compréhension de ce modèle, deux concepts sont introduits ici :
产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。 产品族 ：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
Rôle :
抽象工厂（AbstractFactory）：担任这个角色的是抽象工厂模式的核心，是与应用系统的商业逻辑无关的。 具体工厂（Factory）：这个角色直接在客户端的调用下创建产品的实例，这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统商业逻辑紧密相关的。 抽象产品（AbstractProduct）：担任这个角色的类是抽象工厂模式所创建的对象的父类，或它们共同拥有的接口 具体产品（Product）：抽象工厂模式所创建的任何产品对象都是一个具体的产品类的实例。
Diagramme de classes UML : 
Exemple de code :
<?php interface TV{
public function open();
public function use();}class HaierTv implements TV{
public function open()
{
echo "Open Haier TV <br>";
} public function use()
{
echo "I'm watching TV <br>";
}
}interface PC{
public function work();
public function play();}class LenovoPc implements PC{
public function work()
{
echo "I'm working on a Lenovo computer <br>";
} public function play()
{
echo "Lenovo computers can be used to play games <br>";
}
}abstract class Factory{
abstract public static function createPc();
abstract public static function createTv();}class ProductFactory extends Factory{
public static function createTV()
{
return new HaierTv();
} public static function createPc()
{
return new LenovoPc();
}
}$newTv = ProductFactory::createTV();$newTv->open();$newTv->use();$newPc = ProductFactory::createPc();$newPc->work();$newPc->play();2. Mode constructeur
Aussi connu sous le nom de : mode générateur, c'est un mode de construction d'objets. Il peut abstraire le processus de construction d'objets complexes (catégorie abstraite), de sorte que différentes méthodes de mise en œuvre de ce processus abstrait puissent construire des objets avec différentes performances (attributs).
Le modèle de construction consiste à créer un objet complexe étape par étape. Il permet aux utilisateurs de créer des objets complexes uniquement en spécifiant leur type et leur contenu. Les utilisateurs n'ont pas besoin de connaître les détails de construction internes spécifiques. Par exemple, une voiture est composée de roues, de moteurs et d'autres pièces. Pour les gens ordinaires, nous n'utilisons qu'une voiture complète. Pour le moment, nous devons ajouter un constructeur pour nous aider à assembler ces composants afin de devenir une voiture complète.
Rôle :
Builder：抽象构造者类，为创建一个Product对象的各个部件指定抽象接口。 ConcreteBuilder：具体构造者类，实现Builder的接口以构造和装配该产品的各个部件。定义并明确它所创建的表示。提供一个检索产品的接口 Director：指挥者，构造一个使用Builder接口的对象。 Product：表示被构造的复杂对象。ConcreateBuilder创建该产品的内部表示并定义它的装配过程。 包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
Diagramme de classes UML :
Exemple de code :
<?php /**
* chouxiang builer
*/abstract class Builder{
protected $car; abstract public function buildPartA();
abstract public function buildPartB();
abstract public function buildPartC();
abstract public function getResult();}class CarBuilder extends Builder{
function __construct()
{
$this->car = new Car();
} public function buildPartA(){
$this->car->setPartA('发动机');
} public function buildPartB(){
$this->car->setPartB('轮子');
} public function buildPartC(){
$this->car->setPartC('其他零件');
} public function getResult(){
return $this->car;
}
}class Car{
protected $partA; protected $partB; protected $partC; public function setPartA($str){
$this->partA = $str;
} public function setPartB($str){
$this->partB = $str;
} public function setPartC($str){
$this->partC = $str;
} public function show()
{
echo "这辆车由：".$this->partA.','.$this->partB.',和'.$this->partC.'组成';
}
}class Director{
public $myBuilder; public function startBuild()
{
$this->myBuilder->buildPartA(); $this->myBuilder->buildPartB(); $this->myBuilder->buildPartC(); return $this->myBuilder->getResult();
} public function setBuilder(Builder $builder)
{
$this->myBuilder = $builder;
}
}$carBuilder = new CarBuilder();$director = new Director();$director->setBuilder($carBuilder);$newCar = $director->startBuild();$newCar->show();3. 🎜>
单例模式，也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。 实现单例模式的思路是：一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。 ---维基百科
Singleton：单例类
<?php class Singleton{
private static $instance; //私有构造方法，禁止使用new创建对象
private function __construct(){} public static function getInstance(){
if (!isset(self::$instance)) { self::$instance = new self;
} return self::$instance;
} //将克隆方法设为私有，禁止克隆对象
private function __clone(){} public function say()
{
echo "这是用单例模式创建对象实例 <br>";
} public function operation()
{
echo "这里可以添加其他方法和操作 <br>";
}
}// $shiyanlou = new Singleton();$shiyanlou = Singleton::getInstance();$shiyanlou->say();$shiyanlou->operation();$newShiyanlou = Singleton::getInstance();
var_dump($shiyanlou === $newShiyanlou);上述的五个模式均属于创建型模式，关于结构型模式，
更多请看实验楼教程【16个PHP设计模式详解】
文中涉及一些 UML 类图，为了更好地理解，可以先阅读 UML 类图。
一、工厂模式
工厂模式具体可分为三类模式：简单工厂模式，工厂方法模式，抽象工厂模式；
1.简单工厂模式
又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
角色：
Factory类：负责创建具体产品的实例 Product类：抽象产品类，定义产品子类的公共接口 ConcreteProduct 类：具体产品类，实现Product父类的接口功能，也可添加自定义的功能
UML类图：
示例代码：
<?php //简单工厂模式class Cat{
function __construct()
{
echo "I am Cat class <br>";
}
}class Dog{
function __construct()
{
echo "I am Dog class <br>";
}
}class Factory{
public static function CreateAnimal($name){
if ($name == 'cat') { return new Cat();
} elseif ($name == 'dog') { return new Dog();
}
}
}$cat = Factory::CreateAnimal('cat');$dog = Factory::CreateAnimal('dog');简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。
2.工厂方法模式
此模式中，通过定义一个抽象的核心工厂类，并定义创建产品对象的接口，创建具体产品实例的工作延迟到其工厂子类去完成。这样做的好处是核心类只关注工厂类的接口定义，而具体的产品实例交给具体的工厂子类去创建。当系统需要新增一个产品是，无需修改现有系统代码，只需要添加一个具体产品类和其对应的工厂子类，是系统的扩展性变得很好，符合面向对象编程的开闭原则;
角色：
Product：抽象产品类 ConcreteProduct：具体产品类 Factory：抽象工厂类 ConcreteFactory：具体工厂类
UML类图：
16 modèles de conception PHP introduits
示例代码：
<?php interface Animal{
public function run();
public function say();}class Cat implements Animal{
public function run(){
echo "I ran slowly <br>";
} public function say(){
echo "I am Cat class <br>";
}
}class Dog implements Animal{
public function run(){
echo "I'm running fast <br>";
} public function say(){
echo "I am Dog class <br>";
}
}abstract class Factory{
abstract static function createAnimal();}class CatFactory extends Factory{
public static function createAnimal()
{
return new Cat();
}
}class DogFactory extends Factory{
public static function createAnimal()
{
return new Dog();
}
}$cat = CatFactory::createAnimal();$cat->say();$cat->run();$dog = DogFactory::createAnimal();$dog->say();$dog->run();工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
3.抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。
此模式是对工厂方法模式的进一步扩展。在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，但是，如果需要一个具体的工厂生产多种产品对象，那么就需要用到抽象工厂模式了。
为了便于理解此模式，这里介绍两个概念：
产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。 产品族 ：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
角色：
抽象工厂（AbstractFactory）：担任这个角色的是抽象工厂模式的核心，是与应用系统的商业逻辑无关的。 具体工厂（Factory）：这个角色直接在客户端的调用下创建产品的实例，这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统商业逻辑紧密相关的。 抽象产品（AbstractProduct）：担任这个角色的类是抽象工厂模式所创建的对象的父类，或它们共同拥有的接口 具体产品（Product）：抽象工厂模式所创建的任何产品对象都是一个具体的产品类的实例。
UML类图：
示例代码：
<?php interface TV{
public function open();
public function use();}class HaierTv implements TV{
public function open()
{
echo "Open Haier TV <br>";
} public function use()
{
echo "I'm watching TV <br>";
}
}interface PC{
public function work();
public function play();}class LenovoPc implements PC{
public function work()
{
echo "I'm working on a Lenovo computer <br>";
} public function play()
{
echo "Lenovo computers can be used to play games <br>";
}
}abstract class Factory{
abstract public static function createPc();
abstract public static function createTv();}class ProductFactory extends Factory{
public static function createTV()
{
return new HaierTv();
} public static function createPc()
{
return new LenovoPc();
}
}$newTv = ProductFactory::createTV();$newTv->open();$newTv->use();$newPc = ProductFactory::createPc();$newPc->work();$newPc->play();二、建造者模式
又名：生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。例如，一辆汽车由轮子，发动机以及其他零件组成，对于普通人而言，我们使用的只是一辆完整的车，这时，我们需要加入一个构造者，让他帮我们把这些组件按序组装成为一辆完整的车。
角色：
Builder：抽象构造者类，为创建一个Product对象的各个部件指定抽象接口。 ConcreteBuilder：具体构造者类，实现Builder的接口以构造和装配该产品的各个部件。定义并明确它所创建的表示。提供一个检索产品的接口 Director：指挥者，构造一个使用Builder接口的对象。 Product：表示被构造的复杂对象。ConcreateBuilder创建该产品的内部表示并定义它的装配过程。 包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
UML类图：
示例代码：
<?php /**
* chouxiang builer
*/abstract class Builder{
protected $car; abstract public function buildPartA();
abstract public function buildPartB();
abstract public function buildPartC();
abstract public function getResult();}class CarBuilder extends Builder{
function __construct()
{
$this->car = new Car();
} public function buildPartA(){
$this->car->setPartA('发动机');
} public function buildPartB(){
$this->car->setPartB('轮子');
} public function buildPartC(){
$this->car->setPartC('其他零件');
} public function getResult(){
return $this->car;
}
}class Car{
protected $partA; protected $partB; protected $partC; public function setPartA($str){
$this->partA = $str;
} public function setPartB($str){
$this->partB = $str;
} public function setPartC($str){
$this->partC = $str;
} public function show()
{
echo "这辆车由：".$this->partA.','.$this->partB.',和'.$this->partC.'组成';
}
}class Director{
public $myBuilder; public function startBuild()
{
$this->myBuilder->buildPartA(); $this->myBuilder->buildPartB(); $this->myBuilder->buildPartC(); return $this->myBuilder->getResult();
} public function setBuilder(Builder $builder)
{
$this->myBuilder = $builder;
}
}$carBuilder = new CarBuilder();$director = new Director();$director->setBuilder($carBuilder);$newCar = $director->startBuild();$newCar->show();三、单例模式
单例模式，也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。 实现单例模式的思路是：一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。 ---维基百科
单例模式的要点有：某个类只能有一个实例；它必须自行创建本身的实例；它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。
角色：
Singleton：单例类
UML 类图：
示例代码：
<?php class Singleton{
private static $instance; //私有构造方法，禁止使用new创建对象
private function __construct(){} public static function getInstance(){
if (!isset(self::$instance)) { self::$instance = new self;
} return self::$instance;
} //将克隆方法设为私有，禁止克隆对象
private function __clone(){} public function say()
{
echo "这是用单例模式创建对象实例 <br>";
} public function operation()
{
echo "这里可以添加其他方法和操作 <br>";
}
}// $shiyanlou = new Singleton();$shiyanlou = Singleton::getInstance();$shiyanlou->say();$shiyanlou->operation();$newShiyanlou = Singleton::getInstance();
var_dump($shiyanlou === $newShiyanlou);上述的五个模式均属于创建型模式，关于结构型模式。
相关推荐：
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Outils d'IA chauds
Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes
AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.
Undress AI Tool
Images de déshabillage gratuites
Clothoff.io
Dissolvant de vêtements AI
AI Hentai Generator
Générez AI Hentai gratuitement.
Article chaud
Outils chauds
Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit
SublimeText3 version chinoise
Version chinoise, très simple à utiliser
Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP
Dreamweaver CS6
Outils de développement Web visuel
SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)
Guide d'installation et de mise à niveau de PHP 8.4 pour Ubuntu et Debian
Dec 24, 2024 pm 04:42 PM
PHP 8.4 apporte plusieurs nouvelles fonctionnalités, améliorations de sécurité et de performances avec une bonne quantité de dépréciations et de suppressions de fonctionnalités. Ce guide explique comment installer PHP 8.4 ou mettre à niveau vers PHP 8.4 sur Ubuntu, Debian ou leurs dérivés. Bien qu'il soit possible de compiler PHP à partir des sources, son installation à partir d'un référentiel APT comme expliqué ci-dessous est souvent plus rapide et plus sécurisée car ces référentiels fourniront les dernières corrections de bogues et mises à jour de sécurité à l'avenir.
Comment configurer Visual Studio Code (VS Code) pour le développement PHP
Dec 20, 2024 am 11:31 AM
Visual Studio Code, également connu sous le nom de VS Code, est un éditeur de code source gratuit – ou environnement de développement intégré (IDE) – disponible pour tous les principaux systèmes d'exploitation. Avec une large collection d'extensions pour de nombreux langages de programmation, VS Code peut être c
7 fonctions PHP que je regrette de ne pas connaître auparavant
Nov 13, 2024 am 09:42 AM
Si vous êtes un développeur PHP expérimenté, vous aurez peut-être le sentiment d'y être déjà allé et de l'avoir déjà fait. Vous avez développé un nombre important d'applications, débogué des millions de lignes de code et peaufiné de nombreux scripts pour réaliser des opérations.
Comment analysez-vous et traitez-vous HTML / XML dans PHP?
Feb 07, 2025 am 11:57 AM
Ce tutoriel montre comment traiter efficacement les documents XML à l'aide de PHP. XML (Language de balisage extensible) est un langage de balisage basé sur le texte polyvalent conçu à la fois pour la lisibilité humaine et l'analyse de la machine. Il est couramment utilisé pour le stockage de données et
Expliquez les jetons Web JSON (JWT) et leur cas d'utilisation dans les API PHP.
Apr 05, 2025 am 12:04 AM
JWT est une norme ouverte basée sur JSON, utilisée pour transmettre en toute sécurité des informations entre les parties, principalement pour l'authentification de l'identité et l'échange d'informations. 1. JWT se compose de trois parties: en-tête, charge utile et signature. 2. Le principe de travail de JWT comprend trois étapes: la génération de JWT, la vérification de la charge utile JWT et l'analyse. 3. Lorsque vous utilisez JWT pour l'authentification en PHP, JWT peut être généré et vérifié, et les informations sur le rôle et l'autorisation des utilisateurs peuvent être incluses dans l'utilisation avancée. 4. Les erreurs courantes incluent une défaillance de vérification de signature, l'expiration des jetons et la charge utile surdimensionnée. Les compétences de débogage incluent l'utilisation des outils de débogage et de l'exploitation forestière. 5. L'optimisation des performances et les meilleures pratiques incluent l'utilisation des algorithmes de signature appropriés, la définition des périodes de validité raisonnablement,
Programme PHP pour compter les voyelles dans une chaîne
Feb 07, 2025 pm 12:12 PM
Une chaîne est une séquence de caractères, y compris des lettres, des nombres et des symboles. Ce tutoriel apprendra à calculer le nombre de voyelles dans une chaîne donnée en PHP en utilisant différentes méthodes. Les voyelles en anglais sont a, e, i, o, u, et elles peuvent être en majuscules ou en minuscules. Qu'est-ce qu'une voyelle? Les voyelles sont des caractères alphabétiques qui représentent une prononciation spécifique. Il y a cinq voyelles en anglais, y compris les majuscules et les minuscules: a, e, i, o, u Exemple 1 Entrée: String = "TutorialSpoint" Sortie: 6 expliquer Les voyelles dans la chaîne "TutorialSpoint" sont u, o, i, a, o, i. Il y a 6 yuans au total
Expliquez la liaison statique tardive en PHP (statique: :).
Apr 03, 2025 am 12:04 AM
Liaison statique (statique: :) implémente la liaison statique tardive (LSB) dans PHP, permettant à des classes d'appel d'être référencées dans des contextes statiques plutôt que de définir des classes. 1) Le processus d'analyse est effectué au moment de l'exécution, 2) Recherchez la classe d'appel dans la relation de succession, 3) il peut apporter des frais généraux de performance.
Quelles sont les méthodes PHP Magic (__construct, __ destruct, __ call, __get, __set, etc.) et fournir des cas d'utilisation?
Apr 03, 2025 am 12:03 AM
Quelles sont les méthodes magiques de PHP? Les méthodes magiques de PHP incluent: 1. \ _ \ _ Construct, utilisé pour initialiser les objets; 2. \ _ \ _ Destruct, utilisé pour nettoyer les ressources; 3. \ _ \ _ Appel, gérer les appels de méthode inexistants; 4. \ _ \ _ GET, Implémentez l'accès à l'attribut dynamique; 5. \ _ \ _ SET, Implémentez les paramètres d'attribut dynamique. Ces méthodes sont automatiquement appelées dans certaines situations, améliorant la flexibilité et l'efficacité du code.
