Como usar operadores em Golang

Operadores são a base de toda linguagem de programação. Portanto, a funcionalidade da linguagem Golang fica incompleta sem o uso de operadores. Operadores nos permitem realizar diferentes tipos de operações em operandos. Na linguagem Go, os operadores podem ser classificados com base em suas diferentes funções .

Operadores aritméticos

Esses operadores são usados ​​para executar operações em operandos na linguagem Go:

• Adição: '+' adiciona dois operandos. Por exemplo: x+y.
• Subtração: '-' subtrai dois operandos. Exemplo: xy.
• Multiplicação: '*' multiplica dois operandos. Por exemplo: x*y.
• Divisão: '/' divide o primeiro operando pelo segundo operando. Por exemplo: x/y.
• Resto: O operador '%' retorna o resto quando o primeiro operando é dividido pelo segundo operando. Por exemplo: x%y.

 Nota: -, +, !, &, *, <- e ^ também são chamados de operadores unários e a precedência de operadores unários é maior. Os operadores ++ e — vêm de instruções, eles não são expressões, então ficam fora da hierarquia de operadores.

Por exemplo:

//Minh họa chương trình Go dùng toán tử số học
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// Phép cộng
result1:= p + q 
fmt.Printf("Result of p + q = %d", result1) 
	
// Phép trừ
result2:= p - q 
fmt.Printf("\nResult of p - q = %d", result2) 
	
// Phép nhân
result3:= p * q 
fmt.Printf("\nResult of p * q = %d", result3) 
	
// Division 
result4:= p / q 
fmt.Printf("\nResult of p / q = %d", result4) 
	
// Modulus 
result5:= p % q 
fmt.Printf("\nResult of p %% q = %d", result5) 
} 

Resultado:

Kết quả của p + q = 54
Kết quả của p - q = 14
Kết quả của p * q = 680
Kết quả của p / q = 1
Kết quả của p % q = 14

Operadores Relacionais

Operadores relacionais são usados ​​para comparar dois valores. Vamos analisar cada operador um por um:

• O operador '=='(Equals) verifica se os dois operandos fornecidos são iguais ou não. Se igual, retorna verdadeiro. Caso contrário, ele retorna falso. Por exemplo, 5==5 retornará verdadeiro.
• O operador '!='(Diferente de) verifica se os dois operandos fornecidos são iguais ou não. Caso contrário, ele retorna verdadeiro. Caso contrário, ele retorna falso. Este é o complemento booleano exato do operador '=='. Por exemplo, 5!=5 retornará falso.
• O operador '>'(Maior que) verifica se o primeiro operando é maior que o segundo operando. Se for maior, retorna verdadeiro. Se for menor, retorna falso. Por exemplo, 6>5 retornará verdadeiro.
• O operador '<'(menor que) verifica se o primeiro operando é menor que o segundo operando. Se for menor, retorna verdadeiro. Caso contrário, ele retorna falso. Por exemplo, <5 retornará
• O operador '>='(Maior que igual) verifica se o primeiro operando é maior ou igual ao segundo operando. Se maior ou igual, retorna verdadeiro. Se for menor ou igual, retorna falso. Por exemplo: 5>=5 retornará verdadeiro.
• O operador '<=' (menor ou igual a) verifica se o primeiro operando é menor ou igual ao segundo operando. Se for maior ou igual, retorna verdadeiro. Se for menor ou igual, retorna falso. Por exemplo: <=5 também retornará

Por exemplo:

// Minh họa chương trình Go dùng toán tử quan hệ
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// ‘=='(Equal To) 
result1:= p == q 
fmt.Println(result1) 
	
// ‘!='(Not Equal To) 
result2:= p != q 
fmt.Println(result2) 
	
// ‘<‘(less than)="" result3:="p">< q="" fmt.println(result3)="" ‘="">'(Greater Than) 
result4:= p > q 
fmt.Println(result4) 
	
// ‘>='(Greater Than Equal To) 
result5:= p >= q 
fmt.Println(result5) 
	
// ‘<='(less than="" equal="" to)="" result6:="p"><= q="" fmt.println(result6)="" }="">

Resultado:

false
true
false
true
true
false

Operadores lógicos

Eles são usados ​​para combinar duas ou mais condições/restrições ou para complementar a avaliação da condição inicial em consideração.

• E: O operador '&&' retorna verdadeiro quando ambas as condições em consideração são satisfeitas. Caso contrário, ele retorna falso. Por exemplo, a && b retorna verdadeiro quando a e b são verdadeiros (ou seja, diferentes de zero).
• OU: Operador '||' Retorna verdadeiro quando uma (ou ambas) as condições em consideração são satisfeitas. Caso contrário, ele retorna falso. Por exemplo: a || b retorna verdadeiro se a ou b for verdadeiro (ou seja, diferente de zero). Claro, ele retorna verdadeiro quando a e b são verdadeiros.
• NÃO lógico: O '!' operador Retorna verdadeiro quando a condição em consideração não é satisfeita. Caso contrário, ele retorna falso. Por exemplo: !a retorna verdadeiro se a for falso, ou seja, quando a = 0.

Por exemplo:

// Minh họa chương trình Go dùng toán tử logic
package main 
import "fmt"
func main() { 
	var p int = 23
	var q int = 60
		
	if(p!=q && p<=q){ fmt.println("true")="" }="" if(p!="q" ||=""><=q){ fmt.println("true")="" }="" if(!(p="=q)){" fmt.println("true")="" }="" }="">

Resultado:

True
True
True

Operadores bit a bit

Na linguagem Go, há 6 operadores bit a bit que operam no nível de bit ou são usados ​​para executar operações bit a bit. Os seguintes são os operadores bit a bit:

• & (bitwise AND): recebe dois números como operandos e executa AND em cada bit dos dois números. O resultado de AND só será 1 se ambos os bits forem 1.
• | (OU bit a bit): recebe dois números como operandos e executa OU em cada bit dos dois números. O resultado de OR é 1 se qualquer um dos dois bits for 1.
• ^ (XOR bit a bit): recebe dois números como operandos e executa XOR em cada bit dos dois números. O resultado do XOR é 1 se os dois bits forem diferentes.
• < (deslocar para a esquerda): pega dois números, desloca os bits do primeiro operando para a esquerda, o segundo operando determina o número de posições a deslocar
• >> (deslocar para a direita): Pegue dois números, desloque os bits do primeiro operando para a direita, o segundo operando determina o número de posições a serem deslocadas.
• &^ (AND NOT): Este é um operador bit a bit explícito.

Por exemplo:

// Minh họa chương trình Go dùng toán tử bitwise
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// & (bitwise AND) 
result1:= p & q 
fmt.Printf("Result of p & q = %d", result1) 
	
// | (bitwise OR) 
result2:= p | q 
fmt.Printf("\nResult of p | q = %d", result2) 
	
// ^ (bitwise XOR) 
result3:= p ^ q 
fmt.Printf("\nResult of p ^ q = %d", result3) 
	
// < (left="" shift)="" result4:="p">< 1="" fmt.printf("\nresult="" of="" p="">< 1="%d" ,"="" result4)="">> (right shift) 
result5:= p >> 1
fmt.Printf("\nResult of p >> 1 = %d", result5) 
	
// &^ (AND NOT) 
result6:= p &^ q 
fmt.Printf("\nResult of p &^ q = %d", result6) 
	
	
} 

Resultado:

Kết quả của p & q = 0
Kết quả của p | q = 54
Kết quả của p ^ q = 54
Kết quả của p < 1="68" kết="" quả="" của="" p="">> 1 = 17
Kết quả của p &^ q = 34

Operador de Atribuição

