Kā apgūt objektorientētu PHP

Informatec Digital » programmēšana » Kā apgūt objektorientētu PHP

Tīmekļa izstrādes pasaule nepārtraukti attīstās, un objektorientētais vaicājums (OOP) ir kļuvis par neaizstājamu rīku programmētājiem, kuri vēlas izveidot stabilas, mērogojamas un apkopjamas tīmekļa lietojumprogrammas. Šajā rakstā mēs iedziļināsimies PHP OOP pamatjēdzienos, priekšrocībās un paraugpraksē, nodrošinot jūs ar rīkiem, kas nepieciešami, lai paceltu savas programmēšanas prasmes uz nākamo līmeni.

Objektorientēta PHP

Objektorientētā PHP ir programmēšanas paradigma, kas organizē programmatūras dizainu, pamatojoties uz datiem vai objektiem, nevis funkcijām un loģiku. Šī pieeja ļauj labāk organizēt kodu, atvieglojot tā atkārtotu izmantošanu un uzturēšanu. Atšķirībā no procesuālās programmēšanas, PHP OOP iekapsulē datus un uzvedību objektos, kā rezultātā kods ir modulārāks un vieglāk saprotams.

Objektorientētās PHP pamati

Klases un objekti

PHP OOP pamatā ir klases un objekti. Klase ir kā projekts, kas nosaka īpašības un metodes, kas būs no tās izveidotajiem objektiem. Piemēram:

class Coche {
    public $marca;
    public $modelo;

    public function arrancar() {
        echo "El coche está arrancando";
    }
}

$miCoche = new Coche();
$miCoche->marca = "Toyota";
$miCoche->modelo = "Corolla";
$miCoche->arrancar();

Šajā piemērā Coche Tā ir klase un $miCoche ir šīs klases instantiēts objekts. Klases ļauj mums radīt datu struktūras komplekss, kas var savstarpēji mijiedarboties saskaņotā veidā.

Iekapsulēšana

Iekapsulēšana ir viens no PHP OOP pīlāriem. Tas attiecas uz datu grupēšanu ar metodēm, kas darbojas ar šiem datiem vienības vai klases ietvaros. Tas slēpj iekšējās detaļas par to, kā objekts darbojas, un atklāj tikai nepieciešamo. PHP mēs izmantojam piekļuves modifikatorus, piemēram public, private y protected lai kontrolētu piekļuvi klases īpašībām un metodēm.

class CuentaBancaria {
    private $saldo = 0;

    public function depositar($cantidad) {
        if ($cantidad > 0) {
            $this->saldo += $cantidad;
            return true;
        }
        return false;
    }

    public function getSaldo() {
        return $this->saldo;
    }
}

Šajā gadījumā, $saldo Tas ir privāts, un to var mainīt, tikai izmantojot šo metodi depositar(), kas ļauj mums apstiprināt ievadi un uzturēt datu integritāti.

Mantojums

Mantojums ļauj vienai klasei (sauktai par bērnklasi) mantot rekvizītus un metodes no citas klases (ko sauc par vecākklasi). Tas veicina koda atkārtotu izmantošanu un ļauj izveidot klašu hierarhijas. Piemēram:

class Vehiculo {
    protected $numeroRuedas;

    public function setNumeroRuedas($numero) {
        $this->numeroRuedas = $numero;
    }

    public function getNumeroRuedas() {
        return $this->numeroRuedas;
    }
}

class Bicicleta extends Vehiculo {
    public function __construct() {
        $this->setNumeroRuedas(2);
    }
}

$miBici = new Bicicleta();
echo $miBici->getNumeroRuedas(); // Imprime: 2

Šeit, Bicicleta manto no Vehiculo, izmantojot tās metodes un īpašības.

Polimorfisms

Polimorfisms ļauj dažādu klašu objektiem unikāli reaģēt uz vienu un to pašu metodi. To bieži panāk, izmantojot mantojumu un saskarnes. Piemēram:

interface Sonido {
    public function hacerSonido();
}

class Perro implements Sonido {
    public function hacerSonido() {
        echo "Guau!";
    }
}

class Gato implements Sonido {
    public function hacerSonido() {
        echo "Miau!";
    }
}

function hacerRuido(Sonido $animal) {
    $animal->hacerSonido();
}

$perro = new Perro();
$gato = new Gato();

