¿Cuál es el uso correcto de las funciones y variables globales?

Question

Recientemente he visto en la pregunta ¿Cómo crear una function global que contenga el id de la urls? que en una de sus respuestas se menciona que las variables globales son en general una mala práctica.

Como referencia existe esta pregunta: ¿Por qué es considerado una mala práctica utilizar variables globales? existe una gran documentación confusa, cierta parte mal criticada las funciones globales, al menos que este confundido sobre el tema y que mis variables globales no sean globales.

Se dice en unas de las respuestas que las variables globales crean dependencias ocultas, cuando se trata de aplicaciones grandes mencionando que ni uno mismo sabe/recuerda/no se tiene claro los objetos que tienes y sus relaciones.

Las variables globales dentro de funciones son una gran utilidad, yo las considero de tal manera, a la hora de trabajar conjuntamente con PHP & HTML.

En este ejemplo no veo como puede ser una mala práctica, al menos que exista alguna vulnerabilidad de seguridad en ellas.

$connect = new mysqli('127.0.0.1', 'tu_usuario', 'tu_contraseña', 'sakila');

function user(){...
  global $connect; //conexión a la base de datos  

   // Código de la consulta
}

Resultado de la function en HTML

<div><?php  user();?></div>

¿Me podrían explicar cómo sería una mala practica?

¿A qué variables se les determina como una variable global?

Las palabras reservadas de PHP global $conexion; intervienen en el tema.

Nota: Existe una pregunta de por qué es considerado una mala práctica, quizás este enlazado al mismo tema, pero la pregunta es muy distinta entre sí, existe la manera de uso pero no ejemplos para novatos en programación, mucha teoría sin práctica sería confuso, en resumen la respuesta se trata de ver más el lado malo a una solución, es para mí algo muy confuso entre tantas lineas a pesar que tengo experiencia programando.

Answer 1

Yendo al grano y hablando desde un punto de vista estrictamente de PHP

¿Por qué evitar las variables globales en PHP?

1. Las variables globales son más costosas que las locales. Ya que obliga a PHP a escanear todo el ambito de variables hasta encontrarla, por lo que una variable local dentro de una función siempre será más rápida que una global.

2. Reducen la reusabilidad del código. La razón es que todos los proyectos no tienen las mismas variables globales por lo que una función que utilice variables globales dificulta la reutilización de dicha función. en POO directamente rompen la encapsulación.

3. Las funciones que utilizan variables globales pueden llevar a engaño, esto esta ligado al punto anterior. Una funcion que el argumento este pasado en el cuerpo como global puede aparentar que no necesita argumentos, lo que puede generar un código confuso y ambiguo. Si una función requiere argumentos mejor pasarlos directamente.

4. Al utilizar variables locales en lugar de globales existe menor probabilidad de conflicto de nombres con otras variables, ya que las variables locales solo existen en el ámbito local.

5. Las variables globales pueden ser modificadas desde cualquier parte del programa, algo que puede dar muchos dolores de cabeza ya que sera difícil saber donde y cuando se ha modificado.

Ejemplos al final.

---

¿A qué variables se les determina como una variable global?

Las variables globales son aquellas variables que estan definidas en el ámbito general del programa (ámbito de las variables). Por otro lado tenemos las superglobales que además de lo anterior también pueden ser accedidas desde cualquier parte del programa directamente, PHP provee múltiples variables superglobales entra ellas $GLOBALS que es un segundo método para acceder a las variables del ámbito global.

---

Funciones globales

Si nos referimos a funciones globales, en el manual podemos encontrar lo siguiente:

Funciones definidas por el usuario

Todas las funciones (no confundir con los métodos de una clase) y clases de PHP tienen ámbito global. Se pueden llamar desde fuera de una función incluso si fueron definidas dentro, y viceversa.

---

Métodos de clase globales

Cómo tal no se pueden declarar los métodos de una clase como globales, por lo que no se pueden utilizar directamente en el ámbito global sin instanciar antes la clase, básicamente los métodos globales no existen. No obstante, PHP nos permite declarar métodos estáticos, estos métodos estaticos podrán ser accedidos en cualquier ámbito, anteponiendo el nombre de la clase y el doble dos puntos a dicho método estático (miClase::miMetodo( )).

---

Ejemplos

Ejemplo punto 3

// Función con global
// Más lento/más costoso
// Argumento en cuerpo, resulta en una dependencia escondida
$var = 'miConexion';
function mi_funcion()
{ 
    // Depende de que $var exista globalmente 
    global $var;
    // Resto de operaciones
    // $var puede ser modificado globalmente 
}

