Lue englanniksi

Jaa


Tyypit

Tyypin arvo on arvo, joka luokittelee muut arvot. Arvo, joka luokitellaan tyypin mukaan, noudattaa tätä tyyppiä. M-tyyppijärjestelmä koostuu seuraavanlaisista tyypeistä:

  • Primitiivityypit, jotka luokittelevat primitiiviset arvot (binary, date, datetime, datetimezone, duration, , list, logical, , null, numberrecord, text, timetype) ja sisältävät myös joukon abstrakteja tyyppejä (function, , tableanyanynonnullja )none

  • Tietuetyypit, jotka luokittelevat tietuearvot kenttien nimien ja arvotyyppien perusteella

  • Luettelotyypit, jotka luokittelevat luetteloita käyttäen yksittäistä kohteen perustyyppiä

  • Funktiotyypit, jotka luokittelevat funktioiden arvot parametrien tyyppien ja palautusarvojen perusteella

  • Taulukkotyypit, jotka luokittelevat taulukon arvot sarakkeiden nimien, saraketyyppien ja avainten perusteella

  • Tyhjäarvoiset tyypit, jotka luokittelevat arvon tyhjäarvoksi kaikkien perustyypin luokittelemien arvojen lisäksi

  • Tyyppityypit, jotka luokittelevat arvot, jotka ovat tyyppejä

Sarja primitiivityyppejä sisältää primitiiviarvojen tyypit ja joukon abstrakteja tyyppejä, jotka ovat tyyppejä, jotka eivät luokittele arvoja yksilöllisesti: function, table, anyanynonnull ja none. Kaikki funktioiden arvot ovat abstraktin tyypin functionmukaisia, kaikki taulukon arvot vastaavat abstraktia tyyppiä table, kaikki arvot vastaavat abstraktia tyyppiä any, kaikki muut kuin tyhjäarvot vastaavat abstraktia tyyppiä anynonnulleikä mikään arvo vastaa abstraktia tyyppiä none. Tyyppiä olevan lausekkeen none täytyy aiheuttaa virhe, tai se ei voi päättyä, koska tyypin nonemukaista arvoa ei voitu tuottaa. Ota huomioon, että primitiivityypit function ja table ovat abstrakteja, koska mikään funktio tai taulukko ei ole suoraan kyseisistä tyypeistä. Primitiivityypit record ja list ovat ei-abstrakteja, koska ne edustavat avointa tietuetta, jolla ei ole määritettyjä kenttiä eikä mitään tyyppiluetteloa.

Kaikkia tyyppejä, jotka eivät ole primitiivityyppien suljettujen joukon jäseniä ja niiden tyhjäarvoja tukevia vastapuolia, kutsutaan yhteisesti mukautetuiksi tyypeiksi. Mukautettuja tyyppejä voi kirjoittaa käyttämällä type-expression:

type-expression:
      primary-expression

       type primary-type
tyyppi:
      primary-expression
      primary-type
primary-type:
      primitive-type
      record-type
      list-type
      function-type
      table-type
      nullable-type
primitive-type:
joku seuraavista
      any anynonnull binary date datetime datetimezone duration function list logical
      none null number record table text time type

primitive-type-nimet ovat kontekstuaalisia avainsanoja, jotka tunnistetaan vain tyypin kontekstissa. Sulkeiden käyttö tyypin kontekstissa siirtää kieliopin takaisin säännönmukaiseen lausekekontekstiin, joka edellyttää tyyppiavainsanan käyttämistä takaisin tyyppikontekstiin siirtymiseksi. Jos esimerkiksi haluat käynnistää funktion tyypin kontekstissa, sulkeita voidaan käyttää:

type nullable ( Type.ForList({type number}) )   
// type nullable {number}

Sulkeiden avulla voidaan myös käyttää muuttujaa, jonka nimi on ristiriidassa primitive-type-nimen kanssa:

let  record = type [ A = any ]  in  type {(record)} 
// type {[ A = any ]}

Seuraavassa esimerkissä määritetään tyyppi, joka luokittelee lukuluettelon:

type { number }

Myös seuraava esimerkki määrittää mukautetun tyypin, joka luokittelee tietueet, joissa on pakollisia kenttiä nimeltään X ja Y joiden arvot ovat lukuja:

type [ X = number, Y = number ]

Arvon määritetty tyyppi saadaan käyttämällä vakiokirjastofunktiota Value.Type, kuten seuraavissa esimerkeissä esitetään:

