Funksjoner

Artikkel
08/27/2023

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).

Skrivefunksjoner

Funksjoner skrives ved hjelp av et funksjonsuttrykk:

funksjon-uttrykk:
      (parameter-list_opt)function-return-type_opt=>function-body
funksjonstekst:
      Uttrykk
parameterliste:
      fast-parameter-liste
      fast-parameter-liste,valgfritt-parameter-liste
      valgfri parameterliste
fast-parameter-liste:
      parameter
      parameter,fast-parameter-liste
Parameteren:
      parameternavnparametertype
parameternavn:
      identifikator
parametertype:
      assertion
funksjon-retur-type:
      assertion
Påstand:
      asnullable-primiitve-type
valgfri parameterliste:
      valgfri parameter
      valgfri parameter,valgfri parameterliste
valgfri parameter:
      optionalParameteren
nullable-primitve-type
      nullable_optprimitive-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	Result
`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.)

Aktivere funksjoner

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.

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 og y:
```
  [ 
      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 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
  ] 
```

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 for F. 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 funksjonen F hvis følgende er sant:
- (N >= Fast) og (N <= (fast + valgfritt))
- Argumenttypene er kompatible med Ftilsvarende parametertyper
Hvis funksjonen har en deklarert returtype, er resultatverdien for brødteksten i funksjonen F kompatibel med Freturtypen 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" .

Rekursive funksjoner

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 
]

Nedleggelser

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.

Funksjoner og miljøer

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.

Forenklede deklarasjoner

Hvert uttrykk er en syntaktisk shorthand for deklarering av uskrevne funksjoner som tar én enkelt parameter med navnet _ (understrekingstegn).

hvert uttrykk:
eachhver-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 )

Share via