sirve - simbolo en php




Referencia-¿Qué significa este símbolo en PHP? (12)

¿Que es esto?

Esta es una colección de preguntas que surgen de vez en cuando sobre la sintaxis en PHP. Este es también un wiki de la comunidad, por lo que todos están invitados a participar en el mantenimiento de esta lista.

¿Por qué es esto?

Solía ​​ser difícil encontrar preguntas sobre operadores y otros tokens de sintaxis.
La idea principal es tener enlaces a preguntas existentes sobre el desbordamiento de pila, por lo que es más fácil para nosotros hacer referencia a ellas, no copiar el contenido del Manual de PHP.

¹ Nota: Desde enero de 2013, el Desbordamiento de pila admite caracteres especiales . Simplemente rodee los términos de búsqueda entre comillas, por ejemplo, [php] "==" vs "==="

¿Qué debo hacer aquí?

Si alguien lo ha señalado aquí porque ha formulado una pregunta de este tipo, encuentre la sintaxis específica a continuación. Las páginas vinculadas al manual de PHP junto con las preguntas vinculadas probablemente responderán a su pregunta en ese momento. Si es así, te animamos a votar por la respuesta. Esta lista no pretende sustituir la ayuda proporcionada por otros.

La lista

Si su token en particular no aparece en la lista a continuación, puede encontrarlo en la Lista de tokens de analizador .

& Bitwise Operadores o References

=& References

&= Operadores de Bitwise

&& Operadores lógicos

% operadores aritméticos

!! Operadores logicos

@ Operadores de control de errores

?: Operador Ternario

?? Operador Nulo Coalesce (desde PHP 7)

: Sintaxis alternativa para estructuras de control , operador ternario

:: Operador de resolución de alcance

\ Namespaces

-> Clases y objetos

=> Arrays

^ Operadores bitwise

>> Operadores de Bitwise

<< Operadores de Bitwise

<<< Heredoc o Nowdoc

= Operadores de Asignación

== Operadores de comparación

=== Operadores de comparación

!== Operadores de comparación

!= Operadores de comparación

<> Operadores de comparación

<=> Operadores de comparación (desde PHP 7.0)

  • Operador de la nave espacial (comparación de tres vías)

| Operadores de Bitwise

|| Operadores logicos

~ Operadores bitwise

+ Operadores aritméticos , Operadores de matrices

+= y -= Operadores de asignación

++ y -- Incremento / decremento de operadores

.= Operadores de Asignación

. Operadores de cuerdas

, Argumentos de la función

Declaraciones Variables

$$ Variables variables

` Operador de Ejecución

<?= Etiquetas cortas abiertas

[] Arrays (sintaxis corta desde PHP 5.4)

<? Apertura y cierre de etiquetas.

... Argumento desempaquetado (desde PHP 5.6)

** Exponentiation (desde PHP 5.6)

# Comentario de estilo shell de una línea

https://code.i-harness.com


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.


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)

<=> 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;
});

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

==se utiliza para verificar la igualdad sin tener en cuenta el tipo de datos variable

===se utiliza para verificar la igualdad tanto para el valor variable * como para el tipo de datos **

Ejemplo

$a = 5

  1. if ($a == 5) - Evaluará a verdadero

  2. if ($a == '5') - evaluará como verdadero, porque al comparar esto, ambos valores php convierten internamente ese valor de cadena en un entero y luego comparan ambos valores

  3. if ($a === 5) - Evaluará a verdadero

  4. if ($a === '5') - evaluará a falso, porque el valor es 5, pero este valor 5 no es un número entero.


{} Llaves

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:


Cadenas de PHP: Las cadenas de PHP se pueden especificar de cuatro maneras, no solo de dos maneras:

1) Cadenas de una sola cita:

$string = 'This is my string'; // print This is my string

2) Cadenas de doble cita:

$str = 'string';

$string = "This is my $str"; // print This is my string

3) Heredoc:

$string = <<<EOD
This is my string
EOD; // print This is my string

4) Nowdoc (desde PHP 5.3.0):

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string

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';
?>

Pregunta :

¿Qué significa "&" aquí en PHP?

Operador PHP "&"

Hace la vida más fácil una vez que nos acostumbramos a ella (ver el ejemplo a continuación con cuidado)

Y usualmente se comprueban los bits que están establecidos tanto en $ a como en $ b.

¿Te has dado cuenta de cómo funcionan estas llamadas?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

Así que detrás de todo lo anterior está el juego de bit a bit y el operador.

Un caso útil de estos son las configuraciones fáciles, como las que aparecen a continuación, por lo que un solo campo entero puede almacenar miles de combos para usted.

La mayoría de las personas ya han leído los documentos, pero no han confiado el caso de uso en el mundo real de estos operadores de bitwise.

Ejemplo que te encantará

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird

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"




php-5.3