Value.Type( 2 )                 // type number 
Value.Type( {2} )               // type list 
Value.Type( [ X = 1, Y = 2 ] )  // type record

operaattoria is käytetään määrittämään, onko arvon tyyppi yhteensopiva määritetyn tyypin kanssa, kuten seuraavissa esimerkeissä esitetään:

1 is number          // true 
1 is text            // false 
{2} is list          // true

Operaattori as tarkistaa, onko arvo yhteensopiva määritetyn tyypin kanssa, ja aiheuttaa virheen, jos se ei ole. Muussa tapauksessa se palauttaa alkuperäisen arvon.

Value.Type( 1 as number )   // type number 
{2} as text                 // error, type mismatch

Huomioi, että is ja as operaattorit hyväksyvät vain tyhjäarvoja tukevia primitiivityyppejä oikeaksi operandiksi. M ei tarjoa keinoja tarkistaa arvoja mukautettujen tyyppien vastaavuuden osalta.

Tyyppi on yhteensopiva tyypin kanssa, jos ja vain, jos kaikki arvot, jotka ovat X mukaisia, ovat myös mukaisia.YXY Kaikki tyypit ovat yhteensopivia tyypin any kanssa, joten mitkään tyypit (paitsi none itse) eivät ole yhteensopivia tyypin nonekanssa. Seuraavassa kaaviossa näytetään yhteensopivuussuhde. (Tyypin yhteensopivuus on refleksiivinen ja transitiivinen. Se muodostaa säleikön tyypin any kanssa ylimmäksi ja tyyppi none alimmaksi arvoksi.) Abstraktien tyyppien nimet on määritetty kursivoituina.

Tyypin yhteensopivuus

Seuraavat operaattorit on määritetty tyyppiarvoille:

Operaattori Result
x = y Equal
x <> y Not equal
x ?? y Coalesce

Tyyppiarvojen alkuperäinen tyyppi on perustyyppi type.

Primitiivityypit

M-kielen tyypit muodostavat epäyhtäisen hierarkian, jonka juurena on tyyppi any, joka on tyyppi, joka luokittelee kaikki arvot. Mikä tahansa M-arvo noudattaa täsmälleen yhtä primitiivistä alityyppiä any. Tyypistä any johdettujen primitiivityyppien suljetut sarjat ovat seuraavat:

  • type null, joka luokittelee tyhjäarvon.
  • type logical, joka luokittelee arvot tosi ja epätosi.
  • type number, joka luokittelee lukuarvot.
  • type time, joka luokittelee aika-arvot.
  • type date, joka luokittelee päivämääräarvot.
  • type datetime, joka luokittelee päivämäärä- ja aika-arvot.
  • type datetimezone, joka luokittelee päivämäärä- ja aikavyöhykearvot.
  • type duration, joka luokittelee kestoarvot.
  • type text, joka luokittelee tekstiarvot.
  • type binary, joka luokittelee binaariarvot.
  • type type, joka luokittelee tyyppiarvot.
  • type list, joka luokittelee luetteloarvot.
  • type record, joka luokittelee tietuearvot.
  • type table, joka luokittelee taulukkoarvot.
  • type function, joka luokittelee funktioarvot.
  • type anynonnull, joka luokittelee kaikki arvot paitsi tyhjäarvoa.
  • type none, joka ei luokittele arvoja.

Mikä tahansa tyyppi

Tyyppi any on abstrakti, luokittelee kaikki M-arvot, ja kaikki M-tyypit ovat yhteensopivia :n kanssa any. Tyyppiä any olevan muuttujan voi sitoa kaikkiin mahdollisiin arvoihin. Koska any on abstrakti, sen arvot eivät voi olla eli mikään arvo ei ole suoraan tyyppiä any.

Luettelotyypit

Mikä tahansa arvo, joka on luettelo, on sisäisen tyypin listmukainen, mikä ei aseta mitään rajoituksia luetteloarvon kohteille.

list-type:
       { item-type}
item-type:
      tyyppi

list-type-tyypin arvioinnin list

Seuraavissa esimerkeissä havainnollistetaan yhdenmukaisten luettelotyyppien määrittämissyntaksi:

type { number }        // list of numbers type 
     { record }        // list of records type
     {{ text }}        // list of lists of text values

Arvo on yhdenmukainen luettelotyypin kanssa, jos arvo on luettelo ja jokainen kyseisen luetteloarvon kohde vastaa luettelotyypin kohdetyyppiä.

