Go no tiene el concepto de un tipo de clase, por lo tanto, no tiene objetos en Go. Puede hacer referencia a cualquier tipo de datos en Go como un objeto. Go proporciona varios tipos de datos, como int8, int16, int32, int64, float64, string, bool, etc. Hay tres formas diferentes de encontrar el tipo de una variable en Go en tiempo de ejecución.
1. Usar fmt para una descripción de tipo de string
%T en el paquete fmt es una representación de sintaxis Go del tipo del valor. Puede usar %T para encontrar el tipo de variable.
Sintaxis:
func typeofobject(x interface{}) {
fmt.Sprintf("%T", x)
}
Ejemplo 1:
// Golang program to find the variable type
package main
// importing required packages
import (
"fmt"
)
// main function
func main() {
f := true
st := ""
a := 1
d := 1.0
arr := []string{"Go", "Is", "Fun"}
fmt.Printf("%T\n", f)
fmt.Printf("%T\n", st)
fmt.Printf("%T\n", a)
fmt.Printf("%T\n", d)
fmt.Printf("%T\n", arr)
}
Producción:
bool string int float64 []string
Ejemplo 2:
// Golang program to show how to find
// the type of an object
package main
// importing required packages
import (
"fmt"
)
func main() {
types := []interface{}{"Code", 10, true, 10.55}
for _, x := range types {
fmt.Printf("%T\n", x)
}
}
Producción:
string int bool float64
Nota: una interfaz vacía se indica mediante interface{} y se puede usar para contener valores de cualquier tipo.
2. Usando el paquete de reflejo
También puede usar el paquete reflect que implementa la reflexión en tiempo de ejecución, lo que permite que un programa manipule objetos con tipos arbitrarios. Las funciones reflect.TypeOf y reflect.ValueOf(x).Kind() nos ayudan a encontrar el tipo de variable requerido.
Sintaxis:
func typeofobject(x interface{}){
fmt.Println(reflect.TypeOf(x))
}
O
func typeofobject(x interface{}){
fmt.Println(reflect.ValueOf(x).Kind())
}
Ejemplo 1:
// Golang program to demonstrate
// the use of reflect.TypeOf function
package main
//importing reflect package
import (
"fmt"
"reflect"
)
func main() {
f := true
st := ""
a := 1
d := 1.0
arr := []string{"Go", "Is", "Fun"}
fmt.Println(reflect.TypeOf(f))
fmt.Println(reflect.TypeOf(st))
fmt.Println(reflect.TypeOf(a))
fmt.Println(reflect.TypeOf(d))
fmt.Println(reflect.TypeOf(arr))
}
Producción:
bool string int float64 []string
Podemos hacerlo de manera similar usando la función ValueOf().Kind().
Ejemplo 2:
// Golang program to demonstrate
// the use of reflect.ValueOf(x).Kind() function
package main
import (
"fmt"
"reflect"
)
func main() {
f := true
st := ""
a := 1
d := 1.0
arr := []string{"Coding", "In", "Go"}
fmt.Println(reflect.ValueOf(f).Kind())
fmt.Println(reflect.ValueOf(st).Kind())
fmt.Println(reflect.ValueOf(a).Kind())
fmt.Println(reflect.ValueOf(d).Kind())
fmt.Println(reflect.ValueOf(arr).Kind())
}
Producción:
bool string int float64 slice
Ejemplo 3:
package main
// importing required packages
import (
"fmt"
"reflect"
)
func main() {
types := []interface{}{"Code", true, 5, 3.14, []int{1, 2, 3, 4}}
for _, x := range types {
fmt.Println(reflect.ValueOf(x).Kind())
}
}
Producción:
string bool int float64 slice
3. Usar aserciones de tipo
Puede usar un cambio de tipo para hacer varias aserciones de tipo. Un cambio de tipo utiliza varias aserciones de tipo en serie y ejecuta el primer tipo coincidente. En este cambio, el caso contiene el tipo que se va a comparar con el tipo presente en la expresión del cambio, y si ninguno de los casos coincide, se evalúa el caso predeterminado.
Sintaxis:
switch optstatement; typeswitchexpression{
case typelist 1: Statement..
case typelist 2: Statement..
...
default: Statement..
}
Ejemplo:
// Golang program to check the object type
// using type switch
package main
//importing required packages
import (
"fmt"
)
func main() {
types := []interface{}{"Code", true, 5, 3.14, []int{1, 2, 3}}
for _, x := range types {
// type switch with multiple cases
switch x.(type) {
case int:
fmt.Println("int:", x)
case float64:
fmt.Println("float64:", x)
case string:
fmt.Println("string:", x)
case bool:
fmt.Println("bool:", x)
default:
fmt.Printf("data type: %T", x)
}
}
}
Producción:
string: Code bool: true int: 5 float64: 3.14 data type: []int
Publicación traducida automáticamente
Artículo escrito por Hritika Rajput y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA