Tipos de datos en Golang

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:

• Número
• Booleano
• Cadena

Tipos de datos comunes en Golang

• Números en Golang
• Booleano
• Cadena

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 inty los enteros sin signo se representan por uint.

Posibles operaciones aritméticas: suma, resta, multiplicación, división, resto

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)

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. float32y float64tambié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

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