PHP Traits (OOP)

PHP traits are a methodology for code reuse that allows us to group functions, but don’t get me wrong, these groupings are not inside the class, you can use the same grouping in different classes.

Of course, the traits are related, you cannot directly instantiate a trait, you must do it within the class using use.

The semantics when combining traits and classes are defined in such a way that reduces their complexity and avoids the typical problems associated with multiple inheritance and mixins.

To better understand the concept of mixins, I recommend you take a look at what mixins are in Sass and this section of Mozilla that explains mixins in JavaScript: https://developer.mozilla.org/en-US/docs/Glossary/Mixin.

In fact, the first example given on PHP.net is a mixin.

<?php
class Base {
    public function decirHola() {
        echo '¡Hola ';
    }
}

trait DecirMundo {
    public function decirHola() {
        parent::decirHola();
        echo 'Mundo!';
    }
}

class MiHolaMundo extends Base {
    use DecirMundo;
}

$o = new MiHolaMundo();
$o->decirHola();
?>

¡Hola Mundo!

Notice that the same function is used in both the trait and the class.

You can use multiple traits within a class, simply use use Trait1, Trait2, …, TraitN;.

Cases where I can use traits

Code reuse:

If you have several classes that share certain functions or common behaviors, you can define a trait that contains that code and use it in all those classes. This allows you to avoid code duplication and simplify code maintenance.

One thing to keep in mind is to have the classes in the same namespace (namespaces in PHP), which will make the code much cleaner. Traits are obviously a methodology used in object-oriented programming.

You can do similar things by using inheritance, you can see inheritance in PHP.

Implement interfaces:

If you have a class that needs to implement several interfaces, you can define a trait that implements those interfaces and then incorporate that trait into the class. This allows you to separate the implementation of the interfaces from the rest of the code of the class and improve its readability.

Let’s see an example for these cases:

interface Repositorio {
  public function crearRegistro($datos);
  public function leerRegistro($id);
  public function actualizarRegistro($id, $datos);
  public function eliminarRegistro($id);
}

trait RepositorioTrait {
  public function crearRegistro($datos) {
    // Aquí iría el código para crear un registro en la base de datos
  }

  public function leerRegistro($id) {
    // Aquí iría el código para leer un registro de la base de datos
  }

  public function actualizarRegistro($id, $datos) {
    // Aquí iría el código para actualizar un registro en la base de datos
  }

  public function eliminarRegistro($id) {
    // Aquí iría el código para eliminar un registro de la base de datos
  }
}

class Tabla implements Repositorio {
  use RepositorioTrait;

  // Aquí iría el resto del código de la clase Tabla
}

Event Handling:

If you have an application that uses events to communicate different parts of the code, you can define a trait that contains functions that allow you to register and handle those events. Then, you can use that trait in different classes that need to handle those events.

What could be an event?

Well, for example, when we register or subscribe, we can make these actions like send an email to the user or subscriber, which can be for their verification or to receive notifications of new topics.

Implementación de funcionalidades opcionales:

If you have a class that can have several optional functionalities, you can define a trait for each of those functionalities and then incorporate only the corresponding traits in each instance of the class. This allows you to avoid creating specialized classes for each combination of functionalities.

trait NadarTrait {
    public function nadar() {
        echo "Estoy nadando\n";
    }
}

class Animal {
    public function moverse() {
        echo "Estoy moviéndome\n";
    }
}

class Pez extends Animal {
    use NadarTrait;
}

class Pajaro extends Animal {
    // La clase Pajaro no utiliza el trait NadarTrait
}

Ejemplos de Traits

trait AutenticacionTrait {
  public function verificarAutenticacion() {
    // Aquí iría el código que verifica si el usuario está autenticado
  }
}

class Usuario {
  use AutenticacionTrait;

  // Aquí iría el resto del código de la clase Usuario
}

class Administrador {
  use AutenticacionTrait;

  // Aquí iría el resto del código de la clase Administrador
}

trait DescuentoTrait {
  public function aplicarDescuento($porcentaje) {
    // Aquí iría el código para aplicar el descuento a los productos en el carrito
  }
}

class Carrito {
  use DescuentoTrait;

  public function agregarProducto($producto, $cantidad) {
    // Aquí iría el código para agregar el producto al carrito
  }

  public function eliminarProducto($producto) {
    // Aquí iría el código para eliminar el producto del carrito
  }

  public function actualizarProducto($producto, $cantidad) {
    // Aquí iría el código para actualizar la cantidad del producto en el carrito
  }
}