PHP 6

Variables

Una variable es un espacio de memoria reservado para almacenar un valor que corresponde a un tipo de dato soportado por el lenguaje de programación. Una variable es representada y usada a través de una etiqueta (un nombre) que le asigna un programador o que ya viene predefinida.

Las variables pueden ser del tipo:

Tipo de datos

Estos se definen como un conjunto de valores y las operaciones que se permiten en esos valores.
El tipo de datos básicos incluidos en PHP son variables, es decir; son identificadores para la ubicación de memoria para almacenar datos.

Integer (entero: -1): $q = -1;

Double (real: 1.2e4): $q = 1.2e4;

String (cadena de caracteres: "Hola"): $q = "Hola";

Boolean (true, false):

        
	$q = true;
	$q = ( $var1 > $var2 ); 
$Cadena = "Tipo de dato de cadena";

$NumeroEntero = 1;  // Un valor entero 

$NumeroFlotante = 1.55; // Un valor numérico con decimales 

$Booleano = True; // Un valor booleano True (1) o False (0)  
 
$Matriz[0]= "A"; // Primer elemento de un matriz  
 
$Matriz[2] = 3; // Matriz con índice 2 y valor numérico 3 
 
$Matriz[4] = "Barcelona"; // Matriz índice 4, dato de tipo cadena  
 
$Matriz[5] = "París"; // Matriz índice 5, dato de tipo cadena 

  echo "_ Booleano: " . $Booleano . " <br />";

  echo "_ $Matriz[0]: " . $Matriz[0] . ", Valor de matriz con índice '0'<br />";

  echo "_ $Matriz[2]: " . $Matriz[2] . ", Valor de matriz con índice 2<br />";

  echo "Permiten almacenar una parte fraccionaria: <br />";

  echo "_ Exponencial: " . $NumeroFlotanteExp;
  echo "_ Estándar: " . $NumeroFlotanteEst;  

__ Booleano: 1
__ $Matriz[0]: A, Valor de matriz con subíndice '0'
__ $Matriz[2]: 3, Valor de matriz con subíndice 2

Permiten almacenar una parte fraccionaria:

__ Exponencial: 1550
__ Estándar: 1.55

Tipo numérico

__ $NumeroEntero: Número entero: 1
__ $NumeroFlotante: Número flotante: 1.55 , permiten almacenar una parte fraccionaria.

// OTROS TIPOS DE DATOS 

$NumeroOctal = 012; // octal 12 es decimal 10

// En la asignación Hexadecimal se indica 0x delante y luego números de 0 a 9 y letras de A a F.
// {que se corresponden con los números decimales de l0 a l5)
$NumeroHexadecimal = 0x1C; // hexadecimal 1c igual a decimal 28
$NumeroNegativo = -33; // números negativos llevan el signo menos (-) delante

// Son los que permiten almacenar una parte fraccionaria. 
// Existen dos sintaxis: estándar y exponencial
$NumeroFlotanteExp = 1.55e3; // Exponenecial
$NumeroFlotanteEst = 1.55; // Etándar

$comillasDobles = 'permire tener comillas dobles interiores';
$comillasDobles2 = 'permite comillas dobles en el interior , 
				    "escapándolo con barra invertida (\)"'; 

__ $NumeroOctal: 10 , se indica un cero delante y luego números entre 0 y 7.
__ $NumeroHexadecinal: 28 , se indica 0x delante y luego números de 0 a 9 y letras de A a F (que se corresponden con los números decimales de l0 a l5).
__ $NumeroNegativo: -33

Cadenas

__ Cadena:Tipo de dato de cadena, en PHP 6 se incluye soporte a Unicode y los caracteres en esta codificación pueden ocupar más de un byte.
__ Si en una variable entera se almacena un valor mayor al que puede soportar la variable se combierte automáticamente a flot
__ En PHP 6 se incluye soporte a Unicode y los caracteres en esta codificación pueden ocupar más de un 'byte'
__ Cadena definida por sintaxis de documento incrustado ('<<<'), denominada sintaxis heredoc
__ Cadena definida por sintaxis de documento incrustado ('>>>'), denominada sintaxis nowdoc. Es una variante de heredoc implementada a partir de PHP 5.3.
__ Permire tener comillas dobles interiores
__ Permite comillas dobles en el interior , "escapándolo con barra invertida (\)"

Códigos de escape más utilizados

__f: Salto de página (form feed)
__n: Nueva línea (line feed)
__r: Retomo de carro (carriage retum)
__t: Tabulación
__\': Comilla simple
__\": Comilla dobles
__$: Carácter dólar

Conversión automática de tipos

PHP convierte automáticamente de un tipo a otro tipo, cualquier valor de una variable, siempre que sea posible. Es decir, que si se asigna un valor cadena a una variable, esta, se convierte en una variable de tipo cadena.
Para obtener el tipo de una variable, utilizaremos la función gettype().

// Saber de que tipo es la variable 
$conver1 = "47cadena"; // cadena 
$conver2 = true; // booleano (TRUE = 1) 
$conver3 = 1; // entero 
$conver4 = 5.6; // doble 

	echo '$conver1 es de tipo: ' . gettype ($conver1) . '<br />';
	echo '$conver2 es de tipo: ' . gettype ($conver2) . '<br />';
	echo '$conver3 es de tipo: ' . gettype ($conver3) . '<br />';
	echo '$conver4 es de tipo: ' . gettype ($conver4) . '<br />';


