Kifejezések

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

Fontos

Válassza ki a cikk platformjának és verziójának megfelelő verzióját. A verzióválasztó a tartalomjegyzék felett található. Keresse meg az Azure DevOps-platformot és -verziót.

A kifejezések számos helyen használhatók, ahol sztringet, logikai vagy számértéket kell megadni egy folyamat létrehozásakor. Amikor egy kifejezés tömböt ad vissza, a normál indexelési szabályok érvényesek, és az index a következővel 0kezdődik: .

A kifejezések leggyakrabban olyan feltételekkel használhatók, amelyek meghatározzák, hogy egy feladatnak vagy lépésnek futnia kell-e.

# Expressions are used to define conditions for a step, job, or stage
steps:
- task: ...
  condition: <expression>

A kifejezések másik gyakori használata a változók definiálása. A kifejezések fordításkor vagy futásidőben is kiértékelhetők. A fordítási időkifejezések bárhol használhatók; a futtatókörnyezeti kifejezések változókban és feltételekben használhatók. A futtatókörnyezeti kifejezések a változók és állapotok tartalmának kiszámítására szolgálnak (például: condition).

# Two examples of expressions used to define variables
# The first one, a, is evaluated when the YAML file is compiled into a plan.
# The second one, b, is evaluated at runtime.
# Note the syntax ${{}} for compile time and $[] for runtime expressions.
variables:
  a: ${{ <expression> }}
  b: $[ <expression> ]

A futtatókörnyezet és a fordítási idő kifejezésszintaxisai között elsősorban az a különbség, hogy milyen környezet érhető el. A fordítási idő kifejezésben (${{ <expression> }}) hozzáféréssel parameters rendelkezik, és statikusan definiált variables. Egy futtatókörnyezeti kifejezésben ($[ <expression> ]) több variables , de paraméter nélküli hozzáféréssel rendelkezik.

Ebben a példában egy futtatókörnyezeti kifejezés a következő értéket állítja $(isMain)be: . Egy fordítási kifejezés statikus változója a következő értéket állítja $(compileVar)be: .

variables:
  staticVar: 'my value' # static variable
  compileVar: ${{ variables.staticVar }} # compile time expression
  isMain: $[eq(variables['Build.SourceBranch'], 'refs/heads/main')] # runtime expression

steps:
  - script: |
      echo ${{variables.staticVar}} # outputs my value
      echo $(compileVar) # outputs my value
      echo $(isMain) # outputs True

A kifejezés lehet literál, változóra mutató hivatkozás, függőségre mutató hivatkozás, függvény vagy ezek érvényes beágyazott kombinációja.

Literálok

Egy kifejezés részeként logikai, null, szám, sztring vagy verziókonstansokat használhat.

# Examples
variables:
  someBoolean: ${{ true }} # case insensitive, so True or TRUE also works
  someNumber: ${{ -1.2 }}
  someString: ${{ 'a b c' }}
  someVersion: ${{ 1.2.3 }}

Logikai

True logikai False literálkifejezések.

Null

A Null egy speciális literálkifejezés, amelyet egy szótár kihagyása után ad vissza, például (variables['noSuch']). A null lehet egy kifejezés kimenete, de nem hívható meg közvetlenül egy kifejezésen belül.

Szám

A következővel kezdődik: '-', '.', vagy '0' a '9' között.

Sztring

Az egyszeres idézőjelet kell megadni. Például: 'this is a string'

A literális egy idézőjel kifejezéséhez egyetlen idézőjellel kell feloldani. Például: 'It''s OK if they''re using contractions.'

Többsoros sztringekhez pipa karaktert (|) is használhat.

myKey: |
  one
  two
  three

Verzió

Legfeljebb négy szegmenst tartalmazó verziószám. Egy számmal kell kezdődnie, és két vagy három pont (.) karaktert kell tartalmaznia. Például: 1.2.3.4

Változók

Egy kifejezés részeként a változókat két szintaxis egyikével érheti el:

• Index szintaxisa: variables['MyVar']
• Tulajdonságeltérés szintaxisa: variables.MyVar

A tulajdonság dereferencia szintaxisának használatához a tulajdonságnévnek a következőnek kell lennie:

• Kezdje a a-Z_
• Kövesse a következőt: a-Z0-9 vagy _

A végrehajtási környezettől függően különböző változók érhetők el.

• Ha YAML használatával hoz létre folyamatokat, akkor a folyamatváltozók elérhetők.
• Ha klasszikus szerkesztővel hoz létre buildfolyamatokat, akkor a buildváltozók elérhetők.
• Ha klasszikus szerkesztővel hoz létre kiadási folyamatokat, akkor kiadási változók érhetők el.

A változók mindig sztringek. Ha gépelt értékeket szeretne használni, akkor inkább paramétereket kell használnia.

Feljegyzés

A változóknak a klasszikus és a YAML-folyamatok kifejezéseivel való használatára korlátozás vonatkozik, ha az ilyen változókat a változók lap felhasználói felületén keresztül állítja be. A kifejezésként definiált változók nem függhetnek egy másik, értékben megadott kifejezéssel rendelkező változótól, mivel nem garantált , hogy mindkét kifejezés megfelelően lesz kiértékelve. Van például olyan változónk a , amelynek értékét $[ <expression> ] a változó bértékének részeként használjuk. Mivel a változók feldolgozási sorrendje nem garantált, a kiértékelés után a változó ba értéke helytelen lehet.

