#4 GoSchool: Operadores

Seja bem vindo ao tutorial #4 da GoSchool!

Caso você tenha perdido o tutorial #3 sobre Declarações e Tipos Primitivos, segue o link:

#3 GoSchool: Declarações e Tipos

Hoje, vamos falar de um assunto muito importante, que será utilizado em todos os desenvolvimentos em GO. Sim, estou falando dos Operadores.

Toda e qualquer tarefa dentro de um algoritmo é feita utilizando operadores, que por sua vez, irá executar alguma ação baseada em seu tipo.

- “Como assim, uma ação baseada em tipo?”

Os principais tipos de operadores são:

• Aritméticos
• Relacionais
• Lógicos
• Atribuição

Cada tipo de operador é responsável por uma determinada operação. Alguns são popularmente conhecidos, dentro e fora da programação, como é o caso dos operadores aritméticos.

Chega de enrolação e vamos colocar a mão na massa para entendermos os diferentes tipos de operadores.

Vamos seguir a ordem da lista apresentada anteriormente, ok?

1. Aritméticos

Como citei anteriormente, operadores aritméticos são responsáveis pela realização de operações básicas de processamento, muitas vezes utilizadas em nosso cotidiano.

Em GO possuímos sete operadores aritméticos, que são:

• Soma +
• Subtração -
• Multiplicação *
• Divisão /
• Módulo (Resto da Divisão) %
• Incremento ++
• Decremento --

Soma ( + )

Operação de “combinação” entre dois números.

num1 := 4
num2 := 8
resultado := num1 + num2
fmt.Println(resultado)
OUTPUT: 12

Subtração ( - )

Operação de subtração entre dois números.

num1 := 10
num2 := 5
resultado := num1 - num2
fmt.Println(resultado)
OUTPUT: 5

Multiplicação ( * )

Operação entre dois número que visa obter um resultado que representa a soma de uma quantidade finita de um mesmo número.

num1 := 8
num2 := 3
resultado := num1 * num2
fmt.Println(resultado)
OUTPUT: 24

Divisão ( / )

Operação que visa obter um quociente a partir da divisão de dois números.

num1 := 100
num2 := 10
resultado := num1 / num2
fmt.Prinln(resultado)
OUTPUT: 10

Módulo — Resto da Divisão ( % )

Operação que visa obter um resto a partir da divisão de dois números.

num1 := 17
num2 := 2
resultado := num1 % num2
fmt.Prinln(resultado)
OUTPUT: 1

Incremento ( ++ )

Operador responsável por adicionar 1 à uma variável.

num1 := 10
num1++
fmt.Println(num1)
OUTPUT: 11

++ é o mesmo que +1 .

Decremento ( -- )

Operador responsável por remover 1 à uma variável.

num1 := 20
num1--
fmt.Println(num1)
OUTPUT: 19

-- é o mesmo que -1 .

Operadores aritméticos são simples, já que fazem parte de tudo aquilo que praticamos dentro e fora do mundo da programação.

2. Relacionais

Operadores relacionais verificam uma expressão e retornam um valor boolean de aceitação true ou negação false .

São utilizados por todos os processos dentro de um algoritmo, já que ditam retornos de critérios lógicos.

Em GO possuímos seis principais operadores relacionais, que são:

• Comparação ==
• Diferença !=
• Maior >
• Menor <
• Maior ou igual >=
• Menor ou igual >=

Comparação ( == )

Verifica igualdade entre variáveis, retornando o status relacional de ambas.

num1 := 5
num2 := 5
resultado := num1 == num2
fmt.Println(resultado)
OUTPUT: true

O processo de comparação é feito utilizando variáveis do mesmo tipo.

Diferença ( != )

Verifica diferença entre variáveis, retornando o status relacional de ambas.

num1 := 8
num2 := 15
resultado := num1 != num2
fmt.Println(resultado)
OUTPUT: true

O processo de diferença é feito utilizando variáveis do mesmo tipo.

Maior ( > )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é maior que o segundo argumento.

num1 := 30
num2 := 20
resultado := num1 > num2
fmt.Println(resultado)
OUTPUT: true