$conver1 es de tipo: string
$conver2 es de tipo: boolean
$conver3 es de tipo: integer
$conver4 es de tipo: double

Conversión forzada de tipos:
Vamos a forzar el cambio de tipo de la variables anteriores con la función settype():

// Forzar a cambiar el tipo de una variable con la función settype().

	// $conver1 se establece ahora en 47 (entero) 
   echo settype ($conver1, " integer ") . ' ' . gettype ($conver1) . '<br />'; 
	
   // $conver2 es ahora el valor "1" (cadena) 
   echo settype ($conver2, " string ") . ' ' . gettype ($conver2) . '<br />';  
	
   // $conver3 es ahora el valor "1" (doble) 
   echo settype ($conver3, " double ") . ' ' . gettype ($conver3) . '<br />';
	
   // $conver4 es ahora el valor "TRUE o 1" (booleano) 
   echo settype ($conver4, " boolean ") . ' ' . gettype ($conver4) . '<br />'; 

Forzar a cambiar el tipo de una variable con settype().
$conver1 establecer a tipo : 1 integer
$conver2 establecer a tipo : 1 string
$conver3 establecer a tipo : 1 double
$conver4 establecer a tipo : 1 boolean

Otro ejemplo de conversión forzada de tipos:

// CONVERSIÓN FORZADA DE TIPOS  
$forzada1 = (integer) 250.75 . ", queda como nº entero (integer)"; 
$forzada2 = (real) "250.75" . ", nº entre comillas, es una cadena (string)";
$forzada3 = (real) 250.75 . ", nº sin comillas queda como nº flotante (real)";

echo $forzada1 . "<br />"; // Como nº entero 
echo $forzada2 . "<br />"; // Como cadena 
echo $forzada3 . "<br />"; // Como nº flotante  

250, queda como nº entero (integer)
250.75, nº entre comillas, queda como una cadena (string)
250.75, nº sin comillas queda como nº flotante (real)

Tipos utilizados para la conversión:
(int), (integer): Fuerza la conversión a entero.
(real), (double), (float): Fueza la conversión a coma flotante.
(string): Fuerza la conversión a cadena de caracteres.
(array): Fuerza la conversión a matriz.
(object): Fuerza la conversión a un objeto.

Si lo que queremos es cambiar temporalmente el tipo de una variable, por ejemplo, utilizarla dentro de una expresión, utilizaremos (tipo) seguido de la variable a cambiar.
Pondremos atención al convertir un valor de doble a entero, ya que conducirá a una pérdida de información, posiblemente importante.

// type()
// Cambiar temporalmente los tipos 
$varType1 = ( string ) $conver1;
$varType2 = ( boolean ) $conver2;
$varType3 = ( integer ) $conver3;
$varType4 = ( double ) $conver4;

	// Variables con sus tipos cambiados 
	echo '$varType1 es de tipo: ' . gettype ($varType1) . ' <br />';
	echo '$varType2 es de tipo: ' . gettype ($varType2) . ' <br />';
	echo '$varType3 es de tipo: ' . gettype ($varType3) . ' <br />';
	echo '$varType4 es de tipo: ' . gettype ($varType4) . ' <br />';


$varType1 es de tipo: string
$varType2 es de tipo: boolean
$varType3 es de tipo: integer
$varType4 es de tipo: double

CONCATENACIÓN, operador punto (.)
Podemos unir dos cadenas mediante el operador punto (.) que es el único operador de cadena en PHP.

// Operador punto (.) 
$concat1 = 'Rasmus Lerdorf creó ';
$concat2 = 'el previo procesado de hipertexto ';
$concat3 = '"PHP".';
	
// Concatenar el valor de las variables mediante el operador punto '.' 
	echo $concat1 . $concat2 . $concat3; 

Reusltado de concatenar las tres cadenas:
Rasmus Lerdorf creó el previo procesado de hipertexto "PHP".

OPERADOR SUMA (+)
No debemos confundir el operador suma (+) para concatenar cadenas, como sucede por ejemplo en el lenguaje JavaScript. Con el operador (+) podemos sumar dos cadena de tipo cadena, pero tendremos especial cuidado en colocar el carácter numérico al inicio de la cadena, de lo contrario el valor resultante seria el de la primera cadena evaluada.

// CONCATENACIÓN 

$varNum = "9";
// Cadena con carácter numérico no inicial 
$varCaracter = "suma, concatenación, resta, multiplicación, división, 1";
// Cadena con caracter numérico al inicio 
$varNumCaracter = "1, Si número delante de cadena => se sumará, 
		    si número va detrás de cadena, no";
			
$varCaracter = $varNum + $varCaracter; // Suma solo cuando el nº está delante de la cadena. 
$varNumCarac = $varNum + $varNumCaracter; 

echo "Con Nº detrás de cadena: " . $varCaracter . " no sumará. <br />";
echo "Con Nº delante de cadena: " . $varNumCarac . " si se sumará. <br />"; 

Con Nº detrás de cadena: 9 no sumará.
Con Nº delante de cadena: 10 si se sumará.

MATRIZ