A leírt szerkezetek csak akkor engedélyezettek, ha változókat állít be a VÁLTOZÓk kulcsszón keresztül a YAML-folyamatban. A változókat a feldolgozásuk sorrendjében kell elhelyezni, hogy a feldolgozás után megkapják a megfelelő értékeket.

Functions

A kifejezésekben az alábbi beépített függvények használhatók.

és

• Kiértékeli, hogy True az összes paraméter True
• Minimális paraméterek: 2. Maximális paraméterek: N
• Paramétereket ad ki logikai értékre kiértékeléshez
• Rövidzárlatok az első után False
• Példa: and(eq(variables.letters, 'ABC'), eq(variables.numbers, 123))

coalesce

• A paramétereket sorrendben értékeli ki (balról jobbra), és az első értéket adja vissza, amely nem egyenlő null vagy üres sztringgel.
• A rendszer nem ad vissza értéket, ha a paraméterértékek mindegyike null vagy üres sztring.
• Minimális paraméterek: 2. Maximális paraméterek: N
• Példa: coalesce(variables.couldBeNull, variables.couldAlsoBeNull, 'literal so it always works')

contains

• Kiértékeli, hogy a sztring True bal oldali paramétere tartalmaz-e jobb paramétert
• Minimális paraméterek: 2. Maximális paraméterek: 2
• Paramétereket ad ki kiértékeléshez a Sztringbe
• A sorszámok figyelmen kívül hagyása összehasonlítása
• Példa: contains('ABCDE', 'BCD') (igaz értéket ad vissza)

containsValue

• Kiértékeli True , hogy a bal oldali paraméter tömb-e, és minden elem egyenlő-e a megfelelő paramétersel. Azt is kiértékeli True , hogy a bal oldali paraméter objektum-e, és bármely tulajdonság értéke megegyezik-e a megfelelő paramétersel.
• Minimális paraméterek: 2. Maximális paraméterek: 2
• Ha a bal oldali paraméter tömb, konvertálja az egyes elemeket a megfelelő paraméter típusának megfelelően. Ha a bal oldali paraméter egy objektum, konvertálja az egyes tulajdonságok értékét a megfelelő paraméter típusának megfelelően. Az egyes elemek egyenlőségi összehasonlítása kiértékeli False , hogy az átalakítás sikertelen-e.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Rövidzárlatok az első meccs után

Feljegyzés

A YAML-folyamatokban nincs konstans szintaxis a tömbök megadásához. Ez a függvény általános folyamatokban korlátozottan használható. A folyamat dekorátorkörnyezetében a rendszer által biztosított tömbökkel, például a lépések listájával való használatra szolgál.

A containsValue kifejezéssel egyező értéket kereshet egy objektumban. Íme egy példa, amely bemutatja, hogy a forráságak listájában keres-e egyezést Build.SourceBranch.

parameters:
- name: branchOptions
  displayName: Source branch options
  type: object
  default:
    - refs/heads/main
    - refs/heads/test

jobs:
  - job: A1 
    steps:
    - ${{ each value in parameters.branchOptions }}:
      - script: echo ${{ value }}

  - job: B1 
    condition: ${{ containsValue(parameters.branchOptions, variables['Build.SourceBranch']) }}
    steps:
      - script: echo "Matching branch found"

convertToJson

• Vegyen fel egy összetett objektumot, és JSON-ként adja ki.
• Minimális paraméterek: 1. Maximális paraméterek: 1.

parameters:
  - name: listOfValues
    type: object
    default:
      this_is:
        a_complex: object
        with:
          - one
          - two

steps:
- script: |
    echo "${MY_JSON}"
  env:
    MY_JSON: ${{ convertToJson(parameters.listOfValues) }}

Szkript kimenete:

{
  "this_is": {
    "a_complex": "object",
    "with": [
      "one",
      "two"
    ]
  }
}

számláló

• Ez a függvény csak egy változót definiáló kifejezésben használható. Lépés, feladat vagy szakasz feltételeként nem használható.
• Kiértékel egy számot, amely egy folyamat minden egyes futtatásával növekszik.
• Paraméterek: 2. prefix és seed.
• Az előtag egy sztringkifejezés. Az előtag minden egyedi értékéhez külön számlálóérték lesz nyomon követve. A prefix karakternek UTF-16 karaktert kell használnia.
• A mag a számláló kezdőértéke

Létrehozhat egy számlálót, amely automatikusan növekszik a folyamat minden egyes végrehajtása során. Számláló definiálásakor ad meg egy prefix és egy seed. Íme egy példa, amely ezt szemlélteti.

variables:
  major: 1
  # define minor as a counter with the prefix as variable major, and seed as 100.
  minor: $[counter(variables['major'], 100)]

steps:
- bash: echo $(minor)

A fenti példában szereplő érték minor a folyamat első futtatásakor 100. A második futtatásban ez 101, feltéve, hogy az értéke major még mindig 1.

Ha szerkessze a YAML-fájlt, és a változó major értékét 2-es értékre frissíti, akkor a folyamat következő futtatásakor az érték minor 100 lesz. A későbbi futtatások a számlálót 101, 102, 103, ...

Később, ha szerkessze a YAML-fájlt, és 1-esre állítja major vissza az értéket, akkor a számláló értéke ott folytatódik, ahol az előtagnál abbahagyta. Ebben a példában 102-nél folytatódik.

Íme egy másik példa egy olyan változó beállítására, amely számlálóként működik, amely 100-nál kezdődik, minden futtatásnál 1-zel növekszik, és naponta 100-ra lesz visszaállítva.