// La llamada aparentemente no necesita argumentos
// pues aparentemente no se pasa nada a la función 
mi_funcion(); 

/*-----------------------------*/

// Función SIN global
// Más rápido/menos costoso
// Argumentos requeridos claros
function mi_funcion_2($conexion)
{ 
    // Operaciones con $conexion
    // $Conexion solo se puede modificar localmente 
}

// sabemos que se está pasando a la función
mi_funcion_2('miConexion');

Ejemplo punto 5:

<?php
// Modificar el valor de $var
$var = 'Hola';
function mi_funcion()
{
    global $var;
    $var.= ' mundo!';
    echo $var; // Hola mundo!
}

mi_funcion();
echo $var; // Hola mundo!

/*-----------------------------*/

// NO modifica el valor de $var
$var = 'Hola';
function mi_funcion_2($var)
{
    $var.= ' mundo!';
    echo $var; // Hola mundo!
}

mi_funcion_2($var);
echo $var; // Hola 

El beneficio de utilizar variables globales en PHP es minimo y utilizarlas por comodidad no es más que vagueza.

Answer 2

Cuando se plantea como diseñar un sistema de información, la forma de hacerlo para que resulte mantenible en el tiempo, y por diferentes personas, es dividirlo en sub-sistemas mas simples tendiendo a llegar unidades lógicas (programas) que tengan una única responsabilidad, que se comporten como si fueran un “componente”. Y por otro lado reducir al mínimo las dependencias entre estos programas.

En la medida en que mejor podamos cumplir con estos dos objetivos más rápido un nuevo programador puede entender el funcionamiento del sistema, y menos complejo es cambiar, reemplazar, o eliminar alguno de los programas.

Las variables principalmente caen del lado del las dependencias.

Una variable local a una función, nace y muere dentro de la función y ningún otro programa sabe de su existencia. Entonces, si la función es modificada y esa variable cambia de nombre, de tipo de dato, de rango de valores, o se elimina, el impacto del cambio queda dentro de la función y mientras que esta función siga recibiendo los mismos datos como parámetro y siga entregando el mismo resultado, al resto del sistema le es transparente lo que se haya hecho con esa variable local.

Ahora, supongamos que esta función utiliza una variable global, esto es una variable que está definida a nivel del sistema y todos los programas, funciones, procedimientos tiene acceso a ella la usen (lean y/o modifiquen) o no. Eso significa que ya no es sólo la función la que puede leer o modificar esa variable.
La variable global crea una dependencia entre la función y el resto de las funciones, programas, o procedimientos que también utilizan la misma variable global, y esto hace más complejo el mantenimiento. Es decir, si tenemos que eliminar esa función, cambiarle el tipo de dato a la variable, o su rango de valores, hay que revisar en todos lados donde se utilice esa variable para determinar el impacto del cambio, y en muchos casos este tipo de dependencias provoca que una modificación en una función, traiga aparejado más modificaciones en otras partes del sistema que a simple vista parecen no tener relación.

Cuando esto se piensa en sistemas con cientos de programas y miles de líneas de código, y se le suma la rotación de programadores, lo más probable es que alguno de estos cambios no sea detectado y aflore en producción de forma totalmente inesperada e incluso en apariencia no relacionada con la modificación que se hizo, lo que contribuye a que sean errores también muy engorrosos de corregir.

EDICIÓN I

Respecto a mantener la conexión a la base de datos en una variable global.

Si se usa una sola conexión que no se cierre hasta que no termina el programa, la variable ya es global por naturaleza ya sea que la guarde en una variable global o se la pase como parámetro por todo el sistema, y no está exenta de los problemas mencionados. Por ejemplo, al hacer un mantenimiento, alguien puede introducir inadvertidamente el cierre de la conexión en algún lado, o hacer un commit o un rollback de una transacción en un lugar incorrecto y afectar otras funciones que se hacen más adelante en el flujo del programa (para dar un par de ejemplos).

La otra opción es abrir una conexión cada vez que se necesita hacer un query y cerrarla después de haberlo ejecutado.

Pero abrir conexiones a la base de datos es costoso en términos de tiempo. Entonces se suelen balancean los pros y contras de ambas opciones y si los pros superan a las contras se opta por dejar la conexión como recurso global y se toman algunas otras medidas como para mitigar la ocurrencia de problemas.

