Ir Operadores idioma

Next: Ir declarações condicionais de linguagem

Operadores são usados para executar operações matemáticas ou lógicas em um aplicativo em execução.

Vão operadores são incorporadas ao idioma:

operadores aritméticos
Operadores relacionais
Operadores lógicos
Operadores bit a bit
Operadores de atribuição
outros operadores

Vamos olhar para cada um em detalhe os operadores introduzidas.

operadores aritméticos

A tabela seguinte lista todos os idiomas Ir operadores aritméticos. Suponha que A é 10, B é 20.

operadores	descrição	Exemplos
+	adicionando	A saída de + B 30
-	subtração	A - Saída B -10
*	multiplicado	A * B 200 de saída
/	dividido	B / A de saída 2
%	restante	B% A saída 0
++	incremento	A saída ++ 11
-	diminuição	saída A-- 9

O exemplo a seguir demonstra o uso de vários operadores aritméticos:

package main

import "fmt"

func main() {

   var a int = 21
   var b int = 10
   var c int

   c = a + b
   fmt.Printf("第一行 - c 的值为 %d\n", c )
   c = a - b
   fmt.Printf("第二行 - c 的值为 %d\n", c )
   c = a * b
   fmt.Printf("第三行 - c 的值为 %d\n", c )
   c = a / b
   fmt.Printf("第四行 - c 的值为 %d\n", c )
   c = a % b
   fmt.Printf("第五行 - c 的值为 %d\n", c )
   a++
   fmt.Printf("第六行 - c 的值为 %d\n", a )
   a--
   fmt.Printf("第七行 - c 的值为 %d\n", a )
}

Exemplos dos resultados operacionais acima:

第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - c 的值为 22
第七行 - c 的值为 21

Operadores relacionais

A tabela a seguir lista todos os operadores relacionais linguagem Go. Suponha que A é 10, B é 20.

operadores	descrição	Exemplos
==	Verifique os dois valores são iguais, retornos iguais verdadeiro se o contrário False.	(A == B) é falsa
! =	Verifique se os dois valores não forem iguais, não retornos iguais Verdadeiro se o contrário False.	(A! = B) é verdadeiro
>	Verifique o valor esquerdo é maior que o valor do lado direito, um retorno verdadeiro, caso contrário False.	(A> B) é falsa
<	Verifique o valor esquerdo é menor que o valor do lado direito, um retorno verdadeiro, caso contrário False.	(A <B) é verdadeiro
> =	Verifique se o valor for igual ou superior à esquerda para o valor correto, ele retorna True se for caso contrário False.	(A> = B) é falsa
<=	Verifique se o valor for menor ou igual à esquerda para o valor correto, ele retorna True se for caso contrário False.	(A <= B) é verdadeiro

O exemplo seguinte demonstra o uso de operadores relacionais:

package main

import "fmt"

func main() {
   var a int = 21
   var b int = 10

   if( a == b ) {
      fmt.Printf("第一行 - a 等于 b\n" )
   } else {
      fmt.Printf("第一行 - a 不等于 b\n" )
   }
   if ( a < b ) {
      fmt.Printf("第二行 - a 小于 b\n" )
   } else {
      fmt.Printf("第二行 - a 不小于 b\n" )
   } 
   
   if ( a > b ) {
      fmt.Printf("第三行 - a 大于 b\n" )
   } else {
      fmt.Printf("第三行 - a 不大于 b\n" )
   }
   /* Lets change value of a and b */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("第四行 - a 小于等于  b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("第五行 - b 大于等于 b\n" )
   }
}

Exemplos dos resultados operacionais acima:

第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于  b
第五行 - b 大于等于 b

Operadores lógicos

A tabela seguinte lista todos os idiomas Ir operadores lógicos. Suponha que A é verdadeiro, B é falso.

operadores	descrição	Exemplos
&&	Operador lógico AND. Se ambos os lados dos operandos são verdadeiros, a condição é verdadeira, caso contrário, False.	(A && B) é falsa
\|\|	Operador lógico OR. Se os operandos em ambos os lados há uma verdade, a condição é verdadeira, caso contrário, False.	(A \|\| B) é verdadeiro
!	NÃO lógico operador. Se a condição for verdadeira, então a lógica NÃO condicionar False, caso contrário True.	! (A && B) é verdadeiro

O exemplo seguinte demonstra a utilização de operadores lógicos:

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("第一行 - 条件为 true\n" )
   }
   if ( a || b ) {
      fmt.Printf("第二行 - 条件为 true\n" )
   }
   /* 修改 a 和 b 的值 */
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("第三行 - 条件为 true\n" )
   } else {
      fmt.Printf("第三行 - 条件为 false\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("第四行 - 条件为 true\n" )
   }
}

Exemplos dos resultados operacionais acima:

第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true

Operadores bit a bit

Operadores bit a bit em números inteiros em bits de memória operar.

A tabela a seguir lista os operadores bit a bit &, | e ^ é calculada:

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Suponha que A = 60; B = 13; seu número binário para:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

símbolo linguagem suporte C Bit computação mostrado na tabela a seguir. Suponha que A é 60, B é 13:

