Go Academy · Lektion

Dynamiske funktionskald

Kald funktioner og angiv værdier via reflect

Lektion 3 af 413 trin

Dynamiske funktionskald er en gratis Go Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Go Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Go Academy-kurset indeholder 4 lektioner i alt.

reflect.Value.Call

Value.Call(args) kalder den funktion, som Value repræsenterer, med de angivne argumenter (som en []reflect.Value) og returnerer resultaterne som en []reflect.Value.

fn := reflect.ValueOf(add)
results := fn.Call([]reflect.Value{
    reflect.ValueOf(2),
    reflect.ValueOf(3),
})
fmt.Println(results[0].Int()) // 5

Kontrol af argumenttyper

Sørg for, at argumenttyperne stemmer overens med funktionssignaturen, før du kalder funktionen. Typemismatch medfører en panik.

t := reflect.TypeOf(fn)
if t.NumIn() != len(args) { panic("wrong arg count") }
for i, arg := range args {
    if !reflect.TypeOf(arg).AssignableTo(t.In(i)) { panic("type mismatch") }
}

Variadiske funktioner

Kald en variadisk funktion med Value.Call, hvor slicen udfoldes, eller Value.CallSlice, hvor de variadiske argumenter sendes som en slice-værdi:

sum := reflect.ValueOf(func(ns ...int) int {
    total := 0
    for _, n := range ns { total += n }
    return total
})
args := reflect.ValueOf([]int{1,2,3})
results := sum.CallSlice([]reflect.Value{args})

reflect.MakeFunc

reflect.MakeFunc opretter en ny funktion under kørsel med en given type og en wrapper-krop. Det bruges til at generere adapterfunktioner til grænseflader.

t := reflect.TypeOf(func(int) string { return "" })
fn := reflect.MakeFunc(t, func(args []reflect.Value) []reflect.Value {
    return []reflect.Value{reflect.ValueOf(strconv.Itoa(args[0].Interface().(int)))}
})

Kald af metoder efter navn

Hent en metode efter navn, og kald den:

v := reflect.ValueOf(myObj)
m := v.MethodByName("Process")
if m.IsValid() {
    m.Call(nil)
}

Kontrol af, om en metode findes

Kontrollér altid m.IsValid(), før du kalder metoden — MethodByName returnerer den tomme Value, hvis metoden ikke findes, og et kald af den tomme Value medfører en panik.

Anvendelser af dynamisk dispatch

Dynamiske funktionskald bruges i: plugin-systemer, hvor funktioner kaldes efter strengnavn, testframeworks, hvor TestXxx-funktioner kaldes, RPC-dispatchere, hvor metodenavne knyttes til handlere, og dekoratorer.

Ydeevne

reflect.Call er cirka 10-50× langsommere end et direkte kald. Gem reflect.Value for funktioner, der kaldes ofte, og undgå dem i varme løkker.

Typesikkert hjælpeværktøj

Pak dynamiske kald ind i en typesikker hjælpefunktion, der udfører refleksionsarbejdet én gang under opstart og gentagne gange kalder den gemte Value:

type Processor func(context.Context, []byte) ([]byte, error)
// Build at startup, reuse at request time

Håndtering af fejlretur

Hvis funktionen returnerer en fejl som sit sidste resultat, skal du udtrække og kontrollere den:

results := fn.Call(args)
if !results[len(results)-1].IsNil() {
    return results[len(results)-1].Interface().(error)
}

Alternativer til refleksion

Hvis mængden af funktioner er kendt ved kompileringstid, skal du bruge et kort over funktionsværdier (map[string]func(...)) i stedet for refleksion — det er sikrere og hurtigere.

handlers := map[string]func(ctx context.Context, req []byte) []byte{
    "greet": greetHandler,
}

Hurtig kontrol

Hvad returnerer reflect.Value.Call?

Besvar den i den interaktive lektion

Opsummering: Dynamiske funktionskald

Vigtige punkter:

Value.Call([]reflect.Value) kalder funktionen og returnerer []reflect.Value
Kontrollér m.IsValid(), før du kalder resultatet fra MethodByName
MakeFunc opretter en ny funktion med en given type under kørsel
Foretræk map[string]func frem for refleksion ved kendte funktionsmængder

Gratis at komme i gang

Lær Go med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Dynamiske funktionskald” gratis?

Ja — alle 3 lektioner i læringssporet Go Academy, inklusive “Dynamiske funktionskald”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Go Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Dynamiske funktionskald”?

Kald funktioner og angiv værdier via reflect Du øver dig i Go Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Go Academy?

Der kræves ingen tidligere erfaring. Go Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Dynamiske funktionskald”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Go Academy-lektion?

Ja. Alle Go Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Go Academy