Feljegyzés

pipeline.startTime kifejezésen kívül nem érhető el. pipeline.startTime formázása system.pipelineStartTime dátum- és időobjektummá, hogy használható legyen a kifejezésekhez. Az alapértelmezett időzóna az pipeline.startTime UTC. Módosíthatja a szervezet időzónáját.

jobs:
- job:
  variables:
    a: $[counter(format('{0:yyyyMMdd}', pipeline.startTime), 100)]
  steps:
  - bash: echo $(a)

Íme egy példa arra, hogy van egy számláló, amely külön értéket tart fenn a PRS- és CI-futtatásokhoz.

variables:
  patch: $[counter(variables['build.reason'], 0)]

A számlálók hatóköre egy folyamatra terjed ki. Más szóval az értéke a folyamat minden egyes futtatásához növekszik. Nincsenek projekthatókörű számlálók.

endsWith

• Kiértékeli, hogy a sztring True bal oldali paramétere jobb paraméterrel végződik-e
• Minimális paraméterek: 2. Maximális paraméterek: 2
• Paramétereket ad ki kiértékeléshez a Sztringbe
• A sorszámok figyelmen kívül hagyása összehasonlítása
• Példa: endsWith('ABCDE', 'DE') (igaz értéket ad vissza)

eq

• Kiértékeli, True hogy a paraméterek egyenlőek-e
• Minimális paraméterek: 2. Maximális paraméterek: 2
• A jobb oldali paramétert a bal oldali paraméter típusának megfelelőre konvertálja. Visszaadja, False ha az átalakítás sikertelen.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Példa: eq(variables.letters, 'ABC')

format

• Kiértékeli a záró paramétereket, és beszúrja őket a vezető paramétersztringbe
• Minimális paraméterek: 1. Maximális paraméterek: N
• Példa: format('Hello {0} {1}', 'John', 'Doe')
• .NET egyéni dátum- és időformátum-meghatározókat használ a dátumformázáshoz (yyyy, yy, , MM, M, ddd, HH, H, sssffffmmmKfff)
• Példa: format('{0:yyyyMMdd}', pipeline.startTime) Ebben az esetben pipeline.startTime egy speciális dátum-időobjektum-változó.
• Menekülés a kapcsos zárójelek megduplázásával. Például: format('literal left brace {{ and literal right brace }}')

ge

• Kiértékeli True , hogy a bal oldali paraméter nagyobb vagy egyenlő-e a megfelelő paraméternél
• Minimális paraméterek: 2. Maximális paraméterek: 2
• A jobb oldali paramétert a bal oldali paraméter típusának megfelelőre konvertálja. Hibák, ha az átalakítás sikertelen.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Példa: ge(5, 5) (igaz értéket ad vissza)

Gt

• Kiértékeli, True hogy a bal oldali paraméter nagyobb-e a jobb paraméternél
• Minimális paraméterek: 2. Maximális paraméterek: 2
• A jobb oldali paramétert a bal oldali paraméter típusának megfelelőre konvertálja. Hibák, ha az átalakítás sikertelen.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Példa: gt(5, 2) (igaz értéket ad vissza)

in

• Kiértékeli, True hogy a bal oldali paraméter egyenlő-e a jobb oldali paraméterekkel
• Minimális paraméterek: 1. Maximális paraméterek: N
• A jobb paramétereket a bal oldali paraméter típusának megfelelővé alakítja. Az egyenlőségi összehasonlítás kiértékeli, False hogy az átalakítás sikertelen-e.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Rövidzárlatok az első egyezés után
• Példa: in('B', 'A', 'B', 'C') (igaz értéket ad vissza)

Csatlakozás

• Összefűzi a jobb oldali paramétertömb összes elemét a bal oldali paramétersztringgel elválasztva.
• Minimális paraméterek: 2. Maximális paraméterek: 2
• A tömb minden eleme sztringgé alakul. Az összetett objektumok üres sztringgé alakulnak.
• Ha a megfelelő paraméter nem tömb, az eredmény a sztringgé konvertált megfelelő paraméter.

Ebben a példában pontosvesszőt adunk hozzá a tömb egyes elemei között. A paraméter típusa objektum.

parameters:
- name: myArray
  type: object
  default:
    - FOO
    - BAR
    - ZOO

variables:
   A: ${{ join(';',parameters.myArray) }}

steps:
  - script: echo $A # outputs FOO;BAR;ZOO

le

• Kiértékeli, True hogy a bal oldali paraméter kisebb vagy egyenlő-e a megfelelő paraméternél
• Minimális paraméterek: 2. Maximális paraméterek: 2
• A jobb oldali paramétert a bal oldali paraméter típusának megfelelőre konvertálja. Hibák, ha az átalakítás sikertelen.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Példa: le(2, 2) (igaz értéket ad vissza)

length (hossz)

• Egy sztring vagy tömb hosszát adja vissza, amely a rendszerből származik, vagy egy paraméterből származik
• Minimális paraméterek: 1. Maximális paraméterek 1
• Példa: length('fabrikam') 8-at ad vissza

Alsó

• Sztring- vagy változóértékek konvertálása kisbetűs karakterekké
• Minimális paraméterek: 1. Maximális paraméterek 1
• Egy sztring kisbetűs megfelelője.
• Példa: lower('FOO') visszaadja foo

Hadnagy

