manejo - variables globales php entre paginas

Referencia: ¿Qué es el alcance variable, qué variables son accesibles desde dónde y qué son los errores de "variable indefinida"?

Question

Nota: Esta es una pregunta de referencia para tratar el alcance variable en PHP. Cierre cualquiera de las muchas preguntas que coincidan con este patrón como duplicado de este.

¿Qué es el "alcance variable" en PHP? ¿Las variables de un archivo .php son accesibles en otro? ¿Por qué a veces obtengo errores de "variable indefinida" ?

Answer 1

¿Qué es el "alcance variable"?

Las variables tienen un "alcance" limitado, o "lugares desde los cuales son accesibles". Solo porque escribiste $foo = ''bar''; una vez en algún lugar de su aplicación no significa que puede consultar $foo desde cualquier otro lugar dentro de la aplicación. La variable $foo tiene un alcance determinado dentro del cual es válido y solo el código en el mismo ámbito tiene acceso a la variable.

¿Cómo se define un alcance en PHP?

Muy simple: PHP tiene alcance de función . Ese es el único tipo de separador de alcance que existe en PHP. Las variables dentro de una función solo están disponibles dentro de esa función. Las variables fuera de las funciones están disponibles en cualquier lugar fuera de las funciones, pero no dentro de ninguna función. Esto significa que hay un alcance especial en PHP: el alcance global . Cualquier variable declarada fuera de cualquier función está dentro de este alcance global.

Ejemplo:

<?php

$foo = ''bar'';

function myFunc() {
    $baz = 42;
}

$foo está en el alcance global , $baz está en un ámbito local dentro de myFunc . Solo el código dentro de myFunc tiene acceso a $baz . Solo el código fuera de myFunc tiene acceso a $foo . Ninguno de los dos tiene acceso al otro:

<?php

$foo = ''bar'';

function myFunc() {
    $baz = 42;

    echo $foo;  // doesn''t work
    echo $baz;  // works
}

echo $foo;  // works
echo $baz;  // doesn''t work

Ámbito y archivos incluidos

Los límites del archivo no separan el alcance:

a.php

<?php

$foo = ''bar'';

b.php

<?php

include ''a.php'';

echo $foo;  // works!

Se aplican las mismas reglas para include código d que se aplica a cualquier otro código: solo alcance separado de la function . A los fines del alcance, puede pensar en incluir archivos como copiar y pegar código:

c.php

<?php

function myFunc() {
    include ''a.php'';

    echo $foo;  // works
}

myFunc();

echo $foo;  // doesn''t work!

En el ejemplo anterior, a.php fue incluido dentro de myFunc , cualquier variable dentro de a.php solo tiene alcance de función local. El hecho de que parezcan estar en el ámbito global en a.php no necesariamente significa que lo sean, sino que realmente depende del contexto en el que se incluye / ejecuta el código.

¿Qué hay de las funciones dentro de las funciones y clases?

Cada nueva declaración de function introduce un nuevo alcance, es así de simple.

funciones (anónimas) dentro de las funciones

function foo() {
    $foo = ''bar'';

    $bar = function () {
        // no access to $foo
        $baz = ''baz'';
    };

    // no access to $baz
}

clases

$foo = ''foo'';

class Bar {

    public function baz() {
        // no access to $foo
        $baz = ''baz'';
    }

}

// no access to $baz

¿Para qué sirve el alcance?

Hacer frente a los problemas del alcance puede parecer molesto, ¡pero el alcance variable limitado es esencial para escribir aplicaciones complejas! Si cada variable que usted declara estuviera disponible desde cualquier otro lugar dentro de su aplicación, estaría pasando por encima de sus variables sin una forma real de rastrear qué cambia qué. Solo hay muchos nombres razonables que puede dar a sus variables, es probable que desee utilizar la variable " $name " en más de un lugar. Si solo pudieras tener este nombre único de variable una vez en tu aplicación, tendrías que recurrir a esquemas de nomenclatura realmente complicados para asegurarte de que tus variables sean únicas y de que no estés cambiando la variable incorrecta del código equivocado.

Observar:

function foo() {
    echo $bar;
}

Si no había alcance, ¿qué haría la función anterior? ¿De dónde viene $bar ? ¿Qué estado tiene? ¿Está incluso inicializado? ¿Tienes que verificarlo todo el tiempo? Esto no es mantenible. Lo que nos lleva a ...

Cruzando los límites del alcance

La forma correcta: pasar variables dentro y fuera

function foo($bar) {
    echo $bar;
    return 42;
}

La variable $bar entra explícitamente en este ámbito como argumento de función. Solo mirando esta función, está claro de dónde se originan los valores con los que trabaja. Luego devuelve explícitamente un valor. La persona que llama tiene la confianza de saber con qué variables funcionará la función y de dónde provienen sus valores de retorno:

$baz   = ''baz'';
$blarg = foo($baz);

Extender el alcance de las variables a funciones anónimas

$foo = ''bar'';

$baz = function () use ($foo) {
    echo $foo;
};

$baz();

La función anónima explícitamente incluye $foo desde su alcance circundante. Tenga en cuenta que esto no es lo mismo que el alcance global .

El camino equivocado: global

Como se dijo antes, el alcance global es algo especial, y las funciones pueden importar variables explícitamente desde allí:

$foo = ''bar'';

function baz() {
    global $foo;
    echo $foo;
    $foo = ''baz'';
}

Esta función usa y modifica la variable global $foo . ¡No hagas esto! _{(A menos que realmente realmente sepas realmente lo que estás haciendo, e incluso entonces: ¡no!)}

