Interfaces del lenguaje Go (Interfaces)

Las interfaces en Go son diferentes de otras lenguajes. En Go, una interfaz es un tipo personalizado que se utiliza para especificar un conjunto de una o más firmas de métodos, y la interfaz es abstracta, por lo que no se permite crear una instancia de la interfaz. Sin embargo, se puede crear una variable de tipo interfaz y se puede asignar un valor específico de tipo que tenga los métodos necesarios para la interfaz. En otras palabras, la interfaz es tanto una colección de métodos como un tipo personalizado.

¿Cómo crear una interfaz?

En Go, puede usar la siguiente sintaxis para crear una interfaz:

type interface_name interface{
　　　　//Firma del método
}

Por ejemplo:

//Crear una interfaz
type myinterface interface{
　　　　//　Métodos
　　　　fun1() int
　　　　fun2() float64
}

Aquí, el nombre de la interfaz se incluye entre las palabras clave type y interface, y la firma del método se incluye entre corchetes.

¿Cómo implementar una interfaz?

En Go, para implementar una interfaz, es necesario implementar todos los métodos declarados en la interfaz. La implementación de interfaces en Go es implícita. Al igual que otros lenguajes, no contiene ninguna palabra clave específica para implementar la interfaz. A continuación, se muestra un ejemplo:

//　Explicación del programa de Golang
//Implementar la interfaz
package　main
import　"fmt"
//Crear una interfaz
type tank interface {
　　　　//　Métodos
　　　　Tarea() float64
　　　　Volume() float64
}
type myvalue struct {
　　　　radius float64
　　　　height float64
}
//método de implementación
//Tubo (Tank) interfaz
func (m myvalue) Tarea() float64　{
　　　　return　2*m.radius*m.height　+　2*3.14*m.radius*m.radius
}
func (m myvalue) Volume() float64　{
　　　　return　3.14　*　m.radius　*　m.radius　*　m.height
}
func　main()　{
　　　　//　Acceso utilizando el interfaz del barril
　　　　var t tank
　　　　t = myvalue{10,　14}
　　　　fmt.Println("El área del barril:", t.Tarea())
　　　　fmt.Println("La capacidad del barril:", t.Volume())
}

Salida:

El área del barril:　908
La capacidad del barril:　4396

Consideraciones

• El valor cero del interfaz es nil.

• Cuando el interfaz contiene cero métodos, este tipo de interfaz se llama interfaz vacío. Por lo tanto, todos los tipos implementan el interfaz vacío.

  Sintaxis:

  interface{}

• Tipo de interfaz:Este interfaz tiene dos tipos, uno estático y otro dinámico. El tipo estático es el interfaz en sí mismo, por ejemplo, el tank en el siguiente ejemplo. Pero el interfaz no tiene valor estático, por lo que siempre apunta al valor dinámico.
  Las variables del tipo de interfaz contienen valores de tipos que implementan el interfaz, por lo tanto, los valores de este tipo se denominan valores dinámicos, y este tipo es el tipo dinámico. También se denominan valores específicos y tipos específicos.

  Ejemplo

  //Explicación de los conceptos del programa Go
  //Valor y tipo dinámicos
  package　main
  import　"fmt"
  //Creación de interfaz
  type tank interface {
  　　　　//　Métodos
  　　　　Tarea() float64
  　　　　Volume() float64
  }
  func　main()　{
  　　　　var t tank
  　　　　fmt.Println("El valor de interfaz de tank es: ", t)
  　　　　fmt.Printf("El tipo de tank es: %T ", t)
  }

  Salida:

  El valor de interfaz de tank es: <nil>
  El tipo de tank es: <nil>

  En el ejemplo anterior, hay un interfaz llamado tank. En este ejemplo,fmt.Println("El valor de interfaz de tank es: ", t) La sentencia devuelve el valor dinámico del interfaz, mientras que la sentencia fmt.Printf("El tipo de tank es: %T ", t) devuelve el tipo dinámico del interfaz, es decir, nil, porque aquí el interfaz no sabe quién lo implementa.

