Funktiot

Artikkeli
08/27/2023

Funktiolla on arvo, joka edustaa argumenttiarvojen joukon yhdistämismääritystä yksittäiseen arvoon. Funktio käynnistetään antamalla joukko syötearvoja (argumenttiarvoja) ja tuottaa yksittäisen tulostearvon (palautusarvo).

Kirjoitusfunktiot

Funktiot kirjoitetaan käyttämällä function-expression:

function-expression:
      ( parameter-list_opt)function-return-type_opt=>function-body
function-body:
      lauseke
parameter-list:
      fixed-parameter-list
      fixed-parameter-list , optional-parameter-list
      optional-parameter-list
fixed-parameter-list:
      parametri
      parameter , fixed-parameter-list
parametri:
      parameter-name parameter-type_opt
parameter-name:
      tunniste
parameter-type:
      assertion
function-return-type:
      assertion
väite:
      as nullable-primiitve-type
optional-parameter-list:
      optional-parameter
      optional-parameter , optional-parameter-list
optional-parameter:
      optionalparametri
nullable-primitve-type
      nullable_opt primitive-type

Seuraavassa on esimerkki funktiosta, joka vaatii täsmälleen kaksi arvoa x ja , ja yse tuottaa -operaattorin + käytön näihin arvoihin. ja x ovat parametreja, jotka ovat osa funktion parameter-list-luetteloa, ja x + y on function-body:y

(x, y) => x + y

function-expression-arvioinnin tuloksena on tuottaa funktioarvo (ei function-body-arviointia). Tämän asiakirjan käytäntönä funktioiden arvot (toisin kuin funktioiden lausekkeet) näytetään parameter-list-luettelossa, mutta niissä on kolme pistettä (...) function-body:n sijaan. Kun esimerkiksi yllä oleva funktion lauseke on arvioitu, se näytetään seuraavan funktion arvona:

 (x, y) => ...

Seuraavat operaattorit on määritetty funktioarvoille:

Operaattori	Result
`x = y`	Equal
`x <> y`	Not equal

Funktioiden arvojen alkuperäinen tyyppi on mukautettu funktiotyyppi (johdettu perustyypistä function), joka luetteloi parametrien nimet ja määrittää kaikki parametrityypit ja palautustyypiksi any. (Siirry kohteeseen Funktiotyypit lisätietoja funktioiden tyypeistä.)

Funktioiden kutsuminen

Funktion function-body suoritetaan kutsumalla funktion arvo käyttämällä invoke-expression-lauseketta. Funktion arvon käynnistäminen tarkoittaa, että funktion arvon function-body arvioidaan ja arvo palautetaan tai annetaan virhe.

invoke-expression:
primary-expression ( argument-list_opt )
argument-list:
expression-list

Aina, kun käytetään funktion arvoa, arvojoukko määritetään argument-list-luettelona, jota kutsutaan funktion argumenteiksi .

argument-list-luetteloa käytetään määrittämään kiinteä määrä argumentteja suoraan lausekkeiden luettelona. Seuraava esimerkki määrittää tietueen, jolla on funktion arvo kentässä, ja kutsuu sitten funktion tietueen toisesta kentästä:

[ 
    MyFunction = (x, y, z) => x + y + z, 
    Result1 = MyFunction(1, 2, 3)           // 6
]

Seuraava pätee funktioita kutsuttaessa:

Function-body-ympäristön arvioiminen sisältää muuttujan, joka vastaa kutakin parametria samalla nimellä kuin parametri. Kunkin parametrin arvo vastaa argument-list-luettelosta invoke-expression muodostettua arvoa, joka on määritetty parametreissa.
Kaikki funktioiden argumentteja vastaavat lausekkeet arvioidaan, ennen kuin function-body arvioidaan.
Virheet, jotka on esitetty arvioitaessa lausekkeita expression-list tai function-body välitetään.
argument-list-luettelosta rakennettujen argumenttien määrän on oltava yhteensopiva funktion parametrien kanssa, tai virhe annetaan syykoodilla "Expression.Error". Yhteensopivuuden määrittämisprosessi on määritetty kohdassa Parametrit.

Parametrit

parameter-list-luettelossa voi esiintyä kahdenlaisia parametreja:

Required-parametri ilmaisee, että parametria vastaava argumentti on aina määritettävä, kun funktiota käynnistetään. Pakolliset parametrit on määritettävä ensin parameter-list-luettelossa. Seuraavassa esimerkissä määritetään pakolliset parametrit x ja y:
```
  [ 
      MyFunction = (x, y) => x + y, 

      Result1 = MyFunction(1, 1),     // 2 
      Result2 = MyFunction(2, 2)      // 4
  ] 
```
Valinnainen parametri ilmaisee, että parametria vastaava argumentti voidaan määrittää, kun funktiota käynnistetään, mutta sitä ei ole määritettävä. Jos valinnaista parametria vastaavaa argumenttia ei määritetä, kun funktiota käynnistetään, käytetään sen sijaan arvoa null . Valinnaisten parametrien on oltava näkyvissä kaikkien pakollisten parametrien jälkeen parametriluettelossa. Seuraavassa esimerkissä määritetään kiinteä parametri x ja valinnainen parametri y:
```
  [ 
      MyFunction = (x, optional y) =>
                        if (y = null) x else x + y, 
      Result1 = MyFunction(1),        // 1 
      Result2 = MyFunction(1, null),  // 1 
      Result3 = MyFunction(2, 2),     // 4
  ] 
```

Funktioita käynnistäessä määritettyjen argumenttien määrän on oltava yhteensopiva parametriluettelon kanssa. Funktioiden F argumenttijoukon A yhteensopivuus lasketaan seuraavasti:

Anna arvon N edustaa argument-list-luettelosta rakennettujen argumenttien A määrää. Esimerkkejä:

  MyFunction()             // N = 0 
  MyFunction(1)            // N = 1 
  MyFunction(null)         // N = 1 
  MyFunction(null, 2)      // N = 2 
  MyFunction(1, 2, 3)      // N = 3 
  MyFunction(1, 2, null)   // N = 3 
  MyFunction(1, 2, {3, 4}) // N = 3

Anna arvon Required edustaa kiinteiden parametrien F määrää ja Optional valinnaisten parametrien Fmäärää . Esimerkkejä:

()               // Required = 0, Optional = 0 
(x)              // Required = 1, Optional = 0 
(optional x)     // Required = 0, Optional = 1 
(x, optional y)  // Required = 1, Optional = 1

Argumentit A ovat yhteensopivia funktion F kanssa, jos seuraavat ovat tosia:
- (N >= Fixed) ja (N <= (Fixed + Optional))
- Argumenttityypit ovat yhteensopivia :n vastaavien parametrityyppien kanssa F
Jos funktiolla on määritetty palautustyyppi, funktion tulosarvo on yhteensopiva - F paluutyypin kanssa F, jos seuraava on tosi:
- Arvo, joka on saatu arvioimalla funktioiden runkoa käyttäen annettuja argumentteja funktioparametreilla, on tyyppi, joka on yhteensopiva palautustyypin kanssa.
Jos funktioiden runko tuottaa arvon, joka ei ole yhteensopiva funktion palautustyypin kanssa, annetaan virhe, jonka syykoodi "Expression.Error" on .

Rekursiiviset funktiot

Jotta voit kirjoittaa rekursiivisen funktion arvon, on tarpeen käyttää alue-operaattoria (@) viittaamaan funktioon sen vaikutusalueella. Esimerkiksi seuraava tietue sisältää kentän, joka määrittää funktion Factorial , ja toisen kentän, joka kutsuu sitä:

[ 
    Factorial = (x) => 
                if x = 0 then 1 else x * @Factorial(x - 1), 
    Result = Factorial(3)  // 6 
]

Samoin keskenään rekursiivisia funktioita voidaan kirjoittaa niin kauan kuin kullakin käytettävissä olevalla funktiolla on nimi. Seuraavassa esimerkissä osa -funktiosta Factorial on refaktioitu toiseen Factorial2 funktioon.

[ 
    Factorial = (x) => if x = 0 then 1 else Factorial2(x), 
    Factorial2 = (x) => x * Factorial(x - 1), 
    Result = Factorial(3)     // 6 
]

Sulkemiset

Funktio voi palauttaa toisen funktion arvona. Tämä funktio voi puolestaan riippua yhdestä tai useammasta parametrista alkuperäiseen funktioon. Seuraavassa esimerkissä kenttään MyFunction liittyvä funktio palauttaa funktion, joka palauttaa sille määritetyn parametrin:

[ 
    MyFunction = (x) => () => x, 
    MyFunction1 = MyFunction(1), 
    MyFunction2 = MyFunction(2), 
    Result = MyFunction1() + MyFunction2()  // 3 
]

Aina, kun funktio käynnistetään, palautetaan uusi funktion arvo, joka säilyttää parametrin arvon niin, että kun se käynnistetään, parametrin arvo palautetaan.

Funktiot ja ympäristöt

Parametrien lisäksi function-expression-funktio function-body voi viitata muuttujiin, jotka ovat ympäristössä, kun funktiota alustetaan. Esimerkiksi -kentän MyFunction määrittämä funktio voi käyttää sulkevan tietueen Akenttää C :

[ 
A =  
    [ 
        MyFunction = () => C, 
        C = 1 
    ], 
B = A[MyFunction]()           // 1 
]

Kun MyFunction käynnistetään, se käyttää muuttujan Carvoa, vaikka se käynnistetään ympäristöstä (B), joka ei sisällä muuttujaa C.

Yksinkertaistetut määrittelyt

each-expression on syntaktinen lyhenne, jonka mukaan tyypittömät funktiot ottavat käyttöön yksittäisen parametrin nimeltä _ (alaviiva).

each-expression:
eacheach-expression-body
each-expression-body:
function-body

Yksinkertaistettuja määrittelyjä käytetään yleisesti parantamaan korkeamman asteen funktioiden kutsun luettavuutta.

Esimerkiksi seuraavat määrittelyjen parit ovat semanttisesti toisiaan vastaavia:

each _ + 1 
(_) => _ + 1  
each [A] 
(_) => _[A] 
 
Table.SelectRows( aTable, each [Weight] > 12 ) 
Table.SelectRows( aTable, (_) => _[Weight] > 12 )

Jaa