Los vectores o array son listas ordenadas de elementos. Utilizaremos la función Array para definir un vector en PHP.
Cuando hayamos definido un vector, accederemos a sus elementos identificados mediante un número ( empezando por 0 ) o una clave (tipo cadena de carácteres).
Tipo de dato de Array

$Cadena = // Tipo de dato de cadena  
 
$NúmeroEntero = 1; // Un valor entero  
 
$NúmeroFlotante = 1.55; // Un valor numérico con decimales  
 
$Booleano = True; // Un valor booleano True (1) o False (0)  
 
$Matriz[0]= "A"; // Un valor de matriz con subíndice 0  
 
$Matriz[2] = 3; // Un valor de matriz con subíndice 2  
 
$Matriz[4] = "Barcelona"  // String, dato de cadena  
 
$Matriz[5] = "París"  // String, dato de cadena 
Accediendo a los elementos de un Array  
 
$vector = array("clave 1" => "elemento 1", "clave 2" => "elemento 2") 
 
// Acceder índice numérico  
$vector[0] // Devuelve elemento 1  
 
// Acceder índice (tipo cadena)  
$vector['clave 1']  // Devuelve elemento 1  

MATRIZ ASOCIATIVA

Matrices asociativas son los que tienen claves o índices de tipo caracter o cadena de caracteres. En este tipo de Arrays accederemos al Array por la nomenclatura de índices y acederemos a los elementos mediante el nombre de la CLAVE que se haya indicado.

// MATRIZ ASOCIATIVA 

// Índices entre corchetes '[ ]' de tipo cadena de caracteres 
$MatrizY["Jose"] = "Manuel";
$MatrizY["Maria"] = "Paz";
$MatrizY["Piter"] = "Gómez";


// MATRIZ ASOCIATIVA 
echo "En este tipo de matrices se sustituye el número de índice 
      por un campo de cadena <br />";

// Llamando al índice 'Piter', devuelve su valor 'Gómez' 
echo $MatrizY[" Piter "]"; // Devuelve 'Gómez'  

En este tipo de matrices se sustituye el número de índice por un campo de cadena
Gómez
Ver más sobre Arrays

OBJETO

Es una estructura de datos que contiene propiedades (lo que nomalmente se consideran datos) y métodos (código que nos permite manipular las propiedades del objeto).

// OBJETO 
class objetoprueva{
	function metodoprueva(){
		echo "Este objeto es un icono PHP.";
		// Imagen 
		echo "<img src='imagen.png' />";
	}
}


// Lamada a un método de objeto 
$objVar = new objetoprueva; // Definimos objeto prueva 
$objVar -> metodoprueva(); // Llamamos un método de objeto  

Este objeto es un icono PHP.

RECURSOS

Son valores especiales que hacen referencia a una información de estado o memoria que es de origen externo al propio PHP. Útil para que PHP se comunique con algún progmma extemo (por ejemplo, con MySQL) que utiliza memoria del programa en respuesta al requerimiento de PHP.
El programador PHP no se tiene que preocupar por la liberación de esa memoria ya que PHP liberará todo al finalizar la ejecución del código de la página.
Los recursos se crean a pafir del uso de deteminadas funciones que dan como valor de retomo un recurso que después se puede reutilizar para otras operaciones afines. Por ejemplo la función mysql-connect() nos devuelve un recurso cuando la conexión con la base de datos se ejecuta corectamente:

Var res = mysql_connect();
La variable res se puede reasignar posteriormente con otro recurso o con el valor NULL.

NULL

Este valor representa a una variable sin valor asignado. La constante NULL es insensible a mayúsculas y minúsculas.
Una variable púede ser nula por tres razones:


// NULL 
$nullVar = ""; // No se le asignó aún ningún valor  
$nullVar2 = "CON VALOR"; 
$nullVarGlobal = " Solo una variable local dentro de una
				función se puede quitar conunset().";

function retornaNull() {
	
     // Solo la variable local es destruida 
    $nullVarLocal = " Quitar valor con unset() ";
    global $nullVarLocal;
    unset( $nullVarLocal ); // Quitar valor de esta variable 
	
}

// Llamada función 
retornaNull(); 


echo "$nullVar2: Se le asigno el valor: " . $nullVar2; // Devuelve CON VALOR 

echo "$nullVar: No se le asignó aún ningún valor: " . $nullVar; // Valor vacio 

echo "$nullVarLocal: Se anuló el valor con la función unset()" . 
      $nullVarLocal; // Quitar el valor 

echo "$varNula: Se asignó el valor NULL " . $varNula; // Valor Nulo 

echo "$nullVarGlobal: No se puede anular el valor de una variable global 
      desde dentro de una función con el método unset()" . $nullVarGlobal;
     // Devuelve valor de variable  

$nullVar2: Se le asigno un valor: CON VALOR
$nullVar: No se le asignó aún ningún valor:
$nullVarLocal: Se anuló el valor con la función unset()
$varNula: Se asignó el valor NULL
$nullVarGlobal: No se puede anular el valor de una variable global desde dentro de una función con el método unset() Solo una variable local dentro de una función se puede quitar con unset().

Variables por referencia

