[go] interface {}의 의미는 무엇입니까?

” Gos 에서 인터페이스를 사용하는 방법 “( ” Russ Cox의 인터페이스 설명 “을 기반으로) 기사를 참조 할 수 있습니다 .

무엇 이며 인터페이스는?

인터페이스는 두 가지입니다.

• 일련의 방법이며
• 그러나 그것은 또한 유형입니다

interface{}유형은 빈 인터페이스는 아무런 방법이없는 인터페이스입니다.

구현 키워드가 없기 때문에 모든 유형은 최소 0 개의 메소드를 구현하며 인터페이스 만족은 자동으로 수행 되므로 모든 유형은 빈 인터페이스를 충족합니다 .
즉, interface{}값을 매개 변수로 사용 하는 함수를 작성하면 해당 함수에 임의의 값을 제공 할 수 있습니다 .

(그것은 Msg당신의 질문에서 대표하는 것입니다 : 모든 가치)

func DoSomething(v interface{}) {
   // ...
}

혼란스러운 부분은 다음과 같습니다.

DoSomething함수 내부에서 유형 은 무엇 v입니까?

초보자 고퍼들은“ v모든 유형의” 것이라고 믿게 되지만 그것은 잘못입니다.
v어떤 유형도 아닙니다. 그것은이다 interface{}유형 .

에 값을 전달할 때 DoSomething기능의 이동 런타임에서 수행 타입 변환 (필요할 경우), 및 내지 An 값을 변환 interface{}값 .
모든 값은 런타임시 정확히 하나의 유형을 가지며, v하나의 정적 유형은 interface{}입니다.

인터페이스 값은 두 단어의 데이터로 구성됩니다 .

• 한 단어는 값의 기본 유형에 대한 메소드 테이블을 가리키는 데 사용됩니다.
• 다른 단어는 해당 값이 보유한 실제 데이터를 가리키는 데 사용됩니다.

부록 : 인터페이스 구조에 관한 Russ의 기사는 다음과 같습니다.

type Stringer interface {
    String() string
}

인터페이스 값은 인터페이스에 저장된 유형에 대한 정보를 가리키는 포인터와 관련 데이터를 가리키는 두 단어 쌍으로 표시됩니다.
Stringer 유형의 인터페이스 값에 b를 지정하면 인터페이스 값의 두 단어가 설정됩니다.

인터페이스 값의 첫 번째 단어는 내가 인터페이스 테이블 또는 itable이라고 부르는 것을 가리 킵니다 (i-table로 발음됩니다. 런타임 소스에서 C 구현 이름은 Itab입니다).
itable은 관련된 유형에 대한 일부 메타 데이터로 시작한 다음 함수 포인터 목록이됩니다.
itable은 dynamic type이 아닌 인터페이스 유형에 해당합니다 .
이 예에서는 StringerBinary 유형 을 보유 할 수있는 Stringer를 만족시키는 데 사용되는 메소드를 나열합니다 String. Binary의 다른 메소드 ( Get)는에 나타나지 않습니다 itable.

인터페이스 값의 두 번째 단어는 실제 데이터 ( 이 경우 사본)를 가리 킵니다b .
할당은 var s Stringer = b(A)의 복사본을 만드는 b에서보다는 포인트 b같은 이유로 var c uint64 = b복사본을 만듭니다를 다음과 같은 경우 b나중에 변경, s그리고 c원래 값이 아닌 새로운 하나가 가정된다.
인터페이스에 저장된 값은 임의로 클 수 있지만 인터페이스 구조에서 값을 보유하기 위해 한 단어 만 사용되므로 할당은 힙에 메모리 청크를 할당하고 포인터를 한 단어 슬롯에 기록합니다.

답변

package main

import (
    "fmt"
)

type Body struct {
    Msg interface{}
}

func main() {
    b := Body{}
    b.Msg = "5"
    fmt.Printf("%#v %T \n", b.Msg, b.Msg) // Output: "5" string
    b.Msg = 5

    fmt.Printf("%#v %T", b.Msg, b.Msg) //Output:  5 int
}

body := Body{3}
fmt.Printf("%#v\n", body) // -> main.Body{Msg:3}

body = Body{"anything"}
fmt.Printf("%#v\n", body) // -> main.Body{Msg:"anything"}

body = Body{body}
fmt.Printf("%#v\n", body) // -> main.Body{Msg:main.Body{Msg:"anything"}}

type Runner interface {
    Run()
}

type Program struct {
    /* fields */
}

func (p Program) Run() {
    /* running */
}

func (p Program) Stop() {
    /* stopping */
}

type Empty interface {
    /* it has no methods */
}

// Because, Empty interface has no methods, following types satisfy the Empty interface
var a Empty

a = 5
a = 6.5
a = "hello"

a = Program{} // ok

var b interface{}

// true: a == b

b = a
b = 9
b = "bye"

package main

import (
    . "fmt"
    "strconv"
)

var c = cat("Fish")
var d = dog("Bone")

func main() {
    var i interface{} = c
    switch i.(type) {
    case cat:
        c.Eat() // Fish
    }

    i = d
    switch i.(type) {
    case dog:
        d.Eat() // Bone
    }

    i = "4.3"
    Printf("%T %v\n", i, i) // string 4.3
    s, _ := i.(string)      // type assertion
    f, _ := strconv.ParseFloat(s, 64)
    n := int(f)             // type conversion
    Printf("%T %v\n", n, n) // int 4
}

type cat string
type dog string
func (c cat) Eat() { Println(c) }
func (d dog) Eat() { Println(d) }