-
Notifications
You must be signed in to change notification settings - Fork 0
2 operadores en php
Índice de contenido
1. Precedencia de operadores | 7. Operadores de ejecución |
2. Operadores aritméticos | 8. Operadores de incremento/decremento |
3. Operadores de asignación | 9. Operadores lógicos |
4. Operadores bit a bit | 10. Operadores para strings |
5. Operadores de comparación | 11. Operadores para arrays |
6. Operadores de control de errores | 12. Operadores de tipo |
La precedencia de los operadores en PHP sigue casi las mismas reglas que en matemáticas, por ejemplo: multiplicación y división preceden a suma y resta, los paréntesis fuerzan una precedencia, etc.
Cuando tienen la misma precedencia, su asociatividad decide cómo ordenar los operadores. Por ejemplo el operador suma + tiene asociatividad izquierda, por lo que la operación 1 + 2 + 3 sumará primero 1 y 2, y después 3 => (1 + 2) + 3. Por el contrario, el operador = tiene asociatividad derecha, por lo que $x = $y = $z se agrupa de forma $x = ($y = $z).
Los operadores de misma precedencia que no son asociativos no pueden usarse juntos, esto: 1 < 2 > 1 es incorrecto.
En ocasiones es aconsejable usar paréntesis aunque no sea necesario para mejorar la legibilidad.
La precedencia de operadores y su asociatividad sólo determinan cómo se agrupan las expresiones.
Lista de operadores ordenados por precedencia:
Asociatividad | Operadores |
No asociativo | clone, new |
Izquierda | [ |
Derecha | ** |
Derecha | ++, --, ~, (int), (float), (string), (array), (object), (bool), @ |
No asociativo | instanceof |
Derecha | ! |
Izquierda | *, /, % |
Izquierda | +, -, . |
Izquierda | <<, >> |
No asociativo | <, <=, >, >= |
No asociativo | ==, !=, ===, !==, <> |
Izquierda | & |
Izquierda | ^ |
Izquierda | |
Izquierda | && |
Izquierda | |
Izquierda | ?: |
Derecha | =, +=, -=, *=, **=, /=, .=, %=, &=, /=, ^=, <<=, >>=, => |
Izquierda | and |
Izquierda | xor |
Izquierda | or |
Izquierda | , |
Los operadores aritméticos en PHP son los mismos que en las matemáticas:
Operadores artiméticos | Representación |
Suma | $x + $y |
Resta | $x - $y |
Multiplicación | $x * $y |
División* | $x / $y |
Módulo** | $x % $y |
Exponenciación | $x ** $y |
Negación | -$x |
*División devuelve un (int) si $x y $y son divisibles, o (float) si no lo son.
**En Módulo se eliminarían primero las partes decimales transformándose en (int) en caso de ser (float) y luego se haría la operación. El signo (+ o -) del resultado dependerá del dividendo, por ejemplo: -5 % 3 mostraría -2.
Existen operadores básicos y combinados:
El operador básico de asignación es "=", que actúa como definidor, no como igualador. El valor de una expresión de asignación es el valor que se le ha asignado, esto es: "$x = 3" tiene un valor de 3.
En el caso de arrays, se asigna un valor a una clave nombrada mediante el operador "=>".
Los operadores combinados permiten usar un valor en una expresión y establecer su nuevo valor como resultado de esa expresión:
<?php
$x = 3;
$x += 5;
// $x vale ahora 8
$y = "Hola ";
$y .= ", ¿Qué tal?";
// $y vale ahora "Hola, ¿Qué tal?"
Hay una excepción a la asignación por valor en PHP, y son los objetos, que se asignan por referencia. Los objetos se copian mediante la palabra clone.
La asignación por referencia significa que las variables apuntan a los mismos valores, sin hacer ninguna copia:
<?php
$x = 3;
$y = &$x;
print "$x, $y"; // Mostrará 3, 3
$x = 5;
print "$x, $y"; // Mostrará 5, 5
Las referencias actúan como cuando se crea un acceso directo o alias de un archivo o carpeta en el ordenador.
Los operadores bit a bit permiten la evaluación y manipulación de bits específicos dentro de un integer.
Ejemplo | Nombre |
$x & $y | And |
$x | $y | Or |
$x ^ $y | Xor |
~$x | Not |
$x << $y | Shift left (desplazamiento izquierda) |
$x >> $y | Shift right (desplazamiento derecha) |
Los operadores de comparación permiten comparar dos valores. Estos valores dependen de los tipos que tengan asignados. Pueden verse las diferencias comparativas en la tabla de comparación de tipos.
Ejemplo | Nombre | Resultado |
$x == $y | Igual | true sean del mismo tipo o no |
$x === $y | Idéntico | true sólo si son del mismo tipo |
$x != $y | Distinto | true si son diferentes sean del mismo tipo o no |
$x <> $y | Distinto | true si son diferentes sean del mismo tipo o no |
$x !== $y | No idéntico | true sólo si no son iguales y tampoco del mismo tipo |
$x < $y | Menor que | true si $x es menor que y |
$x > $y | Mayor que | true si $x es mayor que $y |
$x <= $y | Menor o igual que | true si $x es menor o igual que $y |
$x >= $a | Mayor o igual que | true si $x es mayor o igual que $y |
Si se compara un número con un string o la comparación es entre strings numéricos, cada string se convierte en número y la comparación se realiza numéricamente (esto también se incluye con el uso de switch). Cuando se hacen comparaciones idénticas como === esto no tiene sentido ya que también se comparan los tipos.
<?php
var_dump(0 == "x"); // 0 == 0 true
var_dump("1" == "01"); // 1 == 1 true
var_dump("10" == "1y1"); // 10 == 10 true
var_dump(100 == "1e2"); // 100 == 100 true
switch ("x") {
case 0:
echo "0";
break;
case "x": // Nunca llegará porque "x" ya se ha encontrado con el caso "0"
echo "x";
break;
}
Cuando un string se evalúa en un contexto numérico, el valor y el tipo dependen de la conversión de string a números.
Comparaciones entre varios tipos:
$x | $y | Resultado |
null o string | string | null se convierte en "", comparación numérica o léxica |
bool o null | cualquiera | Ambos serán bool, y false < true |
object | object | Dos objetos serán iguales si tienen los mismos atributos y valores, siendo instancias de la misma clase. Dos objetos serán idénticos si además hacen referencia a la misma instancia de la misma clase. |
string, resource o number | string, resource o number | Se traducen a números y se comparan matemáticamente |
array | array | Un array con menos elementos es menor. Si una key no coincide en ambos arrays, son arrays incomparables. Se compara valor por valor. |
object | cualquiera | object siempre mayor |
array | cualquiera | array siempre mayor |
Debido a la forma en que son interpretados internamente los floats, su comparación puede dar resultados inesperados, aunque existen formas de poder compararlos.
<?php
$x = "";
$accion = (empty($x)) ? 'valor1' : 'valor2'; // Devolverá (string) valor1
// Lo anterior será lo mismo que:
if(empty($x)) {
$accion = 'valor1';
} else {
$accion = 'valor2';
}
Supongamos la expresión $x ? $y : $z. Si $x es true, se evaluará $y. Si $x es false, se evaluará $z.
Una forma más reducida del operador ternario es mediante ?:. Suponiendo $x ?: $y, devolverá $x si $x es true, y $y si $x es false.
Cuando se antepone el símbolo de arroba @ ante cualquier expresión, cualquier mensaje de error que pueda generar esa expresión será ignorado.
Si track_errors está activado, el último error se guardará en la variable $php_errormsg y podrá emplearse.
<?php
$miArchivo = @file('archivo_que_no_existe') or
die("No se ha podido abrir, el error ha sido '$php_errormsg'");
// Funciona también si por ejemplo se intenta acceder al key de un array que no existe:
$valor = @$array[$key]
@ Sólo funciona con expresiones (variables, llamadas a funciones o includes, constantes...) no funciona con definiciones de clases o funciones, condicionales como if o foreach...
El operador de ejecución `` hace que el contrenido entre las comillas invertidas se ejecute como comando de consola. Este operador es lo mismo que usar la functión shell_exec().
<?php
$var = `ls -al`; // Comando linux para mostrar un listado de archivos completo del directorio actual
echo "<pre>$var</pre>";
- Si safe_mode está activado o shell_exec() está desactivado, las comillas no funcionarán.
- Las comillas invertidas no significan nada cuando van dentro de comillas dobles.
Los operadores de incremento y decremento sólo afectan a números y strings, sin afectar a arrays, objects o resources. Decrementar un valor NULL no tiene efecto, pero si se incrementa se obtiene 1. Incrementar o decrementar booleanos no tiene efecto.
Operador | Efecto |
++$x | Incrementa $x en 1 y luego devuelve $x |
$x++ | Retorna $x, y luego incrementa $x en 1 |
--$x | Decrementa $x en 1, y luego retorna $x |
$x-- | Retorna $x, y luego decrementa $x en 1 |
Ejemplo:
<?php
$x = 4;
echo "Esto es 4: " . $x++ . "</br>";
echo "Y esto es 5: " . $x . "</br>";
$x = 4;
echo "Esto es 5: " . ++$x . "</br>";
echo "Y esto es 5: " . $x . "</br>";
$x = 4;
echo "Esto es 4: " . $x-- . "</br>";
echo "Y esto es 3: " . $x . "</br>";
Al trabajar sobre caracteres, de Z pasa a AA. Por ejemplo:
<?php
$x = 'Z';
echo ++$x; // Devolverá AA
echo ++$x; // Devolverá AB
$x = 'A9';
echo ++$x; // Devolerá B0
echo ++$x; // Devolverá B1
$x = 'A09';
echo ++$x; // Devolverá A10
echo ++$x; // Devolverá A11
Operador | Resultado |
$x and $y | true si $x y $y son true |
$x or $y | true si uno de los dos es true (o los dos) |
$x xor $y | true si sólo uno de los dos es true |
!$x | true si $x no es true |
$x && $y | true si $x y $y son true |
$x |
- && y || tienen precedencia sobre and y or.
Notas importantes:
<?php
$w = (false && foo()); // false
$x = (true || foo()); // true
$y = (false and foo()); // false
$z = (true or foo()); // true
// Actúa como: ($m = (false || true))
$m = false || true;
// Actúa como: (($n = false) or true)
$n = false or true;
var_dump($m, $n);
// Actúa como: ($a = (true && false))
$a = true && false;
// Actúa como: (($b = true) and false)
$b = true and false;
var_dump($a, $b);
Existen dos operadores para strings:
- Operador de concatenación '.'. Concatena los argumentos derecho e izquierdo.
- Operador de asignación sobre concatenación '.=', añade el argumento del lado derecho al argumento del lado izquierdo.
<?php
$x = "Hola";
$y = $x . ", ¿Qué tal?"; // $y = "Hola, ¿Qué tal?"
$x = "Hola ";
$x .= ", ¿Qué tal?"; // $x = "Hola, ¿Qué tal?"
Operador | Resultado |
$x + $y | Unión de $x e $y |
$x == $y | true si $x e $y tienen las mismas parejas key => value |
$x === $y | true si $x e $y tienen mismas parejas key => value, mismo orden y mismos tipos |
$x != $y | true si $x no es igual a $y |
$x <> $y | true si $x no es igual a $y |
$x !== $y | true si $x no es idéntica a $y |
El operador + devuelve el array derecho ($y) añadido al del izquierdo ($x). Si hay keys que existen en ambas, se utilizarán las keys del array izquierdo.
Ejemplo de unión:
$a = array("x" => "perro", "y" => "gato");
$b = array("x" => "pato", "y" => "liebre", "z" => "conejo");
// Unión de $a y $b
$c = $a + $b;
echo "Unión de \$a y \$b: \n";
var_dump($c);
/*
* array (size=3)
'x' => string 'perro' (length=5)
'y' => string 'gato' (length=4)
'z' => string 'conejo' (length=6)
*/
// Unión de $b y $a
$c = $b + $a;
echo "Union de \$b y \$a: \n";
var_dump($c);
/*
* array (size=3)
'x' => string 'pato' (length=4)
'y' => string 'liebre' (length=6)
'z' => string 'conejo' (length=6)
*/
Ejemplo de comparación:
$x = array("perro", "gato");
$y = array(1 => "gato", "0" => "perro");
var_dump($x == $y); // bool(true)
var_dump($x === $y); // bool(false)
instanceof es utilizado para saber si una variable es un objeto instanciado de una clase.
class MiClase
{
}
class NoEsMiClase
{
}
$x = new MiClase;
var_dump($x instanceof MiClase); // true
var_dump($y instanceof NoEsMiClase); // false
- Devuelve true si la instancia es de una clase padre. instanceof PadreClass
- Devuelve true con la interface de una clase que la implementa. instanceof MyInterface
- Devuelve true si la variable es un string con el nombre de la clase: $c = 'MiClase'; instanceof $c
- Si la variable que está siendo comprobada no es un objeto, no devuelve error, devuelve false.
Anterior | Siguiente |
@intelguasoft - Full Stack Developer
Versión: | 0.0.3-beta |
El curso está organizado según las temáticas indicadas en la página oficial de Rogue Wave Zend para la certificación de PHP.
Esta curso no tiene ninguna relación con Zend. |
---|---|---|
Fecha: | 28.11.2018 |
Básicos
Sintaxis básicaOperadores
Operadores bit a bit
Variables
Estructuras de control
Constantes y constructores base
Espacio de nombres
Extensiones
Configuraciones
Variables al descubierto
Recolector de basuras
Rendimiento (Performance)
Funciones
FuncionesArgumentos en funciones
Funciones variables
Valores por referencia en funciones
Funciones que devuelven algo
Ámbito de variables
Funciones anónimas y closure's
Cadenas y patrones
Las comillas y las cadenas de caracteresHeredoc y Nowdoc
Comparando cadenas de caracteres
Extracción en cadenas de caracteres
Análisis en cadenas de caracteres
Reemplazos en cadenas de caracteres
Formato de cadena de caracteres
Expresiones regulares (RegEx)
Codificación de caracteres
Codificación en cadenas de caracteres
Arreglos (Array's)
ArreglosArreglos asociativos
Iterar arreglos
Funciones de arreglos
SPL Arreglos mediante objetos
Conversión de arreglos
Archivos (I/O)
Manejo de archivosLectura de archivos
Escritura de archivos
Funciones del sistema de archivos
Socket's y archivos
Streams (?)
Seguridad
Concepto y funcionamiento CGIConfigurando la seguridad
Seguridad en Sesiones
Ataques XSS
Ataques CSRF
Ataques SQLInjection
Ataques CodeInjection
Ataques EmailInjection
Filtrado de datos de entrada
Escape de datos de salida
Encriptación y contraseñas
Seguridad en el almacenamiento de datos
Seguridad en la subida de datos
SSL y OpenSSL
Base de datos
Principios básicos SQLLos joins en SQL
Principales funciones SQL
Preparando sentencias SQL
Transacciones en SQL
Algo de PDO
Programación Orientada a Objetos
Instancias de clasesModificadores y herencia de clases
Interfaces
Excepciones
Auto-carga (Autoload)
Reflexión (Reflection)
Determinación de tipos (Type hinting)
Constantes de clase
Enlace estático de ejecución (Late Static Binding)
Métodos mágicos
Librería estándar PHP (SPL)
Generadores (Generators)
Traits
Clases abstractas
Formatos de información
Algo de XMLAlgo de SimpleXML
Algo de XML Parser
Algo de PHP DOM
Algo de Web Services
Web Services con SOAP
Algo de REST
Algo de JSON
Formato de fecha y hora
Características web's
SesionesFormularios
Métodos GET y POST
Cookies
Protocolo HTTP y sus headers
Autenticación HTTP
Códigos de estado HTTP