Una de las mayores bellezas de la programación está bajo la palabra: REUTILIZAR. Adaptar un mismo trozo de código para múltiples situaciones, haciendo la ejecución mucho más rápida y armónica, es una práctica que no todos tienen, especialmente cuando empezamos a programar de forma no ordenada.

Definición

Wikipedia define el Principio de no Repetirse de la siguiente manera:
“Cada pieza de información debe tener una única, inequívoca, representación autorizada dentro de un sistema.”

Vamos a tomar esta definición y dividirlo en algunos trozos fáciles de entender. Y luego vamos a aplicarlo al código. 

Cada pieza de información: en un desarrollo podría ser una clase, una función, o incluso simplemente un bloque de código dentro de una función.

Única, inequívoca, representación autorizada: el código debe existir sólo una vez y debe estar claramente escrito.

Dentro de un sistema: dentro de su componente, módulo, plugin, aplicación, etc

Si tomamos estas piezas y volvemos a escribir la definición en nuestros nuevos términos se vería más como esta:
“Cualquier código escrito y utilizado en el componente debe existir en un solo lugar y debe estar claramente escrito.”

Esto parece tener más sentido. Ahora que tenemos una buena definición de lo que está involucrado en el principio de “No te repitas” echemos un vistazo a algunos ejemplos de cómo se podría hacer esto dentro de tú código.

Ejemplo un código mal escrito: 

function getSingleItem($id) 
{
     // asumir todas las variables necesarias
     $query = $this->db->getQuery(TRUE)
          ->select($this->db->quoteName(array('i.*', 'c.name', 'a.something')))
          ->from($this->db->quoteName('#__myitems', 'i'))
          ->join('LEFT', $this->db->quoteName('#__categories', 'c') . ' ON (' .$this->db->quoteName('i.category_id') . ' = ' . $this->db ->quoteName('c.category_id') . ')')
          ->join('LEFT', $this->db->quoteName('#__attributes', 'a') . ' ON (' .$this->db->quoteName('a.item_id') . ' = ' . $this->db->quoteName('i.item_id') . ')')
          ->where($this->db->quoteName('i.item_id') . ' = '. (int) $id);
     $this->db->setQuery($query);
     $item = $this->db->loadObject();
} 

function getManyItems($ids) 
{ 
          // asumir todas las variables necesarias
          $query = $this->db->getQuery(TRUE) 
               ->select($this->db->quoteName(array('i.*', 'c.name', 'a.something'))) 
               ->from($this->db->quoteName('#myitems', 'i')) 
               ->join('LEFT', $this->db->quoteName('#categories', 'c') . ' ON (' . $this->db->quoteName('i.category_id') . ' = ' . $this->db->quoteName('c.category_id') . ')') 
               ->join('LEFT', $this->db->quoteName('#__attributes', 'a') . ' ON (' . $this->db->quoteName('a.item_id') . ' = ' . $this->db->quoteName('i.item_id') . ')') 
               ->where($this->db->quoteName('i.item_id') . ' IN '. implode(',', $ids)); 
         $this->db->setQuery($query); 
         $item = $this->db->loadObject(); 
}

¿No se ve similar ese código? Pues debería, ya que he creado la segunda función copiando la primera función y luego cambiar una sola línea. (Pista: Mira la cláusula "where"). Entonces, ¿cómo se vería este código si lo volvemos a escribir, pero sin duplicar las líneas de código? Aquí está un ejemplo posible.

Ejemplo de un código bien escrito: 

function getSingleItem($id) 
{ 
          // asumir todas las variables necesarias 
          $query = $this->getQuery(); 
          $query->where($this->db->quoteName('i.item_id') . ' = '. (int) $id); 
               $this->db->setQuery($query); 
          $item = $this->db->loadObject(); 
}

function getManyItems($ids) 
{ 
          // asumir todas las variables necesarias 
          $query = $this->getQuery(); 
          $query->where($this->db->quoteName('i.item_id') . ' IN '. implode(',', $ids));
               $this->db->setQuery($query);
          $item = $this->db->loadObject();
}

function getQuery() 
{ 
          $query = $this->db->getQuery(TRUE) 
               ->select($this->db->quoteName(array('i.*', 'c.name', 'a.something'))) 
               ->from($this->db->quoteName('#myitems', 'i')) 
               ->join('LEFT', $this->db->quoteName('#categories', 'c') . ' ON (' . $this->db->quoteName('i.category_id') . ' = ' . $this->db->quoteName('c.category_id') . ')') 
               ->join('LEFT', $this->db->quoteName('#__attributes', 'a') . ' ON (' . $this->db->quoteName('a.item_id') . ' = ' . 
          $this->db->quoteName('i.item_id') . ')');
 
          return $query;
}

En lugar de volver a escribir la función de consulta dos veces, una vez dentro de cada función, he extraído el código repetido y lo he puesto en una tercera función que ahora se puede llamar desde cualquiera de las otras dos funciones. Parece sencillo. De hecho, muchos desarrolladores están probablemente ya implementando este tipo de codificación para hacer su código aún  mejor.

Beneficios

¿Por qué es importante que no se repita? Hay muchos beneficios al escribir el código una sola vez. Claro, nadie le gusta perder el tiempo escribiendo código una y otra vez, pero aún más importante es que reduce la posibilidad de que se produzcan errores. Menos código significa menos posibilidades de puntos de fallo. Estoy seguro de que todos hemos tenido esos momentos en los que no podemos encontrar el problema hasta después de desperdiciar una hora o más mirando de encontrar un punto y coma que falta. A mi me ha pasado. Hay otros beneficios también. Si más tarde se da cuenta que necesita añadir otra tabla a la consulta, ya que su cliente necesita más información de la base de datos, ¡sólo tiene que actualizar una consulta ahora!

Seguro que MUCHOS Desarrolladores ya son conscientes de este principio de “No te repitas”. En caso contrario, si has aprendido este “nuevo” concepto, ¡felicidades PORQUE, habrás aprendido lo que significa escribir un código DRY (Don't Repeat Yourself - No te repitas a ti mismo).