Asignar una variable por referencia a otra: La segunda variable no mantiene una copia del valor sino la dirección de la variable a la que hace referencia.
El signo & (ámpersan) delante del nombre de la variable, indica que se está almacenando la dirección y no el contenido.
El uso de las variables por referencia es similar a utilizar un alias para un nombre de variable. Es decir, son dos nombres de variables que apuntan a una misma dirección de memoria.

// Por referencia "&" 
$CadenaReferencia = "Tipo de dato de cadena";

// En $Ref se guarda la dirección de $CadenaReferencia. 
$Ref = &$CadenaReferencia; 

// Cambiamos el valor de estavariable 
$CadenaReferencia = "-- Valor de la variable " CadenaReferencia " --" ;

echo "Valor que guarda la variable en su lugar de memoria: " . $Ref;
// Devuelve '-- Valor de la variable " CadenaReferencia " --' 


// Otra variable POR REFERENCIA "&" 
	$varRef = 5; // varRef Vale 5 
	$varPorRef = & $varRef; // varPorRef vale el contenido de varRef 
	$varPorRef = 6; // varPorRef ahora vale 6, y varRef, también vale 6  

	echo 'Variable a: ';
	var_dump($varRef);
	
	echo 'Variable b: ';
	var_dump($varPorRef); 

Este es el valor que guarda la variable en su lugar de memoria: -- Valor de la variable "CadenaReferencia" --, y este valor se ha pasado por referencia a esta otra variable: Ref.

Aquí la variable a empieza valiendo 5, la variable b la coge por referencia, y ahora a vale 5, al asignar un valor diferente a la variable b, la variable a, cambia también a ese nuevo valor.

Variable a = 6

Variable b = 6

Variables por referencia transitiva

La variable de origen puede no tener contenido de datos, podría contener una referencia referencia transitiva, Es decir, si queremos crear una segunda variable PorRef2 haciendo referencia a la variable PorRef (que por su parte tiene la referencia a Ref) lograremos visualizar el contenido de Ref utilizando )PorRef2.
En cuestión, son dos nombres de variables que apuntan a una misma dirección de memoria.

// Por referencia transitiva " & " 
	$Ref = "MiVariable por referencia "transitiva"";
	$PorRef = & $Ref; // PorRef vale Ref 
	$PorRef2 = & $PorRef; // PorRef2 ahora vale PorRef 

	echo "Variable PorRef2 = " . $PorRef2;
	echo strlen($PorRef2) . " caracteres."; 

Variable PorRef2 = MiVariable por referencia "transitiva". 38 caracteres.

Variable de Variable

Son nombres de variables que se pueden definir y usar dinámicamente. Es decir, una variable variable toma el valor de otra variable y lo trata como el nombre de una variable.

Podemos usar variables de variables con matrices la sintaxis es la siguiente:
${$a[0]} para el primer elemento y ${$a}[1] para el segundo elemento.

// VARIABLE DE VARIABLE ($$) 
$varDeVar = "CONTENIDO"; // Asignamos CONTENIDO a variable $varDeVar 
$$varDeVar = "CONTENIDO_2"; // Asignamos CONTENIDO_2 a variable $CONTENIDO
				   		   			  // Variable $$varDeVar significa "$CONTENIDO" 
	
$varDeVar = "CONTENIDO"; 
$$varDeVar = "CONTENIDO_2"; // Asignamos un símbolo $ delante del valor de la // variable a la que apunta, convirtiéndolo en otra variable. // Otra forma de sacar el valor "CONTENIDO_2" echo ${$varDeVar};

CONTENIDO: Valor de $varDeVar
CONTENIDO_2: Valor de $CONTENIDO
CONTENIDO_2: Valor de $$varDeVar
CONTENIDO_2: Otra forma de sacar el Valor "echo ${$varDeVar}"

En este caso se están definiendo dos variables ($varDeVar y $CONTENIDO) que ocupan dos direcciones de memoria diferentes y con contenidos diferentes.
Podriamos decir que es una forma de acceder a las variables usando a la vez otras variables.

Ámbito de las variables

Es el contexto en el que se puede acceder a una variable: global y local.
LOCAL: Es de manera predeterminada cuando una variable se define dentro de una función. Es decir, no es accesible desde fuera de la función.

GLOBAL: Es la que se define fuera de las funciones y podemos utilizarlas dentro de las funciones. PHP nos obliga a definir explícitamente dentro de la función, a las variables globales para poder usarlas dentro de la función matriz $CLOBALS.

$CLOBALS: Si queremos evitar la definición global podemos utilizar la matriz asociativa que poseen todas las variables globales $CLOBALS es una superglobal.

SUPERGLOBAL: Es un cojunto de variables que son globoles de forma automática, no hace falta definirlas como global dentro de una función.

Definición global de una variable

// Definimos una variable global 
$varGlobal = 20; // variable global 

// Formas para acceder a variables globales 
function PruebaSinGlobal(){ 
   $varGlobal++; // variable local (ESTA LÍNEA PUEDE MOSTRAR UN ERROR) 
	echo "Prueba sin global. $varGlobal  :" . $varGlobal . "
				al no haber definición global y no usar $GLOBALS,
		  			 			se trata como una variable local.";
				
   // Al no haber definición global y no usar
     // $GLOBALS, $varGlobal se trata como una variable local
     // por esa razón imprime 1 en lugar de 21. 
} 
	
	// Llamar función 
	PruebaSinGlobal();

Variable sin definición global.

Prueba sin global. $varGlobal :1 al no haber definición global y no usar $GLOBALS, se trata como una variable local.

// Variable definida como 'global' dentro de función 
$varGlobal = 20; // variable global

// Formas para acceder a variables globales 
function PruebaConGlobal(){ 
    global 20; // Definición global 
	$varGlobal++;
	echo "Prueba con global. $varGlobal  :" . $varGlobal . " 
				ya no es local, se trata como global.";
						
	// 20 ya no es local, se trata como global 
	// imprime 21  

} 
	
	// Llamar función 
	PruebaConGlobal(); 

Variable definida como 'global'.

Prueba con global. $varGlobal :21 ya no es local, se trata como global.

// Variable definida como '$GLOBALS' dentro de función 
$varGlobal = 20; // variable global

// Formas para acceder a variables globales 
function PruebaConGlobals(){ 
    $GLOBALS[" varGlobal "]++; // Definición global 
	echo "Prueba con $GLOBALS. $varGlobal  :" . $GLOBALS["varGlobal"] . " 
				ya no es local, se trata comno global.";
				
   // $varGlobal ya no es local, se trata comno global  
	// imprime 22 
} 
	
	// Llamar función 
	PruebaConGlobals(); 

Variable definida como '$GLOBALS'.

Prueba con $GLOBALS. $varGlobal :22 ya no es local, se trata como global.

Subir

Variable estática "static"

Tambien están las variables static y parameter

STATIC, "estática": Cuando una función se ha completado, todas sus variables normalmente se eliminan.
Sin embargo, a veces queremos una variable local que no se pueda eliminar.
Para ello, utilizaremos la palabra clave static, "estático" la primera vez que declaramos la variable .
Así que cada vez que se llama a la función, esa variable todavía tendrá la información contenida en él desde la última vez que se llama a la función.

// Variables estáticas  
function miVarEstatica(){
	
   // Las variables "estáticas" no se eliminan después de ejecutarse, 
	// sino que queda guardada con su último valor.
	
	static $x = " A "; 
	echo $x;
	
	$x++; // Incrementa el valor de la variable, primero vale A, luego B y por último vale C.
}

// Hacemos 3 llamadas a la misma variable
miVarEstatica(); // 1ª llamada = A
miVarEstatica(); // 2ª llamada = B
miVarEstatica(); // 3ª llamada = C 

Resultado de la 1ª llamada => A

Resultado de la 2ª llamada => B

Resultado de la 3ª llamada => C

PARAMETER, "parámetro": Un parámetro es una variable local cuyo valor se pasa a la función por el código de llamada.
Los parámetros se declaran en una lista de parámetros como parte de la declaración de la función

// paramenter ($x = parámetro de la función) 
function varParametro($x){
	echo $x;// Devuelve '5' 
	}

	// Lamada a función con parámetro 
	varParametro(5); // Parámetro pasado con la variable  

Resultado:
Parámetro pasado con la variable = 5

Variable NO estática

// NO STATIC 
function localNoStatic(){ 
    $noStatic = 0; // var no estática, no incrementa en ninguna llamada 
	static$numer; // var estática que se incrementara en cada llamada de las funciones 
	echo "Variable local no estática. $noStatic  :  Llamada de la función "
	     . ++$numer . " => " . ++$noStatic; 
} 
 
localNoStatic(); // imprime 1 
localNoStatic(); // imprime 1 
localNoStatic(); // imprime 1 


// STATIC 
function localStatic(){
    static$varStatic; 
	echo "Variable local estática. $varStatic  : Llamada de la función ". 
	     ++$varStatic;
 
} 
 
localStatic(); // imprime 1 
localStatic(); // imprime 2 
localStatic(); // imprime 3  

Variable local no estática. $noStatic : Llamada de la función 1 => 1

Variable local no estática. $noStatic : Llamada de la función 2 => 1

Variable local no estática. $noStatic : Llamada de la función 3 => 1

Las variable local estáticas no se eliminan del espacio de memoria despues de terminar la función, sino que queda guardada con su último valor.

Variable local estática. $varStatic : Llamada de la función 1

Variable local estática. $varStatic : Llamada de la función 2

Variable local estática. $varStatic : Llamada de la función 3

Constantes

Una constante es un identificador de un dato que NO cambia de valor durante toda la ejecución de un programa.
Una constante es como una variable pero con la diferencia que una vez toma un valor este no puede variar durante la ejecucion del script, otra particularidad de las constantes es que son globales, por lo que se pueden leer desde el interior de una funcion sin tener que pasarlas como parametro. Al contrario que las variables, las constantes no necesitan el signo del dolar ($) para expresarse, se definen utilizando la funcion define(NombreConstante, SuValor).

define ("pi", 3.14156 );
		
		if(defined ("pi")) {
			
			echo "PI definida"; <br />
			
		}else {
			
			echo "PI no definida"; <br />
			
		} 

PI es una constante definida

En ciertos casos no es posible llegar al valor de una constante directamente por su nombre, ya que este nombre puede coincidir con el de una funcion y el resultado no sería el deseado, en ese caso utiliremos la funcion constant para leer el valor de esa constante.

defined('echo','valorDeConstante');
	