Antes de continuar!

Nos exemplos, estou utilizando apenas variáveis numéricas. Contudo, o processo de verificação pode ser feito utilizando qualquer tipo primitivo da linguagem, como strings, números e booleans.

Nas operações lógicas utilizando string, por exemplo, o comparativo é feito utilizando os valores decimais de cada caractere presente na tabela ASCII.

Vale lembrar, que uma operação envolvendo soma de strings é válida e chamada de concatenação. Assunto abordado no tutorial sobre funções.

Menor ( < )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é menor que o segundo argumento.

num1 := 10
num2 := 40
resultado := num1 < num2
fmt.Println(resultado)
OUTPUT: true

Maior ou igual ( >= )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é maior ou igual ao segundo argumento.

num1 := 20
num2 := 20
resultado := num1 >= num2
fmt.Println(resultado)
OUTPUT: true

Menor ou igual ( <= )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é maior ou igual ao segundo argumento.

num1 := 5
num2 := 20
resultado := num1 <= num2
fmt.Println(resultado)
OUTPUT: true

Operadores relacionais não possuem grandes segredos, já que realizam processos lógicos comparativos de forma rápida dentro de seu algoritmo.

Entendido o assunto de operadores relacionais, podemos utiliza-los em conjunto com um novo tipo de operador. Os operadores lógicos.

3. Lógicos

Como o nome já diz, são responsáveis por definir uma lógica baseada em critérios e valores relacionais.

- “Legal, me fale mais sobre isso…”

Operações lógicas tem como objetivo, o retorno de valores booleanos trueou false , que poderão ser utilizados em estruturas de controle (Assunto que será abordado no próximo tutorial).

Em GO possuímos três principais operadores lógicos, que são:

• Conjunção (E) &&
• Disjunção (Ou) ||
• Negação !=

Conjunção ( && )

Conjunção é a operação que possui o objetivo de “agregar” valores relacionais e verificar se os mesmos são condizentes à uma condição.

Calma lá! Vamos melhorar essa explicação.

Vamos utilizar a seguinte frase:

Caruso e Esteves escrevem artigos sobre GO.

Agora, vamos trata-los como variáveis:

autor1 := "Caruso"
autor2 := "Esteves"

Vamos adicionar um critério. Apenas uma ideia:

“Só existem artigos sobre GO, se Caruso e Esteves forem os autores.”

Beleza!

Agora que possuímos valores e um critério, conseguimos utilizar nosso operador lógico de conjunção junto com um operador relacional para obter um resultado lógico booleano.

//Seguindo nosso critério
autor1 := "Caruso"
autor2 := "Esteves"
criterio := autor1 == "Caruso" && autor2 == "Esteves"
fmt.Println(criterio)
OUTPUT: true

Repare que autor1 e autor2 satisfazem o critério que: Somente quando Caruso e Esteves estiverem juntos, o resultado será positivo

Note que, caso uma das variáveis não seja válida, o algoritmo retorna false .

//Seguindo nosso critério
autor1 := "Guilherme"
autor2 := "Esteves"
criterio := autor1 == "Caruso" && autor2 == "Esteves"
fmt.Println(criterio)
OUTPUT: false

Em um operador lógico de conjunção, todos os critérios relacionais devem ser true .

Disjunção ( || )

Disjunção tem como objetivo verificar se um dos critérios relacionais é válido, gerando um resultado baseado na ordem de chamada.

- “Ordem de chamada?”

Um algoritmo é lido da esquerda para a direita, dessa forma, variáveis declaradas mais a esquerda são lidas e interpretadas antes das variáveis declaradas mais a direita.

Ainda não ficou claro?

Pense da seguinte forma:

Você precisa encontrar uma porta que esteja destrancada. Em um total de 4 portas, a primeira que você conseguir abrir, finaliza o seu processo de busca.

Dessa forma temos:

Porta 1 || Porta 2 || Porta 3 || Porta 4

• Você tenta acessar a porta 1 e percebe que ela esta trancada;
• Verifica a porta de número 2 que também esta trancada;
• Verificando a porta de número 3 ela se abre.