Luettelotyypin kohdetyyppi ilmaisee sidoksen: kaikki vaatimustenmukaisuusluettelon kohteet ovat kohteen tyypin mukaisia.

Tietuetyypit

Mikä tahansa arvo, joka on tietue, on sisäisen tyypin mukainen tietue, mikä ei aseta mitään rajoituksia kenttien nimille tai arvoille tietueen arvossa. record-type-arvoa käytetään rajoittamaan kelvollisten nimien joukkoa sekä niiden arvojen tyyppejä, joiden sallitaan liittyvän näihin nimiin.

record-type:
       [ open-record-marker]
       [ field-specification-listopt]
       [ field-specification-list , open-record-marker]
field-specification-list:
      field-specification
      field-specification,field-specification-list
field-specification:

       optional opt field-name field-type-specificationopt
field-type-specification:

       = field-type
field-type:
      tyyppi
open-record-marker:

      ...

record-type-tyypin arvioinnin tulos on tyypin arvo, jonka perustyyppi on record.

Seuraavissa esimerkeissä havainnollistetaan tietuetyyppien määrittämissyntaksi:

type [ X = number, Y = number] 
type [ Name = text, Age = number ]
type [ Title = text, optional Description = text ] 
type [ Name = text, ... ]

Tietuetyypit on suljettu oletusarvoisesti, mikä tarkoittaa, että lisäkenttiä, joita ei ole fieldspecification-list-luettelossa, ei sallita vaatimustenmukaisuusarvoissa. Mukaan lukien openrecord-marker tietuetyypissä ilmaisee tyypin, jonka tulee olla avoin, mikä sallii kenttien olevan kenttämääritysluettelossa. Seuraavat kaksi lauseketta vastaavat toisiaan:

type record   // primitive type classifying all records 
type [ ... ]  // custom type classifying all records

Arvo on tietuetyypin mukainen, jos arvo on tietue ja jokainen kentän määritys tietuetyypissä täyttyy. Kentän määritys täyttyy, jos jokin seuraavista on tosi:

  • Tietueessa on määrityksen tunnusta vastaava kentän nimi, ja siihen liittyvä arvo on määrityksen tyypin mukainen

  • Määritys on merkitty valinnaiseksi, eikä vastaavaa kentän nimeä löydy tietueesta

Vaatimustenmukainen arvo voi sisältää kenttien nimiä, joita ei ole lueteltu kentän määritysluettelossa, jos ja vain, jos tietuetyyppi on avoin.

Funktiotyypit

Mikä tahansa funktioiden arvo vastaa primitiivityyppiä function, joka ei aseta mitään rajoituksia funktioiden muodollisten parametrien tyypeille tai funktioiden paluuarvolle. Mukautettua function-type-arvoa käytetään asettamaan tyyppirajoituksia yhteensopiviksi funktioiden arvojen allekirjoituille.

function-type:
       function ( parameter-specification-listopt)function-return-type
parameter-specification-list:
      required-parameter-specification-list
      required-parameter-specification-list
,optional-parameter-specification-list
      optional-parameter-specification-list
required-parameter-specification-list:
      required-parameter-specification
      required-parameter-specification
,required-parameter-specification-list
required-parameter-specification:
      parameter-specification
optional-parameter-specification-list:
      optional-parameter-specification
      optional-parameter-specification
,optional-parameter-specification-list
optional-parameter-specification:

       optional parameter-specification
parameter-specification:
      parameter-name parameter-type
function-return-type:
      assertion
väite:

       as nullable-primitive-type

function-type-tyypin arvioinnin tulos on tyypin arvo, jonka perustyyppi on function.

Seuraavissa esimerkeissä havainnollistetaan funktiotyyppien määrittämissyntaksi:

type function (x as text) as number 
type function (y as number, optional z as text) as any

Funktion arvo noudattaa funktion tyyppiä, jos funktion arvon palautustyyppi on yhteensopiva funktion tyypin palautustyypin kanssa ja jokainen parametrimääritys on yhteensopiva positionally-funktion vastaavan muodollisen parametrin kanssa. Parametrimääritys on yhteensopiva muodollisen parametrin kanssa, jos määritetty parameter-type-tyyppi on yhteensopiva muodollisen parametrin tyypin kanssa ja parametrimääritys on valinnainen, jos muodollinen parametri on valinnainen.

Muodolliset parametrien nimet ohitetaan määritettäessä funktiotyypin vastaavuus.

Parametrin määrittäminen valinnaisena tekee tyypistä implisiittisesti tyhjäarvon sallivan. Seuraavat luovat identtiset funktiotyypit:

type function (optional x as text) as any
type function (optional x as nullable text) as any

Taulukkotyypit

Taulukkoarvon rakennetta määritetään table-type-arvon avulla.

table-type:
       table row-type
row-type:

       [ field-specification-listopt]

table-type-tyypin arvioinnin tulos on tyypin arvo, jonka perustyyppi on table.

Taulukon rivityyppi määrittää taulukon sarakkeiden nimet ja saraketyypit suljetuksi tietuetyypeiksi. Jotta kaikki taulukon arvot olisivat tyypin tablemukaisia, sen rivityyppi on record (tyhjä avoin tietuetyyppi). Tyyppitaulukko on siis abstrakti, koska minkään taulukon arvon tyyppi tableei voi olla :n rivityyppi (mutta kaikilla taulukon arvoilla on rivityyppi, joka on yhteensopiva tyypin tablerivityypin kanssa). Seuraavassa esimerkissä näytetään taulukkotyypin rakenne:

type table [A = text, B = number, C = binary] 
// a table type with three columns named A, B, and C 
// of column types text, number, and binary, respectively

Table-type-arvo sisältää myös taulukon arvon avainten määrittelyn. Avain on sarakenimien joukko. Enintään yksi avain voidaan nimetä taulukon perusavaimeksi. (M-taulukkoavaimilla ei ole semanttista merkitystä. Ulkoisten tietolähteiden, kuten tietokantojen tai OData-syötteiden avainten määrittäminen kuitenkin tavallista taulukoiden yli. Power Query käyttää avaintietoja parantaakseen kehittyneiden toimintojen suorituskykyä, kuten ristilähdetoiminnot.)

Vakiokirjastofunktioiden Type.TableKeys, Type.AddTableKeyja Type.ReplaceTableKeys avulla voidaan hankkia taulukkotyypin avaimia, lisätä avain taulukkotyyppiin ja korvata kaikki taulukkotyypin avaimet.

Type.AddTableKey(tableType, {"A", "B"}, false) 
// add a non-primary key that combines values from columns A and B 
Type.ReplaceTableKeys(tableType, {}) 
// returns type value with all keys removed

Tyhjäarvoja sallivat tyypit

type TKaikille nolla-arvoinen variantti voidaan johtaa käyttämällä nullable-type-tyyppiä:

nullable-type:
       nullable tyyppi

Tulos on abstrakti tyyppi, joka sallii tyypin T arvot tai arvon null.

42 is nullable number             // true null is
nullable number                   // true

Merkintä type nullable T vähentää merkintään tai type. (Muista, että tyhjäarvoja sisältävät tyypit ovat abstrakteja, eikä mikään arvo voi olla suoraan abstraktia tyyppiä.)

Value.Type(42 as nullable number)       // type number
Value.Type(null as nullable number)     // type null

Vakiokirjastofunktioita Type.IsNullable ja Type.NonNullable voidaan käyttää testaamaan tyhjäarvon tyyppiä ja poistamaan tyhjäarvon tyypistä.

Seuraava pätee (mikä tahansa type T):

  • type T on yhteensopiva :n kanssa type nullable T
  • Type.NonNullable(type T) on yhteensopiva :n kanssa type T

Seuraavat ovat pareittain toisiaan vastaavia (mikä tahansa type T):

    type nullable any
    any

    Type.NonNullable(type any)
    type anynonnull

    type nullable none
    type null

    Type.NonNullable(type null)
    type none

    type nullable nullable T
    type nullable T

    Type.NonNullable(Type.NonNullable(type T))
    Type.NonNullable(type T)

    Type.NonNullable(type nullable T)
    Type.NonNullable(type T)

    type nullable (Type.NonNullable(type T))
    type nullable T

Arvon määritetty tyyppi

Arvon määritetty tyyppi on tyyppi, jonka mukaan arvo on määritetty vaatimusten mukaiseksi.

Arvolle voidaan määrittää tyyppi käyttämällä kirjastofunktiota Value.ReplaceType. Tämä funktio joko palauttaa joko uuden arvon, jolle on määritetty tyyppi, tai aiheuttaa virheilmoituksen, jos uusi tyyppi on yhteensopimaton arvon kanssa.

