Tipos de dados em Golang

O tipo de dados especifica que tipo de dados uma variável Golang válida pode conter . Na linguagem Go, os tipos são divididos em quatro categorias, como segue:

• Tipos básicos: números, strings e booleanos
• Tipos de agregados: matrizes e estruturas
• Tipos de referência: ponteiro, fatia, mapa, função e canal
• Tipo de interface

Aqui discutiremos sobre os tipos básicos de dados na linguagem Go. Eles são classificados em três subcategorias:

• Número
• Booleano
• Corrente

Tipos de dados comuns em Golang

• Números em Golang
• Booleano
• Corrente

Números em Golang

Na linguagem Go, os números são divididos em três subcategorias:

Inteiros: Na linguagem Go, inteiros com e sem sinal vêm em quatro tamanhos diferentes, conforme mostrado na tabela abaixo. Os inteiros com sinal são representados por inte os inteiros sem sinal são representados por uint.

Operações aritméticas possíveis: adição, subtração, multiplicação, divisão, resto

Por exemplo:

// Chương trình Go sử dụng số nguyên
package main 
import "fmt"
		
func main() {
	
	// Dùng 8-bit unsigned int 
	var X uint8 = 225
	fmt.Println(X, X-3)
	
	// Dùng 16-bit signed int 
	var Y int16 = 32767
	fmt.Println(Y+2, Y-2) 
}

Resultado:

225 222
-32767 32765

Exemplo de operações aritméticas:

// Các phép tính số học có thể có đối với số nguyên
// Tác giả : Chhanda Saha

package main

import "fmt"

func main() {

	var x int16 = 170
	var y int16 = 83
	//Cộng
	fmt.Printf(" addition : %d + %d = %d\n ", x, y, x+y)
	//Trừ
	fmt.Printf("subtraction : %d - %d = %d\n", x, y, x-y)
	//Nhân
	fmt.Printf(" multiplication : %d * %d = %d\n", x, y, x*y)
	//Chia
	fmt.Printf(" division : %d / %d = %d\n", x, y, x/y)
	//Mô đun
	fmt.Printf(" remainder : %d %% %d = %d\n", x, y, x%y)
}

Resultado:

Cộng :  170 + 83 = 253
Trừ : 170 - 83 = 87
Nhân : 170 * 83 = 14110
Chia : 170 / 83 = 2
Số dư : 170 % 83 = 4 

• Números de ponto flutuante: Na linguagem Go, os números de ponto flutuante são divididos em dois tipos, conforme mostrado na tabela abaixo.
  • As operações aritméticas podem ser: adição, subtração, multiplicação, divisão.
  • Existem três fontes:
    • decimal (3,15)
    • potência (12e18 ou 3e10)
    • misto (13.16e12)

Por exemplo:

//Minh họa chương trình Go dùng số dấu chấm động
package main 
import "fmt"
		
func main() {
	a := 20.45
	b := 34.89
	
	// Phép trừ hai số dấu chấm động
	c := b-a
	
	// Hiện kết quả
	fmt.Printf("Result is: %f", c)
	
	// Hiện kiểu biến C
	fmt.Printf("\nThe type of c is : %T", c) 
}

Resultado:

Kết quả: 14.440000
Kiểu của C là : float64

Exemplo de operações aritméticas para números de ponto flutuante:

// Các phép toán số học có thể có cho số thực
// Tác giả : Chhanda Saha
package main

import "fmt"

func main() {
	var x float32 = 5.00
	var y float32 = 2.25
	//Phép cộng
	fmt.Printf("addition : %g + %g = %g\n ", x, y, x+y)
	//Phép trừ
	fmt.Printf("subtraction : %g - %g = %g\n", x, y, x-y)
	//Phép nhân
	fmt.Printf("multiplication : %g * %g = %g\n", x, y, x*y)
	//Phép chia
	fmt.Printf("division : %g / %g = %g\n", x, y, x/y)

}

Resultado:

Phép cộng :  5 + 2.25 = 7.25
Phép trừ : 5 - 2.25 = 2.75
Phép nhân : 5 * 2.25 = 11.25
Phép chia : 5 / 2.25 = 2.2222223

• Números complexos: Os números complexos são divididos em duas partes, mostradas na tabela abaixo. float32e float64também faz parte desses números complexos. A função de integração gera um número complexo a partir de suas partes imaginárias e reais, e a função de integração extrai essas partes.
  • Existem várias funções integradas em números complexos:
    • complexo – cria um número complexo a partir de dois números flutuantes.
    • real() – obtém a parte real do número complexo de entrada como um float.
    • imag() – obtém a parte imaginária do número complexo de entrada como um float

Por exemplo:

// Chương trình Go dùng số phức
package main
import "fmt"

func main() {
	
var a complex128 = complex(6, 2)
var b complex64 = complex(9, 2)
fmt.Println(a)
fmt.Println(b)
	
// Hiện kiểu
fmt.Printf("The type of a is %T and "+
			"the type of b is %T", a, b)
}

Resultado:

(6+2i)
(9+2i)
Kiểu của a là complex128, kiểu của b là complex64

Exemplos de funções integradas:

// Các hàm tích hợp là số phức
// Tác giả : Chhanda Saha
package main

import "fmt"

func main() {
	comp1 := complex(10, 11)
	// cú pháp init số phức
	comp2 := 13 + 33i
	fmt.Println("Complex number 1 is :", comp1)
	fmt.Println("Complex number 1 is :", comp2)
	// lấy phần real
	realNum := real(comp1)
	fmt.Println("Real part of complex number 1:", realNum)
	// lấy phần hình ảnh
	imaginary := imag(comp2)
	fmt.Println("Imaginary part of complex number 2:", imaginary)

}

Resultado:

Số phức 1 là: (10+11i)
Số phức 1 là: (13+33i)
Phần thực của số phức 1: 10
Phần ảo của số phức 2: 33

Booleano

O tipo de dado booleano representa apenas um bit de informação que é verdadeiro ou falso. Valores do tipo booleano não são convertidos implícita ou explicitamente para nenhum outro tipo.

Por exemplo:

//Minh họa chương trình dùng boolean
package main
import "fmt"

func main() {
	
	// Các biến
str1 := "Quantrimang"
str2:= "quantrimang"
str3:= "Quantrimang"
result1:= str1 == str2
result2:= str1 == str3
	
// Hiện kết quả
fmt.Println( result1)
fmt.Println( result2)
	
// Hiện kiểu của result1 và result2
fmt.Printf("Kiểu của result1 là %T và "+
				"kiểu của result2 là %T",
							result1, result2)
	
}

Resultado:

false
true
Kiểu của result1 là bool và kiểu của result2 là bool

Corrente

O tipo de dados string representa uma sequência de pontos de código Unicode. Em outras palavras, podemos dizer que uma string é uma sequência imutável de bytes, o que significa que, uma vez criada, uma string não pode mais ser alterada. Strings podem conter dados arbitrários, incluindo bytes de valor zero em formato legível por humanos. Strings podem ser concatenadas usando o operador de adição (+).

Por exemplo:

// Chương trình Go dùng chuỗi
package main
import "fmt"

func main() {
	
	// Biến str chứa chuỗi
str := "Quantrimang"
	
// Hiện độ dài của chuỗi
fmt.Printf("Length of the string is:%d",
								len(str))
	
// Hiện chuỗi
fmt.Printf("\nString is: %s", str)
	
// Hiện kiểu biến str 
fmt.Printf("\nType of str is: %T", str)
}

Resultado:

Chiều dài của chuỗi là: 13
Chuỗi là: Quantrimang
Kiểu của chuỗi là: chuỗi

Exemplo de concatenação de strings:

// Nối chuỗi
// Tác giả : Chhanda Saha
package main

import "fmt"

func main() {
	var str1 string = "STRING_"
	var str2 string = "Concatenation"

	// Nối chuỗi bằng toán tử + 
	fmt.Println("New string : ", str1+str2)

}

Resultado:

New string :  STRING_Concatenation