hacerRuido($perro); // Imprime: Guau!
hacerRuido($gato); // Imprime: Miau!

Šis kods parāda, kā dažādas klases var ieviest vienu un to pašu saskarni, bet ar unikālu uzvedību.

Objektorientētā PHP priekšrocības

Koda atkārtota izmantošana

Viena no lielākajām PHP OOP priekšrocībām ir iespēja atkārtoti izmantot kodu. Izmantojot mantošanu un sastāvu, mēs varam izveidot jaunas klases, pamatojoties uz esošajām klasēm, ietaupot laiku un samazinot koda dublēšanos.

Uzturamība un mērogojamība

PHP OOP ļauj vieglāk izveidot uzturējamāku un mērogojamāku kodu. Iekapsulējot loģiku objektos, ir vieglāk atjaunināt un paplašināt kodu, neietekmējot citas sistēmas daļas. Tas ir īpaši noderīgi lielos, sarežģītos projektos.

Praktiskā īstenošana

Nodarbību izveide PHP valodā

Lai izveidotu klasi PHP, mēs izmantojam atslēgvārdu class. Šeit ir praktisks piemērs:

class Usuario {
    private $nombre;
    private $email;

    public function __construct($nombre, $email) {
        $this->nombre = $nombre;
        $this->email = $email;
    }

    public function getNombre() {
        return $this->nombre;
    }

    public function getEmail() {
        return $this->email;
    }
}

$usuario = new Usuario("Juan", "[email protected]");
echo $usuario->getNombre(); // Imprime: Juan

Šis piemērs parāda, kā izveidot vienkāršu klasi ar konstruktora un ieguvēja metodēm.

Metodes un īpašības

Metodes ir funkcijas, kas definētas klasē, savukārt īpašības ir mainīgie. Tie var būt publiski, privāti vai aizsargāti atkarībā no tā, kā mēs vēlamies, lai tie būtu pieejami.

class Producto {
    private $nombre;
    private $precio;

    public function __construct($nombre, $precio) {
        $this->nombre = $nombre;
        $this->precio = $precio;
    }

    public function getNombre() {
        return $this->nombre;
    }

    public function getPrecio() {
        return $this->precio;
    }

    public function aplicarDescuento($porcentaje) {
        $this->precio -= $this->precio * ($porcentaje / 100);
    }
}

$producto = new Producto("Laptop", 1000);
echo $producto->getPrecio(); // Imprime: 1000
$producto->aplicarDescuento(10);
echo $producto->getPrecio(); // Imprime: 900

Šis piemērs parāda, kā metodes var mijiedarboties ar klases īpašībām.

Celtnieki un postītāji

Konstruktori ir īpašas metodes, kuras tiek izsauktas automātiski, kad tiek izveidots objekts. No otras puses, iznīcinātāji tiek izsaukti, kad objekts tiek iznīcināts vai skripts beidzas.

class Conexion {
    private $conexion;

    public function __construct() {
        $this->conexion = mysqli_connect("localhost", "usuario", "contraseña", "basedatos");
        echo "Conexión establecida";
    }

    public function __destruct() {
        mysqli_close($this->conexion);
        echo "Conexión cerrada";
    }
}

$db = new Conexion(); // Imprime: Conexión establecida
// Al final del script o cuando $db sale del ámbito, se imprime: Conexión cerrada

Šis piemērs parāda, kā izmantot konstruktorus un iznīcinātājus, lai pārvaldītu resursus, piemēram, datu bāzes savienojumus.

Objektorientēti dizaina modeļi PHP

Dizaina modeļi ir pārbaudīti risinājumi izplatītām programmatūras izstrādes problēmām. PHP OOP daži populāri modeļi ietver:

vieninieks

Singleton modelis nodrošina, ka klasei ir tikai viens gadījums, un nodrošina tai globālu piekļuves punktu.

class Configuracion {
    private static $instancia;
    private $configuraciones;

    private function __construct() {
        // Cargar configuraciones
        $this->configuraciones = [
            'debug' => true,
            'db_host' => 'localhost',
            'db_name' => 'mi_app'
        ];
    }

    public static function obtenerInstancia() {
        if (self::$instancia == null) {
            self::$instancia = new Configuracion();
        }
        return self::$instancia;
    }

    public function obtenerConfiguracion($clave) {
        return isset($this->configuraciones[$clave]) ? $this->configuraciones[$clave] : null;
    }
}

