PHP también posee otros operadores importantes y muy usados como los de asignación, incremento/decremento y concatenación.
Operador de asignación
Representado por el signo = se usa para asignarle un valor determinado a una variable o constante:
<?php$a=100;$b=50+30;
Este no se debe leer como "igual a" pues para expresar igualdad tenemos otros operadores como == (igual a) o === (idéntico a).
Operadores de incremento/decremento
Estos operadores solo afectan a números y strings, pero no arrays, objects ni resources. Además, decrementar valores null tampoco tiene efecto, sin embargo, incrementarlos resulta en 1.
Operador de incremento
Representado por la secuencia de signos += son operadores utilizados para abreviar la forma en que incrementamos el valor de una variable. Veamos la siguiente línea de código:
<?php$contador=0;$contador=$contador+10;echo$contador;echo"\n";#-----------------------# Mensaje en pantalla:# 10
Esta puede ser simplificada usando un operador de incremento:
<?php$contador=0;$contador+=10;echo$contador;echo"\n";#-----------------------# Mensaje en pantalla:# 10
Si solo queremos incrementar en 1 nuestra variable podemos abreviar el código aún más:
$contador=0;$contador++;echo$contador;echo"\n";#-----------------------# Mensaje en pantalla:# 1
La secuencia ++ es otro operador de incremento que nos permite solo incrementar en una unidad nuestra variable.
Operador de decremento
Es la contraparte delos operadores de incremento.
Están representadas por -= y -- en donde la primera puede decrementar en más de una unidad, pero la segunda solo nos permite reducir en 1 el valor de nuestra variable:
$contador_1=100;$contador_1-=10;$contador_2=10;$contador_2--;echo"El contador 1 es igual a $contador_1 \n";echo"El contador 2 es igual a $contador_2 \n";#-----------------------# Mensaje en pantalla:# El contador 1 es igual a 90# El contador 2 es igual a 9
Válido también para la multiplicación y división
Estos operadores están representados por la secuencia de signos *= y /=:
<?php$contador_1=5;$contador_1*=10;$contador_2=1000;$contador_2/=2;echo"El contador 1 es igual a $contador_1 \n";echo"El contador 2 es igual a $contador_2 \n";#-----------------------# Mensaje en pantalla:# El contador 1 es igual a 50# El contador 2 es igual a 500
Operadores de concatenación
Su funcionamiento es similar a los operadores de incremento/decremento.
Son normalmente empleados para concatenar variables de tipo String con otras cadenas de caracteres.
Es representado por la siguiente secuencia: .=.
<?php$nombre="Carlos";$nombre.=" "."Santana";# Esto es lo mismo que: $nombre = $nombre . " " . "Santana";echo$nombre;echo"\n";# Salto de línea#-----------------------# Mensaje en pantalla:# Carlos Santana
El operador de Asignación, representado por el signo =, se usa para indicar al intérprete que un determinado identificador deberá apuntar a un valor en memoria.
El operador de Incremento, representado por la secuencia +=, se usa para simplificar la asignación de una adición sobre la misma variable.
$index=0;$index+=10;// Equivale a la sentencia '$index = $index + 10;'
El operador de Incremento unitario, representado por la secuencia ++, se usa para simplificar la asignación de una adición unitaria sobre la misma variable. Sin embargo, si el operador se encuentra a la izquierda de la variable, se considera Pre-incremento (Incrementa en uno, y luego retorna el valor); y si el operador se encuentra a la derecha de la variable, se considera Post-incremento (Retorna el valor, y luego lo incrementa en uno).
$length=6;$length++;// Equivale a la sentencia '$length = $length + 1;'
El operador de Decremento, representado por la secuencia -=, se usa para simplificar la asignación de una sustracción sobre la misma variable.
$juegos=335;$juegos-=20;// Equivale a la sentencia '$juegos = $juegos - 20;'
El operador de Decremento unitario, representado por la secuencia --, se usa para simplificar la asignación de una sustracción unitaria sobre la misma variable. Sin embargo, si el operador se encuentra a la izquierda de la variable, se considera Pre-decremento (Reduce en uno, y luego retorna el valor); y si el operador se encuentra a la derecha de la variable, se considera Post-decremento (Retorna el valor, y luego lo reduce en uno).
$peces=15;$peces--;// Equivale a la sentencia '$peces = $peces - 1;'
El operador de Multiplicación, representado por la secuencia *=, se usa para simplificar la asignación de una multiplicación sobre la misma variable.
$casas=3;$casas*=3;// Equivale a la sentencia '$casas = $casas * 3;'
El operador de División, representado por la secuencia /=, se usa para simplificar la asignación de una división sobre la misma variable.
$cupcakes=25;$cupcakes/=5;// Equivale a la sentencia '$cupcakes = $cupcakes / 5;'
El operador de Concatenación, representado por la secuencia .=, se usa para simplificar la asignación de una concatenación sobre la misma variable.
$nombre="Blanca";$nombre.=" Nieves";// Equivale a la sentencia '$nombre = $nombre . " Nieves";'
Super!👏😀
Muchas gracias!!
Otros Operadores
Operador de Asignación, =
Operador de Incremento, +=
$contador=1;$contador= $ contador +1;$contador+=1;$contador++;/Sirve para incrementar de 1 en 1
Poniendo en practica los aprendizajes de esta unidad.
por qué no me da el incremento la línea de
echo $contador++;
?? acaso no funciona antecedido por el echo?
Esto sucede por la precedencia
En este ejemplo hice lo mismo pero le agregue dos lineas mas
echo "Contador solo: ".$contador;echo "\n";
(linea 6 y 7)
Lo que hace es volver a imprimir la variable, lo que nos muestra de que SI se hizo el incremento +1 a la variable contador
Pd: Si le pones paréntesis aun así no funciona a la primera
gracias
Para los que estén viendo este curso luego de ver algún otro lenguaje como JS sin saber mucho de PHP y se les haga raro que pueda crear $edad_de_pepito dentro de una variable y luego pueda acceder fuera de esta variable.
Lo que sucedes es simplemente que se crea en el scopo en el que se declara, por ejemplo:
functionedades(){$edad_pepito =($edad_jaimito =20)+30;echo "La edad de pepito es $edad_pepito";echo "La edad de jaimito es $edad_jaimito";};echo $edad_jaimito;// En este caso si ejecutamos edades no habría ningún problema, pero si queremos hacer un echo de la edad de jaimito fuera de la función, nos dirá que está indefinida.
Esto se aplica para otras cosas que tengan scopos como por ejemplo un if o while, entonces ocurrirá lo mismo que con la función.
Excelente explicación.
Gracias, Saludos 😁💚
Gran complemento de operadores para ahorrarnos un poco en la cantidad de código cuando queremos hacer lo mismo.
La curiosidad del ultimo ejemplo creo es por que primero le asigna el valor de la variable y después aplica el incremento o decremento pero igual esperare primero a ver la razón real de ese comportamiento.
Por el momento comparto mi apunte de la clase de hoy :)
$nombreCompleto ="Carlos";$nombreCompleto .=" Santana";echo($nombreCompleto);// Carlos Santanaecho "\n";
<?php
// Operador de asignación$edad_de_jaimito =($edad_de_pepito =18)+5;echo "La edad de pepito es $edad_de_pepito \n";echo "La edad de jaimito es $edad_de_jaimito";echo "\n\n";// Operadores de incremento$contador =1;//$contador = $contador + 1;//$contador += 1;$contador++;echo $contador ."\n\n";/*
+=
-=
*=
/=
*/$nombre ="Carlos";$nombre .=" "."Santana";echo $nombre,"\n\n";$contador =1;$resultado = $contador++;echo $contador ."\n";echo $resultado;echo "\n";
El de la concatenación no lo sabia :O
<?php
$a = 5;
$b = 5;
$b2 = "5";
$c = 9;
$d = 2;
// == igual
var_dump($a == $b);
var_dump($a == $b2);
// === identico
var_dump($a === $b2);
var_dump($a === $b);
// != diferente
var_dump($a != $b);
var_dump($a != $c);
// != diferente igual compara tipos de variables
var_dump($a !== $b2);
// < menor que
var_dump($a < $c);
var_dump($c < $a);
// <= menor o igual que
var_dump($a <= $c);
var_dump($c <= $a);
// > mayor que
var_dump($a > $c);
var_dump($c > $a);
// > mayor igual que
var_dump($a >= $c);
var_dump($c >= $a);
// <=> operador de nave espacial
/*echo 2 <=> 1 . "\n" ; // 1
echo -50 <=> 1 . "\n" ; // -1
echo 1 <=> 1 . "\n" ; // 0
*/
// ?? fusion de null nos dice la primera variable definida
$edad_camilo = 23;
echo $edad_paola ?? $edad_camilo . "\n";
// operador de asignacion
$edad_mama = ($edad_papa = 46) + 44;
echo " la edad de mi papa es: $edad_papa \n" ;
echo " la edad de mi mama es: $edad_mama \n";
// operador de incremento
$contador = 1;
$contador ++;
echo $contador
//$contador +=1;
/*
+=
-=
*=
/=
*/
//$contador = $contador+1;
?>
```\<?php
$a = 5;$b = 5;$b2 = "5";$c = 9;$d = 2;
// == igual
var\_dump($a == $b);var\_dump($a == $b2);
// === identico
var\_dump($a === $b2);var\_dump($a === $b);
// != diferente
var\_dump($a != $b);var\_dump($a != $c);
// != diferente igual compara tipos de variables
var\_dump($a !== $b2);
// < menor que
var\_dump($a < $c);
var\_dump($c < $a);
// <= menor o igual que
var\_dump($a <= $c);
var\_dump($c <= $a);
// > mayor que 
var\_dump($a > $c);
var\_dump($c > $a);
// > mayor igual que 
var\_dump($a >= $c);
var\_dump($c >= $a);
// <=> operador de nave espacial
/\*echo 2 <=> 1 . "\n" ; // 1echo -50 <=> 1 . "\n" ; // -1echo 1 <=> 1 . "\n" ; // 0\*/
// ?? fusion de null nos dice la primera variable definida
$edad\_camilo = 23;
echo $edad\_paola ?? $edad\_camilo . "\n";
// operador de asignacion
$edad\_mama = ($edad\_papa = 46) + 44;
echo " la edad de mi papa es: $edad\_papa \n" ;echo " la edad de mi mama es: $edad\_mama \n";
// operador de incremento
$contador = 1;$contador ++;echo $contador
//$contador +=1;/\*+=-=\*=/=
\*///$contador = $contador+1;
?>
$counter1=1;$result1=$counter1++;//Primero asigna luego aumenta$counter2=1;$result2=++$counter2;//Primero aumenta y luego asignaecho$result1;//1echoPHP_EOL;echo$result2;//2echoPHP_EOL;
Super, aprendi el operador de concatenación (.=)
Wow Como hiciste una tabla en VSC?
En VSC? Como lo hiciste ?
Estoy en el minuto 4:20 y se me ha ocurrido una posible aplicación real de =
