#3 GoSchool: Declarações e Tipos Primitivos
Seja bem vindo ao tutorial de número #3, onde iremos falar sobre declarações e tipos da linguagem.
Caso você tenha perdido o #2 sobre Estrutura Básica, segue o link:
O material do tutorial será dividido da seguinte forma:
- Declarações
- Variável
- Constante
2. Tipos Primitivos
Tenha em vista que após esse tutorial, você estará preparado para começar a desbravar pequenos projetos na linguagem.
VAMOS LÁ!
1. Declarações
Variáveis
Variáveis são nossas companheiras durante todo e qualquer desenvolvimento, já que são responsáveis por iniciar, armazenar e disponibilizar qualquer tipo de informação.
Há diversas formas possíveis para se declarar uma variável, algumas delas são:
- Declaração explícita
var nomeDaVariavel tipoDessa forma declaramos de forma explicita o nome da variável e o seu “tipo” sem um valor definido. O valor por sua vez, é definido baseado no tipo da variável, mais adiante abordaremos este assunto.
- Declaração explicita com valor definido
var nomeDaVariavel tipo = valorDaVariavelDessa forma, iniciamos uma variável e já atribuimos um valor ao mesmo tempo. Vale lembrar que a partir do momento que um tipo é definido para uma variável, ele não irá aceitar valores de tipagem diferente.
Para os preguiçosos de plantão, a linguagem também permite iniciarmos mais de uma variável ao mesmo tempo, atribuindo ou não valores à ela.
- Declaração explícita — Declaração múltipla
var nomeVar1, nomeVar2 tipoO único detalhe é que esse tipo de declaração define o mesmo “tipo”para as diferentes variáveis, sendo proibido definir mais de um “tipo”.
- Declaração explícita com valor definido — Declaração múltipla
var nomeVar1, nomeVar2 tipo = valor1, valor2Um detalhe bem bacana, é que a linguagem permite que você inicie uma nova variável sem a necessidade de declarar de forma explicita o seu “tipo”, dessa forma, ela se torna a responsável por identificar a definir essa informação. O único detalhe é que esse suporte só ocorre para declarações com valores já definidos.
- Declaração implícita com valor definido;
var nomeVar = valor1- Declaração implícita com valor definido — Declaração múltipla
var nomeVar, nomeVar2 = valor, valor2- “Você falou que a linguagem era fácil… tenho que escrever muito!”
Muita calma nessa hora padawan, deixei a cereja do bolo de variáveis para o final!
Como GO possui sintaxe semelhante a linguagem de programação C, algumas de suas características foram “herdadas”. A mais utilizada, na minha opinião, a mais “bonita”, é a declaração reduzida de variáveis que é feita utilizando := , sim, apenas isso.
- Declaração implícita reduzida
nomeVar := valor- Declaração implícita reduzida — Declaração múltipla
nomeVar, nomeVar2 := valor, valor2Esse tipo de declaração, diferente do tipo explícito, permite que você declare ao mesmo tempo diferentes tipos de variáveis.
Esse tipo de declaração só pode ser utilizado em um escopo de função, causando erro de compilação caso seja declarada de outra forma.
package maini := valorfunc main() {}
O modelo acima irá gerar um erro de compilação
package mainfunc main() {i := valor}
o modelo acima apresenta uma declaração correta
Por fim, ao utilizarmos a declaração reduzida, qualquer alteração no valor da variável deve ser feito utilizando símbolo de igualdade =, já que := representa a inicialização de uma nova variável.
variavel := valor // valorvariavel = novoValor // novoValor
Muita calma nessa hora, pois existe mais uma forma de declararmos múltiplas variáveis!
Anteriormente comentei sobre a declaração múltipla em linha, ou seja:
variavel, variavel2 := 1, 2Esse tipo de declaração facilita o processo de criação, contudo, possuímos uma forma ainda mais agradável de declararmos múltiplas variáveis de forma implícita ou explícita.
- Declaração explícita aninhada — Declaração múltipla
var (variavel tipo = valor
variavel2 tipo = valor
variavel3 tipo = valor)
- Declaração implícita aninhada — Declaração múltipla
var (variavel = valor
variavel2 = valor
variavel3 = valor)
Chegamos ao fim da explicação sobre variáveis!
Aos poucos vamos nos adaptando com sua utilização fazendo com que a sua escrita seja feita de forma quase automática.
Constantes
Saindo do maravilhoso mundo das variáveis, chegamos no não tão belo mundo das constantes.
- “Mas qual o motivo de não ser tão belo?”
O único motivo para essa frase é que como o próprio nome já diz, as constantes devem nascer com um valor já definido e em momento algum possuem seus valores alterados.
A sua declaração é semelhante a utilizada nas variáveis, ficando da seguinte forma:
- Declaração explícita
const nomeConstante tipo = valorConstanteAo ser inicializado, deve possuir seu valor final definido.
- Declaração implícita
const nomeConstante = valorconstanteSemelhante a variável, o tipo da constante não precisa ser explícito.
Por fim, podemos declarar constantes de forma aninhada.
- Declaração explícita aninhada — Declaração múltipla
const (constante tipo = valor
constante2 tipo = valor
constante3 tipo = valor)
- Declaração implícita aninhada — Declaração múltipla
constante (constante = valor
constante2 = valor
constante3 = valor)
Essa etapa foi bem rápida, já que as constantes não possuem declarações reduzidas ou “firulas” bonitinhas 😃.
Chegamos ao fim das declarações!
Podemos iniciar o assunto relacionado aos tipos primitivos da linguagem que tanto comentamos anteriormente.
2. Tipos primitivos
A partir de agora vamos abordar os tipos primitivos utilizados na linguagem GO.
Um tipo primitivo representa o nível mais baixo de declaração de um valor, podendo atuar como um texto, número ou booleano.
String
O tipo String é o responsável por representar valores de texto. Sim, simples e direto.
Uma curiosidade a respeito da utilização de textos na linguagem GO, é que a mesma utiliza codificação binária UTF-8 Para saber mais sobre UTF-8 acesse AQUI!
- “Tá, mas como posso declarar uma String?”
A declaração de uma String pode ser feita de duas formas:
- Aspas duplas
"..."
novaString := "Essa é uma nova String"- Backticks
`...`
novaString := `Essa é uma nova String`Um detalhe a respeito da utilização do backtick, é que ele permite uma quebra de linha durante a sua declaração.
novaString := `Essa é
uma nova String`Caso queira declarar uma String de forma explícita, é possível utilizar a seguinte sintaxe:
var novaString stringnovaString = "Oi"
Agora que você já possui conhecimento sobre a utilização de String, podemos falar de um outro tipo muito utilizado, o Boolean.
Boolean
O tipo boolean é responsável por definir o valor de uma variável como true (verdadeiro) ou false (falso). Diferente de outras linguagens de programação, em GO, um boolean não pode ser representado por números ,0 e 1, por exemplo.
A declaração de um boolean é feita seguindo o padrão:
var novoBooleano boolnovoBooleano = true
Vale ressaltar que também que é possível declarar um boolean de forma reduzida.
novoBoolean := falsePor padrão, quando declaramos um boolean e não definimos um valor inicial para ele, o mesmo passa a ter false como seu valor.
Ok, a utilização do boolean pode ser um pouco abstrata nesse momento, mas nas próximas aulas veremos o seu verdadeiro potencial em prática!
Tipos numéricos
Enfim, chegamos aos tipos numéricos que, assim como o nome diz, representam todo e qualquer tipo de variável contendo números.
A lista é um pouco extensa, mas logo tudo ficará bem claro.
╔═════════╦══════════════════════════════════════════════════════╗
║ Tipo ║ Faixa ║
╠═════════╬══════════════════════════════════════════════════════╣
║ rune ║-2,147,483,648 ~ 2,147,483,647 ║
║ int8 ║-128 ~ 127 ║
║ int16 ║-32,768 ~ 32,767 ║
║ int32 ║-2,147,483,648 ~ 2,147,483,647 ║
║ int64 ║-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807║
║ byte ║ 0 ~ 255 ║
║ uint8 ║ 0 ~ 255 ║
║ uint16 ║ 0 ~ 65,535 ║
║ uint32 ║ 0 ~ 4,294,967,295 ║
║ uint64 ║ 0 ~ 18,446,744,073,709,551,615 ║
║ float32 ║ -3.4^38 ~ +3.4^38 ║
║ float64 ║ -1.7^308 to +1.7^308 ║
╚═════════╩══════════════════════════════════════════════════════╝Podemos notar que
runepossui as mesmas características de umint32, assim como umbyteesta parauint8.
Além dos tipos apresentados na tabela, existem outros dois que apresentarei de forma breve devido ao seu nível de complexidade.
Estou falando do complex64 e complex128
- “Tudo bem. Uma dúzia de tipos e valores, mas como realmente podemos utiliza-los? ”
Vou separar a explicação em três etapas para que seja possível iniciarmos de forma descomplicada.
- Inteiros
- Fracionários
- Complexos
Inteiros
“Os números inteiros são constituídos dos números naturais e seus simétricos negativos, incluindo o zero.”
Dentro dos inteiros simétricos possuímos os seguintes tipos:
╔═════════╦══════════════════════════════════════════════════════╗
║ Tipo ║ Faixa ║
╠═════════╬══════════════════════════════════════════════════════╣
║ rune ║-2,147,483,648 ~ 2,147,483,647 ║
║ int8 ║-128 ~ 127 ║
║ int16 ║-32,768 ~ 32,767 ║
║ int32 ║-2,147,483,648 ~ 2,147,483,647 ║
║ int64 ║-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807║
╚═════════╩══════════════════════════════════════════════════════╝A única grande diferença entre eles está na capacidade de bytes que cada tipo suporta.
- “Já falou muita coisa. Como posso utiliza-los?”
A declaração explícita de inteiros simétricos é bem simples.
var runeVar rune = 255
var intVar int8 = 100
var intVar2 int16 = -300
var intVar3 int32 = 1000
var intVar4 int64 = -10000A declaração de qualquer tipo de número, diferente dos textos, não necessita da utilização de
""ou``.
Ainda sobre inteiros, existem os que possuem capacidade apenas, para valores positivos.
╔═════════╦══════════════════════════════════════════════════════╗
║ Tipo ║ Faixa ║
╠═════════╬══════════════════════════════════════════════════════╣
║ byte ║ 0 ~ 255 ║
║ uint8 ║ 0 ~ 255 ║
║ uint16 ║ 0 ~ 65,535 ║
║ uint32 ║ 0 ~ 4,294,967,295 ║
║ uint64 ║ 0 ~ 18,446,744,073,709,551,615 ║
╚═════════╩══════════════════════════════════════════════════════╝O processo de declaração explícita continua idêntico ao descrito anteriormente.
var byteVar byte = 20
var uintVar uint8 = 20
var uintVar2 uint16 = 100
var uintVar3 uint32 = 1233
var uintVar4 uint64 = 12313- “Você falou que GO era fácil!”
Claro que GO é uma linguagem fácil!
Caso a declaração não seja explícita, nosso querido e amado GO se encarrega de solucionar este problema.
Atenção: O código abaixo irá demonstrar apenas o processo de identificação automático da linguagem. Não se preocupe em entendê-lo agora.
package mainimport ("fmt""reflect")func main() {variavelInteira := -2000fmt.Println(reflect.TypeOf(variavelInteira))}// OUTPUT: int
A variável foi interpretada e automaticamente definida como int, algo que pode ocorrer com qualquer outro tipo numérico.
Agora que conhecemos todos os tipos de inteiros, vamos falar dos fracionários, que garantem um pouco mais de liberdade durante sua utilização.
Fracionários
“ Fração é um modo de expressar uma quantidade a partir de um valor que é dividido por um determinado número de partes iguais entre si. Número fracionário expressa esta condição. ”
Todo e qualquer número representado por uma fração de um valor. Os tipos utilizados em GO, são:
╔═════════╦══════════════════════════════════════════════════════╗
║ Tipo ║ Faixa ║
╠═════════╬══════════════════════════════════════════════════════╣
║ float32 ║ -3.4^38 ~ +3.4^38 ║
║ float64 ║ -1.7^308 to +1.7^308 ║
╚═════════╩══════════════════════════════════════════════════════╝Sua declaração explícita é semelhante a utilizada anteriormente, contudo, a fração de seu valor deve ser representada através de um . .
var variavelFloat float32 = 15.50
var variavelFloat2 float64 = 35.588Podemos deixar mais uma vez a responsabilidade de definição de tipos com o GO.
Atenção: O código abaixo irá demonstrar apenas o processo de identificação automático da linguagem. Não se preocupe em entendê-lo agora.
package mainimport ("fmt""reflect")func main() {num1 := 5.5fmt.Println(reflect.TypeOf(num1))}// OUTPUT: float64
ENFIM CHEGAMOS AO ÚLTIMO TÓPICO DESTE TUTORIAL!
Complexos
Comentei anteriormente que este seria um tópico rápido e sem muitos detalhes, já que seu nome representa a dificuldade de utiliza-lo.
De forma direta, um número complexo é representado através da fórmula complexa a + bi onde a,b são números reais e i é o resultado da equação i² = -1 , já que o seu valor final não pode ser representada por um número real.
Por convenção:
ié denominado de número imaginárioaé denominado de parte realbié denominado de parte imaginária
Os números complexos deram origem ao teorema fundamental da álgebra
- “ ????? ”
Para prender sua atenção nesse momento final, veja como os fractais criados e estudados através de números complexos são lindos!
complex64 e complex128 são os tipos complexos existentes em GO.
Sua declaração é idêntica a utilizada nos inteiros e fracionários.
var complexo complex64 = 1+2i
var complexo2 complex128 = 10+4iComo a utilização de complexos é restrita a cálculos avançados e “diferenciados”, GO disponibiliza de forma nativa um pacote contendo funções já prontas para sua utilização. Caso queira saber mais sobre esse pacote, ACESSE!
Preciso ressaltar que números complexos possuem utilização muito específica. Com isso, caso você não entenda sobre sua utilização, fique tranquilo que isso não terá impacto algum na sua performance daqui pra frente! #VocêÉoMelhor
CHEGAMOS AO FIM !!!!!
Após essa longa jornada, finalmente chegamos ao fim.
Espero que de alguma forma, você tenha absorvido e compreendido esse dois tópicos que serão a base para todo e qualquer desenvolvimento a partir de agora.
Nesse tutorial vimos:
- Declarações de variáveis e constantes;
- Definição de todos os tipos primitivos da linguagem.
Nos vemos no próximo post sobre operadores!