echo constant('echo'); // El nombre de la constante coincide con el de la función (echo())
				      // En este caso utilizamos la función constant para diferenciar 
					  // el nombre de la constante de la función "echo". 

Desde la versión PHP 5.3 tenemos otro modo para definir una constante (fuera de una clase), mediante la palabra clave const.

const("pi", 3.14156); 

Nomenclatura de las constantes

Pueden comenzar con una letra o guión bajo (no empiezan con el símbolo $), seguido por letras, números o guiones bajos.

Ámbito de una constante

Su ámbito es siempre global, tanto si está definida fuera como dentro de una función, y peden ser de tipo booleano, entero, coma flotante o cadena. Y no peude reinicializarse.

Operadores

Un operador es algo que toma uno o más valores (o expresiones, en jerga de programación) y produce otro valor (de modo que la construcción en si misma se convierte en una expresión).

Tipos de operadores:

Precedencia de operadores

// PRECEDENCIA DE OPERADORES 
echo "Negación: -$varNegación. Opuesto de $varNegación";
echo "Operador suma (+), (5 + 3): " . (5 + 3); // muestra 8 
echo "Operador resta (-), (5 - 3): " . (5 - 3); // muestra 2 
echo "Operador cociente (/), (5 / 3): " . (5 / 3); // muestra 1.66 
echo "Operador producto (*), (5 * 3): " . (5 * 3); // muestra 15 
echo "Operador módulo (%), (5 % 3): " . (5 % 3); // muestra 2 
echo "Operador módulo (%), (5 % -3): " . (5 % -3); // muestra 2 
echo "Operador módulo (%), (-5 % 3): " . (-5 % 3); // muestra -2 
echo "Operador módulo (%), (-5 % -3): " . (-5 % -3); // muestra -2  

Ejemplo de precedencia de operadores:
Negación: -$varNegación. Opuesto de $varNegación
Operador suma (+), (5 + 3): 8
Operador resta (-), (5 - 3): 2
Operador cociente (/), (5 / 3): 1.66666666667
Operador producto (*), (5 * 3): 15
Operador módulo (%), (5 % 3): 2
Operador módulo (%), (5 % -3): 2
Operador módulo (%), (-5 % 3): -2
Operador módulo (%), (-5 % -3): -2


Subir

Operadores aritméticos

// OPERADORES ARITMÉTICOS 
echo "Negación: -$varNegación. Opuesto de $varNegación";
echo "Operador suma (+), (5 + 3): " . (5 + 3); // muestra 8 
echo "Operador resta (-), (5 - 3): " . (5 - 3); // muestra 2 
echo "Operador cociente (/), (5 / 3): " . (5 / 3); // muestra 1.66 
echo "Operador producto (*), (5 * 3): " . (5 * 3); // muestra 15 
echo "Operador módulo (%), (5 % 3): " . (5 % 3); // muestra 2 
echo "Operador módulo (%), (5 % -3): " . (5 % -3); // muestra 2 
echo "Operador módulo (%), (-5 % 3): " . (-5 % 3); // muestra -2 
echo "Operador módulo (%), (-5 % -3): " . (-5 % -3); // muestra -2  

Ejemplo de operadores aritméticos:
Negación: -$varNegación. Opuesto de $varNegación
Operador suma (+), (5 + 3): 8
Operador resta (-), (5 - 3): 2
Operador cociente (/), (5 / 3): 1.66666666667
Operador producto (*), (5 * 3): 15
Operador módulo (%), (5 % 3): 2
Operador módulo (%), (5 % -3): 2
Operador módulo (%), (-5 % 3): -2
Operador módulo (%), (-5 % -3): -2


Subir

Operadores de asignación

// Operadores de asignación 
$a = ( $b=4 ) + 5; 

echo "Variable $a vale: " . $a . "<br />    // $a vale 9 
	  Variable $b vale: " . $b . "<br />"; // $b vale 4 
Variable $a vale: 9
Variable $b vale: 4


Subir

Operadores bit a bit

// OPERADOR DE BIT A BIT 
$format= '( %1$2d = %1$04b ) = ( %2$2d = %2$04b )' .
	   ' %3$s ( %4$2d = %4$04b )';

echo <<// EJEMPLO BIT A BIT 
$values = array(0, 1, 2, 4, 8);
$test = 1 + 4;

echo "AND bit a bit ";
	
	foreach ($values as $value) {
		$result = $value & $test;
		printf( $format, $result, $value, '&', $test );
	}

echo "OR inclusivo bit a bit ";
	
	foreach ($values as $value) {
		$result = $value | $test;
		printf( $format, $result, $value, '|', $test);
	}

echo "OR exclusivo (XOR) bit a bit ";
	
	foreach ($values as $value) {
		$result = $value ^ $test;
		printf( $format, $result, $value, '^', $test );
	} 

Ejemplo de operador bit a bit:

   ------------    ---------   ---   ----------
   resultado     valor     o    prueba
   ------------    ---------   ---   ----------

AND bit a bit

( 0 = 0000) = ( 0 = 0000) & ( 5 = 0101)

( 1 = 0001) = ( 1 = 0001) & ( 5 = 0101)

( 0 = 0000) = ( 2 = 0010) & ( 5 = 0101)

( 4 = 0100) = ( 4 = 0100) & ( 5 = 0101)