• Kiértékeli, True hogy a bal oldali paraméter kisebb-e a jobb paraméternél
• Minimális paraméterek: 2. Maximális paraméterek: 2
• A jobb oldali paramétert a bal oldali paraméter típusának megfelelőre konvertálja. Hibák, ha az átalakítás sikertelen.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Példa: lt(2, 5) (igaz értéket ad vissza)

ne

• Kiértékeli, True hogy a paraméterek nem egyenlők-e
• Minimális paraméterek: 2. Maximális paraméterek: 2
• A jobb oldali paramétert a bal oldali paraméter típusának megfelelőre konvertálja. Visszaadja, True ha az átalakítás sikertelen.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Példa: ne(1, 2) (igaz értéket ad vissza)

Nem

• Kiértékeli, True hogy a paraméter False
• Minimális paraméterek: 1. Maximális paraméterek: 1
• Érték konvertálása logikai értékké kiértékeléshez
• Példa: not(eq(1, 2)) (igaz értéket ad vissza)

notIn

• Kiértékeli, True hogy a bal oldali paraméter nem egyenlő-e a megfelelő paraméterekkel
• Minimális paraméterek: 1. Maximális paraméterek: N
• A jobb paramétereket a bal oldali paraméter típusának megfelelővé alakítja. Az egyenlőségi összehasonlítás kiértékeli, False hogy az átalakítás sikertelen-e.
• Sztringek sorszámos figyelmen kívül hagyása–kis- és nagybetűk összehasonlítása
• Rövidzárlatok az első egyezés után
• Példa: notIn('D', 'A', 'B', 'C') (igaz értéket ad vissza)

vagy

• Kiértékeli, True hogy van-e paraméter True
• Minimális paraméterek: 2. Maximális paraméterek: N
• Paramétereket ad ki logikai értékre kiértékeléshez
• Rövidzárlatok az első után True
• Példa: or(eq(1, 1), eq(2, 3)) (igaz, rövidzárlatokat ad vissza)

Helyettesít

• Egy új sztringet ad vissza, amelyben az aktuális példány összes sztringpéldánya lecserélődik egy másik sztringre
• Minimális paraméterek: 3. Maximális paraméterek: 3
• replace(a, b, c): a értéket adja vissza, a b összes példányát c
• Példa: replace('https://www.tinfoilsecurity.com/saml/consume','https://www.tinfoilsecurity.com','http://server') (visszaadja http://server/saml/consume)

hasít

• Sztring felosztása részsztringekre a megadott elválasztó karakterek alapján
• Minimális paraméterek: 2. Maximális paraméterek: 2
• Az első paraméter a felosztandó sztring
• A második paraméter az elválasztó karakterek
• Részszűrések tömbjének visszaadása. A tömb üres sztringeket tartalmaz, ha a határoló karakterek egymás után vagy a sztring végén jelennek meg
• Példa:

  variables:
  - name: environments
    value: prod1,prod2 
  steps:  
    - ${{ each env in split(variables.environments, ',')}}:
      - script: ./deploy.sh --environment ${{ env }}
  

• Példa a split() és a replace() használatára:

  parameters:
  - name: resourceIds
    type: object
    default:
    - /subscriptions/mysubscription/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/kubernetes-internal
    - /subscriptions/mysubscription02/resourceGroups/myResourceGroup02/providers/Microsoft.Network/loadBalancers/kubernetes
  - name: environments
    type: object
    default: 
    - prod1
    - prod2
  
  trigger:
  - main
  
  steps:
  - ${{ each env in parameters.environments }}:
    - ${{ each resourceId in parameters.resourceIds }}:
        - script: echo ${{ replace(split(resourceId, '/')[8], '-', '_') }}_${{ env }}
  

startsWith

• Kiértékeli, True hogy a bal oldali paraméter sztringje a jobb paraméterrel kezdődik-e
• Minimális paraméterek: 2. Maximális paraméterek: 2
• Paramétereket ad ki kiértékeléshez a Sztringbe
• A sorszámok figyelmen kívül hagyása összehasonlítása
• Példa: startsWith('ABCDE', 'AB') (igaz értéket ad vissza)

Felső

• Sztring vagy változó értékét minden nagybetűs karakterre konvertálja
• Minimális paraméterek: 1. Maximális paraméterek 1
• Egy sztring nagybetűs megfelelőjének visszaadása
• Példa: upper('bah') visszaadja BAH

Xor

• Kiértékeli, True hogy pontosan egy paraméter van-e True
• Minimális paraméterek: 2. Maximális paraméterek: 2
• Paramétereket ad ki logikai értékre kiértékeléshez
• Példa: xor(True, False) (igaz értéket ad vissza)

Feladatállapot-ellenőrző függvények

Az alábbi állapotellenőrzési függvényeket kifejezésekként használhatja a feltételekben, a változódefiníciókban azonban nem.

mindig

• Mindig ezt értékeli True ki (még akkor is, ha megszakítja). Megjegyzés: A kritikus hibák továbbra is megakadályozhatják a tevékenységek futtatását. Ha például a források lekérése sikertelen volt.

Visszavont

• Kiértékeli, hogy True a folyamat megszakadt-e.

sikertelen

• Egy lépésnél a következőnek felel meg: eq(variables['Agent.JobStatus'], 'Failed').
• Feladat esetén:
  • Argumentumok nélkül csak akkor értékeli ki a True függvényt, ha a függőségi gráf valamelyik korábbi feladata sikertelen volt.
  • Ha a feladatnevek argumentumként vannak megadva, a True kiértékelés csak akkor történik meg, ha valamelyik feladat meghiúsult.

Sikerült

• Egy lépésnél a következővel egyenértékű: in(variables['Agent.JobStatus'], 'Succeeded', 'SucceededWithIssues')
• Használja a dependsOn feladatok használatakor, és szeretné kiértékelni, hogy egy korábbi feladat sikeres volt-e. A feladatok úgy vannak kialakítva, hogy párhuzamosan fussanak, miközben a szakaszok egymás után futnak.
• Feladat esetén:
  • Argumentumok nélkül csak akkor értékeli ki a True függvényt, ha a függőségi gráf összes korábbi feladatának sikeres volt vagy részben sikerült.
  • Ha a feladatnevek argumentumként vannak megadva, a kiértékelése azt jelzi, hogy True az összes feladat sikeres volt-e, vagy részben sikeres volt-e.
  • Kiértékeli, hogy False a folyamat megszakadt-e.

succeededOrFailed

• Egy lépésnél a következővel egyenértékű: in(variables['Agent.JobStatus'], 'Succeeded', 'SucceededWithIssues', 'Failed')

• Feladat esetén:

  • Argumentumok nélkül kiértékeli, függetlenül attól, hogy True a függőségi gráfban lévő feladatok sikeresek vagy sikertelenek-e.
  • A feladatnevek argumentumként való használatával kiértékeli, hogy True a feladatok bármelyike sikeres vagy sikertelen volt-e.
  • Érdemes lehet inkább használni not(canceled()) , ha a függőségi gráfban vannak korábbi kihagyott feladatok.

  Ez olyan, mint always()a folyamat megszakításának kiértékelése False .

Feltételes beszúrás

A if, elseifés else záradékokkal feltételesen hozzárendelhet változó értékeket, vagy bemeneteket állíthat be a tevékenységekhez. Feltételesen is futtathat egy lépést, ha teljesül egy feltétel.

A feltételes függvények csak sablonszintaxis használatakor működnek. További információ a változószintaxisról.

Sablonok esetén feltételes beszúrást használhat szekvencia vagy leképezés hozzáadásakor. További információ a feltételes beszúrásról a sablonokban.

Változó feltételes hozzárendelése

variables:
  ${{ if eq(variables['Build.SourceBranchName'], 'main') }}: # only works if you have a main branch
    stageName: prod

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: echo ${{variables.stageName}}

Tevékenységbevitel feltételes beállítása

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Pipeline.Workspace)'
    ${{ if eq(variables['Build.SourceBranchName'], 'main') }}:
      artifact: 'prod'
    ${{ else }}:
      artifact: 'dev'
    publishLocation: 'pipeline'

