Diferencia entre revisiones de «Plantilla:ManuelRomero/PHP/OperadoresExpresiones»

De WikiEducator
Saltar a: navegación, buscar
(Página creada con «**Índice de contenido** | | | | -------- | -------- | | 1. Precedencia de operadores | 7. Operadores de ejecución | | 2. Operadores artiméticos | 8. Operadores de incre...»)
 
Línea 1: Línea 1:
−
**Índice de contenido**
+
<div class="slide">
  
−
| | |
+
==Operadores y expresiones==
−
| -------- | -------- |
+
−
| 1. Precedencia de operadores | 7. Operadores de ejecución |
+
−
| 2. Operadores artimé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 |
+
  
−
### 1. Precedencia de operadores
+
{{MRM_Definicion|Title=¿Qué es una expresión?|
  
−
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.
+
Una expresión es una parte esencial de las frases en un lenguaje de programación. }}
 +
{{MRM_Definicion|Title=Definición técnica de expresión|
 +
; Es un conjunto de operadores y operandos
 +
; que, al evaluarse, producen un valor.
 +
; Este valor puede ser usado dentro de otras instrucciones o asignado a variables.
 +
}}
 +
</div>
  
−
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).
+
<div class="slide">
 +
{{MRM_Puntos clave|Title=Notas importantes sobre expresiones en PHP|
  
−
Los **operadores de misma precedencia** que **no** son **asociativos** no pueden usarse juntos, esto: 1 < 2 > 1 es **incorrecto**.
+
* Una '''expresión tiene un tipo asociado'''. Este tipo depende del resultado de su evaluación.
 +
* En PHP, '''el operador determina el tipo de la expresión''' en muchos casos.
 +
* Los operandos '''intentan adaptarse al tipo esperado''' por el operador mediante conversiones automáticas (casting implícito).
 +
* Una expresión '''no es una instrucción completa''', sino parte de ella. Por ejemplo:
 +
<source lang=php>
 +
//Instruccion:
 +
$resultado = 5+3;
 +
// Expresión =>  5+3
 +
// Operador =>  +
 +
// Operandos =>  el 5 y el 3
 +
// Resultado => 8
 +
//Tipo de expresión => Aritmética, lo marca el operador
 +
</source>
  
−
En ocasiones es aconsejable usar paréntesis aunque no sea necesario para mejorar la legibilidad.
+
}}</div>
 +
