PREGUNTA:

¿Qué significa => ?

RESPONDER:

=> Es el símbolo que los humanos decidimos usar para separar pares "Key" => "Value" en matrices asociativas.

ELABORANDO:

Para entender esto, tenemos que saber qué son matrices asociativas. Lo primero que surge cuando un programador convencional piensa en una matriz ( en PHP ) sería algo similar a:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

Donde, si quisiéramos llamar a la matriz en una parte posterior del código, podríamos hacerlo:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

Hasta ahora tan bueno. Sin embargo, como seres humanos, nos puede resultar difícil recordar que el índice [0] de la matriz es el valor del año 2016, el índice [1] de la matriz es un saludo , y el índice [2] de la matriz es un simple valor entero La alternativa que tendríamos entonces es usar lo que se llama una matriz asociativa . Una matriz asociativa tiene algunas diferencias con respecto a una matriz secuencial ( que es lo que eran los casos anteriores, ya que incrementan el índice utilizado en una secuencia predeterminada, incrementando en 1 por cada valor siguiente ).

Diferencias ( entre una matriz secuencial y asociativa ):

• Al anular la declaración de una matriz asociativa, no solo incluye el value de lo que desea colocar en la matriz, sino que también coloca el valor de índice (llamado key ) que desea utilizar al llamar a la matriz en partes posteriores del código. La siguiente sintaxis se usa durante su declaración: "key" => "value" .

• Cuando se usa la matriz asociativa, el valor key se colocará dentro del índice de la matriz para recuperar el value deseado.

Por ejemplo:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

Y ahora, para recibir la misma salida que antes, el valor de key se usaría en el índice de arrays:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

PUNTO FINAL:

Entonces, a partir del ejemplo anterior, es bastante fácil ver que el símbolo => se usa para expresar la relación de una matriz asociativa entre cada uno de los pares key y value en una matriz DURANTE el inicio de los valores dentro de la matriz.

Operador bitwise

Que es un poco Un bit es una representación de 1 o 0. Básicamente OFF (0) y ON (1)

¿Qué es un byte? Un byte se compone de 8 bits y el valor más alto de un byte es 255, lo que significaría que cada bit se establece. Veremos por qué el valor máximo de un byte es 255.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

Esta representación de 1 byte.

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 byte)

Algunos ejemplos para una mejor comprensión.

El operador "AND": &

$a =  9;
$b = 10;
echo $a & $b;

Esto daría como resultado el número 8. ¿Por qué? Bueno, veamos usando nuestro ejemplo de mesa.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

Así que puedes ver en la tabla que el único bit que comparten juntos es el 8 bit.

Segundo ejemplo

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

Los dos bits compartidos son 32 y 4, que cuando se suman devuelven 36.

El operador "O": |

$a =  9;
$b = 10;
echo $a | $b;

Esto daría como resultado el número 11. ¿Por qué?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

Notará que tenemos 3 bits establecidos, en las columnas 8, 2 y 1. Súmalos: 8 + 2 + 1 = 11.

Constantes mágicas : aunque no son solo símbolos sino una parte importante de esta familia de fichas. Hay ocho constantes mágicas que cambian dependiendo de dónde se usan.

__LINE__ : el número de línea actual del archivo.

__FILE__ : La ruta completa y el nombre del archivo. Si se utiliza dentro de una inclusión, se devuelve el nombre del archivo incluido. Desde PHP __FILE__ , __FILE__ siempre contiene una ruta absoluta con enlaces simbólicos resueltos, mientras que en versiones anteriores contenía rutas relativas en algunas circunstancias.

__DIR__ : El directorio del archivo. Si se utiliza dentro de una inclusión, se devuelve el directorio del archivo incluido. Esto es equivalente a dirname(__FILE__) . Este nombre de directorio no tiene una barra inclinada a menos que sea el directorio raíz. (Añadido en PHP 5.3.0.)