Lépés feltételes futtatása

Ha nincs változókészlet, vagy az érték foo nem felel meg a if feltételeknek, az else utasítás lefut. Itt a visszaadott foo érték igaz a elseif feltételben.

variables:
  - name: foo
    value: contoso # triggers elseif condition

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: echo "start"
- ${{ if eq(variables.foo, 'adaptum') }}:
  - script: echo "this is adaptum"
- ${{ elseif eq(variables.foo, 'contoso') }}: # true
  - script: echo "this is contoso" 
- ${{ else }}:
  - script: echo "the value is not adaptum or contoso"

Minden kulcsszó

A kulcsszóval végigfuttathatja a each paramétereket az objektumtípussal.

parameters:
- name: listOfStrings
  type: object
  default:
  - one
  - two

steps:
- ${{ each value in parameters.listOfStrings }}:
  - script: echo ${{ value }}

Emellett az objektumon belüli beágyazott elemeken keresztül is iterálhat.

parameters:
- name: listOfFruits
  type: object
  default:
  - fruitName: 'apple'
    colors: ['red','green']
  - fruitName: 'lemon'
    colors: ['yellow']
steps:
- ${{ each fruit in parameters.listOfFruits }} :
  - ${{ each fruitColor in fruit.colors}} :
    - script: echo ${{ fruit.fruitName}} ${{ fruitColor }}

Függőségek

A kifejezések a függőségi környezet használatával hivatkozhatnak a korábbi feladatokra vagy szakaszokra. A függőségek a következőhöz használhatók:

• Hivatkozás egy korábbi feladat feladatállapotára
• Hivatkozás egy előző szakasz fázisállapotára
• Referencia kimeneti változók az előző feladatban ugyanabban a szakaszban
• Referencia kimeneti változók az előző fázisban egy fázisban
• Referencia kimeneti változók egy feladat előző szakaszában a következő szakaszban

A környezet feladatokra és szakaszokra van meghívva dependencies , és a változókhoz hasonlóan működik. Ha egy másik fázisban lévő feladat kimeneti változóira hivatkozik, a környezet neve stageDependencies.