O operador de atribuição é usado para atribuir um valor a uma variável. O operando esquerdo do operador de atribuição é uma variável e o operando direito do operador de atribuição é um valor. O valor à direita deve ter o mesmo tipo de dado que a variável à esquerda, caso contrário o compilador retornará um erro. Os diferentes tipos de operadores de atribuição são mostrados abaixo:

• “="(Atribuição simples): Este é o operador de atribuição mais simples. Este operador é usado para atribuir o valor à direita à variável à esquerda.
• “+=” (Atribuição adicional): Este operador é uma combinação dos operadores '+' e '='. Este operador primeiro adiciona o valor atual da variável esquerda ao valor da direita e, em seguida, atribui o resultado à variável esquerda.
• “-=” (Atribuição de menos): Este operador é uma combinação dos operadores '-' e '='. Este operador primeiro subtrai o valor atual da variável esquerda do valor da direita e, em seguida, atribui o resultado à variável esquerda.
• “*=”(Atribuição de Multiplicação): Este operador é uma combinação dos operadores '*' e '='. Este operador primeiro multiplica o valor atual da variável esquerda pelo valor da direita e, em seguida, atribui o resultado à variável esquerda.
• “/=” (Atribuição de divisão): Este operador é uma combinação dos operadores '/' e '='. Este operador primeiro divide o valor atual da variável esquerda pelo valor da direita e, em seguida, atribui o resultado à variável esquerda.
• “%=” (Atribuição de resto): Este operador é uma combinação dos operadores '%' e '='. Este operador primeiro pega o restante do valor atual da variável da esquerda dado o valor da direita e então atribui o resultado à variável da esquerda.
• “&=” (Bitwise AND): Este operador é uma combinação dos operadores '&' e '='. Este operador primeiro faz um “AND bit a bit” do valor atual da variável da esquerda para o valor da direita e então atribui o resultado à variável da esquerda.
• “^=” (OR exclusivo bit a bit): Este operador é uma combinação dos operadores '^' e '='. Este operador primeiro “OU exclusivo bit a bit” o valor atual da variável esquerda pelo valor da direita e então atribui o resultado à variável esquerda.
• “|=”(OR inclusivo bit a bit): Este operador é uma combinação de '|' operadores e '='. Este operador primeiro “Bitwise Inclusive OR” o valor atual da variável esquerda pelo valor da direita e então atribui o resultado à variável esquerda.
• “<=: Este operador é uma combinação dos operadores < ' e '="'." Este operador primeiro “desloca” o valor atual da variável à esquerda pelo valor à direita e então atribui o resultado à variável à direita.
• “>>=”: Este operador é uma combinação dos operadores '>>' e '='. Este operador primeiro “Right Shift ANDs” o valor atual da variável da esquerda pelo valor da direita e então atribui o resultado à variável da esquerda.

Por exemplo:

// Minh họa chương trình Go dùng toán tử gán
package main 
	
import "fmt"
	
func main() { 
var p int = 45
	var q int = 50
	
// “=”(Simple Assignment) 
p = q 
fmt.Println(p) 
	
// “+=”(Add Assignment) 
	p += q 
fmt.Println(p) 
	
//“-=”(Subtract Assignment) 
p-=q 
fmt.Println(p) 
	
// “*=”(Multiply Assignment) 
p*= q 
fmt.Println(p) 
	
// “/=”(Division Assignment) 
	p /= q 
fmt.Println(p) 
	
	// “%=”(Modulus Assignment) 
	p %= q 
fmt.Println(p) 
	
} 

Resultado:

50
100
50
2500
50
0

Outros operadores

• &: Este operador retorna o endereço de uma variável.
• *: Este operador fornece um ponteiro para uma variável.
• <-: O nome deste operador é receive. É usado para receber um valor de

// Minh họa chương trình sử dụng toán tử khác
package main 
	
import "fmt"
	
func main() { 
a := 4
	
// Dùng địa chỉ của toán tử (&) toán tử trỏ gián tiếp (*)

b := &a 
fmt.Println(*b) 
*b = 7
fmt.Println(a) 
} 

Resultado:

4
7