Go Academy · Oppitunti

Dynaamiset funktiokutsut

Funktioiden kutsuminen ja arvojen asettaminen reflectin avulla

Oppitunti 3/413 vaihetta

Dynaamiset funktiokutsut on ilmainen Go Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Go Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Go Academy-kurssilla on yhteensä 4 oppituntia.

reflect.Value.Call

Value.Call(args) kutsuu Valuen esittämää funktiota annetuilla argumenteilla (tyyppiä []reflect.Value) ja palauttaa tulokset tyyppinä []reflect.Value.

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

Argumenttien tyyppien tarkistaminen

Varmistakaa ennen kutsua, että argumenttien tyypit vastaavat funktion allekirjoitusta. Tyyppeihin liittyvä ristiriita aiheuttaa panicin.

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") }
}

Variadiset funktiot

Kutsukaa variadista funktiota Value.Call-metodilla (levittämällä viipale) tai Value.CallSlice-metodilla (välittämällä variadiset argumentit viipaleena):

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 luo ajon aikana uuden funktion annetulla tyypillä ja käärefunktion rungolla. Sitä käytetään rajapintojen sovitinfunktion generointiin.

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)))}
})

Metodien kutsuminen nimen perusteella

Hakekaa metodi nimen perusteella ja kutsukaa sitä:

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

Metodin olemassaolon tarkistaminen

Tarkistakaa aina m.IsValid() ennen kutsua — MethodByName palauttaa nolla-arvon, jos metodia ei löydy, ja nolla-arvon kutsuminen aiheuttaa panicin.

Dynaamisen dispatchin käyttötapaukset

Dynaamisia funktiokutsuja käytetään liitännäisjärjestelmissä (funktioiden kutsuminen merkkijononimen perusteella), testikehyksissä (TestXxx-funktioiden kutsuminen), RPC-dispatchereissa (metodien nimien yhdistäminen käsittelijöihin) ja koristelijoissa.

Suorituskyky

reflect.Call on noin 10–50 kertaa hitaampi kuin suora kutsu. Tallentakaa usein kutsuttujen funktioiden reflect.Value-arvot välimuistiin ja välttäkää niiden käyttöä hot loop -silmukoissa.

Tyyppiturvallinen kääre

Käärikää dynaamiset kutsut tyypitettyyn apufunktioon, joka suorittaa reflect-käsittelyn kerran käynnistyksen aikana ja kutsuu sen jälkeen välimuistiin tallennettua Value-arvoa toistuvasti:

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

Virheen palautuksen käsittely

Jos funktio palauttaa virheen viimeisenä tuloksena, poimikaa se ja tarkistakaa se:

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

Reflectionin vaihtoehdot

Jos funktioiden joukko tunnetaan käännösaikana, käyttäkää reflectionin sijaan funktioarvojen map-rakennetta (map[string]func(...)) — se on turvallisempi ja nopeampi.

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

Pikatarkistus

Mitä reflect.Value.Call palauttaa?

Vastaa interaktiivisessa oppitunnissa

Kertaus: dynaamiset funktiokutsut

Keskeiset kohdat:

Value.Call([]reflect.Value) kutsuu funktion ja palauttaa []reflect.Value-arvon
Tarkistakaa m.IsValid() ennen MethodByName-kutsun tuloksen käyttämistä
MakeFunc luo ajon aikana uuden funktion annetulla tyypillä
Suosikaa map[string]func-rakennetta reflectionin sijaan, kun funktioiden joukko tunnetaan

Aloita maksutta

Opi Go tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 51
Oppitunnit: 203

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Dynaamiset funktiokutsut” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Go Academy-oppimispolun 3 oppituntia, myös oppitunnin “Dynaamiset funktiokutsut”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Go Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Dynaamiset funktiokutsut”?

Funktioiden kutsuminen ja arvojen asettaminen reflectin avulla Harjoittelet Go Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Go Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Go Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Dynaamiset funktiokutsut”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Go Academy-oppitunnilla?

Kyllä. Jokainen Go Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Go Academy