• Afirmación de tipo:En el lenguaje de programación Go, la afirmación de tipo es una operación aplicada a valores de interfaz. En otras palabras, la afirmación de tipo es el proceso de extracción de valores de interfaz.

  Sintaxis:
  

  a.(T)

  Aquí, a es el valor o expresión del interfaz, T es el tipo de afirmación de tipo también conocido. La afirmación de tipo se utiliza para verificar si el tipo dinámico del operando coincide con el tipo afirmado. Si T es un tipo específico, la afirmación de tipo verifica si el tipo dinámico dado de a es igual a T, aquí, si la verificación se realiza con éxito, la afirmación de tipo devuelve el valor dinámico de a. De lo contrario, si la verificación falla, el operando generará una excepción panic. Si T es un tipo de interfaz, la afirmación de tipo verifica si el tipo dinámico dado satisface T, aquí, si la verificación se realiza con éxito, no se extrae el valor dinámico.

  Ejemplo

  //Tipificación de tipo　
  package　main　
  　　
  import　"fmt"
  　　
  func　myfun(a　interface{})　{　
  　　
  　　　　//Extraer el valor de a
  　　　　val　:=　a.(string)　
  　　　　fmt.Println("Valor:　",　val)　
  }　
  func　main()　{　
  　　
  　　　　var　val　interface　{　
  　　　　}　=　"w3codebox"
  　　　　　　
  　　　　myfun(val)　
  }

  Salida:

  el valor es:　　w3codebox

  En el ejemplo anterior, si se cambiaval：= a。（string）la declaración se cambia aval：= a。（int），el programa lanzará una excepción panic. Por lo tanto, para evitar este problema, usamos la siguiente sintaxis:

  value,　ok　:=　a.(T)

  Aquí, si el tipo de a es igual a T, el valor contiene el valor dinámico de a y ok se establece en true. Y si el tipo de a no es igual a T, ok se establece en false y el valor contiene el valor cero y el programa no lanzará una excepción panic. Como se muestra en el siguiente programa:

  Ejemplo

  package　main
  import　"fmt"
  func　myfun(a　interface{})　{
  　　　　value,　ok　:=　a.(float64)
  　　　　fmt.Println(value,　ok)
  }
  func　main()　{
  　　　　var　a1　interface　{
  　　　　}　=　98.09
  　　　　myfun(a1)
  　　　　var　a2　interface　{
  　　　　}　=　"w3codebox"
  　　　　myfun(a2)
  }

  Salida:

  98.09　verdadero
  0　falso

• Evaluación de tipo:En los interfaces de Go, la evaluación de tipo se utiliza para comparar el tipo específico del interfaz con varios tipos proporcionados en la declaración de caso. Es similar a la declaración de tipo, pero con la diferencia de que se especifica el tipo en mayúsculas en lugar del valor. También se puede comparar el tipo con el tipo de interfaz. Como se muestra en el siguiente ejemplo:

  Ejemplo

  package　main
  import　"fmt"
  func　myfun(a　interface{})　{
  　　　　//Uso de la evaluación de tipo
  　　　　switch　a.(type)　{
  　　　　case　int:
  　　　　　　　　fmt.Println("Tipo:　int，valor:",　a.(int))
  　　　　case　string:
  　　　　　　　　fmt.Println("\nTipo:　string，valor:　",　a.(string))
  　　　　case　float64:
  　　　　　　　　fmt.Println("\nTipo:　float64，valor:　",　a.(float64))
  　　　　default:
  　　　　　　　　fmt.Println("\nTipo no encontrado")
  　　　　}
  }

  Salida:

  Tipo:　string，valor:　　w3codebox
  Tipo:　float64，valor:　　67.9
  Tipo no encontrado

• Uso de la interfaz:Cuando desea pasar diferentes tipos de parámetros en un método o función, puede usar una interfaz, como el función Println(). O también se puede usar una interfaz cuando varios tipos implementan el mismo interfaz.