El tipo de datos especifica qué tipo de datos puede contener una variable Golang válida . En el lenguaje Go, los tipos se dividen en cuatro categorías como sigue:

- Tipos básicos: números, cadenas y valores booleanos
- Tipos de agregados: matrices y estructuras
- Tipos de referencia: puntero, segmento, mapa, función y canal
- Tipo de interfaz
Aquí discutiremos sobre los tipos de datos básicos en el lenguaje Go. Se clasifican en tres subcategorías:
Tipos de datos comunes en Golang
Números en Golang
En el lenguaje Go, los números se dividen en tres subcategorías:
Números enteros: en el lenguaje Go, los números enteros con signo y sin signo vienen en cuatro tamaños diferentes, como se muestra en la siguiente tabla. Los enteros con signo se representan por int
y los enteros sin signo se representan por uint
.
Posibles operaciones aritméticas: suma, resta, multiplicación, división, resto
Tipo de datos
|
Describir
|
entero 8 |
entero con signo de 8 bits |
entero 16 |
entero con signo de 16 bits |
int32 |
entero con signo de 32 bits |
entero 64 |
entero con signo de 64 bits |
uint8 |
entero sin signo de 8 bits |
uint16 |
Entero sin signo 1 de 6 bits |
uint32 |
entero sin signo de 32 bits |
uint64 |
entero sin signo de 64 bits |
entero |
Tanto los firmados como los no firmados tienen el mismo tamaño, 32 o 64 bits. |
unidad |
Tanto los firmados como los no firmados tienen el mismo tamaño, 32 o 64 bits. |
runas |
Este es un sinónimo de int32 y también representa puntos de código Unicode. |
byte |
Este es un sinónimo de uint8. |
uintptr |
Este es un tipo entero sin signo. Su ancho no está definido, pero puede contener todos los bits de un valor de puntero. |
Por ejemplo:
// 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
Ejemplo de operaciones 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 punto flotante: en el lenguaje Go, los números de punto flotante se dividen en dos tipos como se muestra en la siguiente tabla.
- Las operaciones aritméticas pueden ser: suma, resta, multiplicación, división.
- Hay tres fuentes:
- decimal (3,15)
- potencia (12e18 o 3e10)
- mixto (13.16e12)
Tipo de datos |
Describir
|
float32 |
Número de punto flotante IEEE 754 de 32 bits |
float64 |
Número de punto flotante IEEE 754 de 64 bits |
Por ejemplo:
//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
Ejemplo de operaciones aritméticas para números de punto flotante:
// 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 complejos: Los números complejos se dividen en dos partes, que se muestran en la siguiente tabla.
float32
y float64
también es parte de estos números complejos. La función de integración genera un número complejo a partir de sus partes imaginarias y reales y la función de integración extrae esas partes.
- Hay varias funciones integradas en números complejos:
- complejo – crea un número complejo a partir de dos flotantes.
- real() – obtiene la parte real del número complejo de entrada como un flotante.
- imag() – obtiene la parte imaginaria del número complejo de entrada como un flotante
Tipo de datos |
Describir
|
complejo64 |
Los números complejos contienen float32 como componentes reales e imaginarios. |
complejo128 |
Los números complejos contienen float64 como componentes reales e imaginarios. |
Por ejemplo:
// 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
Ejemplos de funciones 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
El tipo de datos booleano representa solo un bit de información que es verdadero o falso. Los valores de tipo booleano no se convierten implícita ni explícitamente a ningún otro tipo.
Por ejemplo:
//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
Cadena
El tipo de datos de cadena representa una secuencia de puntos de código Unicode. En otras palabras, podemos decir que una cadena es una secuencia inmutable de bytes, lo que significa que una vez que se crea una cadena, no se puede modificar. Las cadenas pueden contener datos arbitrarios, incluidos bytes de valor cero en formato legible para humanos. Las cadenas se pueden concatenar utilizando el operador de suma (+).
Por ejemplo:
// 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
Ejemplo de concatenación de cadenas:
// 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