$config = Configuracion::obtenerInstancia();
echo $config->obtenerConfiguracion('db_host'); // Imprime: localhost

Šis modelis ir noderīgs, lai apstrādātu koplietotos resursus, piemēram, konfigurācijas vai datu bāzes savienojumus.

Rūpnīcas metode

Factory Method modelis definē saskarni objekta izveidei, bet ļauj apakšklasēm izlemt, kuru klasi izveidot.

interface Transporte {
    public function entregar();
}

class Camion implements Transporte {
    public function entregar() {
        return "Entregando por tierra";
    }
}

class Barco implements Transporte {
    public function entregar() {
        return "Entregando por mar";
    }
}

class FabricaTransporte {
    public function crearTransporte($tipo) {
        switch ($tipo) {
            case 'tierra':
                return new Camion();
            case 'mar':
                return new Barco();
            default:
                throw new Exception("Tipo de transporte no válido");
        }
    }
}

$fabrica = new FabricaTransporte();
$transporte = $fabrica->crearTransporte('tierra');
echo $transporte->entregar(); // Imprime: Entregando por tierra

Šis modelis ir noderīgs, ja mums ir jāizveido objekti, nenorādot precīzu izveidojamā objekta klasi.

Novērotājs

Novērotāja modelis definē atkarību starp objektiem viens pret daudziem, lai, mainot objekta stāvokli, visi tā atkarīgie tiek automātiski informēti un atjaunināti.

interface Observador {
    public function actualizar($mensaje);
}

class Usuario implements Observador {
    private $nombre;

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

    public function actualizar($mensaje) {
        echo $this->nombre . " recibió el mensaje: " . $mensaje . "\n";
    }
}

class NotificadorBlog {
    private $observadores = [];

    public function agregarObservador(Observador $observador) {
        $this->observadores[] = $observador;
    }

    public function notificar($mensaje) {
        foreach ($this->observadores as $observador) {
            $observador->actualizar($mensaje);
        }
    }
}

$blog = new NotificadorBlog();
$blog->agregarObservador(new Usuario("Juan"));
$blog->agregarObservador(new Usuario("María"));

$blog->notificar("Nuevo post en el blog!");
// Imprime:
// Juan recibió el mensaje: Nuevo post en el blog!
// María recibió el mensaje: Nuevo post en el blog!

Šis modelis ir noderīgs izplatīto notikumu sistēmu ieviešanai.

Paraugprakse objektorientētā PHP

SOLID principi

SOLID principi ir vadlīniju kopums, kas palīdz padarīt objektorientētu programmatūru saprotamāku, elastīgāku un uzturamāku:

1. SVienas atbildības princips
2. Opildspalva/slēgtais princips (atvērtais/slēgtais princips)
3. LLiskova aizstāšanas princips
4. IInterfeisa segregācijas princips
5. Datkarības inversijas princips

Piemēram, vienotās atbildības princips liek domāt, ka klasei ir jābūt tikai vienam iemeslam, lai mainītu:

// Mal ejemplo
class Usuario {
    public function guardarEnBaseDeDatos() { /* ... */ }
    public function generarInforme() { /* ... */ }
}

// Buen ejemplo
class Usuario {
    private $datos;

    public function getDatos() {
        return $this->datos;
    }
}

class RepositorioUsuario {
    public function guardar(Usuario $usuario) { /* ... */ }
}

class GeneradorInformeUsuario {
    public function generar(Usuario $usuario) { /* ... */ }
}

Nosaukšanas konvencijas

Konsekventu nosaukumu piešķiršanas noteikumu ievērošana ir ļoti svarīga koda lasāmībai:

• Klašu nosaukumi: PascalCase (piemēram, MiClase)
• Metodes un rekvizītu nosaukumi: camelCase (piemēram, miMetodo, miPropiedad)
• Konstantes: UPPERCASE_WITH_UNDERSCORES (piem., MI_CONSTANTE)

class UsuarioAdmin {
    const NIVEL_ACCESO = 'admin';
    private $nombreUsuario;

Ievērojot šos noteikumus, jūsu kods ir vieglāk lasāms un saprotams citiem izstrādātājiem.

Atkļūdošana un kļūdu apstrāde

Izņēmumi PHP OOP

Izņēmumu apstrāde ir būtiska objektorientētā PHP sastāvdaļa. Izņēmumi ļauj rīkoties ar kļūdām elegantāk un kontrolētāk. Apskatīsim piemēru:

class DivisionPorCeroException extends Exception {}

class Calculadora {
    public function dividir($a, $b) {
        if ($b == 0) {
            throw new DivisionPorCeroException("No se puede dividir por cero");
        }
        return $a / $b;
    }
}

$calc = new Calculadora();

try {
    echo $calc->dividir(10, 2); // Imprime: 5
    echo $calc->dividir(10, 0); // Lanza una excepción
} catch (DivisionPorCeroException $e) {
    echo "Error: " . $e->getMessage(); // Imprime: Error: No se puede dividir por cero
} finally {
    echo "\nOperación finalizada";
}

Šajā piemērā mēs izveidojam pielāgotu izņēmumu DivisionPorCeroException. Pēc tam metodē dividir, mēs izmetam šo izņēmumu, ja dalītājs ir nulle. Bloks try-catch ļauj mums graciozi rīkoties ar šo izņēmumu finally vienmēr tiek izpildīts neatkarīgi no tā, vai tika izdarīts izņēmums vai nē.

Objektorientēti PHP ietvari

Mūsdienu PHP ietvari pilnībā izmanto objektu orientētās paradigmas priekšrocības, lai nodrošinātu stabilus un mērogojamus ietvarus tīmekļa izstrādei.

Laravel

Laravel ir viens no populārākajiem PHP ietvariem un plaši izmanto OOP principus. Piemēram, Laravel maršrutēšanas sistēma eleganti izmanto objektorientētu programmēšanu:

Route::get('/usuarios', [UsuarioController::class, 'index']);

class UsuarioController extends Controller
{
    public function index()
    {
        $usuarios = Usuario::all();
        return view('usuarios.index', compact('usuarios'));
    }
}

Šajā piemērā Laravel izmanto kontrolieru jēdzienu kā klases, un šo klašu metodes apstrādā dažādus lietojumprogrammas maršrutus.

Symfony

Symfony ir vēl viena PHP sistēma, kas plaši izmanto OOP. Piemēram, to atkarības iesmidzināšanas sistēma ir lielisks piemērs tam, kā SOLID principus var pielietot praksē:

use Symfony\Component\DependencyInjection\ContainerBuilder;

$container = new ContainerBuilder();
$container->register(Mailer::class);
$container->register(Newsletter::class)
    ->addArgument(Mailer::class);

$newsletter = $container->get(Newsletter::class);

Šis kods parāda, kā Symfony izmanto atkarības injekciju, lai elastīgi un atsaistītā veidā apstrādātu attiecības starp dažādām klasēm.

Veiktspējas optimizācija PHP OOP

Lazy Loading

Lazy Loading ir optimizācijas paņēmiens, kurā mēs aizkavējam objekta ielādi līdz brīdim, kad tas ir nepieciešams. Tas var ievērojami uzlabot lielu lietojumprogrammu veiktspēju:

class Usuario {
    private $datos;
    private $db;

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

    public function getDatos() {
        if ($this->datos === null) {
            $this->datos = $this->db->query("SELECT * FROM usuarios WHERE id = 1");
        }
        return $this->datos;
    }
}

Šajā piemērā lietotāja dati tiek ielādēti tikai tad, kad tiek izsaukta metode. getDatos(), nevis tad, kad objekts ir izveidots Usuario.

Objekta kešatmiņa

Objektu kešatmiņa var ievērojami uzlabot veiktspēju, izvairoties no biežas dārgu objektu atjaunošanas:

class CacheObjetos {
    private static $instancias = [];

    public static function obtener($clase, ...$args) {
        $clave = $clase . serialize($args);
        if (!isset(self::$instancias[$clave])) {
            self::$instancias[$clave] = new $clase(...$args);
        }
        return self::$instancias[$clave];
    }
}

$usuario1 = CacheObjetos::obtener(Usuario::class, 1);
$usuario2 = CacheObjetos::obtener(Usuario::class, 1); // Devuelve la misma instancia que $usuario1

Šī kešatmiņas sistēma novērš atkārtotu identisku objektu izveidi, kas var būt īpaši noderīgi objektiem, kuru izveide ir dārga vai kurus bieži izmanto.

Drošība objektorientētā PHP

Atkarības injekcija

Atkarības injekcija ir dizaina modelis, kas palīdz izveidot drošāku un elastīgāku kodu, atdalot objektu izveidi no to izmantošanas:

interface Logger {
    public function log($mensaje);
}

class FileLogger implements Logger {
    public function log($mensaje) {
        file_put_contents('app.log', $mensaje . "\n", FILE_APPEND);
    }
}

class Usuario {
    private $logger;

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

    public function login($username, $password) {
        // Lógica de login
        $this->logger->log("Usuario $username ha iniciado sesión");
    }
}

$usuario = new Usuario(new FileLogger());
$usuario->login('juan', 'contraseña123');

Šī pieeja padara kodu pārbaudāmāku un ļauj viegli mainīt reģistrētāja ieviešanu, nepārveidojot klasi. Usuario.

Datu validācija

Datu validācija ir ļoti svarīga drošībai PHP OOP vidē. Vienmēr ir jāvalidē un jādezinficē ievades dati.

class Formulario {
    public function validarEmail($email) {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException("Email no válido");
        }
        return $email;
    }

    public function procesarFormulario($datos) {
        $emailValidado = $this->validarEmail($datos['email']);
        // Procesar el formulario con el email validado
    }
}

$formulario = new Formulario();
try {
    $formulario->procesarFormulario(['email' => '[email protected]']);
} catch (InvalidArgumentException $e) {
    echo "Error: " . $e->getMessage();
}

Šis piemērs parāda, kā mēs varam izmantot validācijas metodes mūsu klasēs, lai nodrošinātu datu pareizumu pirms to apstrādes.

PHP OOP nākotnes tendences

PHP 8 un vairāk

PHP 8 ieviesa vairākas jaunas funkcijas , kas uzlabo objektorientētas programmēšanas pieredzi , piemēram, konstruktora īpašību reklamēšanu, atbilstības izteiksmes un nosauktos argumentus. Piemēram:

class Punto {
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0,
    ) {}
}

$punto = new Punto(x: 1.0, z: 2.0);
echo $punto->y; // Imprime: 0.0

Šajā kodā tiek izmantota konstruktora rekvizītu veicināšana un nosauktie argumenti — divas PHP 8 ieviestās funkcijas, kas padara kodu kodolīgāku un lasāmāku.

Objektorientēta PHP vs. PHP procesuāls

Lai gan objektorientētā PHP piedāvā daudzas priekšrocības, procesuālā PHP joprojām ir noderīga noteiktos scenārijos. Šeit ir salīdzinājums:

Característica	Objektorientēta PHP	PHP procesuāls
Organizācija	Uz objektu balstīta	Uz funkcijām balstīta
atkārtoti izmantot	Alta	Ierobežots
Sarežģītība	Lielāka mācīšanās līkne	Sākumā vienkāršāk
Mērogojamība	Lielisks	Ierobežots
Sniegums	Mazās lietojumprogrammās tas var būt lēnāks	Parasti ātrāk, izmantojot vienkāršus skriptus

Izvēle starp OOP un procedūru būs atkarīga no jūsu projekta lieluma un sarežģītības, kā arī no jūsu personīgajām vēlmēm un lietojumprogrammas īpašajām vajadzībām.

Secinājums

Objektorientēta PHP ir spēcīgs rīks, kas var ievērojami uzlabot jūsu tīmekļa projektu kvalitāti un apkopi. Šajā rakstā mēs esam izpētījuši PHP OOP pamatus, tā priekšrocības, izplatītos dizaina modeļus, labāko praksi un drošības apsvērumus.

PHP OOP ieviešana ne tikai uzlabo jūsu koda struktūru, bet arī atvieglo sadarbību izstrādes komandās un sagatavo jūsu projektus turpmākai izaugsmei un attīstībai. PHP turpinot attīstīties, objektorientētas programmēšanas apgūšana kļūst arvien svarīgāka izstrādātājiem, kuri vēlas būt soli priekšā nozarei.

Atcerieties, ka PHP OOP meistarība nāk ar praksi. Nebaidieties eksperimentēt ar šiem jēdzieniem savos projektos. Katra jūsu rakstītā koda rindiņa ir iespēja mācīties un uzlabot savas prasmes.

Vai šis raksts par objektorientēto PHP jums šķita noderīgs? Jūtieties brīvi dalīties tajā ar saviem kolēģiem izstrādātājiem un paziņām!