Un ejemplo es reduciendo al mínimo las funciones que usan la conexión. Sería el caso de tener una única función o una familia de funciones bien conocidas que reciba/n los parámetros del query, lo ejecuten y devuelve el resultado a la función invocante vs. que cada función use la variable global directamente.

En esto de balancear los pros y contras hay varias cosas para considerar para ir por uno u otro camino. Entre ellas: detalles de implementación del driver de la base de datos, si se usan pools de conexiones, y si el sistema se ejecuta en un solo hilo o si admite concurrencia.

En el caso de PHP entiendo que corre en un solo hilo y lo más conveniente es abrir la conexión y mantenerla abierta. Por lo que mantener una conexión global es una alternativa viable y se pueden mitigar los riesgos reduciendo el número de funciones que utilizan la conexión.

Answer 3

Al ser un tema subjetivo como una mala práctica, pueden existir distintas opiniones. Generalmente cuando empezás a programar (sin importar el lenguaje) se cae en la tentación de incluir todo el código dentro de una única función (main) porque simplemente parezca mas práctico (al comienzo).

Cuando el desarrollo es chico, y administrado por uno mismo, puede que sea mas práctico usar variables globales en algunas situaciones. Pero cuando el desarrollo es grande, y hay bastantes archivos a veces se pierde el seguimiento o trazabilidad de las variables mas cuando son globales.

Usar variables globales además rompe un poco la modularidad del desarrollo, es como usar el GOTO en C.

Es una buena práctica usar el menor número de variables globales posibles, pero en la mayoría de casos, si las usas simplemente no va a pasar nada.

Answer 4

a mi me pasaba lo mismo, queria hacer uso de mis variables de conexion, datos de usuario, ... en cualquier punto pero me resultaba frustrante la mala legibilidad del codigo, estuve estudiando el uso que hacia PHP de las variables y funciones y al final llegue a una conclusion (mas o menos acertada, pero que funciona), paso a contarosla.

PHP se podria decir que funciona en circulos de actividad, donde uno seria el hilo principal del programa, y todas las variables y funciones declaradas en el, y otro el que comprende a los objetos (clases). Todas las variables y funciones del hilo principal son globales y pueden ser llamadas directamente (funciones) o mediante la declaracion "global" (variables). Las clases se adhieren al hilo principal al instanciarlas o invocarlas (clases static), ademas pueden ser englobadas en otros circulos de actuacion mediante la creacion de "namespaces", unen al hilo principal sus funciones declaradas "public" (por defecto si no declara otra cosa) y mantienen como propias las "private".

Mas o menos (a grandes rasgos) como funciona la parte global y privada de PHP. Ahora bien, el problema que nos ocupa es hacer mas legible el codigo y no perder la parte global de las variables esto se puede conseguir con las funciones de clases "static", una funcion static no necesita tener su objeto asociado instanciado para poder ser llamada (al igual que una variable static), solo necesita tener el objeto cargado bien con "include" o "require".

    &lt?php class MyConfig{ 
             public static $user='Javier';
             public $amigo='Pepito'; 
             public static function abreviatura(){
                 return substr(self::$user,0,3);
             }
          }
          function getAbreviaturaDeJavier(){
                 return MyConfig::abreviatura();
          }
          echo 'Mi nombre es '.MyConfig::$user.' y abreviatura '.getAbreviaturaDeJavier();
?>

Aqui podemos ver como usar esos objetos estaticos, la clase MyConfig tiene una variable estatica $user y una funcion estatica abreviatura(), estos son globales si la clase esta cargada y llamables desde cualquier punto del programa, lo malo de las funciones y metodos estaticos es que son eso "estaticos" no admiten el llamar a metodos del objeto sin instanciarlo, por ejemplo:

  function abreviatura(){
       return substr($this->amigo,0,3);
   }

Esto nos daria un error, ya que, el metodo static no tendria acceso a las variables (no static) del objeto MyConfig. Pero una variable static es como una variable global, ejemplo:

class MyConfig{
  public static $clientIp='10.10.10.10';
}
function getRealIP(){
  MyConfig::$clientIp=$_SERVER['REMOTE_ADDR'];
}
echo getRealIP();
echo MyConfig::$clientIp;

En el ejemplo anterior el objeto MyConfig declara y asigna un valor a la variable $clientIp, que luego es modificado por la funcion getRealIP(), en los dos echo posteriores el valor devuelto es el mismo, ya que, la funcion modifica el valor de la variable del metodo.