__FUNCTION__ : El nombre de la función. (Agregado en PHP 4.3.0) A partir de PHP 5, esta constante devuelve el nombre de la función como se declaró (distingue entre mayúsculas y minúsculas). En PHP 4 su valor siempre está en minúscula.

__CLASS__ : El nombre de la clase. (Agregado en PHP 4.3.0) A partir de PHP 5, esta constante devuelve el nombre de la clase tal como fue declarado (distingue entre mayúsculas y minúsculas). En PHP 4 su valor siempre está en minúscula. El nombre de la clase incluye el espacio de nombres en el que se declaró (por ejemplo, Foo\Bar ). Tenga en cuenta que a partir de PHP 5.4 __CLASS__ funciona también en rasgos. Cuando se usa en un método de rasgo, __CLASS__ es el nombre de la clase en que se usa el rasgo.

__TRAIT__ : El nombre del rasgo. (Agregado en PHP 5.4.0) A partir de PHP 5.4, esta constante devuelve el rasgo tal como fue declarado (distingue entre mayúsculas y minúsculas). El nombre del rasgo incluye el espacio de nombres en el que se declaró (por ejemplo, Foo\Bar ).

__METHOD__ : El nombre del método de clase. (Agregado en PHP 5.0.0) El nombre del método se devuelve como se declaró (distingue entre mayúsculas y minúsculas).

__NAMESPACE__ : el nombre del espacio de nombres actual ( __NAMESPACE__ mayúsculas y minúsculas). Esta constante se define en tiempo de compilación (Agregada en PHP 5.3.0).

Source

Nulo coalesce operador php

El operador de unión nula (??) se ha agregado a PHP7 para el caso común de la necesidad de usar un ternario junto con isset (). Devuelve su primer operando si existe y no es NULL; de lo contrario, devuelve su segundo operando, como el siguiente ejemplo:

$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; 

Operador coalescente nulo (??)

Este operador se ha agregado en PHP 7.0 para el caso común de la necesidad de utilizar un operador ternario junto con isset() . Devuelve su primer operando si existe y no es NULL ; De lo contrario, devuelve su segundo operando.

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

Operador de nave espacial <=> (Añadido en PHP 7)

Ejemplos para <=> operador de nave espacial (PHP 7, Fuente: Manual de PHP):

Números enteros, flotadores, cadenas, matrices y objetos para la comparación de variables de tres vías.

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1

{} Llaves

• ¿Bloques - llaves o no llaves?
• Llaves en una cadena en PHP
• Llaves de PHP en notación de matriz

Y algunas palabras sobre el último post.

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works

Operadores de incremento / decremento

++ operador de incremento

-- operador decremento

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

Estos pueden ir antes o después de la variable.

Si se coloca antes de la variable, primero se realiza la operación de incremento / decremento a la variable y luego se devuelve el resultado. Si se coloca después de la variable, primero se devuelve la variable, luego se realiza la operación de incremento / decremento.

Por ejemplo:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

Ejemplo vivo

En el caso anterior se usa ++$i , ya que es más rápido. $i++ tendría los mismos resultados.

El pre-incremento es un poco más rápido, porque realmente incrementa la variable y después de eso "devuelve" el resultado. El incremento posterior crea una variable especial, copia allí el valor de la primera variable y solo después de que se utiliza la primera variable, reemplaza su valor por el de la segunda.

Sin embargo, debe usar $apples-- , ya que primero desea mostrar el número actual de manzanas, y luego desea restar una de ellas.

También puedes incrementar letras en PHP:

$i = "a";
while ($i < "c") {
    echo $i++;
}

Una vez que se llega a z aa es la siguiente, y así sucesivamente.

Tenga en cuenta que las variables de caracteres pueden incrementarse pero no disminuirse, y aún así solo se admiten caracteres ASCII simples (az y AZ).

Postes de desbordamiento de pila:

• Entendiendo Incremento

Una visión general de los operadores en PHP :

Operadores logicos:

