|
|
(23 revisiones intermedias por el mismo usuario no mostrado) |
Línea 2: |
Línea 2: |
| | | |
| ==Operadores y expresiones== | | ==Operadores y expresiones== |
| + | <br /> |
| | | |
| {{MRM_Definicion|Title=¿Qué es una expresión?| | | {{MRM_Definicion|Title=¿Qué es una expresión?| |
Línea 255: |
Línea 256: |
| | | |
| ===Operadores de Asignación=== | | ===Operadores de Asignación=== |
| + | |
| + | {| class="wikitable" |
| + | |+ style=" color:blue; font-size:1.25em;" | '''Tabla de Operadores de Asignación en PHP''' |
| + | |- |
| + | ! style="background:#0066CC; color:white;" | '''Categoría''' || '''Operador''' || '''Ejemplo''' || '''Descripción''' |
| + | |- |
| + | | style="background:#E6F0FF;" | Asignación básica || = || <source lang=php>$x = 10;</source> || Asigna el valor de la derecha a la variable de la izquierda. |
| + | |- |
| + | | style="background:#FFFFFF;" | Asignación básica (arrays) || => || <source lang=php>$array = ["clave" => "valor"];</source> || Asigna un valor a una clave en un array asociativo. |
| + | |- |
| + | | style="background:#E6F0FF;" | Asignación por referencia || & || <source lang=php>$y = &$x;</source> || Asigna una referencia a otra variable, ambas apuntan al mismo valor. |
| + | |- |
| + | | style="background:#FFFFFF;" | Asignación compuesta || += || <source lang=php>$x += 5;</source> || Suma 5 al valor de $x y asigna el resultado a $x. |
| + | |- |
| + | | style="background:#E6F0FF;" | Asignación compuesta || -= || <source lang=php>$x -= 3;</source> || Resta 3 al valor de $x y asigna el resultado a $x. |
| + | |- |
| + | | style="background:#FFFFFF;" | Asignación compuesta || *= || <source lang=php>$x *= 2;</source> || Multiplica $x por 2 y asigna el resultado a $x. |
| + | |- |
| + | | style="background:#E6F0FF;" | Asignación compuesta || /= || <source lang=php>$x /= 4;</source> || Divide $x entre 4 y asigna el resultado a $x. |
| + | |- |
| + | | style="background:#FFFFFF;" | Asignación compuesta || %= || <source lang=php>$x %= 3;</source> || Asigna a $x el resto de la división de $x entre 3. |
| + | |- |
| + | | style="background:#E6F0FF;" | Asignación compuesta (concatenación) || .= || <source lang=php>$y .= " mundo";</source> || Concatena " mundo" al valor de $y y asigna el resultado a $y. |
| + | |- |
| + | | style="background:#FFFFFF;" | Asignación compuesta (exponenciación) || **= || <source lang=php>$x **= 3;</source> || Eleva $x a la potencia de 3 y asigna el resultado a $x. |
| + | |} |
| | | |
| Los '''operadores de asignación''' permiten asignar un valor a una variable. Existen dos tipos principales: | | Los '''operadores de asignación''' permiten asignar un valor a una variable. Existen dos tipos principales: |
| | | |
− | * **Básicos:** Usan el operador "=" para asignar un valor. | + | * '''Básicos:''' Usan el operador "=" para asignar un valor. |
− | * **Combinados:** Combina un operador aritmético o de concatenación con la asignación. | + | * '''Combinados''' Combina un operador aritmético o de concatenación con la asignación. Siempre van precedidos por el punto antes de la operador antes de la asignación. |
| | | |
| ====Operador de Asignación Básico==== | | ====Operador de Asignación Básico==== |
| | | |
− | El operador "=" **asigna un valor**, pero no actúa como un igual matemático. La asignación retorna el valor que se asignó. | + | El operador '''"="''' '''asigna un valor''', pero no actúa como un igual matemático. La asignación retorna el valor que se asignó. |
| Por ejemplo: | | Por ejemplo: |
| | | |
| <source lang=php> | | <source lang=php> |
| + | //Simple curiosidad que tiene consecuencias en las estructuras de control |
| $x = 3; | | $x = 3; |
| // La expresión $x = 3 tiene un valor de 3 | | // La expresión $x = 3 tiene un valor de 3 |
Línea 286: |
Línea 314: |
| <source lang=php> | | <source lang=php> |
| $x = 3; | | $x = 3; |
− | $x += 5; // Suma 5 a $x | + | $x += 5; // Suma 5 a $x, |
| + | $x=$x+3; //Esto es la misma acción que la instrucción anterior |
| echo $x; // Mostrará: 8 | | echo $x; // Mostrará: 8 |
| </source> | | </source> |
Línea 340: |
Línea 369: |
| </source> | | </source> |
| | | |
− | '''Nota:''' Las referencias son similares a un alias o acceso directo en el sistema de archivos.
| + | {{Nota| Las referencias son similares a un alias o acceso directo en el sistema de archivos.}} |
| | | |
− | ===Resumen=== | + | ===Operadores de Comparación=== |
− | * Los operadores básicos asignan valores directamente.
| + | |
− | * Los operadores combinados simplifican las expresiones cuando la misma variable participa en la operación.
| + | |
− | * La asignación por referencia permite que múltiples variables compartan un mismo valor sin duplicarlo.
| + | |
| | | |
− | ===Actividad Práctica===
| + | Los '''operadores de comparación''' permiten comparar dos valores y devuelven un resultado booleano (`true` o `false`). |
| + | El resultado depende de los tipos de los valores comparados y de las reglas de conversión de tipos de PHP. |
| | | |
− | '''Objetivo:''' Practicar con operadores de asignación básicos, combinados y por referencia.
| + | ====Tabla de Operadores de Comparación==== |
| | | |
− | 1. Escribe un programa que utilice al menos dos operadores básicos y dos combinados. | + | {| class="wikitable" |
− | 2. Implementa un ejemplo de asignación por referencia.
| + | |+ style="color:blue; font-size:1.25em;" | '''Operadores de Comparación''' |
− | 3. Evalúa el resultado e incluye una breve explicación.
| + | |- |
| + | ! style="background:#0066CC; color:white;" | '''Ejemplo''' || '''Nombre''' || '''Resultado''' |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x == $y</source> || Igual || Devuelve `true` si $x y $y tienen el mismo valor, independientemente del tipo. |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x === $y</source> || Idéntico || Devuelve `true` sólo si $x y $y tienen el mismo valor y el mismo tipo. |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x != $y</source> || Distinto || Devuelve `true` si $x y $y son diferentes, independientemente del tipo. |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x <> $y</source> || Distinto || Igual que `!=`. |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x !== $y</source> || No idéntico || Devuelve `true` si $x y $y no son iguales o no son del mismo tipo. |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x < $y</source> || Menor que || Devuelve `true` si $x es menor que $y. |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x > $y</source> || Mayor que || Devuelve `true` si $x es mayor que $y. |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x <= $y</source> || Menor o igual que || Devuelve `true` si $x es menor o igual que $y. |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x >= $y</source> || Mayor o igual que || Devuelve `true` si $x es mayor o igual que $y. |
| + | |} |
| | | |
− | '''Plantilla de Ejemplo:'''
| + | ====Comparación Flexible (==) vs Estricta (===)==== |
| | | |
| + | Cuando se comparan dos valores, es importante entender la diferencia entre '''==''' (comparación flexible) y '''===''' (comparación estricta). |
| + | |
| + | Ejemplo: |
| <source lang=php> | | <source lang=php> |
− | <?php
| + | $num = 1; |
− | // 1. Operadores básicos
| + | |
− | $x = 10; | + | |
− | $y = "Hola";
| + | |
| | | |
− | // 2. Operadores combinados
| + | if ($num == true) { |
− | $x += 5; // $x es ahora 15 | + | echo '$num es igual a true<br>'; |
− | $y .= ", ¿Qué tal?"; // $y es ahora "Hola, ¿Qué tal?"
| + | } |
| | | |
− | // 3. Asignación por referencia
| + | if ($num === true) { |
− | $z = &$x; // $z apunta a la misma referencia que $x | + | echo "Esto nunca se ejecutará"; |
− | $z = 20; // Cambiar $z también afecta a $x
| + | } else { |
| + | echo '$num no es exactamente igual a true'; |
| + | } |
| + | </source> |
| | | |
− | // Muestra los resultados
| + | Salida esperada: |
− | echo "Valor de x: $x\n"; // Debería mostrar 20
| + | <source lang=php> |
− | echo "Valor de y: $y\n"; // Debería mostrar "Hola, ¿Qué tal?"
| + | $num es igual a true |
− | echo "Valor de z: $z\n"; // Debería mostrar 20
| + | $num no es exactamente igual a true |
− | ?>
| + | |
| </source> | | </source> |
| | | |
| + | '''Notas:''' |
| + | * `==` compara valores, permitiendo conversiones de tipo. |
| + | * `===` compara valores y tipos, sin conversiones. |
| | | |
| + | ====Comparaciones Entre Tipos==== |
| | | |
| + | La forma en que PHP compara diferentes tipos puede variar dependiendo de las reglas de conversión. |
| | | |
| + | {| class="wikitable" |
| + | |+ style="color:blue; font-size:1.25em;" | '''Comparación Entre Tipos''' |
| + | |- |
| + | ! style="background:#0066CC; color:white;" | '''$x''' || '''$y''' || '''Resultado''' |
| + | |- |
| + | | style="background:#E6F0FF;" | _null_ o _string_ || _string_ || _null_ se convierte en `""`, luego se compara numéricamente o léxicamente. |
| + | |- |
| + | | style="background:#FFFFFF;" | _bool_ o _null_ || cualquiera || Ambos valores se convierten a booleanos. `false` < `true`. |
| + | |- |
| + | | style="background:#E6F0FF;" | _object_ || _object_ || Dos objetos son '''iguales''' si tienen los mismos atributos y valores. Son '''idénticos''' si además apuntan a la misma instancia. |
| + | |- |
| + | | style="background:#FFFFFF;" | _string_, _resource_ o _number_ || _string_, _resource_ o _number_ || Se convierten a números y se comparan matemáticamente. |
| + | |- |
| + | | style="background:#E6F0FF;" | _array_ || _array_ || Se comparan elemento por elemento. Si los arrays tienen distinto número de elementos o claves no coincidentes, son incomparables. |
| + | |- |
| + | | style="background:#FFFFFF;" | _object_ || cualquiera || Los objetos son siempre mayores que otros tipos. |
| + | |- |
| + | | style="background:#E6F0FF;" | _array_ || cualquiera || Los arrays son siempre mayores que otros tipos. |
| + | |} |
| | | |
| + | '''Importante:''' Las comparaciones entre tipos no numéricos pueden ser confusas. Consulta la [documentación oficial de comparación de tipos](http://php.net/manual/es/types.comparisons.php) para más detalles. |
| | | |
| + | ===Operadores Lógicos=== |
| | | |
− | ====Operadores con asignación en una misma variable====
| + | Los '''operadores lógicos''' permiten combinar o invertir valores booleanos. Son esenciales para construir expresiones condicionales complejas. |
− | *Cuando la variable donde asignamos el resultado de la expresión forma parte de la expresión, la podemos simplificar
| + | |
− | *Veamos el siguiente ejemplo
| + | |
− | <source lang=php>
| + | |
− | $a=$a*5;
| + | |
− | </source>
| + | |
− | *Es igual que hacer
| + | |
− | <source lang=php>
| + | |
− | $a*=5;
| + | |
− | </source>
| + | |
− | *Esto lo podemos hacer con cualquiera de los operadores aritméticos
| + | |
| | | |
| + | ====Tabla de Operadores Lógicos==== |
| | | |
| + | {| class="wikitable" |
| + | |+ style="color:blue; font-size:1.25em;" | '''Operadores Lógicos en PHP''' |
| + | |- |
| + | ! style="background:#0066CC; color:white;" | '''Operador''' || '''Descripción''' || '''Ejemplo''' || '''Resultado''' |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x and $y</source> || Devuelve `true` si ambos $x y $y son `true`. || <source lang=php>(true and false)</source> || `false` |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x or $y</source> || Devuelve `true` si al menos uno de $x o $y es `true`. || <source lang=php>(true or false)</source> || `true` |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x xor $y</source> || Devuelve `true` si '''sólo uno''' de $x o $y es `true`. || <source lang=php>(true xor false)</source> || `true` |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>!$x</source> || Devuelve `true` si $x es `false`. || <source lang=php>(!true)</source> || `false` |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x && $y</source> || Igual que `and`, pero con mayor precedencia. || <source lang=php>(true && false)</source> || `false` |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x || $y</source> || Igual que `or`, pero con mayor precedencia. || <source lang=php>(true || false)</source> || `true` |
| + | |} |
| | | |
| + | ====Notas Importantes==== |
| | | |
− | <div class="slide"> | + | 1. ''Cortocircuito:'' |
| + | Si la primera condición de un operador como `&&` o `||` determina el resultado, las demás no se evalúan. |
| + | Ejemplo: |
| + | <source lang=php> |
| + | $result = (false && foo()); // foo() nunca se ejecutará |
| + | $result = (true || foo()); // foo() nunca se ejecutará |
| + | </source> |
| | | |
− | ====Operadores comparación (==,<,>,>=,<=,<>,!=,===,!==)====
| + | 2. ''Diferencia entre `and` y `&&`, `or` y `||`:'' |
− | :Este tipo de operadores genera un booleano como resultado de evaluar la expresión | + | `&&` y `||` tienen '''mayor precedencia''' que `and` y `or`. |
− | {{MRM_Puntos clave|
| + | Esto afecta cómo se agrupan las expresiones: |
− | *'''''<nowiki>==</nowiki>''''' operador de comparación '''''igual que''''' (mismo valor)
| + | <source lang=php> |
− | *'''''<nowiki>===</nowiki>''''' operador de comparación '''''exactamente igual que''''' (mismo valor y tipo)
| + | $a = false || true; // Actúa como: $a = (false || true) |
− | }}
| + | $b = false or true; // Actúa como: ($b = false) or true |
− | </div>
| + | |
| | | |
− | <div class="slide">
| + | var_dump($a, $b); // $a es true, $b es false |
− | =====Operador == Vs === =====
| + | </source> |
− | <source lang=php>
| + | |
− | $num=1;
| + | |
− | if ($num==true)
| + | |
− | echo '$num es igual a true<br>';
| + | |
− | if ($num===true){
| + | |
− | echo "esto nunca se ejecutará";
| + | |
− | }else
| + | |
− | echo '$num no es exactamente igual a true';
| + | |
− | </source> | + | |
− | </div>
| + | |
| | | |
− | <div class="slide"> | + | 3. ''`xor`:'' |
− | ;Operador == vs === | + | Es Or exclusivo: Devuelve `true` si sólo uno de los operandos es `true`. Si ambos son `true` o ambos son `false`, devuelve `false`. |
| + | Este operador no se usa mucho. |
| + | |
| + | ====Ejemplos de Diferencia de Preferencia==== |
| + | |
| + | 1. '''Ejemplo con `and` vs `&&`:''' |
| + | <source lang=php> |
| + | $x = true && false; // Actúa como: $x = (true && false) |
| + | $y = true and false; // Actúa como: ($y = true) and false |
| + | |
| + | var_dump($x, $y); // $x es false, $y es true |
| + | </source> |
| + | |
| + | 2. '''Ejemplo con `or` vs `||`:''' |
| + | <source lang=php> |
| + | $x = false || true; // Actúa como: $x = (false || true) |
| + | $y = false or true; // Actúa como: ($y = false) or true |
| + | |
| + | var_dump($x, $y); // $x es true, $y es false |
| + | </source> |
| + | |
| + | ===Operadores de Control de Errores=== |
| + | |
| + | *El operador '''@''' permite suprimir mensajes de error (si no es fatal, o sea de warning) que puedan generarse al evaluar una expresión. |
| + | *Es útil para evitar mostrar errores en ciertas situaciones, pero debe usarse con precaución. |
| + | |
| + | ====Funcionamiento==== |
| + | |
| + | * Cuando se coloca '''@''' antes de una expresión, cualquier error generado por esa expresión será ignorado. |
| + | * Si la directiva [`track_errors`](http://php.net/manual/es/errorfunc.configuration.php#ini.track-errors) está activada, el último error generado se almacenará en la variable especial '''$php_errormsg'''. |
| + | |
| + | ====Ejemplo Básico==== |
| | | |
− | *El código anterior generaría la siguiente salida
| |
| <source lang=php> | | <source lang=php> |
− | $num es igual a true | + | <?php |
− | $num no es exactamente igual a true | + | // Intentar abrir un archivo que no existe |
| + | $rtdo = @ (5+"25pepe") |
| + | echo $rtdo |
| + | ?> |
| </source> | | </source> |
− | *Ver la sección '''''comparación de tipos''''' de la página oficial
| |
− | http://php.net/manual/es/language.operators.comparison.php
| |
− | </div>
| |
| | | |
− | <div class="slide">
| + | En este ejemplo: |
− | ====operadores de concatenacón( .) concatena cadena de caracteres.====
| + | * Se produce un warning, ya que uno de los operadores no es un entero (pero puedo convertirlo parcialmente). |
− | :El operador + no está sobre cargado, observa el siguiente código
| + | |
| <source lang=php> | | <source lang=php> |
− | $nombre="Maria"; | + | <?php |
− | $apellido = " de la Oh"; | + | // Intentar abrir un archivo que no existe |
| + | $rtdo = @(5+"pepe") |
| + | echo $rtdo |
| + | ?> |
| + | </source> |
| | | |
− | $nombreCompleto = $nombre.$apellido;
| + | En este ejemplo: |
− | echo "el valor de nombre completo es $nombreCompleto ---<br>";
| + | * Se produce un error, y por lo tanto no actúa el operador. |
| | | |
− | $nombreCompleto = $nombre+$apellido;
| + | ====Usos Típicos==== |
− | echo "el valor de nombre completo es $nombreCompleto --<br>";
| + | |
− | </source>
| + | |
− | </div>
| + | |
| | | |
− | <div class="slide"> | + | 1. **Acceso a claves no existentes en un array:** |
− | ;La salida del código anterior sería | + | <source lang=php> |
| + | <?php |
| + | $array = ["clave1" => "valor1"]; |
| + | $valor = @$array["clave_no_existe"]; |
| + | echo "El valor es: $valor"; // No genera error aunque la clave no exista |
| + | ?> |
| + | </source> |
| + | |
| + | 2. ''Supresión de errores en funciones y expresiones:'' |
| + | <source lang=php> |
| + | <?php |
| + | @$resultado = 10 / "5hola"; // Suprime el warning de tipo |
| + | ?> |
| + | </source> |
| + | |
| + | 3. ''Abrir ficheros que no existen:'' |
| <source lang=php> | | <source lang=php> |
− | el valor de nombre completo es Maria de la Oh ---
| + | <?php |
− | el valor de nombre completo es 0 --
| + | // Intentar abrir un archivo que no existe |
| + | $miArchivo = @file('archivo_que_no_existe') |
| + | |
| + | ?> |
| </source> | | </source> |
− | </div>
| |
| | | |
− | <div class="slide">
| + | |
− | ====Operadores de asignación (= , =>)==== | + | ====Limitaciones del Operador @==== |
− | :Se pueden combinar con los aritméticos (+=, *=, ...) y con los de concatenación (.=)
| + | |
− | :En este caso el valor de la variable de la izquierda se toma como primero operando
| + | * El operador **@** sólo funciona con expresiones (variables, llamadas a funciones, constantes, etc.). |
− | ;Operador de asignación
| + | * No puede usarse en estructuras de control como `if`, `foreach`, o definiciones de clases o funciones. |
| + | |
| + | '''Ejemplo Inválido:''' |
| <source lang=php> | | <source lang=php> |
| <?php | | <?php |
− | $b=1;
| + | // Esto no funcionará: |
− | for ($a=0;$a<10;$a++){
| + | @function miFuncion() { |
− | $b*=10;
| + | echo "No se puede usar @ aquí."; |
− | echo 'valor de $b ='.$b.'<br>'; | + | |
| } | | } |
| + | |
| + | |
| ?> | | ?> |
| </source> | | </source> |
− | </div>
| |
| | | |
− | <div class="slide">
| + | {{Notas| |
− | *El código anterior genera la siguiente salida | + | *1. Usar **@** puede dificultar la depuración, ya que los errores se suprimen y pueden pasar desapercibidos. |
| + | *2. En entornos de producción, es preferible manejar los errores mediante [manejo de excepciones](http://php.net/manual/es/language.exceptions.php) o configuraciones de registro de errores. |
| + | *3. Aunque útil en algunos casos, **@** debe evitarse en código crítico o de gran complejidad. |
| + | }} |
| + | |
| + | ===Operadores Bit a Bit=== |
| + | |
| + | Los '''operadores bit a bit''' permiten la evaluación y manipulación de bits específicos dentro de un número entero (`integer`). |
| + | |
| + | ====Tabla de Operadores Bit a Bit==== |
| + | |
| + | {| class="wikitable" |
| + | |+ style="color:blue; font-size:1.25em;" | '''Operadores Bit a Bit''' |
| + | |- |
| + | ! style="background:#0066CC; color:white;" | '''Ejemplo''' || '''Nombre''' || '''Descripción''' |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x & $y</source> || And || Realiza una operación AND entre cada bit de $x y $y. |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x | $y</source> || Or || Realiza una operación OR entre cada bit de $x y $y. |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x ^ $y</source> || Xor || Realiza una operación XOR entre cada bit de $x y $y. |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>~$x</source> || Not || Invierte todos los bits de $x. |
| + | |- |
| + | | style="background:#E6F0FF;" | <source lang=php>$x << $y</source> || Shift left || Desplaza los bits de $x hacia la izquierda $y posiciones. |
| + | |- |
| + | | style="background:#FFFFFF;" | <source lang=php>$x >> $y</source> || Shift right || Desplaza los bits de $x hacia la derecha $y posiciones. |
| + | |} |
| + | |
| + | ====Ejemplos Prácticos==== |
| + | |
| + | 1. '''Operador AND (&):''' |
| + | <source lang=php> |
| + | $x = 6; // 6 en binario: 110 |
| + | $y = 3; // 3 en binario: 011 |
| + | $resultado = $x & $y; // Resultado: 2 (010 en binario) |
| + | echo "$x & $y = $resultado"; // Mostrará: 6 & 3 = 2 |
| + | </source> |
| + | |
| + | 2. '''Operador OR (|):''' |
| + | <source lang=php> |
| + | $x = 6; // 6 en binario: 110 |
| + | $y = 3; // 3 en binario: 011 |
| + | $resultado = $x | $y; // Resultado: 7 (111 en binario) |
| + | echo "$x | $y = $resultado"; // Mostrará: 6 | 3 = 7 |
| + | </source> |
| + | |
| + | 3. '''Operador XOR (^):''' |
| + | <source lang=php> |
| + | $x = 6; // 6 en binario: 110 |
| + | $y = 3; // 3 en binario: 011 |
| + | $resultado = $x ^ $y; // Resultado: 5 (101 en binario) |
| + | echo "$x ^ $y = $resultado"; // Mostrará: 6 ^ 3 = 5 |
| + | </source> |
| + | |
| + | 4. '''Operador NOT (~):''' |
| + | <source lang=php> |
| + | $x = 6; // 6 en binario: 110 |
| + | $resultado = ~$x; // Resultado: -7 (depende de la representación complementaria a dos) |
| + | echo "~$x = $resultado"; // Mostrará: ~6 = -7 |
| + | </source> |
| + | |
| + | 5. '''Shift Left o desplazamiento a la izquierda (<<):''' |
| + | <source lang=php> |
| + | $x = 2; // 2 en binario: 10 |
| + | $resultado = $x << 1; // Desplaza los bits hacia la izquierda 1 posición: 100 (4 en decimal) |
| + | echo "$x << 1 = $resultado"; // Mostrará: 2 << 1 = 4 |
| + | </source> |
| + | |
| + | 6. '''Shift Right o desplazamiento a la derecha (>>):''' |
| + | <source lang=php> |
| + | $x = 4; // 4 en binario: 100 |
| + | $resultado = $x >> 1; // Desplaza los bits hacia la derecha 1 posición: 10 (2 en decimal) |
| + | echo "$x >> 1 = $resultado"; // Mostrará: 4 >> 1 = 2 |
| + | </source> |
| + | |
| + | ====Notas Importantes==== |
| + | |
| + | * Los operadores bit a bit trabajan directamente sobre la representación binaria de los números. |
| + | * Los desplazamientos (`<<` y `>>`) pueden ser útiles para operaciones de bajo nivel como optimización de cálculos o manejo de banderas. |
| + | * El operador `~` puede producir resultados inesperados debido a la representación de enteros en PHP (complemento a dos). |
| + | |
| + | ====Actividad Práctica==== |
| + | |
| + | '''Objetivo:''' Escribir un programa que: |
| + | 1. Realice operaciones AND, OR, XOR y NOT con dos números. |
| + | 2. Desplace un número hacia la izquierda y hacia la derecha. |
| + | |
| + | '''Plantilla de Ejemplo:''' |
| <source lang=php> | | <source lang=php> |
− | valor de $b =10
| + | <?php |
− | valor de $b =100
| + | // 1. Operaciones bit a bit |
− | valor de $b =1000
| + | $a = 5; // 101 en binario |
− | valor de $b =10000
| + | $b = 3; // 011 en binario |
− | valor de $b =100000
| + | |
− | valor de $b =1000000
| + | echo "$a & $b = " . ($a & $b) . "<br>"; // AND |
− | valor de $b =10000000
| + | echo "$a | $b = " . ($a | $b) . "<br>"; // OR |
− | valor de $b =100000000
| + | echo "$a ^ $b = " . ($a ^ $b) . "<br>"; // XOR |
− | valor de $b =1000000000
| + | echo "~$a = " . (~$a) . "<br>"; // NOT |
− | valor de $b =10000000000
| + | |
| + | // 2. Desplazamiento |
| + | echo "$a << 1 = " . ($a << 1) . "<br>"; // Shift left |
| + | echo "$a >> 1 = " . ($a >> 1) . "<br>"; // Shift right |
| + | ?> |
| </source> | | </source> |
− | </div>
| |
| | | |
− | <div class="slide">
| + | === Operadores de Ejecución (``)=== |
− | ==== Operadores de ejecución (``)====
| + | |
− | :PHP proporciona un operador especial que permite ejecutar sentencias
| + | El operador '''``''' permite ejecutar comandos del sistema directamente desde PHP. Es equivalente a usar la función [shell_exec()](http://php.net/manual/es/function.shell-exec.php). |
− | *Observa el siguiente código | + | |
| + | ====Funcionamiento==== |
| + | |
| + | * Los comandos dentro de las comillas invertidas '''``''' se ejecutan en el sistema operativo, y el resultado se devuelve como una cadena de texto. |
| + | * Es útil para interactuar con el sistema desde un script PHP, pero debe usarse con precaución, especialmente en entornos de producción. |
| + | |
| + | ====Ejemplo Básico==== |
| + | |
| + | El siguiente código ejecuta el comando `df` (para mostrar información sobre discos y particiones en sistemas Linux): |
| + | |
| <source lang=php> | | <source lang=php> |
| <?php | | <?php |
− | $Discos = `df`; | + | $Discos = `df`; // Ejecuta el comando `df` |
− | echo "<pre>$Discos</pre>"; | + | echo "<pre>$Discos</pre>"; // Muestra el resultado en un formato legible |
| ?> | | ?> |
| </source> | | </source> |
− | </div>
| |
| | | |
− | <div class="slide">
| + | El código anterior generará una salida similar a esta (en sistemas Linux): |
− | *El código anterior generará la siguiente salida
| + | |
| <source lang=php> | | <source lang=php> |
| Filesystem 1K-blocks Used Available Use% Mounted on | | Filesystem 1K-blocks Used Available Use% Mounted on |
Línea 514: |
Línea 740: |
| /dev/sda7 101797224 40480360 56122728 42% /home | | /dev/sda7 101797224 40480360 56122728 42% /home |
| </source> | | </source> |
− | </div>
| |
| | | |
− | <div class="slide">
| + | ====Equivalencia con shell_exec()==== |
− | ;Invocando funciones del sistema
| + | |
− | *El operador anterior (comillas invertidas) es igual que la función '''''shell_exec()'''''
| + | |
− | http://php.net/manual/es/function.shell-exec.php
| + | |
− | </div>
| + | |
| | | |
− | <div class="slide"> | + | El operador de comillas invertidas '''``''' es funcionalmente igual a usar la función [shell_exec()](http://php.net/manual/es/function.shell-exec.php). |
− | ==== Operadores lógicos (and,&&, or, ||, xor !)==== | + | |
− | http://php.net/manual/es/language.operators.logical.php
| + | Por ejemplo: |
− | :Funcionan por cortocircuito
| + | <source lang=php> |
− | :El operador '''''xor''''' da verdad si los operando son de diferente valor uno true y el otro false
| + | <?php |
− | :La notación '''''and''''' y '''''&&''''' representan el mismo operador, igual ocurre con '''''or''''' y '''''||''''' | + | $Discos = shell_exec('df'); // También ejecuta el comando `df` |
− | *La diferencia entre los operadores es la prioridad
| + | echo "<pre>$Discos</pre>"; |
− | http://php.net/manual/es/language.operators.precedence.php
| + | ?> |
− | </div> | + | </source> |
| + | |
| + | ====Notas Importantes==== |
| + | |
| + | 1. '''Restricciones del sistema:''' |
| + | Si [safe_mode](http://php.net/manual/es/ini.sect.safe-mode.php#ini.safe-mode) está activado o la función `shell_exec()` está deshabilitada, el operador de ejecución no funcionará. |
| + | Este operador sólo es funcional en entornos donde PHP tiene permisos para ejecutar comandos del sistema. |
| + | |
| + | 2. '''Compatibilidad con el sistema operativo:''' |
| + | En sistemas Linux/Unix, puedes usar comandos como `ls`, `df`, `cat`, etc. |
| + | En sistemas Windows, usa comandos como `dir`, `type`, etc. |
| + | |
| + | 3. '''Precauciones de seguridad:''' |
| + | Nunca uses entradas del usuario directamente dentro del operador de ejecución. |
| + | Usa funciones como [escapeshellcmd()](http://php.net/manual/es/function.escapeshellcmd.php) para evitar inyecciones de comandos. |
| + | |
| + | ====Actividad Práctica==== |
| + | |
| + | 1. Escribe un programa que use el operador `` para listar los archivos del directorio actual (Linux: `ls`, Windows: `dir`). |
| + | 2. Modifica el programa para mostrar el contenido de un archivo específico. |
| + | 3. Usa [escapeshellcmd()](http://php.net/manual/es/function.escapeshellcmd.php) para proteger las entradas del usuario. |
| + | |
| + | '''Plantilla de Ejemplo:''' |
| + | <source lang=php> |
| + | <?php |
| + | // Listar archivos en el directorio actual |
| + | $listado = `ls -al`; // En Linux/Unix |
| + | // $listado = `dir`; // En Windows |
| + | echo "<pre>$listado</pre>"; |
| + | |
| + | // Mostrar contenido de un archivo (protegido) |
| + | $archivo = escapeshellcmd("archivo.txt"); |
| + | $contenido = `cat $archivo`; // En Linux/Unix |
| + | // $contenido = `type $archivo`; // En Windows |
| + | echo "<pre>$contenido</pre>"; |
| + | ?> |
| + | </source> |
(: Las expresiones son piezas fundamentales en cualquier lenguaje de programación. Es importante identificar sus partes (operadores y operandos) para entender cómo funciona el código.
)
Operadores
Los operadores son símbolos que realizan acciones sobre operandos y generan un resultado.
Existen diferentes tipos de operadores en función del tipo de operandos y el resultado esperado.
OPERADORES HABITUALES EN PHP
Tipo de Operador |
Operador |
Tipo de Expresión
|
Operadores aritméticos |
+ - * / % ** |
Numérica
|
Operadores lógicos |
AND OR && || ! |
Lógica
|
Operadores de comparación |
== != < > <= >= <=> ?? |
Lógica
|
Operadores de auto incremento/decremento |
++$a $a++ --$a $a-- |
Numérica o String
|
Operadores de string (concatenación) |
. .= |
String
|
OTROS OPERADORES MENOS HABITUALES
Tipo de Operador |
Operador |
Tipo de Expresión
|
Operadores de asignación simple |
= |
Valor asignado
|
Operadores de asignación compuesta |
+= -= *= /= %= **= .= |
Numérica
|
Operadores de asignación por referencia |
& |
Valor referenciado
|
Operadores bit a bit |
& | ^ ~ << >> |
Numérica
|
Operador de control de errores |
@ |
Silencia errores
|
Operador de ejecución |
`comando` |
Resultado del comando ejecutado
|
- Notas importantes
-
- Algunos operadores, como los de control de errores (@), deben usarse con cuidado, ya que pueden ocultar errores importantes en el código.
- Los operadores de asignación compuesta permiten realizar operaciones y asignar el resultado en un solo paso.
- El operador de ejecución (` `) se utiliza para ejecutar comandos del sistema y devolver su salida.
|
Precedencia de Operadores en PHP
- La precedencia de los operadores define el orden en que se evalúan cuando hay múltiples operadores en una expresión.
- Sigue las reglas básicas de las matemáticas:
- La multiplicación y división tienen mayor prioridad que la suma y la resta.
- Los paréntesis siempre tienen la mayor precedencia.
- Cuando varios operadores tienen la misma precedencia, la asociatividad determina cómo se agrupan:
- Ejemplo (asociatividad izquierda): `1 + 2 + 3` se evalúa como `(1 + 2) + 3`.
- Ejemplo (asociatividad derecha): `$x = $y = $z` se evalúa como `$x = ($y = $z)`.
- Algunos operadores no tienen asociatividad y no pueden combinarse directamente.
- Ejemplo incorrecto: `1 < 2 > 1`.
Nota importante: Usar paréntesis puede hacer que las expresiones sean más legibles, aunque no sean necesarios.
Tabla de Precedencia de Operadores
Precedencia y Asociatividad de Operadores en PHP
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 |
`,`
|
Operadores Aritméticos
Los operadores aritméticos en PHP son similares a los de las matemáticas y realizan operaciones básicas.
Operadores Aritméticos
Operación |
Representación |
Descripción
|
Suma |
|
Devuelve la suma de $x y $y.
|
Resta |
|
Devuelve la diferencia entre $x y $y.
|
Multiplicación |
|
Devuelve el producto de $x y $y.
|
División |
|
Devuelve el cociente de $x dividido por $y. Si ambos son divisibles, devuelve un entero; de lo contrario, un flotante.
|
Módulo |
|
Devuelve el resto de dividir $x entre $y. Si $x o $y son flotantes, se transforman en enteros antes de la operación.
|
Exponenciación |
|
Eleva $x a la potencia de $y.
|
Negación |
|
Cambia el signo de $x.
|
Notas importantes:
- En módulo, el signo del resultado dependerá del dividendo.
Ejemplo:
devolverá
.
- El exponente eleva un número a otro. Ejemplo: devolverá .
Ejemplos Prácticos
1. Preferencia de Operadores:
$num = 5 + 6 * 8 - 4 / 2;
// Mejor usar paréntesis para mayor claridad:
$num = 5 + (6 * 8) - (4 / 2);
Ejecución paso a paso:
$num = 5 + 48 - 2;
$num = 53 - 2;
$num = 51;
2. Uso del módulo:
Actividad
- Buscar los números divisibles por 3 entre 1 y 100.
Posible solución |
---|
for ($n = 1; $n <= 100; $n++) {
if ($n % 3 == 0) {
echo "$n, ";
}
}
- Salida
- Números divisibles por 3 con una coma al final.
|
|
3. Exponenciación:
Actividad
- Calcular las potencias de 2 del 1 al 15
-
Posible solución |
---|
for ($n = 1; $n <= 15; $n++) {
echo "2^$n = " . (2 ** $n) . "<br />";
}
|
|
---
Operadores de Incremento y Decremento
Los operadores de incremento y decremento permiten aumentar o reducir en 1 el valor de una variable.
Incremento y Decremento
Tipo |
Representación |
Descripción
|
Pre-incremento |
|
Incrementa el valor de $a antes de usarlo.
|
Post-incremento |
|
Usa el valor de $a y luego lo incrementa.
|
Pre-decremento |
|
Decrementa el valor de $a antes de usarlo.
|
Post-decremento |
|
Usa el valor de $a y luego lo decrementa.
|
Ejemplo de Diferencias entre Pre y Post:
// Pre-incremento
$a = 5;
echo "Pre-incremento: " . ++$a; // Muestra 6
// Post-incremento
$a = 5;
echo "Post-incremento: " . $a++; // Muestra 5
echo "Nuevo valor: " . $a; // Muestra 6
(: Cuando los operadores de incremento/decremento están en una instrucción más compleja, su posición (pre o post) puede afectar el resultado.)
Operadores de Asignación
Tabla de Operadores de Asignación en PHP
Categoría |
Operador |
Ejemplo |
Descripción
|
Asignación básica |
= |
|
Asigna el valor de la derecha a la variable de la izquierda.
|
Asignación básica (arrays) |
=> |
$array = ["clave" => "valor"]; |
Asigna un valor a una clave en un array asociativo.
|
Asignación por referencia |
& |
|
Asigna una referencia a otra variable, ambas apuntan al mismo valor.
|
Asignación compuesta |
+= |
|
Suma 5 al valor de $x y asigna el resultado a $x.
|
Asignación compuesta |
-= |
|
Resta 3 al valor de $x y asigna el resultado a $x.
|
Asignación compuesta |
*= |
|
Multiplica $x por 2 y asigna el resultado a $x.
|
Asignación compuesta |
/= |
|
Divide $x entre 4 y asigna el resultado a $x.
|
Asignación compuesta |
%= |
|
Asigna a $x el resto de la división de $x entre 3.
|
Asignación compuesta (concatenación) |
.= |
|
Concatena " mundo" al valor de $y y asigna el resultado a $y.
|
Asignación compuesta (exponenciación) |
**= |
|
Eleva $x a la potencia de 3 y asigna el resultado a $x.
|
Los operadores de asignación permiten asignar un valor a una variable. Existen dos tipos principales:
- Básicos: Usan el operador "=" para asignar un valor.
- Combinados Combina un operador aritmético o de concatenación con la asignación. Siempre van precedidos por el punto antes de la operador antes de la asignación.
Operador de Asignación Básico
El operador "=" asigna un valor, pero no actúa como un igual matemático. La asignación retorna el valor que se asignó.
Por ejemplo:
//Simple curiosidad que tiene consecuencias en las estructuras de control
$x = 3;
// La expresión $x = 3 tiene un valor de 3
echo $x; // Mostrará: 3
En el caso de los **arrays**, el operador "=>" se utiliza para asignar valores a claves nombradas:
$array = ["clave1" => "valor1", "clave2" => "valor2"];
echo $array["clave1"]; // Mostrará: valor1
Operadores de Asignación Combinados
Los operadores de asignación combinados permiten realizar una operación y asignar el resultado a la misma variable en un solo paso.
Ejemplo básico:
$x = 3;
$x += 5; // Suma 5 a $x,
$x=$x+3; //Esto es la misma acción que la instrucción anterior
echo $x; // Mostrará: 8
Esto es equivalente a:
Otros operadores combinados:
$y = "Hola";
$y .= ", ¿Qué tal?"; // Concatenación
echo $y; // Mostrará: Hola, ¿Qué tal?
Ejemplo con Operadores de Asignación Combinados
$b = 1;
for ($a = 0; $a < 10; $a++) {
$b *= 10; // Multiplica $b por 10 en cada iteración
echo "Valor de \$b = " . $b . "<br>";
}
Salida del código anterior:
Valor de $b = 10
Valor de $b = 100
Valor de $b = 1000
Valor de $b = 10000
Valor de $b = 100000
Valor de $b = 1000000
Valor de $b = 10000000
Valor de $b = 100000000
Valor de $b = 1000000000
Valor de $b = 10000000000
Asignación por Referencia
La asignación por referencia permite que dos variables apunten al mismo valor, sin crear copias. Esto se realiza con el operador "&".
Ejemplo:
$x = 3;
$y = &$x; // $y apunta a la misma referencia que $x
echo "$x, $y"; // Mostrará: 3, 3
$x = 5;
echo "$x, $y"; // Mostrará: 5, 5
(: Las referencias son similares a un alias o acceso directo en el sistema de archivos.)
Operadores de Comparación
Los operadores de comparación permiten comparar dos valores y devuelven un resultado booleano (`true` o `false`).
El resultado depende de los tipos de los valores comparados y de las reglas de conversión de tipos de PHP.
Tabla de Operadores de Comparación
Operadores de Comparación
Ejemplo |
Nombre |
Resultado
|
|
Igual |
Devuelve `true` si $x y $y tienen el mismo valor, independientemente del tipo.
|
|
Idéntico |
Devuelve `true` sólo si $x y $y tienen el mismo valor y el mismo tipo.
|
|
Distinto |
Devuelve `true` si $x y $y son diferentes, independientemente del tipo.
|
|
Distinto |
Igual que `!=`.
|
|
No idéntico |
Devuelve `true` si $x y $y no son iguales o no son del mismo tipo.
|
|
Menor que |
Devuelve `true` si $x es menor que $y.
|
|
Mayor que |
Devuelve `true` si $x es mayor que $y.
|
|
Menor o igual que |
Devuelve `true` si $x es menor o igual que $y.
|
|
Mayor o igual que |
Devuelve `true` si $x es mayor o igual que $y.
|
Comparación Flexible (==) vs Estricta (===)
Cuando se comparan dos valores, es importante entender la diferencia entre == (comparación flexible) y === (comparación estricta).
Ejemplo:
$num = 1;
if ($num == true) {
echo '$num es igual a true<br>';
}
if ($num === true) {
echo "Esto nunca se ejecutará";
} else {
echo '$num no es exactamente igual a true';
}
Salida esperada:
$num es igual a true
$num no es exactamente igual a true
Notas:
- `==` compara valores, permitiendo conversiones de tipo.
- `===` compara valores y tipos, sin conversiones.
Comparaciones Entre Tipos
La forma en que PHP compara diferentes tipos puede variar dependiendo de las reglas de conversión.
Comparación Entre Tipos
$x |
$y |
Resultado
|
_null_ o _string_ |
_string_ |
_null_ se convierte en `""`, luego se compara numéricamente o léxicamente.
|
_bool_ o _null_ |
cualquiera |
Ambos valores se convierten a booleanos. `false` < `true`.
|
_object_ |
_object_ |
Dos objetos son iguales si tienen los mismos atributos y valores. Son idénticos si además apuntan a la misma instancia.
|
_string_, _resource_ o _number_ |
_string_, _resource_ o _number_ |
Se convierten a números y se comparan matemáticamente.
|
_array_ |
_array_ |
Se comparan elemento por elemento. Si los arrays tienen distinto número de elementos o claves no coincidentes, son incomparables.
|
_object_ |
cualquiera |
Los objetos son siempre mayores que otros tipos.
|
_array_ |
cualquiera |
Los arrays son siempre mayores que otros tipos.
|
Importante: Las comparaciones entre tipos no numéricos pueden ser confusas. Consulta la [documentación oficial de comparación de tipos](http://php.net/manual/es/types.comparisons.php) para más detalles.
Operadores Lógicos
Los operadores lógicos permiten combinar o invertir valores booleanos. Son esenciales para construir expresiones condicionales complejas.
Tabla de Operadores Lógicos
Operadores Lógicos en PHP
Operador |
Descripción |
Ejemplo |
Resultado
|
|
Devuelve `true` si ambos $x y $y son `true`. |
|
`false`
|
|
Devuelve `true` si al menos uno de $x o $y es `true`. |
|
`true`
|
|
Devuelve `true` si sólo uno de $x o $y es `true`. |
|
`true`
|
|
Devuelve `true` si $x es `false`. |
|
`false`
|
|
Igual que `and`, pero con mayor precedencia. |
|
`false`
|
|
Igual que `or`, pero con mayor precedencia. |
|
`true`
|
Notas Importantes
1. Cortocircuito:
Si la primera condición de un operador como `&&` o `||` determina el resultado, las demás no se evalúan.
Ejemplo:
$result = (false && foo()); // foo() nunca se ejecutará
$result = (true || foo()); // foo() nunca se ejecutará
2. Diferencia entre `and` y `&&`, `or` y `||`:
`&&` y `||` tienen mayor precedencia que `and` y `or`.
Esto afecta cómo se agrupan las expresiones:
$a = false || true; // Actúa como: $a = (false || true)
$b = false or true; // Actúa como: ($b = false) or true
var_dump($a, $b); // $a es true, $b es false
3. `xor`:
Es Or exclusivo: Devuelve `true` si sólo uno de los operandos es `true`. Si ambos son `true` o ambos son `false`, devuelve `false`.
Este operador no se usa mucho.
Ejemplos de Diferencia de Preferencia
1. Ejemplo con `and` vs `&&`:
$x = true && false; // Actúa como: $x = (true && false)
$y = true and false; // Actúa como: ($y = true) and false
var_dump($x, $y); // $x es false, $y es true
2. Ejemplo con `or` vs `||`:
$x = false || true; // Actúa como: $x = (false || true)
$y = false or true; // Actúa como: ($y = false) or true
var_dump($x, $y); // $x es true, $y es false
Operadores de Control de Errores
- El operador @ permite suprimir mensajes de error (si no es fatal, o sea de warning) que puedan generarse al evaluar una expresión.
- Es útil para evitar mostrar errores en ciertas situaciones, pero debe usarse con precaución.
Funcionamiento
Ejemplo Básico
<?php
// Intentar abrir un archivo que no existe
$rtdo = @ (5+"25pepe")
echo $rtdo
?>
En este ejemplo:
- Se produce un warning, ya que uno de los operadores no es un entero (pero puedo convertirlo parcialmente).
<?php
// Intentar abrir un archivo que no existe
$rtdo = @(5+"pepe")
echo $rtdo
?>
En este ejemplo:
- Se produce un error, y por lo tanto no actúa el operador.
Usos Típicos
1. **Acceso a claves no existentes en un array:**
<?php
$array = ["clave1" => "valor1"];
$valor = @$array["clave_no_existe"];
echo "El valor es: $valor"; // No genera error aunque la clave no exista
?>
2. Supresión de errores en funciones y expresiones:
<?php
@$resultado = 10 / "5hola"; // Suprime el warning de tipo
?>
3. Abrir ficheros que no existen:
<?php
// Intentar abrir un archivo que no existe
$miArchivo = @file('archivo_que_no_existe')
?>
Limitaciones del Operador @
- El operador **@** sólo funciona con expresiones (variables, llamadas a funciones, constantes, etc.).
- No puede usarse en estructuras de control como `if`, `foreach`, o definiciones de clases o funciones.
Ejemplo Inválido:
<?php
// Esto no funcionará:
@function miFuncion() {
echo "No se puede usar @ aquí.";
}
?>
Plantilla:Notas
Operadores Bit a Bit
Los operadores bit a bit permiten la evaluación y manipulación de bits específicos dentro de un número entero (`integer`).
Tabla de Operadores Bit a Bit
Operadores Bit a Bit
Ejemplo |
Nombre |
Descripción
|
|
And |
Realiza una operación AND entre cada bit de $x y $y.
|
|
Or |
Realiza una operación OR entre cada bit de $x y $y.
|
|
Xor |
Realiza una operación XOR entre cada bit de $x y $y.
|
|
Not |
Invierte todos los bits de $x.
|
|
Shift left |
Desplaza los bits de $x hacia la izquierda $y posiciones.
|
|
Shift right |
Desplaza los bits de $x hacia la derecha $y posiciones.
|
Ejemplos Prácticos
1. Operador AND (&):
$x = 6; // 6 en binario: 110
$y = 3; // 3 en binario: 011
$resultado = $x & $y; // Resultado: 2 (010 en binario)
echo "$x & $y = $resultado"; // Mostrará: 6 & 3 = 2
2. Operador OR (|):
$x = 6; // 6 en binario: 110
$y = 3; // 3 en binario: 011
$resultado = $x | $y; // Resultado: 7 (111 en binario)
echo "$x | $y = $resultado"; // Mostrará: 6 | 3 = 7
3. Operador XOR (^):
$x = 6; // 6 en binario: 110
$y = 3; // 3 en binario: 011
$resultado = $x ^ $y; // Resultado: 5 (101 en binario)
echo "$x ^ $y = $resultado"; // Mostrará: 6 ^ 3 = 5
4. Operador NOT (~):
$x = 6; // 6 en binario: 110
$resultado = ~$x; // Resultado: -7 (depende de la representación complementaria a dos)
echo "~$x = $resultado"; // Mostrará: ~6 = -7
5. Shift Left o desplazamiento a la izquierda (<<):
$x = 2; // 2 en binario: 10
$resultado = $x << 1; // Desplaza los bits hacia la izquierda 1 posición: 100 (4 en decimal)
echo "$x << 1 = $resultado"; // Mostrará: 2 << 1 = 4
6. Shift Right o desplazamiento a la derecha (>>):
$x = 4; // 4 en binario: 100
$resultado = $x >> 1; // Desplaza los bits hacia la derecha 1 posición: 10 (2 en decimal)
echo "$x >> 1 = $resultado"; // Mostrará: 4 >> 1 = 2
Notas Importantes
- Los operadores bit a bit trabajan directamente sobre la representación binaria de los números.
- Los desplazamientos (`<<` y `>>`) pueden ser útiles para operaciones de bajo nivel como optimización de cálculos o manejo de banderas.
- El operador `~` puede producir resultados inesperados debido a la representación de enteros en PHP (complemento a dos).
Actividad Práctica
Objetivo: Escribir un programa que:
1. Realice operaciones AND, OR, XOR y NOT con dos números.
2. Desplace un número hacia la izquierda y hacia la derecha.
Plantilla de Ejemplo:
<?php
// 1. Operaciones bit a bit
$a = 5; // 101 en binario
$b = 3; // 011 en binario
echo "$a & $b = " . ($a & $b) . "<br>"; // AND
echo "$a | $b = " . ($a | $b) . "<br>"; // OR
echo "$a ^ $b = " . ($a ^ $b) . "<br>"; // XOR
echo "~$a = " . (~$a) . "<br>"; // NOT
// 2. Desplazamiento
echo "$a << 1 = " . ($a << 1) . "<br>"; // Shift left
echo "$a >> 1 = " . ($a >> 1) . "<br>"; // Shift right
?>
Operadores de Ejecución (``)
El operador `` permite ejecutar comandos del sistema directamente desde PHP. Es equivalente a usar la función [shell_exec()](http://php.net/manual/es/function.shell-exec.php).
Funcionamiento
- Los comandos dentro de las comillas invertidas `` se ejecutan en el sistema operativo, y el resultado se devuelve como una cadena de texto.
- Es útil para interactuar con el sistema desde un script PHP, pero debe usarse con precaución, especialmente en entornos de producción.
Ejemplo Básico
El siguiente código ejecuta el comando `df` (para mostrar información sobre discos y particiones en sistemas Linux):
<?php
$Discos = `df`; // Ejecuta el comando `df`
echo "<pre>$Discos</pre>"; // Muestra el resultado en un formato legible
?>
El código anterior generará una salida similar a esta (en sistemas Linux):
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda5 86378608 6072360 75895384 8% /
none 4 0 4 0% /sys/fs/cgroup
udev 4023720 4 4023716 1% /dev
tmpfs 806904 1384 805520 1% /run
none 5120 0 5120 0% /run/lock
none 4034504 6588 4027916 1% /run/shm
none 102400 28 102372 1% /run/user
/dev/sda7 101797224 40480360 56122728 42% /home
Equivalencia con shell_exec()
El operador de comillas invertidas `` es funcionalmente igual a usar la función [shell_exec()](http://php.net/manual/es/function.shell-exec.php).
Por ejemplo:
<?php
$Discos = shell_exec('df'); // También ejecuta el comando `df`
echo "<pre>$Discos</pre>";
?>
Notas Importantes
1. Restricciones del sistema:
Si [safe_mode](http://php.net/manual/es/ini.sect.safe-mode.php#ini.safe-mode) está activado o la función `shell_exec()` está deshabilitada, el operador de ejecución no funcionará.
Este operador sólo es funcional en entornos donde PHP tiene permisos para ejecutar comandos del sistema.
2. Compatibilidad con el sistema operativo:
En sistemas Linux/Unix, puedes usar comandos como `ls`, `df`, `cat`, etc.
En sistemas Windows, usa comandos como `dir`, `type`, etc.
3. Precauciones de seguridad:
Nunca uses entradas del usuario directamente dentro del operador de ejecución.
Usa funciones como [escapeshellcmd()](http://php.net/manual/es/function.escapeshellcmd.php) para evitar inyecciones de comandos.
Actividad Práctica
1. Escribe un programa que use el operador `` para listar los archivos del directorio actual (Linux: `ls`, Windows: `dir`).
2. Modifica el programa para mostrar el contenido de un archivo específico.
3. Usa [escapeshellcmd()](http://php.net/manual/es/function.escapeshellcmd.php) para proteger las entradas del usuario.
Plantilla de Ejemplo:
<?php
// Listar archivos en el directorio actual
$listado = `ls -al`; // En Linux/Unix
// $listado = `dir`; // En Windows
echo "<pre>$listado</pre>";
// Mostrar contenido de un archivo (protegido)
$archivo = escapeshellcmd("archivo.txt");
$contenido = `cat $archivo`; // En Linux/Unix
// $contenido = `type $archivo`; // En Windows
echo "<pre>$contenido</pre>";
?>