( 0 = 0000) = ( 8 = 1000) & ( 5 = 0101)

OR inclusivo bit a bit

( 5 = 0101) = ( 0 = 0000) | ( 5 = 0101)

( 5 = 0101) = ( 1 = 0001) | ( 5 = 0101)

( 7 = 0111) = ( 2 = 0010) | ( 5 = 0101)

( 5 = 0101) = ( 4 = 0100) | ( 5 = 0101)

(13 = 1101) = ( 8 = 1000) | ( 5 = 0101)

OR exclusivo (XOR) bit a bit

( 5 = 0101) = ( 0 = 0000) ^ ( 5 = 0101)

( 4 = 0100) = ( 1 = 0001) ^ ( 5 = 0101)

( 7 = 0111) = ( 2 = 0010) ^ ( 5 = 0101)

( 1 = 0001) = ( 4 = 0100) ^ ( 5 = 0101)

(13 = 1101) = ( 8 = 1000) ^ ( 5 = 0101)

$bitVar1 = 8;
	$bitVar2 = 12;
	$bitVar3 = $bitVar1 + $bitVar2; // Son 20 
	
	$bitVar3 = $bitVar1 ^ $bitVar2;
	echo $bitVar3; // 4
	
	$bitVar3 = ~$bitVar1;
	echo $bitVar3; // -9
	
	$bitVar3 = $bitVar1 << 2; // 2 posiciones es como multiplicar por 4
	echo $bitVar3; // 32 
	
	$bitVar3 = ~$bitVar3 >> 2; // 2 posiciones es como dividir entre 4
	echo $bitVar3; // 2 

El desplazamiento de bits en PHP es aritmético. Los bits desplazados por fuera de cualquiera de los extremos son descartados. Desplazamientos de izquierda tienen ceros desplazados a la derecha mientras que el bit de signo es desplazado fuera a la izquierda, es decir que no se conserva el signo de un operando. Desplazamientos a la derecha tienen copias del bit de signo desplazado a la izquierda, es decir que se conserva el signo de un operando.
Utilizar paréntesis para garantizar la precedencia deseada. Por ejemplo, $a & $b == true evalúa la equivalencia y luego el bit a bit, mientras que ($a & $b) == true evalúa el bit a bit y luego la equivalencia.

__\__\__\__\__\__\__\__\__\__\__\__\__

$bitVar1 = 8;
$bitVar2 = 12;
$bitVar3 = $bitVar1 + $bitVar2; // Son 20

$bitVar3 = $bitVar1 ^ $bitVar2 ==> 4

$bitVar3 = ~$bitVar1 ==> -9

$bitVar3 = $bitVar1 << 2 ==> 32

$bitVar3 = $bitVar1 >> 2 ==> 2



Subir

Operadores de comparación

Resultado:
\$a es menor que \$b


Subir

Operadores de ejecución
Estos operadores permiten ejecutar un comando en sistema de operación que aloja el servidos web y el modulo PHP y capturar la salida.

// Operadores de ejecución 
// (dir => para windows, Is -la~ => para Unix y gnuLinux) 
$output = `dir`; // Comillas inversas (``) 

// Muestra la lista de archivos en el directorio del servidor web actual 
echo "$output";

	prueba estas líneas de código.

Operadores de incremento/decremento

// Postincremento 
echo "Postincremento a partir del nº 5 <br />";
$increDecrea = 5;
echo "$var++ = " . $increDecrea++ . "<br />";
echo "$var = " . $increDecrea . "<br />";

// Preincremento 
echo "Preincremento a partir del nº 5 <br />";
$increDecrea = 5;
echo "++$var = " . ++$increDecrea . "<br />";
echo "$var = " . $increDecrea . "<br />";

// Postdecremento 
echo "Postdecremento a partir del nº 5 <br />";
$increDecrea = 5;
echo "$var-- = " . $increDecrea-- . "<br />";
echo "$var = " . $increDecrea . "<br />";

// Predecremento 
echo "Predecremento a partir del nº 5 <br />";
$increDecrea = 5;
echo "--$var = " . --$increDecrea . "<br />";
echo "$var = " . $increDecrea; 

Ejemplo de operadores de incremento y decremento:

Postincremento a partir del nº 5
$var++ = 5
$var = 6

Preincremento a partir del nº 5
++$var = 6
$var = 6

Postdecremento a partir del nº 5
$var-- = 5
$var = 4

Predecremento a partir del nº 5
--$var = 4
$var = 4


Subir

Operadores lógicos

Ejemplo de operadores lógicos

Los operadores lógicos se emplean generalmente con expresiones que develven valores lógicos: TRUE o FALSE.

||, OR

bool(true) bool(false)

&&, AND

bool(false) bool(true)

XOR

or exclusiva (xor) solo se cumple cuando hay solo una operación cierta.

Sí, (evaluado entre paréntesis)

Ejemplo de operdor de negación ( ! )

bool(false) bool(false)
Subir

Operadores para strings

// Operadores para strings 
$operStringa = "Java ";
$operStringb = $operStringa . "Script"; // Concatena argumentos 
echo $operStringb . ' Concatena argumentos mediante " . "';

$operStringa = "Java ";
$operStringa .= "Script"; // Añade argumento 
echo $operStringa . ' Añade argumento mediante " . = "'; 

