php: Variables locales

Una variable declarada en una función se considera local, es decir, que se puede hacer referencia exclusivamente en esa función. Any assignment outside of that function will be considered to be an entirely different variable from the one contained in the function: Cualquier cesión fuera de esa función se considera que una variable totalmente diferente de la que figura en la función:

$x = 4; $ X = 4;

function assignx () { assignx función () {

$x = 0; $ X = 0;

print "\$x inside function is $x. print "\ $ x dentro de la función es de $ x.
"; ";

} }

assignx(); assignx ();

print "\$x outside of function is $x. print "\ $ x fuera de la función es $ x.
"; ";

?> >

OPERADORES ARITMETICOS

The arithmetic operators in PHP are addition (+), subtraction (-), multiplication (*), division (/) and modulus (%). Los operadores aritméticos en PHP son de suma (+), resta (-), multiplicación (*), división (/) y módulo (%). These operators work as in standard algebra. Estos operadores trabajan como en el álgebra normal.

Ejemplo	Nombre	Resultado
-$a	Negación	Opuesto de `$a`.
$a + $b	Adición	Suma de `$a` y `$b`.
$a - $b	Sustracción	Diferencia de `$a` y `$b`.
$a * $b	Multiplicación	Producto de `$a` y `$b`.
$a / $b	División	Cociente de `$a` y `$b`.
$a % $b	Módulo	Resto de `$a` dividido por `$b`

El operador de división ("/") devuelve un valor flotante a menos que los dos operandos sean integers (o strings que se conviertan a integers) y los números sean divisibles, en cuyo caso será devuelto un valor integer.

Los operandos del módulo se convierten en integers (por extracción de la parte decimal) antes del procesamiento.

El resultado del operador módulo % tiene el mismo signo que el dividendo — es decir, el resultado de $a % $b tendrá el mismo signo que $a. Por ejemplo:

OPERADORES LOGICOS

Ejemplo	Nombre	Resultado
$a and $b	And (y)	`TRUE` si tanto `$a` como `$b` son `TRUE`.
$a or $b	Or (o inclusivo)	`TRUE` si cualquiera de `$a` o `$b` es `TRUE`.
$a xor $b	Xor (o exclusivo)	`TRUE` si `$a` o `$b` es `TRUE`, pero no ambos.
! $a	Not (no)	`TRUE` si `$a` no es `TRUE`.
$a && $b	And (y)	`TRUE` si tanto `$a` como `$b` son `TRUE`.
$a \|\| $b	Or (o inclusivo)	`TRUE` si cualquiera de `$a` o `$b` es `TRUE`.


<?php

echo (5 % 3)."\n";           // muestra 2
echo (5 % -3)."\n";          // muestra 2
echo (-5 % 3)."\n";          // muestra -2
echo (-5 % -3)."\n";         // muestra -2

?>

`TIPOS DE DATOS`

A la hora de programar tendremos que hacer uso de multitud de datos, estos datos no serán más que información ya descodificada y concreta.

Por ejemplo “2” es un dato porque es información, está descodificada (conocemos si significado) y es concreta ya que tiene sentido por sí sola.

PHP dispone distintos tipos de estos datos que es necesario conocer para poder programar con garantías. Ninguno de ellos es difícil de asimilar, aunque unos son más simples que otros.

También hay que decir que si asignamos una variable a un tipo de dato, ésta adquirirá en su denominación la del tipo de dato. Por ejemplo, si asignamos a una variable un dato booleano ésta se llamará variable de tipo booleano.

Booleanos

Es el tipo de dato más simple que existe, ya que solo puede tener dos valores posibles que se conocen como true o false. El primer valor significa verdadero, y el segundo falso.

Para hacer una variable de este tipo tan solo hay que escribir su nombre y asignarle o true o false; ya que éstos son los dos únicos datos booleanos que existen.

<?php
 $guapo = true;
 $simpatico = false;
?>

Cabe decir también que el valor false equivale al número 0; mientras que el valor true a cualquier otro número. No obstante, se suele utilizar el número 1 para true.

Enteros

Como en matemáticas, este tipo de dato se refiere a números enteros; es decir, a números que no son decimales, sinó que poseen unidades enteras. También se incluye el cero y los números negativos.

<?php
 $cero = 0;
 $ocho = 8;
 $ocho = -3;
?>

Decimales

Los decimales también son un tipo de datos en PHP, son similares a los enteros pero con la particulariedad de soportar decimales. Estos decimales hay que separarlos del número entero por un punto, y no por una coma como estamos acostumbrados en matemáticas.

<?php
 $mi_nota = 7.5;
 $tu_nota = 8.67;
 $mi_negativo = -2.32;
?>

Cadenas

Estie tipo de dato, las cadenas, es uno de los más importantes ya que es un tipo de dato que se tiene que utilizar muy a menudo en programación PHP. Una cadena es una sucesión de caractéres. Estos pueden ser letras, números, signos de puntuación...

Para escribir cadenas es necesario ponerlas entre comillas, con la posibilidad que sean comillas simples o dobles. Vemos un ejemplo:

<?php
 $mi_cadena = 'hola,  mundo.';
?>

CONSTANTES

Una constante es un identificador (nombre) para expresar un valor simple. Como el nombre sugiere, este valor no puede variar durante la ejecucción del script. (A excepción de las constantes predefinidas , que en realidad no son constantes). Una constante es sensible a mayúsculas por defecto. Por convención, los identificadores de contantes siempre suelen declararse en mayúsculas.

El nombre de una constante sigue las mismas reglas que cualquier otra etiqueta de PHP. Un nombre de constante válido empieza por una letra o subguión, seguido por cualquier número o letras, números o subguiones. Usando una expresión regular, se representaría de la siguiente manera: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*

Nombre	Descripción
`__LINE__`	Línea actual en el fichero.
`__FILE__`	Ruta completa y nombre del fichero. Si se usa dentro de un include, devolverá el nombre del fichero del include. Desde PHP 4.0.2, `__FILE__` siempre contiene la ruta absoluta con symlinks resueltos, en otras versiones contenía la ruta relativa según las circunstancias.
`__DIR__`	Directorio del fichero. Si se utiliza dentro de un include, devolverá el directorio del fichero incluído. Esta constante es igual que dirname(__FILE__). El nombre del directorio no lleva la barra inicial a no ser que esté en el directorio root. (Fue añadida en PHP 5.3.0)
`__FUNCTION__`	Nombre de la función. (Añadida en PHP 4.3.0) Desde PHP 5 esta constante devuelve el nombre de la función donde fue declarada (sensible a mayúsculas). En PHP 4 su valor siempre es en minúsculas.
`__CLASS__`	Nombre de la clase. (Añadida en PHP 4.3.0) Desde PHP 5 esta constante devuelve el nombre de la clase donde fue declarada (sensible a mayúsculas). En PHP 4 su valor siempre es en minúsculas. El nombre de la clase incluye el namespace declarado en (p.e.j. Foo\Bar). Tenga en cuenta que a partir de PHP 5.4 __CLASS__ también funciona con traits. Cuando es usado en un método trait, __CLASS__ es el nombre de la clase del trait que está siendo utilizado.
`__TRAIT__`	El nombre de el trait. (Añadido en PHP 5.4.0) A partir de PHP 5.4 esta constante devuelve el trait que fué declarado (sensible a mayúsculas y minúsculas). El nombre de el trait incluye el namespace si alguno fué declarado en (p.e.j. Foo\Bar).
`__METHOD__`	Nombre del método de la clase. (Añadida en PHP 5.0.0.) Nombre del método devuelto donde fue declarada. (sensible a mayúsculas).
`__NAMESPACE__`	Nombre del espacio de nombres actual (sensible a mayúsculas). Esta constante se define en tiempo de compilación (Añadida en PHP 5.3.0) El nombre del namespace actual (sensible a mayúsculas).

Variables estáticas y globales

El ámbito de una variable es el contexto dentro del que la variable está definida. La mayor parte de las variables PHP sólo tienen un ámbito simple. Este ámbito simple también abarca los ficheros incluídos y los requeridos. Por ejemplo:


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

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


<?php
$a = 1; /* ámbito global */

function test()
{
    echo $a; /* referencia a una variable del ámbito local */
}

test();
?>

Este script no producirá salida, ya que la sentencia echo utiliza una versión local de la variable $a, a la que no se ha asignado ningún valor en su ámbito. Puede que usted note que hay una pequeña diferencia con el lenguaje C, en el que las variables globales están disponibles automáticamente dentro de la función a menos que sean expresamente sobreescritas por una definición local. Esto puede causar algunos problemas, ya que la gente puede cambiar variables globales inadvertidamente. En PHP, las variables globales deben ser declaradas globales dentro de la función si van a ser utilizadas dentro de dicha función.

La palabra clave global

En primer lugar, un ejemplo de uso de global:

Ejemplo #1 Uso de global


<?php
$a = 1;
$b = 2;

function Suma()
{
    global $a, $b;

    $b = $a + $b;
}

Suma();
echo $b;
?>

El script anterior producirá la salida "3". Al declarar $a y $b globales dentro de la función, todas las referencias a tales variables se referirán a la versión global. No hay límite al número de variables globales que se pueden manipular dentro de una función.

Un segundo método para acceder a las variables desde un ámbito global es usando el array $GLOBALS El ejemplo anterior se puede reescribir así:

Ejemplo #2 Uso de $GLOBALS en lugar de global


<?php
$a = 1;
$b = 2;