Si todo esto lo aplicamos al problema de la conexion a la bbdd nos quedaria:

class DB{
    public static $conexion;
    public static function conectarDB($user,$pass,$server){
        self::$conexion=new DB($user,$pass,$server);
        }
   function __construct($user,$pass,$server){
        return new PDO->connect($user,$pass,$server);
   }
}

DB::conectarDB('miuser','mipass','miserver');

function getUser($id){
   $query=DB::$conexion->query('select * from user where id='.$id);
   return $query->fetch();
}

$user=getUser(2);

Las bases de datos y el conector PDO tienen suficientes funciones como para que no nos haga falta mantener mas de una conexion abierta a la bbdd (fetch_all) y de esta forma dispondremos de metodos y variables globales para usar donde nos plazca.

Ademas de esta forma el codigo es mucho mas legible, ordenado y ampliable.

Answer 5

Como ya han explicado el uso de variables globales rompería de alguna manera encapsulamiento. Cuando pensamos en objetos los mismos tienen que tener una alta cohesión y bajo acoplamiento para que puedas reutilizar el código. Pero cuando hablas de un sistema no todo puede convertirse en un objeto que represente el "ámbito del dominio" del problema, también tienes que dar solución al "ámbito de la solución", valga la redundancia, por lo cual esta muy bien el uso de variables globales. Por esta razón la mayoría de los lenguajes orientados a objetos permiten el uso de de datos compartidos sin necesidad de crear objetos para ello. El error a mi entender es que utilices ese mecanismo en forma descontrolada y no estudiada.

Por ejemplo, quizás quieras tener dos variables globales SESSION['tmpNomUsu'] y SESSION['tmpIdUsu'] las cuales pueden ser accedidas desde cualquier parte del programa. para aumentar el control puedes encapsular dichas variables en una clase y acceder a estas siempre desde un objeto.

class tmpVal(){

    definirTmpNomUsu($tmpNomUsu){
       $_SESSION['tmpNomUsu'] = $tmpNomUsu;
    }

    obtenerTmpNomUsu(){
       return $_SESSION['tmpNomUsu'];
    }

    definirTmpIdUsu($tmpIdUsu){
       $_SESSION['tmpIdUsu'] = $tmpIdUsu;
    }

    obtenerTmpIdUsu(){
       return $_SESSION['tmpIdUsu'];
    }

}

Ahora sabes que tus variables globales están encapsuladas en una clase, podrías violar el "contrato" accediendo desde otro lugar que no sea la clase "tmpVal" de la misma forma que lo harías realizando llamadas a la DB desde fuera de una clase.
Por otro lado, aprovechas un mecanismo sencillo para resolver un problema sencillo sin necesidad de hacerlo complejo.

Answer 6

Como habrás leído en las respuestas anteriores, generalmente se considera una mala práctica el uso de variables globales, no solo en PHP, sino en general, en casi cualquier lenguaje de programación.

Algunas razones para no utilizar variables globales...

• El código fuente es más fácil de leer y mantener, ya que tenemos una idea clara de dónde se están afectando los valores y tenemos menor incertidumbre de cambios no esperados.
• No hay validaciones de qué valores son permisibles y cuáles no. No tenemos la certeza de que en cualquier punto de la aplicación se esté modificando a un valor no esperado (si solo debemos aceptar enteros positivos, no hay garantía de que en algún lugar se asigne un valor negativo).
• Alto Acoplamiento. Un programa con uso de variables globales, se vuelve dependiente de esas variables y complica la modularización ¿Qué va a pasar si requiero llevar una parte/módulo del sistema y hay una dependencia de variables globales? Sin duda implicará un esfuerzo de adaptación.
• Problemas de concurrencia. Si se puede acceder a una variable desde múltiples hilos, se requiere asegurar que se controle el acceso concurrente en cada punto en que se pueda modificar.
• Conflictos de nombres. Las variables locales pueden tener el mismo nombre de una variable global, lo que implica que eventualmente se podría tener bugs generados porque estoy intentando modificar el valor de una variable distinta de la que se intenta.

Estos puntos los tomé como base de un artículo en el siguiente link: http://wiki.c2.com/?GlobalVariablesAreBad

En relación a las conexiones de Base de Datos, es cierto que son caras y resulta mejor no estar abriendo y cerrando; sin embargo, algunos gestores de base de datos (Oracle y SQL Server), implementan un pooling de conexiones, a través del cual se optimizan los procesos de apertura y cierre, básicamente reutilizándolas (una especie de cache de conexiones).