Funksjoner
En funksjon er en verdi som representerer en tilordning fra et sett med argumentverdier til én enkelt verdi. En funksjon aktiveres ved å angi et sett med inndataverdier (argumentverdiene), og produserer én enkelt utdataverdi (returverdien).
Funksjoner skrives ved hjelp av et funksjonsuttrykk:
funksjon-uttrykk:
(
parameter-listopt)
function-return-typeopt=>
function-body
funksjonstekst:
uttrykk
parameterliste:
fast-parameter-liste
fast-parameter-liste ,
valgfritt-parameter-liste
valgfri parameterliste
fast-parameter-liste:
parameter
parameter ,
fast-parameter-liste
parameter:
parameternavnparametertype
parameternavn:
identifikator
parametertype:
assertion
funksjon-retur-type:
assertion
påstand:
as
nullable-primiitve-type
valgfri parameterliste:
valgfri parameter
valgfri parameter ,
valgfri parameterliste
valgfri parameter:
optional
parameter
nullable-primitve-type
nullable
opt primitive-type
Følgende er et eksempel på en funksjon som krever nøyaktig to verdier x
og y
, og gir resultatet av å bruke operatoren på +
disse verdiene. Og x
er parametere som er en del av parameterlisten for funksjonen, og x + y
er funksjonsteksten:y
(x, y) => x + y
Resultatet av evalueringen av et funksjonsuttrykk er å produsere en funksjonsverdi (for ikke å evaluere funksjonskroppen). Som en konvensjon i dette dokumentet vises funksjonsverdier (i motsetning til funksjonsuttrykk) med parameterlisten, men med en ellipse (...
) i stedet for funksjonsteksten. Når funksjonsuttrykket ovenfor for eksempel er evaluert, vises det som følgende funksjonsverdi:
(x, y) => ...
Følgende operatorer er definert for funksjonsverdier:
Operator | Resultat |
---|---|
x = y |
Equal |
x <> y |
Not equal |
Den opprinnelige typen funksjonsverdier er en egendefinert funksjonstype (avledet fra den innebygde typen function
) som viser parameternavnene og angir alle parametertyper og returtypen som skal være any
. (Gå til Funksjonstyper for detaljer om funksjonstyper.)
Funksjonsteksten for en funksjon utføres ved å aktivere funksjonsverdien ved hjelp av et aktiveringsuttrykk. Aktivering av en funksjonsverdi betyr at funksjonsteksten for funksjonsverdien evalueres og en verdi returneres eller en feil utløses.
invoke-expression:
valg av argumentliste for primæruttrykk(
)
argumentliste:
uttrykksliste
Hver gang en funksjonsverdi aktiveres, angis et sett med verdier som en argumentliste, kalt argumentene til funksjonen.
En argumentliste brukes til å angi et fast antall argumenter direkte som en liste over uttrykk. Følgende eksempel definerer en post med en funksjonsverdi i et felt, og aktiverer deretter funksjonen fra et annet felt i posten:
[
MyFunction = (x, y, z) => x + y + z,
Result1 = MyFunction(1, 2, 3) // 6
]
Følgende gjelder når du aktiverer en funksjon:
Miljøet som brukes til å evaluere funksjonens funksjonstekst , inneholder en variabel som tilsvarer hver parameter, med samme navn som parameteren. Verdien for hver parameter tilsvarer en verdi som er konstruert fra argumentlisten for aktiveringsuttrykket, som definert i parametere.
Alle uttrykkene som tilsvarer funksjonsargumentene evalueres før funksjonsteksten evalueres.
Feil som oppstår når du evaluerer uttrykkene i uttrykkslisten eller funksjonskroppen , overføres.
Antall argumenter som er konstruert fra argumentlisten , må være kompatible med parameterne for funksjonen, ellers utløses en feil med årsakskode
"Expression.Error"
. Prosessen for å fastslå kompatibilitet er definert i parametere.
Det finnes to typer parametere som kan finnes i en parameterliste:
En nødvendig parameter angir at et argument som tilsvarer parameteren, alltid må angis når en funksjon aktiveres. Obligatoriske parametere må angis først i parameterlisten. Funksjonen i eksemplet nedenfor definerer nødvendige parametere
x
ogy
:[ MyFunction = (x, y) => x + y, Result1 = MyFunction(1, 1), // 2 Result2 = MyFunction(2, 2) // 4 ]
En valgfri parameter angir at et argument som tilsvarer parameteren, kan angis når en funksjon aktiveres, men det kreves ikke å angis. Hvis et argument som tilsvarer en valgfri parameter ikke angis når funksjonen aktiveres, brukes verdien
null
i stedet. Valgfrie parametere må vises etter eventuelle nødvendige parametere i en parameterliste. Funksjonen i eksemplet nedenfor definerer en fast parameterx
og en valgfri parametery
:[ 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 ]
Antall argumenter som angis når en funksjon aktiveres, må være kompatibelt med parameterlisten. Kompatibiliteten til et sett med argumenter A
for en funksjon F
beregnes på følgende måte:
La verdien N representere antall argumenter
A
som er konstruert fra argumentlisten. Eksempel: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
La verdien obligatorisk representere antall faste parametere
F
for og Valgfritt antall valgfrie parametere forF
. Eksempel:() // Required = 0, Optional = 0 (x) // Required = 1, Optional = 0 (optional x) // Required = 0, Optional = 1 (x, optional y) // Required = 1, Optional = 1
Argumenter
A
er kompatible med funksjonenF
hvis følgende er sant:- (N >= Fast) og (N <= (fast + valgfritt))
- Argumenttypene er kompatible med
F
tilsvarende parametertyper
Hvis funksjonen har en deklarert returtype, er resultatverdien for brødteksten i funksjonen
F
kompatibel medF
returtypen hvis følgende er sann:- Verdien som gis ved å evaluere funksjonsteksten med de angitte argumentene for funksjonsparameterne, har en type som er kompatibel med returtypen.
Hvis funksjonsteksten gir en verdi som ikke er kompatibel med funksjonens returtype, utløses en feil med årsakskode
"Expression.Error"
.
Hvis du vil skrive en funksjonsverdi som er rekursiv, er det nødvendig å bruke omfangsoperatoren (@
) til å referere til funksjonen innenfor omfanget. Følgende post inneholder for eksempel et felt som definerer Factorial
funksjonen, og et annet felt som aktiverer den:
[
Factorial = (x) =>
if x = 0 then 1 else x * @Factorial(x - 1),
Result = Factorial(3) // 6
]
På samme måte kan gjensidig rekursive funksjoner skrives så lenge hver funksjon som må åpnes, har et navn. I eksemplet nedenfor har en del av Factorial
funksjonen blitt refaktorert til en annen Factorial2
funksjon.
[
Factorial = (x) => if x = 0 then 1 else Factorial2(x),
Factorial2 = (x) => x * Factorial(x - 1),
Result = Factorial(3) // 6
]
En funksjon kan returnere en annen funksjon som en verdi. Denne funksjonen kan i sin tur avhenge av én eller flere parametere til den opprinnelige funksjonen. I eksemplet nedenfor returnerer funksjonen som er knyttet til feltet MyFunction
, en funksjon som returnerer parameteren som er angitt til den:
[
MyFunction = (x) => () => x,
MyFunction1 = MyFunction(1),
MyFunction2 = MyFunction(2),
Result = MyFunction1() + MyFunction2() // 3
]
Hver gang funksjonen aktiveres, returneres en ny funksjonsverdi som opprettholder verdien for parameteren, slik at parameterverdien returneres når den aktiveres.
I tillegg til parametere kan funksjonsteksten i et funksjonsuttrykk referere til variabler som finnes i miljøet når funksjonen initialiseres. Funksjonen som er definert av feltet MyFunction
, får for eksempel tilgang til feltet C
i den omsluttende posten A
:
[
A =
[
MyFunction = () => C,
C = 1
],
B = A[MyFunction]() // 1
]
Når MyFunction
den aktiveres, får den tilgang til verdien for variabelen C
, selv om den aktiveres fra et miljø (B
) som ikke inneholder en variabel C
.
Hvert uttrykk er en syntaktisk shorthand for deklarering av uskrevne funksjoner som tar én enkelt parameter med navnet _
(understrekingstegn).
hvert uttrykk:
each
hver-uttrykk-brødtekst
hver uttrykkstekst:
funksjon-brødtekst
Forenklede deklarasjoner brukes vanligvis til å forbedre lesbarheten av funksjonsaktivering med høyere rekkefølge.
Følgende deklarasjonspar er for eksempel semantisk like:
each _ + 1
(_) => _ + 1
each [A]
(_) => _[A]
Table.SelectRows( aTable, each [Weight] > 12 )
Table.SelectRows( aTable, (_) => _[Weight] > 12 )