Principio: Tell, Don’t ask

El patrón Tell Don’t Ask es un principio de diseño que se utiliza para mejorar la cohesión y la modificabilidad del código al evitar la tentación de preguntar por los estados de los objetos y, en su lugar, pedirles que realicen una acción. Este patrón se basa en la idea de que cada objeto debe tener un conocimiento limitado de otros objetos y debe comunicarse solo con sus amigos directos.

A continuación te proporciono un ejemplo de cómo podría utilizarse el patrón Tell Don’t Ask en TypeScript:

Copy codeclass Order {
  private items: Item[] = [];
  private total: number = 0;

  constructor() {}

  public addItem(item: Item): void {
    this.items.push(item);
    this.total += item.getPrice();
  }

  public getTotal(): number {
    return this.total;
  }
}

class Item {
  private name: string;
  private price: number;

  constructor(name: string, price: number) {
    this.name = name;
    this.price = price;
  }

  public getPrice(): number {
    return this.price;
  }
}

const order = new Order();
const item1 = new Item('Pizza', 10);
const item2 = new Item('Soda', 2);
order.addItem(item1);
order.addItem(item2);

console.log(order.getTotal());
// Output: 12

En este ejemplo, tenemos dos clases: Order y Item. La clase Order tiene una lista privada de elementos y un atributo privado para el total, y tiene un método público llamado addItem que se utiliza para agregar un elemento a la lista y actualizar el total. La clase Item tiene atributos privados para el nombre y el precio y un método público llamado getPrice que se utiliza para obtener el precio del elemento.

Al utilizar el patrón Tell Don’t Ask, podemos ver cómo la clase Order no pregunta por el precio de un elemento, sino que le pide a la clase Item que devuelva su precio a través de un mensaje. Esto permite mejorar la cohesión y la modificabilidad del código al evitar la tentación de preguntar por los estados de los objetos y, en su lugar, pedirles que realicen una acción.

Tell, Don’t ask (¡Manda y no preguntes!) es un recordatorio de que no tenemos que usar los objetos para pedirles cosas y según la información que nos devuelven tomar decisiones, sino que lo que debemos hacer es decirles a los objetos que hagan cosas y estos objetos internamente tomaran sus propias decisiones según de su estado.

Insiste en el encapsulado de la lógica en la propia clase.

class ControlRiego{
    const MINIMO_HUMEDAD = 20;
    public $humedad;

    public function regar(){}
}

En el código que no sigue los principios de Tell don’t ask toda la acción se realiza fuera del objeto, de este modo:

//Realizamos la instanciación del objeto
$instControlRiego = new ControlRiego();

//chequeamos si la humedad es menor al nivel nímimo.
if ($instControlRiego->humedad < $instControlRiego::MINIMO_HUMEDAD){
    $instControlRiego->regar();
}

Lo mas correcto sería:

class ControlRiego{
    const MINIMO_HUMEDAD = 20;
    //ahora nuestra variable puede ser privada
    private $humedad;

    public function regar(){

        if ($this->humedad < $self::MINIMO_HUMEDAD){
            //retornamos: Se ha llevado a cabo la acción de riego
        }

        //retornamos: No se ha llevado a cabo la acción de riego

    }
}