Nesse momento, você não precisa verificar a porta 4, pois o critério lógico dizia que, ao encontrar a primeira porta aberta o processo seria finalizado.

Sendo assim, ao utilizarmos o operador lógico de disjunção || , estamos buscando em diversas variáveis relacionais, um único valor positivo para que nosso processo seja válido.

Veja o exemplo:

relacional1 := 10 > 30 //false
relacional2 := 20 == 18 //false
relacional3 := 18 < 50 //true
relacional4 := 50 == 50 //true
resultado := relacional1 || relacional2 || relacional3 || relacional4
fmt.Println(resultado)
OUTPUT: true

Note que as duas primeiras variáveis relacionais retornam false, e as duas últimas, true. Por mais que a quarta variável seja verdadeira, o sistema constatou que o resultado era true logo que verificou a terceira variável.

Negação ( != )

Negação pode também ser caracterizado como uma operador relacional, dessa forma, sua explicação é plausível para ambos os casos.

Note que o operador lógico de negação possui as mesmas características que o operador relacional de diferença.

O operador lógico de negação visa comparar variáveis, sejam elas tipos primitivos ou resultados relacionais, a fim de obter uma verdade quando se existe uma diferença.

De forma clara:

nome1 := "Guilherme"
nome2 := "Caruso"
resultado := nome1 != nome2
fmt.Println(resultado)
OUTPUT: true

ou

relacional1 := 10 == 10 // true
relacional2 := 20 < 10 // false
resultado := relacional1 != relacional2
fmt.Println(resultado)
OUTPUT: true

Conseguimos comprovar que o operador lógico de negação se comporta da mesma forma para tipos primitivos e resultados relacionais.

4. Atribuição

Operadores de atribuição possibilitam que valores de variáveis sejam alterados de diversas formas.

Em GO possuímos seis principais operadores de atribuição, que são:

• Atribuição =
• Soma e atribuição +=
• Subtração e atribuição -=
• Multiplicação e atribuição *=
• Divisão e atribuição /=
• Módulo e atribuição %=

Atribuição ( = )

Utilizado para atribuir valor inicial ou sobrescrever um valor já existente de uma variável.

var nome string = "Guilherme"

ou

nome := "Guilherme"
nome = "Caruso"
fmt.Println(nome)
OUTPUT: Caruso

Soma e atribuição ( += )

Utilizado para efetuar somas e, no caso de strings, concatenações. Atribuindo à variável inicial um novo valor já processado.

• Numérico

numero := 20
numero += 10
fmt.Printf("%d", numero)
OUTPUT: 30

• Texto (Concatenação)

nome := "Guilherme"
nome += " Caruso"
fmt.Println(nome)
OUTPUT: Guilherme Caruso

Subtração e atribuição ( -= )

Utilizado para efetuar subtrações. Atribuindo à variável inicial um novo valor já processado.

numero := 50
numero -= 10
fmt.Printf("%d", numero)
OUTPUT: 40

Multiplicação e atribuição ( *= )

Utilizado para efetuar multiplicações . Atribuindo à variável inicial um novo valor já processado.

numero := 20
numero *= 2
fmt.Printf("%d", numero)
OUTPUT: 40

Divisão e atribuição ( /= )

Utilizado para efetuar divisões . Atribuindo à variável inicial o valor do quociente da divisão.

numero := 30
numero /= 2
fmt.Printf("%d", numero)
OUTPUT: 15

Resto e atribuição ( %= )

Utilizado para efetuar divisões . Atribuindo à variável inicial o valor do resto da divisão.

numero := 17
numero %= 2
fmt.Printf("%d", numero)
OUTPUT: 1

Conclusão

Entendendo todos os nossos principais operadores, começamos a ter uma visão cada vez melhor da linguagem. Podemos enxergar possibilidades e aplicações de GO em operações muitas vezes repetitivas do nosso cotidiano.

Nesse tutorial vimos:

• Operadores aritméticos;
• Operadores relacionais;
• Operadores lógicos;
• Operadores de atribuição.

Nos vemos no próximo post sobre estruturas de controle!

#5 GoSchool: Estruturas de Controle