Funkcie
Funkcia je hodnota, ktorá predstavuje mapovanie z množiny hodnôt argumentu na jednu hodnotu. Funkcia sa vyvolá zadaním množiny vstupných hodnôt (hodnoty argumentu) a vytvorí jednu výstupnú hodnotu (vrátená hodnota).
Funkcie sa píšu pomocou výrazu function-expression:
function-expression:
(
parameter-listopt)
function-return-typeopt=>
function-body
function-body:
výraz
parameter-list:
fixed-parameter-list
fixed-parameter-list ,
optional-parameter-list
optional-parameter-list
fixed-parameter-list:
parameter
parameter ,
fixed-parameter-list
parameter:
parameter-name parameter-typeopt
parameter-name:
identifikátor
parameter-type:
assertion
function-return-type:
assertion
tvrdenie:
as
nullable-primiitve-type
optional-parameter-list:
optional-parameter
optional-parameter ,
optional-parameter-list
optional-parameter:
optional
parameter
nullable-primitve-type
nullable
opt primitive-type
Nasleduje príklad funkcie, ktorá vyžaduje presne dve hodnoty x
a y
a výsledkom je použitie +
operátora na tieto hodnoty. a sú parametre, ktoré sú súčasťou zoznamu parameter-list tejto funkcie, a x + y
je telo funkcie function-body: y
x
(x, y) => x + y
Výsledkom vyhodnocovania výrazu function-expression je vytvoriť hodnotu funkcie (nie vyhodnotiť telo funkcie function-body). Ako konvenciu v tomto dokumente sú hodnoty funkcie (na rozdiel od výrazov funkcie) zobrazené so zoznamom parameter-list , ale s tromi bodkami (...
) namiesto tela funkcie function-body. Keď sa napríklad vyhodnotí vyššie uvedený výraz funkcie, zobrazí sa ako nasledujúca hodnota funkcie:
(x, y) => ...
Pre hodnoty funkcie sú definované nasledujúce operátory:
Operátor | Result |
---|---|
x = y |
Equal |
x <> y |
Nerovná sa |
Natívny typ hodnôt funkcie je vlastný typ funkcie (odvodený od vnútorného typu function
), ktorý uvádza názvy parametrov a určuje, že všetky typy parametrov a vrátený typ majú byť any
. (Prejdite na lokalitu Typy funkcií , kde nájdete podrobnosti o typoch funkcií.)
Telo funkcie function-body sa vykoná vyvolaním hodnoty funkcie pomocou výrazu invoke-expression. Vyvolanie hodnoty funkcie znamená, že telo funkcie function-body hodnoty funkcie sa vyhodnotí a vráti sa hodnota alebo sa vyvolá chyba.
invoke-expression:
primary-expression (
argument-listopt )
argument-list:
expression-list
Pri každom vyvolaní hodnoty funkcie sa množina hodnôt zadá ako zoznam argument-list nazývaný argumenty funkcie.
Zoznam argument-list sa používa na určenie pevného počtu argumentov priamo ako zoznamu výrazov. Nasledujúci príklad definuje záznam s hodnotou funkcie v poli a potom vyvolá funkciu z iného poľa záznamu:
[
MyFunction = (x, y, z) => x + y + z,
Result1 = MyFunction(1, 2, 3) // 6
]
Pri vyvolaní funkcie platí:
Prostredie používané na vyhodnocovanie tela funkcie function-body obsahuje premennú, ktorá zodpovedá každému parametru, s rovnakým názvom ako tento parameter. Hodnota každého parametra zodpovedá hodnote vytvorenej zo zoznamu argument-list výrazu invoke-expression, ako je definované v parametroch.
Všetky výrazy zodpovedajúce argumentom funkcie sa vyhodnotia pred vyhodnotením tela funkcie function-body .
Chyby vzniknuté pri vyhodnocovaní výrazov v zozname expression-list alebo tele funkcie function-body sa rozšíria.
Počet argumentov vytvorených zo zoznamu argument-list musí byť kompatibilný s parametrami funkcie, inak sa vyskytne chyba s kódom
"Expression.Error"
príčiny . Proces zisťovania kompatibility je definovaný v parametroch.
Existujú dva druhy parametrov, ktoré sa môžu nachádzať v zozname parametrov:
Povinný parameter označuje, že pri vyvolaní funkcie musí vždy byť zadaný argument zodpovedajúci parametru. Povinné parametre musia byť v zozname parametrov zadané ako prvé. Funkcia v nasledujúcom príklade definuje povinné parametre
x
ay
:[ MyFunction = (x, y) => x + y, Result1 = MyFunction(1, 1), // 2 Result2 = MyFunction(2, 2) // 4 ]
Voliteľný parameter označuje, že pri vyvolaní funkcie môže byť zadaný argument zodpovedajúci parametru, ale jeho zadania sa nevyžaduje. Ak argument, ktorý zodpovedá voliteľnému parametru, nie je zadaný pri vyvolaní funkcie, namiesto toho použije sa hodnota
null
. Voliteľné parametre sa musia v zozname parametrov uviesť po všetkých povinných parametroch. Funkcia v nasledujúcom príklade definuje pevný parameterx
a voliteľný 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 ]
Počet argumentov, ktoré sú zadané pri vyvolaní funkcie, musí byť kompatibilný so zoznamom parametrov. Kompatibilita množiny argumentov A
pre funkciu F
sa vypočíta takto:
Nech hodnota N predstavuje počet argumentov vytvorených
A
zo zoznamu argument-list. Napríklad: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
Nech hodnota Povinné predstavuje počet pevných parametrov
F
a Voliteľné počet voliteľných parametrovF
. Napríklad:() // Required = 0, Optional = 0 (x) // Required = 1, Optional = 0 (optional x) // Required = 0, Optional = 1 (x, optional y) // Required = 1, Optional = 1
Argumenty
A
sú kompatibilné s funkciouF
, ak sú pravdivé nasledujúce podmienky:- (N >= Pevné) a (N <= (Pevné + Voliteľné))
- Typy argumentov sú kompatibilné so
F
zodpovedajúcimi typmi parametrov
Ak má funkcia deklarovaný vrátený typ, hodnota výsledku tela funkcie
F
je kompatibilná s vráteným typomF
, ak je pravdivá nasledujúca podmienka:- Hodnota získaná vyhodnotením tela funkcie so zadanými argumentmi pre parametre funkcie má typ, ktorý je kompatibilný s vráteným typom.
Ak telo funkcie vráti hodnotu nekompatibilnú s vráteným typom funkcie, vyvolá sa chyba s kódom
"Expression.Error"
príčiny .
Ak chcete napísať hodnotu funkcie, ktorá je rekurzívna, je potrebné použiť operátor rozsahu (@
) na odkázanie na funkciu v rámci jej rozsahu. Nasledujúci záznam napríklad obsahuje pole, ktoré definuje Factorial
funkciu, a ďalšie pole, ktoré ju vyvolá:
[
Factorial = (x) =>
if x = 0 then 1 else x * @Factorial(x - 1),
Result = Factorial(3) // 6
]
Podobne je možné zapísať aj vzájomne rekurzívne funkcie, pokiaľ každá funkcia, ku ktorej je potrebný prístup, má názov. V nasledujúcom príklade bola časť Factorial
funkcie opätovne spracovaná do druhej Factorial2
funkcie.
[
Factorial = (x) => if x = 0 then 1 else Factorial2(x),
Factorial2 = (x) => x * Factorial(x - 1),
Result = Factorial(3) // 6
]
Funkcia môže ako hodnotu vrátiť inú funkciu. Táto funkcia môže zasa závisieť od jedného alebo viacerých parametrov pre pôvodnú funkciu. V nasledujúcom príklade funkcia priradená k poľu MyFunction
vráti funkciu, ktorá vráti jeho zadaný parameter:
[
MyFunction = (x) => () => x,
MyFunction1 = MyFunction(1),
MyFunction2 = MyFunction(2),
Result = MyFunction1() + MyFunction2() // 3
]
Pri každom vyvolaní funkcie sa vráti nová hodnota funkcie, ktorá zachová hodnotu parametra, takže pri jej vyvolaní sa vráti hodnota parametra.
Okrem parametrov môže aj telo funkcie function-body výrazu function-expression odkazovať na premenné, ktoré sa nachádzajú v prostredí pri inicializácii funkcie. Napríklad funkcia definovaná poľom MyFunction
pristupuje k poľu C
uzavretého záznamu A
:
[
A =
[
MyFunction = () => C,
C = 1
],
B = A[MyFunction]() // 1
]
Keď MyFunction
sa vyvolá , vykoná prístup k hodnote premennej C
, aj keď sa vyvoláva z prostredia (B
), ktoré neobsahuje premennú C
.
Výraz each-expression je syntaktická skratka na deklarovanie netypových funkcií s jedným parametrom s názvom _
(podčiarkovník).
each-expression:
each
each-expression-body
each-expression-body:
function-body
Zjednodušené deklarácie sa bežne používajú na zlepšenie čitateľnosti vyvolania funkcie s vyšším poradím.
Napríklad nasledujúce dvojice deklarácií sú sémanticky rovnocenné:
each _ + 1
(_) => _ + 1
each [A]
(_) => _[A]
Table.SelectRows( aTable, each [Weight] > 12 )
Table.SelectRows( aTable, (_) => _[Weight] > 12 )