III.1 Variables conceptos básicos

  • 0 Respuestas
  • 892 Vistas

Valarjar
Hijo de Odyn

III.1 Variables conceptos básicos
« en: Abril 11, 2017, 10:39:43 am »
En PHP las variables se representan con un signo de dólar seguido por el nombre de la variable. El nombre de la variable es sensible a minúsculas y mayúsculas.

Los nombres de variables siguen las mismas reglas que otras etiquetas en PHP. Un nombre de variable válido tiene que empezar con una letra o un carácter de subrayado (underscore), seguido de cualquier número de letras, números y caracteres de subrayado. Como expresión regular se podría expresar como: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'

Nota: Para los propósitos de este manual, una letra es a-z, A-Z, y los bytes del 127 al 255 (0x7f-0xff).
Nota: $this es una variable especial que no puede ser asignada.

Código: PHP
  1. <?php
  2. $var = 'Roberto';
  3. $Var = 'Juan';
  4. echo "$var, $Var";      // imprime "Roberto, Juan"
  5.  
  6. $4site = 'aun no';      // inválido; comienza con un número
  7. $_4site = 'aun no';     // válido; comienza con un carácter de subrayado
  8. $täyte = 'mansikka';    // válido; 'ä' es ASCII (Extendido) 228
  9. ?>
  10.  

De forma predeterminada, las variables siempre se asignan por valor. Esto significa que cuando se asigna una expresión a una variable, el valor completo de la expresión original se copia en la variable de destino. Esto quiere decir que, por ejemplo, después de asignar el valor de una variable a otra, los cambios que se efectúen a una de esas variables no afectará a la otra. Para más información sobre este tipo de asignación, vea Expresiones.

PHP también ofrece otra forma de asignar valores a las variables: asignar por referencia. Esto significa que la nueva variable simplemente referencia (en otras palabras, "se convierte en un alias de" ó "apunta a") la variable original. Los cambios a la nueva variable afectan a la original, y viceversa.

Para asignar por referencia, simplemente se antepone un signo ampersand (&) al comienzo de la variable cuyo valor se está asignando (la variable fuente). Por ejemplo, el siguiente segmento de código produce la salida 'Mi nombre es Bob' dos veces:

Código: PHP
  1. <?php
  2. $foo = 'Bob';                // Asigna el valor 'Bob' a $foo
  3. $bar = &$foo;                // Referenciar $foo vía $bar.
  4. $bar = "Mi nombre es $bar";  // Modifica $bar...
  5. echo $bar;
  6. echo $foo;                   // $foo también se modifica.
  7. ?>

Algo importante a tener en cuenta es que sólo las variables con nombre pueden ser asignadas por referencia.

Código: PHP
  1. <?php
  2. $foo = 25;
  3. $bar = &$foo;      // Esta es una asignación válida.
  4. $bar = &(24 * 7);  // Inválida; referencia una expresión sin nombre.
  5.  
  6. function test()
  7. {
  8.    return 25;
  9. }
  10.  
  11. $bar = &test();    // Inválido.
  12. ?>

No es necesario inicializar variables en PHP, sin embargo, es una muy buena práctica. Las variables no inicializadas tienen un valor predeterminado de acuerdo a su tipo dependiendo del contexto en el que son usadas - las booleanas se asumen como FALSE, los enteros y flotantes como cero, las cadenas (p.ej. usadas en echo) se establecen como una cadena vacía y los arrays se convierten en un array vacío.

Ejemplo #1 Valores predeterminados en variables sin inicializar

Código: PHP
  1. <?php
  2. // Una variable no definida Y no referenciada (sin contexto de uso); imprime NULL
  3. var_dump($variable_indefinida);
  4.  
  5. // Uso booleano; imprime 'false' (Vea operadores ternarios para más información sobre esta sintaxis)
  6. echo($booleano_indefinido ? "true\n" : "false\n");
  7.  
  8. // Uso de una cadena; imprime 'string(3) "abc"'
  9. $cadena_indefinida .= 'abc';
  10. var_dump($cadena_indefinida);
  11.  
  12. // Uso de un entero; imprime 'int(25)'
  13. $int_indefinido += 25; // 0 + 25 => 25
  14. var_dump($int_indefinido);
  15.  
  16. // Uso de flotante/doble; imprime 'float(1.25)'
  17. $flotante_indefinido += 1.25;
  18. var_dump($flotante_indefinido);
  19.  
  20. // Uso de array; imprime array(1) {  [3]=>  string(3) "def" }
  21. $array_indefinida[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
  22. var_dump($array_indefinida);
  23.  
  24. // Uso de objetos; crea un nuevo objeto stdClass (vea http://www.php.net/manual/en/reserved.classes.php)
  25. // Imprime: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }
  26. $objeto_indefinido->foo = 'bar';
  27. var_dump($objeto_indefinido);
  28. ?>
« Última modificación: Abril 11, 2017, 11:44:32 am por Valarjar »