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.
No hay comentarios:
Publicar un comentario