Funkcie

Článok
10/05/2023

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 písania

Funkcie sa píšu pomocou výrazu function-expression:

function-expression:
      (parameter-list_opt)function-return-type_opt=>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-type_opt
parameter-name:
      identifikátor
parameter-type:
      assertion
function-return-type:
      assertion
Tvrdenie:
      asnullable-primiitve-type
optional-parameter-list:
      optional-parameter
      optional-parameter,optional-parameter-list
optional-parameter:
      optionalParameter
nullable-primitve-type
      nullable_optprimitive-type

Nasleduje príklad funkcie, ktorá vyžaduje presne dve hodnoty x a ya 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:yx

(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	Výsledok
`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í.)

Vyvolávanie funkcií

Telo funkcie function-body sa vykoná vyvolanímhodnoty 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-list_opt)
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.

Parametre

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 a y:
```
  [ 
      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ý parameter x a voliteľný parameter 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
  ] 
```

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 parametrov F. 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 funkciou F , ak sú pravdivé nasledujúce podmienky:
- (N >= Pevné) a (N <= (Pevné + Voliteľné))
- Typy argumentov sú kompatibilné so Fzodpovedajúcimi typmi parametrov
Ak má funkcia deklarovaný vrátený typ, hodnota výsledku tela funkcie F je kompatibilná s vráteným typom F, 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 .

Rekurzívne funkcie

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 
]

Uzávery

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.

Funkcie a prostredia

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.

Zjednodušené deklarácie

Výraz each-expression je syntaktická skratka na deklarovanie netypových funkcií s jedným parametrom s názvom _ (podčiarkovník).

each-expression:
eacheach-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 )