Ejemplo de operadores para string:

PHP / Concatena argumentos mediante "."

PHP / Añade argumento mediante ". ="


Subir

Operadores para arrays

Ejemplo de operadores para Array

El operador + devuelve el array del lado derecho añadido al array del lado izquierdo; para las claves que existan en ambos arrays, serán utilizados los elementos del array de la izquierda y serán ignorados los elementos correspondientes del array de la derecha.
Los elementos de los arrays son iguales para la comparación si éstos tienen la misma clave y valor.

$a = array("a" => "manzana", "b" => "banana"); 
$b = array("a" => "pera", "b" => "fresa", "c" => "cereza");
$d = array("c" => 2, "x" => "uva", "z" => "higo");

	
$c = $a + $b; // Unión de $a y $b 
echo 'Unión de $a y $b: ';

    foreach($c as $val){
        if($val == "cereza"){
            echo $val;
        }else{
            echo $val . ' -- ';
        }
    }

$c = $b + $a; // Unión de $b y $a 
echo 'Unión de $b y $a: ';

    foreach($c as $val2){
        if($val2 == "cereza"){
            echo $val2;
        }else{
            echo $val2 . ' -- ';
        }
    }

$c = $b + $d; // Unión de $a y $d 
echo 'Unión de $d y $a: ';

    foreach($c as $val3){
        if($val3 == 'higo'){
            echo $val3;
        }else{
            echo $val3 . ' -- ';
        }
    } 

Unión de $a y $b:

manzana -- banana -- cereza

Unión de $b y $a:

pera -- fresa -- cereza

Unión de $d y $a:

pera -- fresa -- cereza -- uva -- higo


Subir

Operadores de tipo

class MiClase{
}

class NoEsMiClase{
}

$operTipo = new MiClase;

echo 'Utilizando instanceof con clases. <br />
	     TRUE o 1 si existe la clase, y FALSE o 0 si NO existe la clase.";

echo 'Tipo de variable:' . gettype($operTipo) . ' ----> ' . ($operTipo
	     instanceof MiClase)
				. ' <br />'; // TRUE o 1 si existe la clase 
echo 'Tipo de variable:' . gettype($operTipo) . ' ----> ' . ($operTipo 
	     instanceof NoEsMiClase );
		 
				// FALSE o O si NO existe la clase  

Utilizando instanceof con clases.
TRUE o 1 si existe la clase, y FALSE o 0 si NO existe la clase.
Tipo de variable:object----> 1
Tipo de variable:object----> 0

instanceof: Comprobar variables con instanceof no lanzará ningún error, simplemente devuolverá FALSE. Las constantes, sin embargo, no está permitidas.

// OPERADOR DE TIPO 

// Comprobar variables 
$a = 1;
$b = NULL;
$c = imagecreate(5, 5);

var_dump($a instanceof stdClass); // Es un entero 
var_dump($b instanceof stdClass); // Es NULL 
var_dump($c instanceof stdClass); // Es un recurso 
var_dump(FALSE instanceof stdClass); // Provoca un error en la página.  

Tipo de variable:integer----> FALSE
Tipo de variable:NULL----> FALSE
Tipo de variable:resource----> FALSE


Subir

Operador ternario.
El operador ternario es otro operador condicional.

$a = 23;
$b = 32; 
$res;

($a < $b) ? $res = "menor" : $res = "mayor";

// Si '$a' es menor que '$b', entonces '$res = menor', si no, '$res = mayor'. 
echo "$a < $b =" . $res;


$ternA = 2; // Si "$ternA" es igual a "3", entonces "one", sino, "otro". echo $ternA == 3 ? 'one' : 'otro'; // Sin paréntesis, muestra otro.
$A = 2; // Si 'A' es igual a 'A', entonces 'one', sino, 'otro'. echo ($A == 2 ? 'one' : 'otro'); // Entre paréntesis, Muestra one, más texto entre etiquetas.

$a < $b = Resultado de $res ==> menor

$ternA vale 3 = Resultado de $ternA: otro

NOTA: El resultado anterior se muestra, pero si queremos que muestre el texto que va encerrado entre etiquetas (tag) deberemos encerrar la expresión entre paréntesis y concatenar el texto, de esta forma:
echo ($A == 2 ? 'one' : 'otro').

Resultado de $A ==> one
Subir

Operadores de control de errores

// OPERADOR DE CONTROL DE ERRORES

// '@' La arroba delante de cualquier función, 'omite' un posible mensaje de ERROR,
// y no deja mostrar el resto de la ejecución del código.
// "include()" Método que incrusta un archivo en esta posición de la página 
(@include ("includeArchiv.php")) // Símbolo "arroba" delante de la expresión 
	
	// O si no lo encuentra, muestra un mensaje 
	or die ("No se pudo encontrar el archivo.php!"); 

Ejemplo de operadores de control de errores

// El símbolo "arroba" delante de la expresión omite el error y muestra la página.
// No se aconseja el uso de la arroba (@) ya que omite el error y puede ocultar la
// ejecución del código que sigue detrás de la función con error omitido.

(@include("includeArchiv.php")) // Si el archivo existe, lo incluye en página
or die("No se pudo encontrar el archivo.php!"); // Si no existe, muestra mensaje en página

No se pudo encontrar el archivo.php!