operadores	descrição	Exemplos
&	Bit a bit E operador "&" é os operadores binários. Sua função é de dois números binários correspondentes a cada fase da operação e participação.	(A & B) resultado é 12, o binário é 0000 1100
\|	OR bit a bit operador "\|" é um operador binário. Sua função é participar na operação de dois números cada fase binário correspondente ou	(A \| B) o resultado é 61, o binário é 00111101
^	Bit a bit OU exclusivo do operador "^" é os operadores binários. Sua função é participar na operação de dois números cada XOR binário correspondente quando dois binário bit correspondente diferente e o resultado é 1.	(A ^ B) resulta em 49 binários para 00.110.001
<<	Esquerda operador de deslocamento "<<" é os operadores binários. desvio à esquerda N-bit é multiplicado por 2 ^ n. Sua função a cada binário "<<" à esquerda do operando à esquerda de toda uma série de bits especificado pelo número "<<" direito de os movimentos decimais, descartando os altos e baixos 0s.	A << 2 resultados para 240 binário é 11110000
>>	Direito operador de deslocamento ">>" são operadores binários. À direita por n bits é dividido por 2 ^ n. Sua função é a vários binário ">>" o operando esquerdo Vários tudo bem, ">>" à direita o número de bits especificado.	A >> 2 resultados para 15 0000 1111 sistema binário

O exemplo seguinte demonstra a utilização de operadores lógicos:

package main

import "fmt"

func main() {

   var a uint = 60	/* 60 = 0011 1100 */  
   var b uint = 13	/* 13 = 0000 1101 */
   var c uint = 0          

   c = a & b       /* 12 = 0000 1100 */ 
   fmt.Printf("第一行 - c 的值为 %d\n", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("第二行 - c 的值为 %d\n", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("第三行 - c 的值为 %d\n", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("第四行 - c 的值为 %d\n", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值为 %d\n", c )
}

Exemplos dos resultados operacionais acima:

第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

Operadores de atribuição

A tabela a seguir lista todas as Go operador de atribuição idioma.

operadores	descrição	Exemplos
=	Simples operador de atribuição atribui um valor expressão de um lvalue	C = A + B A + B vai ser atribuída ao resultado da expressão C
+ =	Somados antes da atribuição	C + = A é igual a C = C + A
- =	Depois de atribuição de subtração	C - = A é igual a C = C - A
* =	Em seguida, multiplicando a atribuição	C * = A é igual a C = C * A
/ =	Divisão depois da atribuição	C / = A é igual a C = C / A
% =	Restante depois da atribuição	C% = A é igual a C = C% A
<< =	À esquerda após a atribuição	C << = 2 igual a C = C << 2
>> =	Logo após a atribuição	C >> = 2 igual a C = C >> 2
& =	Bit a bit e atribuição após	C & = 2 igual a C = C & 2
= ^	Depois de pressionar o XOR atribuição de bits	C ^ = 2 igual a C = C ^ 2
\| =	Depois de pressionar posição ou cargo	C \| = 2 é igual a C = C \| 2

O exemplo a seguir demonstra o uso operador de atribuição:

package main

import "fmt"

func main() {
   var a int = 21
   var c int

   c =  a
   fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %d\n", c )

   c +=  a
   fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c )

   c -=  a
   fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c )

   c *=  a
   fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c )

   c /=  a
   fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c )

   c  = 200; 

   c <<=  2
   fmt.Printf("第 6行  - <<= 运算符实例，c 值为 = %d\n", c )

   c >>=  2
   fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )

   c &=  2
   fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c )

   c ^=  2
   fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c )

   c |=  2
   fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c )

}

Exemplos dos resultados operacionais acima:

第 1 行 - =  运算符实例，c 值为 = 21
第 2 行 - += 运算符实例，c 值为 = 42
第 3 行 - -= 运算符实例，c 值为 = 21
第 4 行 - *= 运算符实例，c 值为 = 441
第 5 行 - /= 运算符实例，c 值为 = 21
第 6行  - <<= 运算符实例，c 值为 = 800
第 7 行 - >>= 运算符实例，c 值为 = 200
第 8 行 - &= 运算符实例，c 值为 = 0
第 9 行 - ^= 运算符实例，c 值为 = 2
第 10 行 - |= 运算符实例，c 值为 = 2

outros operadores

A tabela a seguir lista os outros operadores Ir idioma.

operadores	descrição	Exemplos
&	Retornar endereço de memória variável	& A; vai dar o endereço real da variável.
*	variável ponteiro.	* A; é uma variável de ponteiro

O exemplo a seguir demonstra o uso de outros operadores:

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

   /*  & 和 * 运算符实例 */
   ptr = &a	/* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}

Exemplos dos resultados operacionais acima:

第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

Precedência de operador

Alguns operadores têm uma prioridade mais alta, os operadores binários são direcção operacional da esquerda para a direita. A tabela a seguir lista todos os operadores e as suas prioridades, representantes de cima para baixo em prioridade decrescente:

prioridade	operadores
7	^!
6	* /% ^ & << >> &
5	+ - \| ^
4	==! = << => =>
3	<-
2	&&
1	\|\|

Claro, você pode usar parênteses para melhorar temporariamente a prioridade global da operação de uma expressão.

Exemplos dos resultados operacionais acima:

package main

import "fmt"

func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int;

   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e );  
}

Exemplos dos resultados operacionais acima:

(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50

Anterior: Vá Língua Constante

Next: Ir declarações condicionais de linguagem

Go curso

Ir Operadores idioma

operadores aritméticos

Operadores relacionais

Operadores lógicos

Operadores bit a bit

Operadores de atribuição

outros operadores

Precedência de operador