<div class="slide">
 +
{{Nota| 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===
  
−
La precedencia de operadores y su asociatividad sólo determinan **cómo se agrupan las expresiones**.  
+
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.
  
−
Lista de **operadores ordenados por precedencia**:
+
{| class="wikitable col1cen col2cen center" style="width:auto;" |+ style="color:white; background:blue; font-size:1.50em;" | '''OPERADORES HABITUALES EN PHP''' |- ! style="color:white; background:green;" | '''Tipo de Operador''' || '''Operador''' || '''Tipo de Expresión''' |- | style="color:white; background:red;" | Operadores aritméticos || style="color:blue; background:white;" | + - * / % ** || Numérica |- | style="color:white; background:red;" | Operadores lógicos || style="color:blue; background:white;" | AND OR && || ! || Lógica |- | style="color:white; background:red;" | Operadores de comparación || style="color:blue; background:white;" | == != < > <= >= <=> ?? || Lógica |- | style="color:white; background:red;" | Operadores de auto incremento/decremento || style="color:blue; background:white;" | ++$a $a++ --$a $a-- || Numérica |- | style="color:white; background:red;" | Operadores de string (concatenación) || style="color:blue; background:white;" | . .= || String |}
  
−
| | |
 
−
| -------- | -------- |
 
−
| **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 | , |
 
  
−
### 2. Operadores aritméticos
+
{| class="wikitable col1cen col2cen center" style="width:auto;" |+ style="color:white; background:blue; font-size:1.50em;" | '''OTROS OPERADORES MENOS HABITUALES''' |- ! style="color:white; background:green;" | '''Tipo de Operador''' || '''Operador''' || '''Tipo de Expresión''' |- | style="color:white; background:red;" | Operadores de asignación simple || style="color:blue; background:white;" | = || Valor asignado |- | style="color:white; background:red;" | Operadores de asignación compuesta || style="color:blue; background:white;" | += -= *= /= %= **= .= || Numérica |- | style="color:white; background:red;" | Operadores de asignación por referencia || style="color:blue; background:white;" | & || Valor referenciado |- | style="color:white; background:red;" | Operadores bit a bit || style="color:blue; background:white;" | & | ^ ~ << >> || Numérica |- | style="color:white; background:red;" | Operador de control de errores || style="color:blue; background:white;" | @ || Silencia errores |- | style="color:white; background:red;" | Operador de ejecución || style="color:blue; background:white;" | `comando` || Resultado del comando ejecutado |}
  
−
Los **operadores aritméticos en PHP** son los mismos que en las matemáticas:
+
MRM_Puntos clave|Title=Notas importantes|
 +
;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.
−
| **Operadores artiméticos** | **Representación** |
+
*El operador de ejecución (` `) se utiliza para ejecutar comandos del sistema y devolver su salida.
−
| 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.
+
====Operadores de expresiones numéricas====
 +
<br />
 +
{{MRM_Puntos clave|
 +
;Intervienen con valores numéricos y retorna un número como resultado de su evaluación
 +
}}
 +
#Aritméticos (+,-,*,/,%,**)
 +
#Autoincremente/decremento(++ --)
 +
#Asignación compuesta (los aritmétcios segidos de una asignación += -= *= ....)
  
−
**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.  
+
{{MRM_Puntos clave|title=Valor de retorno|
 +
===== 1.- Operadores aritméticos=====
 +
<br />
 +
;Cuando haya varios en una operación, hay que tener cuidado con la preferencia. Mejor esplicitarla con paréntesis}}
 +
{{MRM_Pregunta|Title=Qué ejecutaría el siguiente código|
 +
<source lang=php>
 +
$num = 5+6*8-4/2;
 +
</source>
 +
;Mejor ponerlo así
 +
<source lang=php>
 +
$num = 5+(6*8)-(4/2);
 +
</source>
 +
{{Plegable|hide|Ejecución|
 +
<source lang=php>
 +
$num = 5+6*8-4/2;
 +
echo "<h1>Valor de número $num</h1>";
 +
$num = 5+(6*8)-(4/2);
 +
$num = 5+48-2;
 +
$num = 53-2;
 +
echo "<h1>Valor de número $num</h1>";
 +
</source>
 +
;Salida
 +
[[Archivo:salida_preferencia_1.png]]
 +
}}
 +
}}
 +
<br />
 +
*El operador quizá menos utilizado es el <span class=r>módulo(%) y el exponente(**)</span>.
 +
{{Nota|El módulo se usa mucho para ver si un número es o no divisible por otro.}}
  
−
### 3. Operadores de asignación
+
{{MRM_Actividad|
 +
;Buscar todos los números divisibles por 3 del 1 al 100
  
−
Existen **operadores básicos** y **combinados**:
+
{{Plegable|hide|Posible solución|
−
 
+
<source lang=php>
−
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.
+
$lista = null;
−
 
+
for($n=1; $n<=100; $n++){
−
En el caso de **arrays**, se asigna un valor a una clave nombrada mediante el operador "**=>**".
+
    if ($n%3==0)
−
 
+
        $lista.="$n, ";
−
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**_.
+
−
 
+
−
#### **Asignación por referencia**
+
−
 
+
−
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.
+
−
 
+
−
### 4. Operadores bit a bit
+
−
 
+
−
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) |
+
−
 
+
−
### 5. Operadores de comparación
+
−
 
+
−
Los **operadores de comparación** permiten comparar dos valores. Estos valores dependen de los [tipos que tengan asignados](http://php.net/manual/es/language.types.type-juggling.php). Pueden verse las diferencias comparativas en la [tabla de comparación de tipos](http://php.net/manual/es/types.comparisons.php).
+
−
 
+
−
| | | |
+
−
| -------- | -------- |
+
−
| **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éntido | 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;
+
 
}
 
}
−
```
+
echo "<h1>$lista</h1>";
 +
</source>
 +
;Salida
 +
[[Archivo:salida_multiplos_3.png]]
 +
}}
  
−
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](http://php.net/manual/es/language.types.string.php#language.types.string.conversion).
 
  
−
**Comparaciones entre varios tipos**:
+
{{Nota|En el ejemplo anterior, al final sale una coma de más, que ya veremos cómo quitarla.}}
 +
}}
  
−
| | | |
+
;El exponente consiste en elevar un número  a otro
−
| -------- | -------- |
+
{{MRM_Actividad|
−
| **$x** | **$y** | **Resultado** |
+
;Obtenerlo las diferentes potencias de 2 hasta elevarlo a 15:   2<sup>1</sup> 2<sup>2</sup> 2<sup>3</sup>...2<sup>15</sup>
−
| _null_ o _string_ | _string_ | _null_ se convierte en "", comparación numérica o léxica |
+
{{Plegable|hide|Posible solución|
−
| _bool_ o _null_ | cualquiera | Ambos serán _bool_, y **false** < **true** |
+
<source lang=php>
−
| _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.|
+
for($n=1; $n<=15; $n++){
−
| _string_, _resource_ o _number_ | _string_, _resource_ o _number_ | Se traducen a números y se comparan matemáticamente |
+
     echo "2<sup>$n</sup>=".(2**$n)."<br />";
−
| _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](http://php.net/manual/es/language.types.float.php#language.types.float.comparison).
+
−
 
+
−
#### **El operador ternario**
+
−
 
+
−
```
+
−
<?php
+
−
$x = "";
+
−
$accion = (empty($x)) ? 'valor1' : 'valor2'; // Devolverá (string) valor1
+
−
 
+
−
// Lo anterior será lo mismo que:
+
−
if(empty($x)) {
+
−
     $accion = 'valor1';
+
−
} else {
+
−
    $accion = 'valor2';
+
 
}
 
}
−
```
+
</source>
 +
;Salida
 +
[[Archivo:salida_potencias_2.png]]
 +
}}
 +
}}
 +
<br />
 +
=====Autoincremente / Decremento =====
 +
*el <span class=r>++, --</span> son valores de autoincremeto y autodecremento, pueder ser <span class=r>pre o post</span>
 +
*El el caso '''''pre''''', primero incrementa y luego toma el valor
 +
*El el caso '''''post''''', primero  toma el valor y luego incrementa
 +
{{
 +
MRM_Puntos clave|Title: forma de usar los operadores
 +
;Pre  es anteponiendo el operador
 +
<source lang=php>
 +
++$a;
 +
--$a
 +
</source>
 +
:Post es posponiéndolo
 +
<source lang=php>
 +
$a++;
 +
$a--;
 +
</source>
 +
}}
 +
<br />
 +
;Para muchos casos es lo mismo hacerlo pre que post. Esto ocurre  <span class=r>cuando en la instrucción solo haga eso</span>
 +
<source lang=php>
 +
$a=5;
 +
$a++;
 +
echo "Valor de a es $a";
 +
</source>
 +
Es igual que
 +
<source lang=php>
 +
$a=5;
 +
++$a;
 +
echo "Valor de a es $a";
 +
</source>
 +
;En ambos casos la salida dará el valor 6
 +
Pero
 +
<source lang=php>
 +
$a=5;
 +
echo "Valor de a es ".++$a."<br />";
 +
echo "Valor de a es $a<br />";
 +
</source>
 +
No es igual que
 +
<source lang=php>
 +
$a=5;
 +
echo "Valor de a es ".$a++."<br />";
 +
echo "Valor de a es $a<br />";
 +
</source>
 +
{{MRM_Pregunta|
 +
'''''Lo ves claro'''''
 +
}}
 +
}}
 +
</div>
  
−
Supongamos la expresión $x ? $y : $z. Si $x es **true**, se evaluará $y. Si $x es **false**, se evaluará $z.
+
{{MRM_Actividad|Title=Realiza el siguiente programa Entendiendo qué hace|
 +
<source lang=php>
 +
//Declara una variable entera y asigna el valor 4
  
−
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.
+
//Usando el operador unario, incrementa una unidad y compáralo con el valor 5
 +
//Muestra un mensaje mostrando su valor
  
−
### 6. Operadores de control de errores
+
//Compáralo con el valor  4 y decrementa en una unidad , muestra información de que no es igual y muestra el valor
 +
//Analiza la salida y prueba deferentes situaciones
 +
</source>
 +
}}
  
−
Cuando se antepone el símbolo de arroba **@** ante cualquier **expresión**, cualquier **mensaje de error** que pueda generar esa expresión será ignorado.
+
<div class="slide">
 +
;Operadores
 +
<source lang=php>
 +
$a=5;
 +
if ($a++==5)
 +
    echo '$a que vale '.$a.' dice que vale 5 ???? <br>'
 +
        . 'Esto es por que primero compara y luego incrementa<br>';
  
−
Si [track_errors](http://php.net/manual/es/errorfunc.configuration.php#ini.track-errors) está activado, el **último error** se guardará en la variable _**$php_errormsg**_ y podrá emplearse.
+
echo 'ahora $a vale '.$a.'<br>';
  
−
```
+
if (++$a==6)
−
<?php
+
     echo 'esto nunca saldrá ya que $a se incrementa antes de comparar';
−
$miArchivo = @file('archivo_que_no_existe') or
+
else
−
     die("No se ha podido abrir, el error ha sido '$php_errormsg'");
+
    echo 'efectivamente ahora $a ya no vale 6 sino '.$a.'<br>';
 +
?>
 +
</source>
 +
</div>
  
−
// Funciona también si por ejemplo se intenta acceder al key de un array que no existe:
+
<div class="slide">
−
$valor = @$array[$key]
+
;Operadores
−
```
+
*El código anterior genera la siguiente salida
 +
<source lang=php>
 +
$a que vale 6 dice que vale 5 ????
 +
Esto es por que primero compara y luego incrementa
 +
ahora $a vale 6
 +
efectivamente ahora $a ya no vale 6 sino 7
 +
</source>
 +
</div>
  
−
@ **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...
+
====Operadores con asignación en una misma variable====
 +
*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
  
−
### 7. Operadores de ejecución
 
  
−
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()](http://php.net/manual/es/function.shell-exec.php).
 
  
−
```
 
−
<?php
 
−
$var = `ls -al`; // Comando linux para mostrar un listado de archivos completo del directorio actual
 
−
echo "<pre>$var</pre>";
 
−
```
 
  
−
*  Si [safe_mode](http://php.net/manual/es/ini.sect.safe-mode.php#ini.safe-mode) está activado o [shell_exec()](http://php.net/manual/es/function.shell-exec.php) está desactivado, las comillas no funcionarán.
+
<div class="slide">
−
*   Las comillas invertidas no significan nada cuando van dentro de comillas dobles.
+
====Operadores comparación (==,<,>,>=,<=,<>,!=,===,!==)====
 +
:Este tipo de operadores genera un booleano como resultado de evaluar la expresión
 +
{{MRM_Puntos clave|
 +
*'''''<nowiki>==</nowiki>''''' operador de comparación '''''igual que''''' (mismo valor)
 +
*'''''<nowiki>===</nowiki>''''' operador de comparación '''''exactamente igual que''''' (mismo valor y tipo)
 +
}}
 +
</div>
  
−
### 8. Operadores de Incremento/decremento
+
<div class="slide">
 +
=====Operador == Vs === =====
 +
<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>
  
−
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.
+
<div class="slide">
 +
;Operador == vs ===
  
−
| | |
+
*El código anterior generaría  la siguiente salida
−
| -------- | -------- |
+
<source lang=php>
−
| **Operador** | **Efecto** |
+
$num es igual a true
−
| ++$x | Incrementa $x en 1 y luego devuelve $x |
+
$num no es exactamente igual a true
−
| $x++ | Retorna $x, y luego incrementa $x en 1 |
+
</source>
−
| --$x | Decrementa $x en 1, y luego retorna $x |
+
*Ver la sección '''''comparación de tipos''''' de la página oficial
−
| $x-- | Retorna $x, y luego decrementa $x en 1 |
+
http://php.net/manual/es/language.operators.comparison.php
 +
</div>
  
−
**Ejemplo**:
+
<div class="slide">
 +
====operadores de concatenacón( .) concatena cadena de caracteres.====
 +
:El operador + no está sobre cargado, observa el siguiente código
 +
<source lang=php>
 +
$nombre="Maria";
 +
$apellido = " de la Oh";
  
−
```
+
$nombreCompleto = $nombre.$apellido;
−
<?php
+
echo "el valor de nombre completo es $nombreCompleto ---<br>";
−
$x = 4;
+
−
echo "Esto es 4: " . $x++ . "</br>";
+
−
echo "Y esto es 5: " . $x . "</br>";
+
  
−
$x = 4;
+
$nombreCompleto = $nombre+$apellido;
−
echo "Esto es 5: " . ++$x . "</br>";
+
echo "el valor de nombre completo es $nombreCompleto --<br>";
−
echo "Y esto es 5: " . $x . "</br>";
+
</source>
 +
</div>
  
−
$x = 4;
+
<div class="slide">
−
echo "Esto es 4: " . $x-- . "</br>";
+
;La salida del código anterior sería
−
echo "Y esto es 3: " . $x . "</br>";
+
<source lang=php>
−
```
+
el valor de nombre completo es Maria de la Oh ---
 +
el valor de nombre completo es 0 --
 +
</source>
 +
</div>
  
−
Al trabajar sobre caracteres, de Z pasa a AA. Por ejemplo:
+
<div class="slide">
−
 
+
====Operadores de asignación (= , =>)====
−
```
+
: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
 +
;Operador de asignación
 +
<source lang=php>
 
<?php
 
<?php
−
$x = 'Z';
+
$b=1;
−
echo ++$x; // Devolverá AA
+
for ($a=0;$a<10;$a++){
−
echo ++$x; // Devolverá AB
+
    $b*=10;
 +
    echo 'valor de $b ='.$b.'<br>';
 +
}
 +
?>
 +
</source>
 +
</div>
  
−
$x = 'A9';
+
<div class="slide">
−
echo ++$x; // Devolerá B0
+
*El código anterior genera la siguiente salida
−
echo ++$x; // Devolverá B1
+
<source lang=php>
 +
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
 +
</source>
 +
</div>
  
−
$x = 'A09';
+
<div class="slide">
−
echo ++$x; // Devolverá A10
+
==== Operadores de ejecución (``)====
−
echo ++$x; // Devolverá A11
+
:PHP proporciona un operador especial que permite ejecutar sentencias
−
```
+
*Observa el siguiente código
−
 
+
<source lang=php>
−
### 9. Operadores lógicos
+
−
 
+
−
| | |
+
−
| -------- | -------- |
+
−
| **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 | true si uno de los dos es true (o los dos) |
+
−
 
+
−
* **&&** y **||** tienen precedencia sobre **and** y **or**.
+
−
 
+
−
**Notas importantes**:
+
−
 
+
−
```
+
 
<?php
 
<?php
−
$w = (false && foo()); // false
+
$Discos = `df`;
−
$x = (true  || foo()); // true
+
echo "<pre>$Discos</pre>";
−
$y = (false and foo()); // false
+
?>
−
$z = (true  or  foo()); // true
+
</source>
 +
</div>
  
−
// Actúa como: ($m = (false || true))
+
<div class="slide">
−
$m = false || true;
+
*El código anterior generará la siguiente salida
−
// Actúa como: (($n = false) or true)
+
<source lang=php>
−
$n = false or true;
+
Filesystem    1K-blocks    Used Available Use% Mounted on
−
 
+
/dev/sda5      86378608  6072360  75895384  8% /
−
var_dump($m, $n);
+
none                  4        0        4  0% /sys/fs/cgroup
−
 
+
udev            4023720        4  4023716  1% /dev
−
// Actúa como: ($a = (true && false))
+
tmpfs            806904    1384    805520   1% /run
−
$a = true && false;
+
none                5120        0      5120   0% /run/lock
−
// Actúa como: (($b = true) and false)
+
none            4034504    6588   4027916  1% /run/shm
−
$b = true and false;
+
none              102400      28    102372  1% /run/user
−
 
+
/dev/sda7      101797224 40480360  56122728  42% /home
−
var_dump($a, $b);
+
</source>
−
```
+
</div>
−
 
+
−
### 10. Operadores para strings
+
−
 
+
−
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?"
+
−
```
+
−
 
+
−
### 11. Operadores para arrays
+
−
 
+
−
| | |
+
−
| -------- | -------- |
+
−
| **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)
+
−
```
+
−
 
+
−
### 12. Operadores de tipo
+
−
 
+
−
_**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
+
<div class="slide">
−
var_dump($y instanceof NoEsMiClase); // false
+
;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>
  
−
*  Devuelve true si la **instancia** es de una **clase padre**. _instanceof PadreClass_
+
<div class="slide">
−
*  Devuelve true con la **interface** de una **clase que la implementa**. _instanceof MyInterface_
+
==== Operadores lógicos (and,&&, or, ||, xor !)====
−
*  Devuelve true si la variable es un _**string**_ con el nombre de la clase:
+
http://php.net/manual/es/language.operators.logical.php
−
    $c = 'MiClase';
+
:Funcionan por cortocircuito
−
    _instanceof $c_
+
:El operador  '''''xor''''' da verdad si los operando son de diferente valor uno true y el otro false
−
*   Si la variable que está siendo comprobada no es un objeto, no devuelve error, devuelve **false**.
+
:La notación '''''and''''' y '''''&&''''' representan el mismo operador, igual ocurre con '''''or''''' y '''''||'''''
 +
*La diferencia entre los operadores es la prioridad
 +
http://php.net/manual/es/language.operators.precedence.php
 +
</div>

Revisión de 20:02 28 nov 2024

Operadores y expresiones

Icon define.gif
¿Qué es una expresión?

Una expresión es una parte esencial de las frases en un lenguaje de programación.



Icon define.gif
Definición técnica de expresión
Es un conjunto de operadores y operandos
que, al evaluarse, producen un valor.
Este valor puede ser usado dentro de otras instrucciones o asignado a variables.



Icon key points.gif

Notas importantes sobre expresiones en PHP


  • Una expresión tiene un tipo asociado. Este tipo depende del resultado de su evaluación.
  • En PHP, el operador determina el tipo de la expresión en muchos casos.
  • Los operandos intentan adaptarse al tipo esperado por el operador mediante conversiones automáticas (casting implícito).
  • Una expresión no es una instrucción completa, sino parte de ella. Por ejemplo: 
//Instruccion:
 $resultado = 5+3;
 // Expresión =>  5+3
 // Operador =>  +
 // Operandos =>  el 5 y el 3
 // Resultado => 8
 //Tipo de expresión => Aritmética, lo marca el operador


(Comment.gif: 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.

MRM_Puntos clave|Title=Notas importantes|
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.
}}

Operadores de expresiones numéricas



Icon key points.gif

Puntos clave

Intervienen con valores numéricos y retorna un número como resultado de su evaluación


  1. Aritméticos (+,-,*,/,%,**)
  2. Autoincremente/decremento(++ --)
  3. Asignación compuesta (los aritmétcios segidos de una asignación += -= *= ....)



Icon key points.gif

Puntos clave

1.- Operadores aritméticos


Cuando haya varios en una operación, hay que tener cuidado con la preferencia. Mejor esplicitarla con paréntesis



Icon qmark.gif
Qué ejecutaría el siguiente código
$num = 5+6*8-4/2;
Mejor ponerlo así 
$num = 5+(6*8)-(4/2);



  • El operador quizá menos utilizado es el módulo(%) y el exponente(**).

(Comment.gif: El módulo se usa mucho para ver si un número es o no divisible por otro.)




Icon activity.jpg
Actividad
Buscar todos los números divisibles por 3 del 1 al 100


(Comment.gif: En el ejemplo anterior, al final sale una coma de más, que ya veremos cómo quitarla.)





El exponente consiste en elevar un número a otro


Icon activity.jpg
Actividad
Obtenerlo las diferentes potencias de 2 hasta elevarlo a 15
21 22 23...215




Autoincremente / Decremento
  • el ++, -- son valores de autoincremeto y autodecremento, pueder ser pre o post
  • El el caso pre, primero incrementa y luego toma el valor
  • El el caso post, primero toma el valor y luego incrementa


Icon key points.gif

Puntos clave

Title: forma de usar los operadores

Pre es anteponiendo el operador 
++$a;
--$a
Post es posponiéndolo 
$a++;
$a--;



Para muchos casos es lo mismo hacerlo pre que post. Esto ocurre cuando en la instrucción solo haga eso 
$a=5;
$a++;
echo "Valor de a es $a";

Es igual que 

$a=5;
++$a;
echo "Valor de a es $a";
En ambos casos la salida dará el valor 6

Pero 

$a=5;
echo "Valor de a es ".++$a."<br />";
echo "Valor de a es $a<br />";

No es igual que 

$a=5;
echo "Valor de a es ".$a++."<br />";
echo "Valor de a es $a<br />";



Icon qmark.gif
Pregunta
Lo ves claro


}}



Icon activity.jpg
Realiza el siguiente programa Entendiendo qué hace
//Declara una variable entera y asigna el valor 4
 
//Usando el operador unario, incrementa una unidad y compáralo con el valor 5
//Muestra un mensaje mostrando su valor
 
//Compáralo con el valor  4 y decrementa en una unidad , muestra información de que no es igual y muestra el valor
//Analiza la salida y prueba deferentes situaciones




Operadores 
$a=5;
if ($a++==5)
    echo '$a que vale '.$a.' dice que vale 5 ???? <br>'
        . 'Esto es por que primero compara y luego incrementa<br>';
 
echo 'ahora $a vale '.$a.'<br>';
 
if (++$a==6)
    echo 'esto nunca saldrá ya que $a se incrementa antes de comparar';
else
    echo 'efectivamente ahora $a ya no vale 6 sino '.$a.'<br>';
?>
Operadores
  • El código anterior genera la siguiente salida 
 $a que vale 6 dice que vale 5 ???? 
 Esto es por que primero compara y luego incrementa
 ahora $a vale 6
 efectivamente ahora $a ya no vale 6 sino 7

Operadores con asignación en una misma variable

$a=$a*5;
$a*=5;



Operadores comparación (==,<,>,>=,<=,<>,!=,===,!==)

Este tipo de operadores genera un booleano como resultado de evaluar la expresión


Icon key points.gif

Puntos clave

  • == operador de comparación igual que (mismo valor)
  • === operador de comparación exactamente igual que (mismo valor y tipo)


Operador == Vs ===
$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';
Operador == vs ===
  • El código anterior generaría la siguiente salida 
$num es igual a true
$num no es exactamente igual a true
  • Ver la sección comparación de tipos de la página oficial 
http://php.net/manual/es/language.operators.comparison.php

operadores de concatenacón( .) concatena cadena de caracteres.

El operador + no está sobre cargado, observa el siguiente código 
$nombre="Maria";
$apellido = " de la Oh";
 
$nombreCompleto = $nombre.$apellido;
echo "el valor de nombre completo es $nombreCompleto ---<br>";
 
$nombreCompleto = $nombre+$apellido;
echo "el valor de nombre completo es $nombreCompleto --<br>";
La salida del código anterior sería 
el valor de nombre completo es Maria de la Oh ---
el valor de nombre completo es 0 --

Operadores de asignación (= , =>)

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
Operador de asignación 
<?php
$b=1;
for ($a=0;$a<10;$a++){
    $b*=10;
    echo 'valor de $b ='.$b.'<br>';
}
?>
  • El código anterior genera la siguiente salida 
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

Operadores de ejecución (``)

PHP proporciona un operador especial que permite ejecutar sentencias
  • Observa el siguiente código 
<?php
$Discos = `df`;
echo "<pre>$Discos</pre>";
?>
  • El código anterior generará la siguiente salida 
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
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

Operadores lógicos (and,&&, or, ||, xor !)

http://php.net/manual/es/language.operators.logical.php
Funcionan por cortocircuito
El operador xor da verdad si los operando son de diferente valor uno true y el otro false
La notación and y && representan el mismo operador, igual ocurre con or y ||
  • La diferencia entre los operadores es la prioridad 
http://php.net/manual/es/language.operators.precedence.php
Obtenido de «https://es.wikieducator.org/index.php?title=Plantilla:ManuelRomero/PHP/OperadoresExpresiones&oldid=31696»