• $ a & Y $ b: VERDADERO si tanto $ a como $ b son VERDADEROS.
• $ a || $ b: VERDADERO si $ a o $ b es VERDADERO.
• $ a xor $ b: VERDADERO si $ ao $ b es VERDADERO, pero no ambos.
• ! $ a: VERDADERO si $ a no es VERDADERO.
• $ a y $ b: VERDADERO si tanto $ a como $ b son VERDADEROS.
• $ ao $ b: VERDADERO si $ ao $ b es VERDADERO.

Operadores de comparación:

• $ a == $ b: VERDADERO si $ a es igual a $ b después del tipo de malabarismo.
• $ a === $ b: VERDADERO si $ a es igual a $ b, y son del mismo tipo.
• $ a! = $ b: VERDADERO si $ a no es igual a $ b después del tipo de malabarismo.
• $ a <> $ b: VERDADERO si $ a no es igual a $ b después del tipo de malabarismo.
• $ a! == $ b: VERDADERO si $ a no es igual a $ b, o no son del mismo tipo.
• $ a <$ b : VERDADERO si $ a es estrictamente menor que $ b.
• $ a> $ b : VERDADERO si $ a es estrictamente mayor que $ b.
• $ a <= $ b : VERDADERO si $ a es menor o igual que $ b.
• $ a> = $ b : VERDADERO si $ a es mayor o igual que $ b.
• $ a <=> $ b : un número entero menor que, igual o mayor que cero cuando $ a es respectivamente menor que, igual o mayor que $ b. Disponible a partir de PHP 7.
• $ a? $ b: $ c : si $ a return $ b, si no, devuelve $ c ( operador ternario )
• $ a ?? $ c : igual que $ a? $ a: $ c ( operador de unión nula - requiere PHP> = 7)

Operadores aritméticos:

• - $ a : Opuesto a $ a.
• $ a + $ b : Suma de $ a y $ b.
• $ a - $ b : Diferencia de $ a y $ b.
• $ a * $ b : Producto de $ a y $ b.
• $ a / $ b : Cociente de $ a y $ b.
• $ a% $ b : Resto de $ a dividido por $ b.
• $ a ** $ b : Resultado de aumentar $ a al poder $ b'th (introducido en PHP 5.6)

Operadores de aumento / decremento:

• ++ $ a : Incrementa $ a por uno, luego devuelve $ a.
• $ a ++ : devuelve $ a, luego incrementa $ a por uno.
• - $ a : Disminuye $ a por uno, luego devuelve $ a.
• $ a-- : devuelve $ a, luego disminuye $ a por uno.

Operadores de bitwise:

• $ a y $ b : se configuran los bits que se establecen tanto en $ a como en $ b.
• $ a | $ b : se configuran los bits que se establecen en $ a o $ b.
• $ a ^ $ b : Bits que se configuran en $ a o $ b, pero no se establecen ambos.
• ~ $ a : los bits que se configuran en $ a no se configuran, y viceversa.
• $ a << $ b : desplace los bits de $ a $ b pasos hacia la izquierda (cada paso significa "multiplica por dos")
• $ a >> $ b : Mueva los bits de los pasos de $ a $ b hacia la derecha (cada paso significa "dividir por dos")

Operadores de cuerdas:

• $ a. $ b : concatenación de $ ay $ b.

Operadores de matrices:

• $ a + $ b : Unión de $ a y $ b.
• $ a == $ b : VERDADERO si $ a y $ b tienen los mismos pares clave / valor.
• $ a === $ b : VERDADERO si $ a y $ b tienen los mismos pares clave / valor en el mismo orden y de los mismos tipos.
• $ a! = $ b : VERDADERO si $ a no es igual a $ b.
• $ a <> $ b : VERDADERO si $ a no es igual a $ b.
• $ a! == $ b : VERDADERO si $ a no es idéntico a $ b.

Operadores de Asignación:

• $ a = $ b : el valor de $ b se asigna a $ a
• $ a + = $ b : Igual que $ a = $ a + $ b
• $ a - = $ b : Igual que $ a = $ a - $ b
• $ a * = $ b : Igual que $ a = $ a * $ b
• $ a / = $ b : Igual que $ a = $ a / $ b
• $ a% = $ b : Igual que $ a = $ a% $ b
• $ a ** = $ b : Igual que $ a = $ a ** $ b
• $ a. = $ b : Igual que $ a = $ a. $ b
• $ a y = $ b : Igual que $ a = $ a y $ b
• $ a | = $ b : Igual que $ a = $ a | $ b
• $ a ^ = $ b : Igual que $ a = $ a ^ $ b
• $ a << = $ b : Igual que $ a = $ a << $ b
• $ a >> = $ b : Igual que $ a = $ a >> $ b

Nota

and operador y / or operador tienen menor prioridad que el operador de asignación = .

Esto significa que $a = true and false; es equivalente a ($a = true) and false .

En la mayoría de los casos, probablemente querrá usar && y || , que se comportan de una manera conocida desde lenguajes como C, Java o JavaScript.

Operador nulo coalesce "??" (Añadido en PHP 7)

No es el nombre más atractivo para un operador, pero PHP 7 trae la fusión nula bastante útil, así que pensé en compartir un ejemplo.

En PHP 5, ya tenemos un operador ternario, que prueba un valor y luego devuelve el segundo elemento si devuelve verdadero y el tercero si no lo hace:

echo $count ? $count : 10; // outputs 10

También hay una taquigrafía para eso que te permite omitir el segundo elemento si es el mismo que el primero: echo $ count?: 10; // también salidas 10

En PHP 7 obtenemos además el ?? operador que, en lugar de indicar una confusión extrema, así es como usualmente usaría dos signos de interrogación, en lugar de eso, nos permite encadenar una cadena de valores. Leyendo de izquierda a derecha, el primer valor que existe y no es nulo es el valor que se devolverá.

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

Este constructo es útil para dar prioridad a uno o más valores que provienen de la entrada del usuario o de la configuración existente, y se pueden recuperar de forma segura en un valor predeterminado dado si falta esa configuración. Es una especie de característica pequeña, pero es una que sé que usaré tan pronto como mis aplicaciones se actualicen a PHP 7.

Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"

<=> Operador de la nave espacial

Añadido en PHP 7

El operador de la nave espacial <=> es el último operador de comparación agregado en PHP 7. Es un operador binario no asociativo con la misma prioridad que los operadores de igualdad ( == != , === !== ). Este operador permite una comparación de tres vías más simple entre los operandos de la izquierda y la derecha.

El operador da como resultado una expresión entera de:

• 0 cuando ambos operandos son iguales
• Menos de 0 cuando el operando de la izquierda es menor que el operando de la derecha
• Mayor que 0 cuando el operando de la izquierda es mayor que el operando de la derecha

p.ej

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

Una buena aplicación práctica de usar este operador sería, en comparación, las devoluciones de llamada de tipo que se espera que devuelvan un entero cero, negativo o positivo basado en una comparación de tres vías entre dos valores. La función de comparación pasada a usort es uno de estos ejemplos.

Antes de PHP 7 escribirías ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

Desde PHP 7 puedes escribir ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});

Operadores de Tipo

instanceof se utiliza para determinar si una variable de PHP es un objeto instanciado de una determinada clase.

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

El ejemplo anterior dará como resultado:

bool(true)
bool(false)

Motivo: el ejemplo anterior $a es un objeto de mclass por mclass tanto, use solo un mclass data sin instancia con sclass

Ejemplo con herencia

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

El ejemplo anterior dará como resultado:

bool(true)
bool(true)

Ejemplo con clon

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

El ejemplo anterior dará como resultado:

bool(true)
bool(true)

Supongamos que no hemos utilizado el operador "@", nuestro código se vería así:

$fileHandle = fopen($fileName, $writeAttributes);

¿Y si no se encuentra el archivo que estamos intentando abrir? Se mostrará un mensaje de error.

Para suprimir el mensaje de error, estamos utilizando el operador "@" como:

$fileHandle = @fopen($fileName, $writeAttributes);