Pregunta Asegúrese de que un tipo implemente una interfaz en tiempo de compilación en Ir


¿Cómo puedo asegurarme de que un tipo implemente una interfaz en tiempo de compilación? La forma típica de hacerlo es no asignar las interfaces de soporte de ese tipo; sin embargo, tengo varios tipos que solo se convierten dinámicamente. En tiempo de ejecución, esto genera mensajes de error muy bruscos, sin los mejores diagnósticos dados para los errores de tiempo de compilación. También es muy inconveniente encontrar en tiempo de ejecución que los tipos que esperaba soportan interfaces, de hecho no.


12
2018-05-08 12:23


origen


Respuestas:


Asumiendo que la pregunta es sobre Go, v.g.

var _ foo.RequiredInterface = myType{} // or &myType{} or [&]myType if scalar

como un TLD lo comprobará en tiempo de compilación.

EDITAR: s / [*] / & /

EDIT2: s / dummy / _ /, gracias Atom


11
2018-05-08 12:56



En el lenguaje Go no hay "implementos"declaración por diseño. La única forma de pedirle al compilador que verifique que el tipo T implementa la interfaz I intentando una asignación (sí, una ficticia :). Nota, Go lang diferencia los métodos declarados en estructura y puntero, usa el correcto en la verificación de asignación!

type T struct{}
var _ I = T{}       // Verify that T implements I.
var _ I = (*T)(nil) // Verify that *T implements I.

Lea las preguntas frecuentes para más detalles ¿Por qué Go no tiene declaraciones "implementa"?


3
2018-01-05 18:48



Me gusta esto:

http://play.golang.org/p/57Vq0z1hq0

package main

import(
    "fmt"
)

type Test int

func(t *Test) SayHello() {
    fmt.Println("Hello");   
}

type Saluter interface{
    SayHello()
    SayBye()
}

func main() {
    t := Saluter(new(Test))
    t.SayHello()
}

Rendirá:

prog.go:19: cannot convert new(Test) (type *Test) to type Saluter:
    *Test does not implement Saluter (missing SayBye method)

1
2018-05-08 13:47



package main

import (
    "fmt"
)

type Sayer interface {
    Say()
}

type Person struct {
    Name string
}

func(this *Person) Say() {
    fmt.Println("I am", this.Name)
}

func main() {
    person := &Person{"polaris"}

    Test(person)
}

func Test(i interface{}) {
    //!!here ,judge i implement Sayer
    if sayer, ok := i.(Sayer); ok {
        sayer.Say()
    }
}

El ejemplo del código está aquí:http://play.golang.org/p/22bgbYVV6q


-1
2017-08-15 09:15



No me gusta la idea de hacer errores de lanzamiento del compilador poniendo líneas ficticias en el código principal. Esa es una solución inteligente que funciona, pero prefiero escribir una prueba para este propósito.

Suponiendo que tenemos:

type Intfc interface { Func() }
type Typ int
func (t Typ) Func() {}

Esta prueba se asegura Typ implementos Intfc:

package main

import (
    "reflect"
    "testing"
)

func TestTypes(t *testing.T) {
    var interfaces struct {
        intfc Intfc
    }
    var typ Typ
    v := reflect.ValueOf(interfaces)
    testType(t, reflect.TypeOf(typ), v.Field(0).Type())
}

// testType checks if type t1 implements interface t2
func testType(t *testing.T, t1, t2 reflect.Type) {
    if !t1.Implements(t2) {
        t.Errorf("%v does not implement %v", t1, t2)
    }
}

Puede verificar todos sus tipos e interfaces agregándolos a TestTypes función. Se introducen pruebas de escritura para Go aquí.


-3
2018-05-12 10:30