Functies

Artikel
08/27/2023

Een functie is een waarde die een toewijzing van een set argumentwaarden aan één waarde vertegenwoordigt. Een functie wordt aangeroepen door een set invoerwaarden (de argumentwaarden) en produceert één uitvoerwaarde (de retourwaarde).

Functies schrijven

Functies worden geschreven met behulp van een functie-expressie:

function-expression:
      (parameter-list_opt)function-return-type_opt=>function-body
functietekst:
      Expressie
parameterlijst:
      fixed-parameter-list
      fixed-parameter-list,optional-parameter-list
      optional-parameter-list
fixed-parameter-list:
      parameter
      parameter,fixed-parameter-list
Parameter:
      parameter-naam parameter-type_opt
parameternaam:
      id
parametertype:
      assertion
function-return-type:
      assertion
Bewering:
      asnullable-primiitve-type
optioneel-parameterlijst:
      optioneel-parameter
      optional-parameter,optional-parameter-list
optioneel-parameter:
      optionalParameter
nullable-primitve-type
      nullable_optprimitive-type

Hier volgt een voorbeeld van een functie waarvoor precies twee waarden x zijn vereist en ydie het resultaat produceert van het toepassen van de + operator op die waarden. De x parameters die y deel uitmaken van de parameterlijst van de functie en de functie is de hoofdtekst van de x + yfunctie:

(x, y) => x + y

Het resultaat van het evalueren van een functie-expressie is het produceren van een functiewaarde (niet om de functietekst te evalueren). Als conventie in dit document worden functiewaarden (in plaats van functie-expressies) weergegeven met de parameterlijst, maar met een beletselteken (...) in plaats van de hoofdtekst van de functie. Zodra de bovenstaande functie-expressie is geëvalueerd, wordt deze bijvoorbeeld weergegeven als de volgende functiewaarde:

 (x, y) => ...

De volgende operators zijn gedefinieerd voor functiewaarden:

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

Het systeemeigen type functiewaarden is een aangepast functietype (afgeleid van het intrinsieke type function) waarin de parameternamen worden vermeld en alle parametertypen en het retourtype worden anyopgegeven. (Ga naar Functietypen voor meer informatie over functietypen.)

Aanroepen van functies

De functietekst van een functie wordt uitgevoerd door de functiewaarde aan te roepen met behulp van een invoke-expression. Het aanroepen van een functiewaarde betekent dat de functietekst van de functiewaarde wordt geëvalueerd en dat er een waarde wordt geretourneerd of dat er een fout optreedt.

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

Telkens wanneer een functiewaarde wordt aangeroepen, wordt een set waarden opgegeven als een argumentenlijst, de argumenten aan de functie genoemd.

Een argumentlijst wordt gebruikt om een vast aantal argumenten rechtstreeks op te geven als een lijst met expressies. In het volgende voorbeeld wordt een record met een functiewaarde in een veld gedefinieerd en wordt de functie vervolgens aangeroepen vanuit een ander veld van de record:

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

Het volgende geldt voor het aanroepen van een functie:

De omgeving die wordt gebruikt om de functietekst van de functie van de functie te evalueren, bevat een variabele die overeenkomt met elke parameter, met dezelfde naam als de parameter. De waarde van elke parameter komt overeen met een waarde die is samengesteld uit de argumentenlijst van de aanroepexpressie, zoals gedefinieerd in Parameters.
Alle expressies die overeenkomen met de functieargumenten worden geëvalueerd voordat de hoofdtekst van de functie wordt geëvalueerd.
Fouten die optreden bij het evalueren van de expressies in de expressielijst of de functietekst worden doorgegeven.
Het aantal argumenten dat is samengesteld op basis van de argumentenlijst , moet compatibel zijn met de parameters van de functie, of er wordt een fout gegenereerd met redencode "Expression.Error". Het proces voor het bepalen van de compatibiliteit wordt gedefinieerd in Parameters.

Parameters

Er zijn twee soorten parameters die mogelijk aanwezig zijn in een parameterlijst:

Een vereiste parameter geeft aan dat een argument dat overeenkomt met de parameter altijd moet worden opgegeven wanneer een functie wordt aangeroepen. Vereiste parameters moeten eerst worden opgegeven in de parameterlijst. De functie in het volgende voorbeeld definieert vereiste parameters x en y:
```
  [ 
      MyFunction = (x, y) => x + y, 

      Result1 = MyFunction(1, 1),     // 2 
      Result2 = MyFunction(2, 2)      // 4
  ] 
```
Een optionele parameter geeft aan dat een argument dat overeenkomt met de parameter kan worden opgegeven wanneer een functie wordt aangeroepen, maar niet vereist is om te worden opgegeven. Als een argument dat overeenkomt met een optionele parameter niet wordt opgegeven wanneer de functie wordt aangeroepen, wordt de waarde null in plaats daarvan gebruikt. Optionele parameters moeten worden weergegeven na de vereiste parameters in een parameterlijst. De functie in het volgende voorbeeld definieert een vaste parameter x en een optionele 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
  ] 
```

Het aantal argumenten dat wordt opgegeven wanneer een functie wordt aangeroepen, moet compatibel zijn met de parameterlijst. De compatibiliteit van een set argumenten A voor een functie F wordt als volgt berekend:

Laat de waarde N het aantal argumenten A vertegenwoordigen dat is samengesteld uit de argumentenlijst. Bijvoorbeeld:

  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

Laat de waarde Vereist het aantal vaste parameters van F en Optioneel het aantal optionele parameters van F. Bijvoorbeeld:

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

Argumenten A zijn compatibel met functie F als het volgende waar is:
- (N >= vast) en (N <= (vast + optioneel))
- De argumenttypen zijn compatibel met Fde bijbehorende parametertypen
Als de functie een gedeclareerd retourtype heeft, is de resultaatwaarde van de hoofdtekst van de functie F compatibel met Fhet retourtype als het volgende waar is:
- De waarde die wordt geretourneerd door de hoofdtekst van de functie te evalueren met de opgegeven argumenten voor de functieparameters, heeft een type dat compatibel is met het retourtype.
Als de hoofdtekst van de functie een waarde oplevert die niet compatibel is met het retourtype van de functie, wordt er een fout met redencode "Expression.Error" gegenereerd.

Recursieve functies

Als u een functiewaarde wilt schrijven die recursief is, moet u de bereikoperator (@) gebruiken om te verwijzen naar de functie binnen het bereik. De volgende record bevat bijvoorbeeld een veld dat de Factorial functie definieert en een ander veld waarmee deze wordt aangeroepen:

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

Op dezelfde manier kunnen wederzijds recursieve functies worden geschreven zolang elke functie die moet worden geopend een naam heeft. In het volgende voorbeeld is een deel van de Factorial functie geherstructureerd in een tweede Factorial2 functie.

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

Sluitingen

Een functie kan een andere functie retourneren als een waarde. Deze functie kan op zijn beurt afhankelijk zijn van een of meer parameters voor de oorspronkelijke functie. In het volgende voorbeeld retourneert de functie die is gekoppeld aan het veld MyFunction een functie die de opgegeven parameter retourneert:

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

Telkens wanneer de functie wordt aangeroepen, wordt een nieuwe functiewaarde geretourneerd die de waarde van de parameter onderhoudt, zodat de parameterwaarde wordt geretourneerd wanneer deze wordt aangeroepen.

Functies en omgevingen

Naast parameters kan de functietekst van een functie-expressie verwijzen naar variabelen die aanwezig zijn in de omgeving wanneer de functie wordt geïnitialiseerd. De functie die door het veld MyFunction is gedefinieerd, heeft bijvoorbeeld toegang tot het veld C van de omsluitrecord A:

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

Wanneer MyFunction deze wordt aangeroepen, krijgt deze toegang tot de waarde van de variabele C, ook al wordt deze aangeroepen vanuit een omgeving (B) die geen variabele Cbevat.

Vereenvoudigde declaraties

De elke expressie is een syntactische afkorting voor het declareren van niet-getypte functies met één parameter met de naam _ (onderstrepingsteken).

elke expressie:
eachelke expressie-hoofdtekst
elke expressie-hoofdtekst:
functietekst

Vereenvoudigde declaraties worden vaak gebruikt om de leesbaarheid van functieaanroepen in hogere volgorde te verbeteren.

De volgende paren declaraties zijn bijvoorbeeld semantisch gelijkwaardig:

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

Share via