Funktioner

Artikel
08/27/2023

En funktion er en værdi, der repræsenterer en tilknytning fra et sæt argumentværdier til en enkelt værdi. En funktion aktiveres ved at angive et sæt inputværdier (argumentværdierne) og opretter en enkelt outputværdi (returværdien).

Skrivefunktioner

Funktioner skrives ved hjælp af et funktionsudtryk:

function-expression:
      (parameter-list_opt)function-return-type_opt=>function-body
function-body:
      Udtryk
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:
      Identifikator
parameter-type:
      assertion
function-return-type:
      assertion
Påstand:
      asnullable-primiitve-type
optional-parameter-list:
      optional-parameter
      optional-parameter,optional-parameter-list
optional-parameter:
      optionalParameter
nullable-primitve-type
      nullable_optprimitive-type

Følgende er et eksempel på en funktion, der kræver nøjagtigt to værdier x og og yog resulterer i anvendelse af operatoren + på disse værdier. xy og er parametre, der er en del af parameterlisten for funktionen, og x + y er function-body:

(x, y) => x + y

Resultatet af evalueringen af et function-expression er at oprette en funktionsværdi (ikke for at evaluere function-body). Som en konvention i dette dokument vises funktionsværdier (i modsætning til funktionsudtryk) med parameterlisten , men med en ellipse (...) i stedet for funktionsteksten. Når funktionsudtrykket ovenfor f.eks. er blevet evalueret, vises det som følgende funktionsværdi:

 (x, y) => ...

Følgende operatorer er defineret for funktionsværdier:

Operator	Resultat
`x = y`	Lig med
`x <> y`	Ikke lig med

Den oprindelige type funktionsværdier er en brugerdefineret funktionstype (afledt af den indbyggede type function), der viser parameternavnene og angiver alle parametertyper og returtypen, der skal være any. (Gå til Funktionstyper for at få flere oplysninger om funktionstyper.)

Aktivering af funktioner

Function-body for en funktion udføres ved at aktivere funktionsværdien ved hjælp af et invoke-expression. Aktivering af en funktionsværdi betyder, at funktionsværdiens funktionsbrødtekst evalueres, og at der returneres en værdi, eller at der udløses en fejl.

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

Hver gang en funktionsværdi aktiveres, angives et værdisæt som en argumentliste, der kaldes argumenterne til funktionen.

En argument-list bruges til at angive et fast antal argumenter direkte som en liste over udtryk. I følgende eksempel defineres en post med en funktionsværdi i et felt, og funktionen aktiveres derefter fra et andet felt i posten:

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

Følgende gælder ved aktivering af en funktion:

Det miljø, der bruges til at evaluere funktionens funktionsbrødtekst , indeholder en variabel, der svarer til hver parameter, med det samme navn som parameteren. Værdien af hver parameter svarer til en værdi, der er oprettet ud fra argument-list for invoke-expression, som defineret i Parametre.
Alle de udtryk, der svarer til funktionsargumenterne, evalueres, før funktionens brødtekst evalueres.
Fejl, der udløses ved evaluering af udtrykkene på udtrykslisten eller funktionsteksten , overføres.
Antallet af argumenter, der oprettes fra argumentlisten , skal være kompatible med parametrene for funktionen, eller der udløses en fejl med årsagskoden "Expression.Error". Processen til bestemmelse af kompatibilitet er defineret i Parametre.

Parametre

Der er to typer parametre, der kan være til stede på en parameterliste:

En påkrævet parameter angiver, at et argument, der svarer til parameteren, altid skal angives, når en funktion aktiveres. Obligatoriske parametre skal angives først på parameterlisten. Funktionen i følgende eksempel definerer påkrævede parametre x og y:
```
  [ 
      MyFunction = (x, y) => x + y, 

      Result1 = MyFunction(1, 1),     // 2 
      Result2 = MyFunction(2, 2)      // 4
  ] 
```
En valgfri parameter angiver, at et argument, der svarer til parameteren, kan angives, når en funktion aktiveres, men ikke er påkrævet. Hvis der ikke er angivet et argument, der svarer til en valgfri parameter, når funktionen aktiveres, bruges værdien null i stedet. Valgfrie parametre skal vises efter eventuelle påkrævede parametre på en parameterliste. Funktionen i følgende eksempel definerer en fast parameter x og en valgfri 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
  ] 
```

Antallet af argumenter, der angives, når en funktion aktiveres, skal være kompatibel med parameterlisten. Kompatibiliteten af et sæt argumenter A for en funktion F beregnes på følgende måde:

Lad værdien N repræsentere antallet af argumenter A , der er oprettet fra argumentlisten. Eksempler:

  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

Lad værdien Required repræsentere antallet af faste parametre for F og Optional antallet af valgfri parametre for F. Eksempler:

()               // 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 funktionen F , hvis følgende er sandt:
- (N >= Fixed) og (N <= (Fixed + Optional))
- Argumenttyperne er kompatible med F's tilsvarende parametertyper
Hvis funktionen har en erklæret returtype, er resultatværdien af funktionens F brødtekst kompatibel med F's returtype, hvis følgende er sand:
- Den værdi, der returneres ved at evaluere funktionsteksten med de angivne argumenter for funktionsparametrene, har en type, der er kompatibel med returtypen.
Hvis funktionens brødtekst giver en værdi, der ikke er kompatibel med funktionens returtype, udløses der en fejl med årsagskoden "Expression.Error" .

Rekursive funktioner

Hvis du vil skrive en funktionsværdi, der er rekursiv, er det nødvendigt at bruge områdeoperatoren (@) til at referere til funktionen inden for dens område. Følgende post indeholder f.eks. et felt, der definerer funktionen Factorial , og et andet felt, der aktiverer den:

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

På samme måde kan gensidigt rekursive funktioner skrives, så længe hver funktion, der skal tilgås, har et navn. I følgende eksempel er en del af funktionen Factorial blevet omstruktureret til en anden Factorial2 funktion.

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

Lukninger

En funktion kan returnere en anden funktion som en værdi. Denne funktion kan igen afhænge af en eller flere parametre til den oprindelige funktion. I følgende eksempel returnerer den funktion, der er knyttet til feltet MyFunction , en funktion, der returnerer den parameter, der er angivet for den:

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

Hver gang funktionen aktiveres, returneres der en ny funktionsværdi, der vedligeholder parameterens værdi, så parameterværdien returneres, når den aktiveres.

Funktioner og miljøer

Ud over parametre kan function-body for et function-expression referere til variabler, der findes i miljøet, når funktionen initialiseres. Den funktion, der er defineret af feltet MyFunction , får f.eks. adgang til feltet C for den omsluttende post A:

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

Når MyFunction aktiveres, får den adgang til værdien af variablen C, selvom den aktiveres fra et miljø (B), der ikke indeholder en variabel C.

Forenklede erklæringer

Each-expression er en syntaktisk oversigt over erklæring af ikke-indtastede funktioner, der tager en enkelt parameter med navnet _ (understregningstegn).

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

Forenklede erklæringer bruges ofte til at forbedre læsbarheden af aktivering af funktioner i højere rækkefølge.

Følgende erklæringspar svarer f.eks. semantisk til hinanden:

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