function Suma()
{
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

Suma();
echo $b;
?>

El array $GLOBALS es un array asociativo con el nombre de la variable global como clave y los contenidos de dicha variable como el valor del elemento del array. $GLOBALS existe en cualquier ámbito, esto ocurre ya que $GLOBALS es una superglobal. Aquí hay un ejemplo que demuestra el poder de las superglobales:

Ejemplo #3 Ejemplo que demuestra las superglobales y el ámbito


<?php
function test_global()
{
    // La mayoría de variables predefinidas no son "super" y requieren
    // 'global' para estar disponibles al ámbito local de las funciones.
    global $HTTP_POST_VARS;

    echo $HTTP_POST_VARS['name'];

    // Las superglobales están disponibles en cualquier ámbito y no
    // requieren 'global'. Las superglobales están disponibles desde
    // PHP 4.1.0, y ahora HTTP_POST_VARS se considera obsoleta.
    echo $_POST['name'];
}
?>

Nota:

Utilizar una clave global fuera de una función no es un error. Esta puede ser utilizada aún si el fichero está incluido desde el interior de una función.

Uso de variables estáticas

Otra característica importante del ámbito de las variables es la variable estática. Una variable estática existe sólo en el ámbito local de la función, pero no pierde su valor cuando la ejecución del programa abandona este ámbito. Consideremos el siguiente ejemplo:

Ejemplo #4 Ejemplo que demuestra la necesidad de variables estáticas


<?php
function test()
{
    $a = 0;
    echo $a;
    $a++;
}
?>

Esta función tiene poca utilidad ya que cada vez que es llamada asigna a $a el valor 0 e imprime un "0". La sentencia $a++, que incrementa la variable, no sirve para nada, ya que en cuanto la función finaliza, la variable $a desaparece. Para hacer una función útil para contar, que no pierda la pista del valor actual del conteo, la variable $a debe declararse como estática:

Ejemplo #5 Ejemplo del uso de variables estáticas


<?php
function test()
{
    static $a = 0;
    echo $a;
    $a++;
}
?>

Ahora, $a se inicializa únicamente en la primera llamada a la función, y cada vez que la función test() es llamada, imprimirá el valor de $a y lo incrementa.

Las variables estáticas también proporcionan una forma de manejar funciones recursivas. Una función recursiva es la que se llama a sí misma. Se debe tener cuidado al escribir una función recursiva, ya que puede ocurrir que se llame a sí misma indefinidamente. Hay que asegurarse de implementar una forma adecuada de terminar la recursión. La siguiente función cuenta recursivamente hasta 10, usando la variable estática $count para saber cuándo parar:

Ejemplo #6 Variables estáticas con funciones recursivas


<?php
function test()
{
    static $count = 0;

    $count++;
    echo $count;
    if ($count < 10) {
        test();
    }
    $count--;
}
?>

Nota:

Las variables estáticas pueden ser declaradas como se ha visto en los ejemplos anteriores. Al tratar de asignar valores a estas variables que sean el resultado de expresiones, causará un error de análisis sintáctico.

Ejemplo #7 Declaración de variables estáticas

<?php function foo(){ static $int = 0; // correcto static $int = 1+2; // incorrecto (ya que es una expresión) static $int = sqrt(121); // incorrecto (es una expresión también) $int++; echo $int; } ?>

Nota:

Las declaraciones estáticas son resueltas en tiempo de compilación.

Nota:

Utilizar una clave global fuera de una función no es un error. Esta pueda ser utilizada aún si el fichero está incluido en el interior de una función.

Referencias con variables globales y estáticas

El motor Zend 1, utilizado por PHP 4, implementa los modificadores static y global para variables en términos de referencias. Por ejemplo, una variable global verdadera importada dentro del ámbito de una función con global crea una referencia a la variable global. Esto puede ser causa de un comportamiento inesperado, tal y como podemos comprobar en el siguiente ejemplo:


<?php
function prueba_referencia_global() {
    global $obj;
    $obj = &new stdclass;
}

function prueba_no_referencia_global() {
    global $obj;
    $obj = new stdclass;
}

prueba_referencia_global();
var_dump($obj);
prueba_no_referencia_global();
var_dump($obj);
?>

El resultado del ejemplo sería:

NULL
object(stdClass)(0) {
}

Un comportamiento similar se aplica a static. Las referencias no son almacenadas estáticamente.


<?php
function &obtener_instancia_ref() {
    static $obj;

    echo 'Objeto estático: ';
    var_dump($obj);
    if (!isset($obj)) {
        // Asignar una referencia a la variable estática
        $obj = &new stdclass;
    }
    $obj->property++;
    return $obj;
}

function &obtener_instancia_no_ref() {
    static $obj;

    echo 'Objeto estático: ';
    var_dump($obj);
    if (!isset($obj)) {
        // Asignar el objeto a la variable estática
        $obj = new stdclass;
    }
    $obj->property++;
    return $obj;
}

$obj1 = obtener_instancia_ref();
$aun_obj1 = obtener_instancia_ref();
echo "\n";
$obj2 = obtener_instancia_no_ref();
$aun_obj2 = obtener_instancia_no_ref();
?>

El resultado del ejemplo sería:

Objeto estático: NULL
Objeto estático: NULL

Objeto estático: NULL
Objeto estático: object(stdClass)(1) {
["property"]=>
int(1)
}

Este ejemplo demuestra que al asignar una referencia a una variable estática, esta no es recordada cuando se invoca la funcion &obtener_instancia_ref() por segunda vez.

php

martes, 8 de mayo de 2012

Variables locales