Ha olyan kimeneti változókkal kapcsolatos problémákat tapasztal, amelyekben idézőjelek (' vagy ") vannak, tekintse meg ezt a hibaelhárítási útmutatót.

Függőségi szintaxis áttekintése

A kimeneti változók függőségekkel való hivatkozásának szintaxisa a körülményektől függően változik. Az alábbiakban áttekintjük a leggyakoribb forgatókönyveket. Előfordulhat, hogy az alternatív szintaxis is működik.

Típus

Leírás

fázistól a fázisig függőség (különböző szakaszok)

Hivatkozzon egy kimeneti változóra a feladat egy korábbi szakaszából egy másik fázisban, a következő feltételben stages: .

• Szintaxis: and(succeeded(), eq(stageDependencies.<stage-name>.outputs['<job-name>.<step-name>.<variable-name>'], 'true'))
• Példa: and(succeeded(), eq(stageDependencies.A.outputs['A1.printvar.shouldrun'], 'true'))

feladat és feladat függősége (ugyanabban a szakaszban)

Hivatkozzon egy kimeneti változóra egy másik feladatban, ugyanabban a szakaszban.stages

• Szintaxis: and(succeeded(), eq(dependencies.<job-name>.outputs['<step-name>.<variable-name>'], 'true'))
• Példa: and(succeeded(), eq(dependencies.A.outputs['printvar.shouldrun'], 'true'))

Feladat a függőség szakaszához (különböző szakaszok)

Hivatkozzon egy kimeneti változóra egy másik fázisban egy job.

• Szintaxis: eq(stageDependencies.<stage-name>.<job-name>.outputs['<step-name>.<variable-name>'], 'true')
• Példa: eq(stageDependencies.A.A1.outputs['printvar.shouldrun'], 'true')

Fázistól fázisig függőség (üzembe helyezési feladat)

Hivatkozás a kimeneti változóra egy üzembehelyezési feladatban, a másik szakaszában stages.

• Szintaxis: eq(dependencies.<stage-name>.outputs['<deployment-job-name>.<deployment-job-name>.<step-name>.<variable-name>'], 'true')
• Példa: eq(dependencies.build.outputs['build_job.build_job.setRunTests.runTests'], 'true')

Fázistól fázisig függőség (üzembehelyezési feladat erőforrással)

Hivatkozzon egy kimeneti változóra egy olyan üzembehelyezési feladatban, amely egy erőforrást tartalmaz a különböző fázisában stages.

• Szintaxis: eq(dependencies.<stage-name>.outputs['<deployment-job-name>.<Deploy_resource-name>.<step-name>.<variable-name>'], 'true')
• Példa: eq(dependencies.build.outputs['build_job.Deploy_winVM.setRunTests.runTests'], 'true')

Az üzembe helyezési feladatok kimeneti változóinak különböző szintaxisai is vannak az üzembe helyezési stratégiától függően. További információ: Üzembe helyezési feladatok.

Függőségek szakaszba lépése

Szerkezetileg az dependencies objektum a feladat- és szakasznevek resultsoutputstérképe. JSON-ként kifejezve a következőképpen nézne ki:

"dependencies": {
  "<STAGE_NAME>" : {
    "result": "Succeeded|SucceededWithIssues|Skipped|Failed|Canceled",
    "outputs": {
        "jobName.stepName.variableName": "value"
    }
  },
  "...": {
    // another stage
  }
}

Feljegyzés

Az alábbi példák szabványos folyamatszintaxist használnak. Ha üzembehelyezési folyamatokat használ, a változó és a feltételes változó szintaxisa is eltérő lesz. A használni kívánt szintaxissal kapcsolatos információkért lásd az üzembe helyezési feladatokat.

Ezen űrlap dependencies használatával változókat képezhet le, vagy fázisszinten ellenőrizheti a feltételeket.

Ebben a példában két fázis létezik: A és B. Az A fázis feltétellel false rendelkezik, és soha nem fog futni eredményként. A B szakasz akkor fut, ha az A Succeededfázis eredménye , SucceededWithIssuesvagy Skipped. A B szakasz azért fut, mert az A szakasz ki lett hagyva.

stages:
- stage: A
  condition: false
  jobs:
  - job: A1
    steps:
    - script: echo Job A1
- stage: B
  condition: in(dependencies.A.result, 'Succeeded', 'SucceededWithIssues', 'Skipped')
  jobs:
  - job: B1
    steps:
    - script: echo Job B1

A szakaszok egy másik fázis kimeneti változóit is használhatják. Ebben a példában két szakasz is létezik. Az A szakasz tartalmaz egy A1 feladatot, amely egy kimeneti változót shouldrun állít be a következőre true: . A B fázis akkor fut, ha shouldrun van true. Mert shouldrun a trueB fázis fut.

stages:
- stage: A
  jobs:
  - job: A1
    steps:
     - bash: echo "##vso[task.setvariable variable=shouldrun;isOutput=true]true"
     # or on Windows:
     # - script: echo ##vso[task.setvariable variable=shouldrun;isOutput=true]true
       name: printvar

- stage: B
  condition: and(succeeded(), eq(dependencies.A.outputs['A1.printvar.shouldrun'], 'true'))
  dependsOn: A
  jobs:
  - job: B1
    steps:
    - script: echo hello from Stage B

Feljegyzés

Alapértelmezés szerint a folyamat minden szakasza a YAML-fájlban lévő előtt lévőtől függ. Ha olyan szakaszra kell hivatkoznia, amely nem közvetlenül az aktuális előtt van, felülbírálhatja ezt az automatikus alapértelmezett beállítást úgy, hogy hozzáad egy szakaszt dependsOn a szakaszhoz.

Feladat–feladat függőségek egy fázison belül

Az adatok egyetlen fázison dependencies belüli feladatszinten nem tartalmaznak szakaszszintű információkat.

"dependencies": {
  "<JOB_NAME>": {
    "result": "Succeeded|SucceededWithIssues|Skipped|Failed|Canceled",
    "outputs": {
      "stepName.variableName": "value1"
    }
  },
  "...": {
    // another job
  }
}

Ebben a példában három feladat van (a, b és c). A feladat mindig ki lesz hagyva a condition: falsekövetkező miatt: . A b feladat azért fut, mert nincsenek társított feltételek. A c feladat azért fut, mert az összes függősége sikeres (b feladat) vagy kihagyva (a feladat).

jobs:
- job: a
  condition: false
  steps:
  - script: echo Job a
- job: b
  steps:
  - script: echo Job b
- job: c
  dependsOn:
  - a
  - b
  condition: |
    and
    (
      in(dependencies.a.result, 'Succeeded', 'SucceededWithIssues', 'Skipped'),
      in(dependencies.b.result, 'Succeeded', 'SucceededWithIssues', 'Skipped')
    )
  steps:
  - script: echo Job c

Ebben a példában a B feladat az A feladat kimeneti változójától függ.

jobs:
- job: A
  steps:
  - bash: echo "##vso[task.setvariable variable=shouldrun;isOutput=true]true"
  # or on Windows:
  # - script: echo ##vso[task.setvariable variable=shouldrun;isOutput=true]true
    name: printvar

- job: B
  condition: and(succeeded(), eq(dependencies.A.outputs['printvar.shouldrun'], 'true'))
  dependsOn: A
  steps:
  - script: echo hello from B

Feladat–feladat függőségek több fázisban

A feladat szintjén hivatkozhat az előző fázisban lévő feladatok kimenetére is. Ehhez a stageDependencies környezet használatára van szükség.

"stageDependencies": {
  "<STAGE_NAME>" : {
    "<JOB_NAME>": {
      "result": "Succeeded|SucceededWithIssues|Skipped|Failed|Canceled",
      "outputs": {
          "stepName.variableName": "value"
      }
    },
    "...": {
      // another job
    }
  },
  "...": {
    // another stage
  }
}

Ebben a példában a B1 feladat akkor fut, ha az A1 feladatot kihagyja. A B2 feladat ellenőrzi az A1 feladat kimeneti változójának értékét annak megállapításához, hogy fut-e.

stages:
- stage: A
  jobs:
  - job: A1
    steps:
     - bash: echo "##vso[task.setvariable variable=shouldrun;isOutput=true]true"
     # or on Windows:
     # - script: echo ##vso[task.setvariable variable=shouldrun;isOutput=true]true
       name: printvar

- stage: B
  dependsOn: A
  jobs:
  - job: B1
    condition: in(stageDependencies.A.A1.result, 'Skipped') # change condition to `Succeeded and stage will be skipped`
    steps:
    - script: echo hello from Job B1
  - job: B2
    condition: eq(stageDependencies.A.A1.outputs['printvar.shouldrun'], 'true')
    steps:
     - script: echo hello from Job B2

Ha egy feladat egy másik fázisban lévő üzembehelyezési feladat által definiált változótól függ, akkor a szintaxis eltérő. Az alábbi példában a feladat run_tests akkor fut, ha az üzembe helyezési build_job feladat be van állítva runTeststrue. Figyelje meg, hogy a szótárhoz használt kulcs az outputsbuild_job.setRunTests.runTests.

stages:
- stage: build
  jobs:
  - deployment: build_job
    environment:
      name: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: PowerShell@2
            name: setRunTests
            inputs:
              targetType: inline
              pwsh: true
              script: |
                $runTests = "true"
                echo "setting runTests: $runTests"
                echo "##vso[task.setvariable variable=runTests;isOutput=true]$runTests"

- stage: test
  dependsOn:
  - 'build'
  jobs:  
    - job: run_tests
      condition: eq(stageDependencies.build.build_job.outputs['build_job.setRunTests.runTests'], 'true')
      steps:
        ...

Üzembehelyezési feladat kimeneti változói

Ha egy szakasz egy másik fázisban lévő üzembehelyezési feladat által definiált változótól függ, akkor a szintaxis eltérő. Az alábbi példában a szakasz test a következő üzembehelyezési build_job beállítástól shouldTesttruefügg: . Figyelje meg, hogy a conditiontest színpadon build_job kétszer jelenik meg.

stages:
- stage: build
  jobs:
  - deployment: build_job
    environment:
      name: Production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: PowerShell@2
            name: setRunTests
            inputs:
              targetType: inline
              pwsh: true
              script: |
                $runTests = "true"
                echo "setting runTests: $runTests"
                echo "##vso[task.setvariable variable=runTests;isOutput=true]$runTests"

- stage: test
  dependsOn:
  - 'build'
  condition: eq(dependencies.build.outputs['build_job.build_job.setRunTests.runTests'], 'true')
  jobs:
    - job: A
      steps:
        - script: echo Hello from job A

A fenti példában a feltétel nem környezeti erőforrásra, hanem környezetre hivatkozik. Egy környezeti erőforrásra való hivatkozáshoz hozzá kell adnia a környezeti erőforrás nevét a függőségi feltételhez. Az alábbi példában a feltétel egy környezeti virtuálisgép-erőforrásra hivatkozik vmtest.

stages:
- stage: build
  jobs:
  - deployment: build_job
    environment:
      name: vmtest
      resourceName: winVM2
      resourceType: VirtualMachine
    strategy:
      runOnce:
        deploy:
          steps:
          - task: PowerShell@2
            name: setRunTests
            inputs:
              targetType: inline
              pwsh: true
              script: |
                $runTests = "true"
                echo "setting runTests: $runTests"
                echo "##vso[task.setvariable variable=runTests;isOutput=true]$runTests"

- stage: test
  dependsOn:
  - 'build'
  condition: eq(dependencies.build.outputs['build_job.Deploy_winVM2.setRunTests.runTests'], 'true')
  jobs:
  - job: A
    steps:
     - script: echo Hello from job A

Szűrt tömbök

Ha elemgyűjteményen dolgozik, a * szintaxissal szűrt tömböt alkalmazhat. A szűrt tömbök a nevüktől függetlenül az összes objektumot/elemet visszaadják.

Vegyük például a nevesített fooobjektumtömböt. Egy tömböt szeretnénk lekérni a id tömb minden objektumában lévő tulajdonság értékeiből.

[
    { "id": 1, "a": "avalue1"},
    { "id": 2, "a": "avalue2"},
    { "id": 3, "a": "avalue3"}
]

Az alábbiakat végezhetjük el:

foo.*.id

Ez arra utasítja a rendszert, hogy szűrt tömbként működjön, foo majd válassza ki a tulajdonságot id .

Ez a következőt adja vissza:

[ 1, 2, 3 ]

Típus-öntés

A kifejezés értékei a kifejezés kiértékelése során egyik típusból a másikba konvertálhatók. Egy kifejezés kiértékelésekor a paramétereket a rendszer a megfelelő adattípusra alakítja, majd sztringekké alakítja vissza.

Ebben a YAML-ben például a kifejezés kiértékelésének és kiértékelésének értékei TrueFalse lesznek konvertálva 10 . A függvény lt() akkor ad True vissza, ha a bal oldali paraméter kisebb a jobb paraméternél.

variables:
  firstEval: $[lt(False, True)] # 0 vs. 1, True
  secondEval: $[lt(True, False)] # 1 vs. 0, False

steps:
- script: echo $(firstEval)
- script: echo $(secondEval)

Ebben a példában az értékek variables.emptyString és az üres sztring egyaránt üres sztringekként lesznek kiértékelve. A függvény coalesce() sorrendben értékeli ki a paramétereket, és az első értéket adja vissza, amely nem egyenlő null vagy üres sztringgel.

variables:
  coalesceLiteral: $[coalesce(variables.emptyString, '', 'literal value')]

steps:
- script: echo $(coalesceLiteral) # outputs literal value

A részletes konverziós szabályok az alábbiakban találhatók.

Feladó/feladó	Logikai	Null	Szám	Sztring	Verzió
Logikai	-	-	Igen	Igen	-
Null	Igen	-	Igen	Igen	-
Szám	Igen	-	-	Igen	Részleges
Sztring	Igen	Részleges	Részleges	-	Részleges
Verzió	Igen	-	-	Igen	-

Logikai

Számba:

• False → 0
• True → 1

Sztringre:

• False → 'False'
• True → 'True'

Null

• Logikai értékre: False
• Számba: 0
• Sztringre: '' (az üres sztring)

Szám

• Logikai értékre: 0 → False, bármely más szám → True
• Verzió: Nullánál nagyobbnak kell lennie, és nem nulla tizedesjegyet kell tartalmaznia. Kisebbnek kell lennie, mint az Int32.MaxValue (decimális összetevő).
• Sztringgé: A számot ezres elválasztó és tizedesjel nélküli sztringgé alakítja.

Sztring

• Logikai: '' (az üres sztring) → False, bármely más sztring → True
• Null értékre: '' (az üres sztring) → Null, bármely más sztring nem konvertálható
• A számhoz: '' (az üres sztring) → 0, ellenkező esetben a C#-ot az InvariantCulture használatával futtatjaInt32.TryParse, és a következő szabályokat: AllowDecimalPoint | AllowLeadingSign | AllowLeadingWhite | AllowThousands | AllowTrailingWhite. Ha TryParse nem sikerül, akkor nem konvertálható.
• Verzió: A C#-fájl futtatása Version.TryParse. Legalább fő- és alösszetevőt kell tartalmaznia. Ha TryParse nem sikerül, akkor nem konvertálható.

Verzió

• Logikai értékre: True
• Karakterlánc: Major.Minor vagy Major.Minor.Build vagy Major.Minor.Build.Revision.

GYIK

Olyan dolgot szeretnék tenni, amit a kifejezések nem támogatnak. Milyen lehetőségekkel bővíthetem a folyamatokat?

A folyamat testre szabható egy kifejezést tartalmazó szkripttel. Ez a kódrészlet például felveszi a változót BUILD_BUILDNUMBER , és felosztja a Bash használatával. Ez a szkript két új változót ad ki, $MAJOR_RUN valamint $MINOR_RUNa fő és a kisebb futtatási számokat. A rendszer ezután két folyamatváltozót hoz létre, $major és $minor a task.setvariable függvényt használja. Ezek a változók elérhetők az alsóbb rétegbeli lépésekhez. A változók folyamatok közötti megosztásához lásd: Változócsoportok.

steps:
- bash: |
    MAJOR_RUN=$(echo $BUILD_BUILDNUMBER | cut -d '.' -f1)
    echo "This is the major run number: $MAJOR_RUN"
    echo "##vso[task.setvariable variable=major]$MAJOR_RUN"

    MINOR_RUN=$(echo $BUILD_BUILDNUMBER | cut -d '.' -f2)
    echo "This is the minor run number: $MINOR_RUN"
    echo "##vso[task.setvariable variable=minor]$MINOR_RUN"

- bash: echo "My pipeline variable for major run is $(major)"
- bash: echo "My pipeline variable for minor run is $(minor)"