Kun arvo on määritetty tyypiksi, vain rajoitettu vastaavuuden tarkistus suoritetaan:

  • Määritettävän tyypin on oltava ei-abstrakti, ei-tyhjäarvoja salliva ja yhteensopiva arvon perustyypin (alkuperäisen) primitiivityypin kanssa.
  • Kun rakenteen määrittävän mukautetun tyypin on vastattava arvon rakennetta.
    • Tietueille: Tyyppi on suljettava, sen on määritettävä sama määrä kenttiä kuin arvo, eikä se saa sisältää valinnaisia kenttiä. (Tyypin kenttien nimet ja kenttätyypit korvaavat tietueeseen tällä hetkellä liittyvät nimet. Aiemmin luotuja kenttien arvoja ei kuitenkaan valita uusissa kenttätyypeissä.)
    • Taulukoille: -tyypin on määritettävä sama määrä sarakkeita kuin arvon. (Tyypin sarakkeiden nimet ja saraketyypit korvaavat taulukkoon tällä hetkellä liittyvät nimet. Olemassa olevia sarakearvoja ei kuitenkaan tarkistetaan uusien saraketyyppien mukaan.)
    • Funktioille: -tyypin on määritettävä sama määrä pakollisia parametreja sekä sama määrä valinnaisia parametreja kuin arvo. (Tyypin parametri ja palautusvahvistukset sekä niiden parametrien nimet korvaavat funktion arvon nykyiseen tyyppiin liittyvät parametrit. Uudet vahvistukset eivät kuitenkaan vaikuta funktion todelliseen toimintaan.)
    • Luetteloille: Arvon on oltava luettelo. (Olemassa olevia luettelokohteita ei kuitenkaan tarkistetaan uuden kohdetyypin mukaan.)

Kirjastofunktiot voivat laskea ja määrittää tulokset monitasoisia tyyppejä tulosten perusteella syötearvoille määritetyille tyypeille.

Arvon määritetty tyyppi voidaan saada käyttämällä kirjastofunktiota Value.Type. Esimerkkejä:

Value.Type( Value.ReplaceType( {1}, type {number} ) 
// type {number}

Tyyppivastaavuus ja yhteensopivuus

Tyyppivastaavuutta ei ole määritetty kohteessa M. M-toteutus voi valinnaisesti päättää käyttää omia sääntöjään tyyppiarvojen välisen yhtäläisyysvertailun suorittamiseen. Kahden yhtäläisyystyyppiarvon vertailun pitäisi antaa tulokseksi se true , pidetäänkö niitä samanlaisina toteutuksessa, ja false muussa tapauksessa. Kummassakin tapauksessa palautetun vastauksen on oltava johdonmukainen, jos samoja kahta arvoa verrataan toistuvasti. Huomaa, että tietyssä toteutuksessa joidenkin identtisten tyyppiarvojen (kuten (type text) = (type text)) vertailu voi palauttaa true, vaikka toiset arvot (kuten (type [a = text]) = (type [a = text])) ei ehkä vertailta.

Tietyn tyypin ja tyhjäarvoisen primitiivityypin yhteensopivuus voidaan määrittää käyttämällä kirjastofunktiota Type.Is, joka hyväksyy satunnaisen tyyppiarvon ensimmäisenä ja tyhjäarvoisen primitiivityypin arvon sen toisena argumenttina:

Type.Is(type text, type nullable text)  // true 
Type.Is(type nullable text, type text)  // false 
Type.Is(type number, type text)         // false 
Type.Is(type [a=any], type record)      // true 
Type.Is(type [a=any], type list)        // false

M-tukea ei ole määritetty tietyn tyypin yhteensopivuuden määrittämiseksi mukautetulla tyypillä.

Vakiokirjasto sisältää kokoelman funktioita, jotka poimivat määritteleviä ominaisuuksia mukautetusta tyypistä, joten tietyt yhteensopivuustestit voidaan ottaa käyttöön M-lausekkeina. Alla on joitakin esimerkkejä. Katso täydelliset tiedot M-kirjastomäärityksestä.

Type.ListItem( type {number} ) 
  // type number 
Type.NonNullable( type nullable text ) 
  // type text 
Type.RecordFields( type [A=text, B=time] ) 
  // [ A = [Type = type text, Optional = false], 
  //   B = [Type = type time, Optional = false] ] 
Type.TableRow( type table [X=number, Y=date] ) 
  // type [X = number, Y = date] 
Type.FunctionParameters(
        type function (x as number, optional y as text) as number) 
  // [ x = type number, y = type nullable text ] 
Type.FunctionRequiredParameters(
        type function (x as number, optional y as text) as number) 
  // 1 
Type.FunctionReturn(
        type function (x as number, optional y as text) as number) 
  // type number