Todo lo que llama de esta función ve es esto:

baz(); // outputs "bar"
unset($foo);
baz(); // no output, WTF?!
baz(); // outputs "baz", WTF?!?!!

No hay indicios de que esta función tenga efectos secundarios , pero lo hace. Esto se convierte fácilmente en un enredo complicado ya que algunas funciones se siguen modificando y requieren algún estado global. Desea que las funciones sean apátridas , actúen solo en sus entradas y devuelvan resultados definidos, no importa cuántas veces las llame.

Debe evitar usar el alcance global de cualquier manera tanto como sea posible; sin duda no debería estar "sacando" variables del alcance global a un ámbito local.

Answer 2

Aunque no se puede acceder desde el exterior a las variables definidas dentro del alcance de una función, eso no significa que no pueda usar sus valores una vez que se complete esa función. PHP tiene una palabra clave static bien conocida que se utiliza ampliamente en PHP orientado a objetos para definir métodos y propiedades estáticos, pero se debe tener en cuenta que también se puede usar estática dentro de las funciones para definir variables estáticas.

¿Qué es ''variable estática''?

La variable estática difiere de la variable ordinaria definida en el alcance de la función en caso de que no pierda valor cuando la ejecución del programa abandona este ámbito. Consideremos el siguiente ejemplo de uso de variables estáticas:

function countSheep($num) {
 static $counter = 0;
 $counter += $num;
 echo "$counter sheep jumped over fence";
}

countSheep(1);
countSheep(2);
countSheep(3);

Resultado:

1 sheep jumped over fence
3 sheep jumped over fence
6 sheep jumped over fence

Si hubiésemos definido $counter sin static , cada valor echoed sería el mismo que el parámetro $num pasado a la función. Usar static permite construir este contador simple sin solución adicional.

Casos de uso de variables estáticas

1. Para almacenar valores entre las llamadas consecuentes a la función.
2. Para almacenar valores entre llamadas recursivas cuando no hay manera (o ningún propósito) de pasarlos como parámetros.
3. Para almacenar en caché el valor que normalmente es mejor recuperar una vez. Por ejemplo, resultado de leer un archivo inmutable en el servidor.

Trucos

La variable estática solo existe en un alcance de función local. No se puede acceder fuera de la función en la que se ha definido. Por lo tanto, puede estar seguro de que mantendrá su valor sin cambios hasta la próxima llamada a esa función.

La variable estática solo se puede definir como una expresión escalar o escalar (desde PHP 5.6). Asignarle otros valores conduce inevitablemente a una falla al menos en el momento en que se escribió este artículo. Sin embargo, puede hacerlo solo en la siguiente línea de su código:

function countSheep($num) {
  static $counter = 0;
  $counter += sqrt($num);//imagine we need to take root of our sheep each time
  echo "$counter sheep jumped over fence";
}

Resultado:

2 sheep jumped over fence
5 sheep jumped over fence
9 sheep jumped over fence

La función estática es un poco ''compartida'' entre métodos de objetos de la misma clase. Es fácil de entender al ver el siguiente ejemplo:

class SomeClass {
  public function foo() {
    static $x = 0;
    echo ++$x;
  }
}

$object1 = new SomeClass;
$object2 = new SomeClass;

$object1->foo(); // 1
$object2->foo(); // 2 oops, $object2 uses the same static $x as $object1
$object1->foo(); // 3 now $object1 increments $x
$object2->foo(); // 4 and now his twin brother

Esto solo funciona con objetos de la misma clase. Si los objetos son de diferentes clases (incluso se extienden entre sí), el comportamiento de vars estáticos será el esperado.

¿La variable estática es la única forma de mantener los valores entre llamadas a una función?

Otra forma de mantener los valores entre llamadas a funciones es usar cierres. Los cierres se introdujeron en PHP 5.3. En dos palabras, le permiten limitar el acceso a un conjunto de variables dentro de un ámbito de función a otra función anónima que será la única forma de acceder a ellas. Estar en variables de cierre puede imitar (más o menos exitosamente) conceptos de OOP como ''constantes de clase'' (si se aprobaron en el cierre por valor) o ''propiedades privadas'' (si se pasan por referencia) en la programación estructurada.

Este último realmente permite usar cierres en lugar de variables estáticas. Qué usar siempre depende del desarrollador decidir, pero se debe mencionar que las variables estáticas son definitivamente útiles cuando se trabaja con recursiones y merecen ser notadas por los desarrolladores.

Answer 3

El alcance de una variable es el contexto dentro del cual está definido. En su mayor parte, todas las variables PHP solo tienen un alcance único. Este único alcance abarca archivos incluidos y necesarios también. Por ejemplo:

<?php
$a = 1;
include ''b.inc'';
?>

Aquí, la variable $a estará disponible dentro del script b.inc incluido. Sin embargo, dentro de las funciones definidas por el usuario se introduce un alcance de función local. Cualquier variable utilizada dentro de una función está limitada por defecto al alcance de la función local. Por ejemplo:

<?php
$a = 1; /* global scope */ 

function test()
{ 
    echo $a; /* reference to local scope variable */ 
} 

test();
?>

Este script no generará ningún resultado porque el enunciado echo hace referencia a una versión local de la variable $ a, y no se le ha asignado un valor dentro de este ámbito. Puede notar que esto es un poco diferente del lenguaje C en que las variables globales en C están automáticamente disponibles para las funciones a menos que sean específicamente anuladas por una definición local. Esto puede causar algunos problemas ya que las personas pueden cambiar inadvertidamente una variable global. En PHP, las variables globales deben declararse globales dentro de una función si se van a usar en esa función.