Qual é a diferença entre o | e || ou operadores?

Eu sempre usei ||(dois pipes) em expressões OR, tanto em C # quanto em PHP. Ocasionalmente eu vejo um único tubo utilizado: |. Qual é a diferença entre esses dois usos? Existem advertências ao usar um sobre o outro ou são intercambiáveis?

Assim como o operador &e &&, o operador duplo é um operador de "curto-circuito".

Por exemplo:

if(condition1 || condition2 || condition3)

Se a condição1 for verdadeira, as condições 2 e 3 NÃO serão verificadas.

if(condition1 | condition2 | condition3)

Isso verificará as condições 2 e 3, mesmo que 1 já seja verdadeiro. Como suas condições podem ter funções bastante caras, é possível obter um bom aumento de desempenho usando-as.

Há uma grande ressalva, NullReferences ou problemas semelhantes. Por exemplo:

if(class != null && class.someVar < 20)

Se a classe for nula, a instrução if será interrompida após class != nullfor falsa. Se você usar apenas o &, ele tentará verificar class.someVare você terá uma boa NullReferenceException. Com o Or-Operator, isso pode não ser uma armadilha, pois é improvável que você desencadeie algo ruim, mas é algo a ter em mente.

Ninguém nunca usa o único &ou |operadores que, a menos que você tem um projeto onde cada condição é uma função que tem de ser executado. Parece um cheiro de design, mas às vezes (raramente) é uma maneira limpa de fazer as coisas. O &operador "executa essas 3 funções e, se uma delas retornar falsa, execute o bloco else", enquanto o |"executa apenas o bloco else se nenhuma retornar false" - pode ser útil, mas, como dito, geralmente é um design cheiro.

Existe um segundo uso do operador |e &, porém: Operações Bitwise .

|| é o operador OR lógico. Parece que você basicamente sabe o que é isso. É usado em declarações condicionais, como se, enquanto, etc.

condition1 || condition2

Avalia como true se uma condição1 OU condição2 for verdadeira.

| é o operador OR bit a bit. É usado para operar em dois números. Você olha cada bit de cada número individualmente e, se um dos bits for 1 em pelo menos um dos números, o bit resultante será 1 também. Aqui estão alguns exemplos:

A = 01010101
B = 10101010
A | B = 11111111

A = 00000001
B = 00010000
A | B = 00010001

A = 10001011
B = 00101100

A | B = 10101111

Espero que isso faça sentido.

Então, para responder às duas últimas perguntas, eu não diria que existem outras advertências além de "saber a diferença entre os dois operadores". Eles não são intercambiáveis ​​porque fazem duas coisas completamente diferentes.

Um é um "bit a bit ou".

10011b 01000b => 11011b

O outro é uma lógica ou.

verdadeiro ou falso => ​​verdadeiro

Boa pergunta. Esses dois operadores funcionam da mesma maneira em PHP e C #.

|é um OR bit a bit. Ele irá comparar dois valores por seus bits. Por exemplo 1101 | 0010 = 1111. Isso é extremamente útil ao usar opções de bits. Por exemplo, Leitura = 01 (0X01) Gravação = 10 (0X02) Leitura-Gravação = 11 (0X03). Um exemplo útil seria abrir arquivos. Um exemplo simples seria:

File.Open(FileAccess.Read | FileAccess.Write);  //Gives read/write access to the file

||é um OR lógico. É assim que a maioria das pessoas pensa em OR e compara dois valores com base em sua verdade. Por exemplo, vou à loja ou irei ao shopping. Esse é o mais usado no código. Por exemplo:

if(Name == "Admin" || Name == "Developer") { //allow access } //checks if name equals Admin OR Name equals Developer

Recurso do PHP: http://us3.php.net/language.operators.bitwise

Recursos C #: http://msdn.microsoft.com/en-us/library/kxszd0kx(VS.71).aspx

http://msdn.microsoft.com/en-us/library/6373h346(VS.71).aspx

Exemplo simples em java

public class Driver {

  static int x;
  static int y;

public static void main(String[] args) 
throws Exception {

System.out.println("using double pipe");
    if(setX() || setY())
        {System.out.println("x = "+x);
        System.out.println("y = "+y);
        }



System.out.println("using single pipe");
if(setX() | setY())
    {System.out.println("x = "+x);
    System.out.println("y = "+y);
    }

}

 static boolean setX(){
      x=5;
     return true;
  }
 static boolean setY(){
      y=5;
      return true;
  }
}

resultado :

using double pipe
x = 5
y = 0
using single pipe
x = 5
y = 5

& - (Condição 1 e Condição 2): verifica os dois casos, mesmo se o primeiro for falso

&& - (Condição 1 && Condição 2): não se preocupe em verificar o segundo caso, se o caso for falso

&& - o operador fará seu código rodar mais rápido, profissionalmente e raramente é usado

| - (Condição 1 | Condição 2): verifica os dois casos, mesmo se o caso 1 for verdadeiro

|| - (Condição 1 || Condição 2): não se preocupe em verificar o segundo caso, se o primeiro for verdadeiro

|| - operador fará seu código rodar mais rápido, profissionalmente | é raramente usado

O tubo único, |, é um dos operadores bit a bit .

Da Wikipedia:

Na família de linguagens de programação C, o operador OR bit a bit é "|" (tubo). Novamente, esse operador não deve ser confundido com sua contraparte "lógica ou" booleana, que trata seus operandos como valores booleanos e é escrita "||" (dois canos).

Pela sua definição matemática, OR e AND são operadores binários; eles verificam as condições de LHS e RHS independentemente, da mesma forma que | e &.

|| e && alteram as propriedades dos operadores OR e AND parando-os quando a condição LHS não é atendida.

O | O operador executa um OR bit a bit de seus dois operandos (o que significa que ambos os lados devem avaliar como false para retornar false) enquanto o || O operador avaliará o segundo operador apenas se for necessário.

http://msdn.microsoft.com/en-us/library/kxszd0kx(VS.71).aspx

http://msdn.microsoft.com/en-us/library/6373h346(VS.71).aspx

O tubo de chamuscado "|" é o "bit a bit" ou e só deve ser usado quando você souber o que está fazendo. O tubo duplo "||" é um lógico ou, e pode ser usado em instruções lógicas, como "x == 0 || x == 1".

Aqui está um exemplo do que o bit a bit ou faz: se a = 0101 eb = 0011, então a | b = 0111. Se você estiver lidando com um sistema lógico que trata qualquer diferente de zero como verdadeiro, então o bit a bit ou atuará da mesma maneira que o lógico ou, mas sua contrapartida (bit a bit e "&") NÃO. Também o bit a bit ou não realiza avaliação de curto-circuito.

Um único pipe (|) é o operador OR bit a bit .

Dois pipes (||) é o operador OR lógico.

Eles não são intercambiáveis.