Megosztás a következőn keresztül:

Kifejezések

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

Fontos

Válasszon ki egy verziót az Azure DevOps Content Version választóból.

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 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. Fordítási idő kifejezésben (${{ <expression> }}) hozzáférhet a parameters-hez és a statikusan definiált variables-höz. Egy futtatókörnyezeti kifejezésben ($[ <expression> ]) több variables-hez fér hozzá, de nem érhet el paramétereket.

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, karaktersorozat 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 }}

Boole-változó

True és False logikai literálkifejezések.

Nulla

A Null egy speciális literálkifejezés, amelyet egy szótárlekérdezési sikertelenség eseté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'-tól '9'-ig.

Sztring

Egyetlen idézőjelet kell használni. Például: 'this is a string'

A szó szerinti egyetlen idézőjel megadásához egyetlen idézőjellel kell megszökni azt. 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 vagy _
  • 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 karakterláncok. Ha gépelt értékeket szeretne használni, akkor inkább paramétereket kell használnia.

Megjegyzé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.

Függvények

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

és

  • Csak akkor értékel True, ha az összes paraméter True
  • Minimális paraméterek: 2. Maximális paraméterek: N
  • Logikai értékké alakít paramétereket kiértékelés céljából
  • Rövidzárlat az első False után
  • Példa: and(eq(variables.letters, 'ABC'), eq(variables.numbers, 123))

összenő

  • 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')

tartalmaz

  • 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 alakít át sztringgé kiértékeléshez
  • Kis- és nagybetűket figyelmen kívül hagyó ordinális összehasonlítás
  • Példa: contains('ABCDE', 'BCD') (igaz értéket ad vissza)

tartalmazÉrtéket

  • 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 rendszertelen, kis- és nagybetűkre érzéketlen összehasonlítása
  • Rövidzárlatok az első meccs után

Megjegyzés

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

A containsValue kifejezéssel egyező értéket kereshet egy objektumban. Íme egy példa, amely bemutatja, hogyan keresünk egyezést a forráságak listájában Build.SourceBranch számára.

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"

konvertálásJsonra

  • 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ó. Nem használható lépés, feladat vagy szakasz feltételeként.
  • Kiértékel egy számot, amely egy csővezeték 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ő minor értéke a csővezeték 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, ... számítva incrementálják.

Később, ha szerkeszti a YAML-fájlt, és visszaállítja az értéket major-ra 1-re, akkor a számláló értéke ott újraindul, ahol előzőleg abbahagyta az adott előtag esetében. 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.

Megjegyzé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 csővezetékre terjed ki. Más szóval az értéke a folyamat minden egyes futtatása esetén növekszik. Nincsenek projektszintű számlálók.

végződik

  • 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 alakít át sztringgé kiértékeléshez
  • Kis- és nagybetűket figyelmen kívül hagyó ordinális összehasonlítás
  • Példa: endsWith('ABCDE', 'DE') (igaz értéket ad vissza)

egyenlet

  • 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 rendszertelen, kis- és nagybetűkre érzéketlen összehasonlítása
  • Példa: eq(variables.letters, 'ABC')

formátum

  • 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')
  • A .NET egyéni dátum- és időformátum-meghatározók használatával történik a dátum és idő formázása (, yyyy, yy, MM, M, dd, d, HH, H, m, mm, ss, s, f, ff, ffff, K)
  • 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 rendszertelen, kis- és nagybetűkre érzéketlen ö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 rendszertelen, kis- és nagybetűkre érzéketlen összehasonlítása
  • Példa: gt(5, 2) (igaz értéket ad vissza)

ban

  • 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 rendszertelen, kis- és nagybetűkre érzéketlen összehasonlítása
  • Rövidzárlatok az első találat után
  • Példa: in('B', 'A', 'B', 'C') (igaz értéket ad vissza)

IIIF

  • A második paramétert adja vissza, ha az első paraméter kiértékeli True, a harmadik paramétert pedig ellenkező esetben.
  • Minimális paraméterek: 1. Maximális paraméterek: 3
  • Az első paraméternek feltételnek kell lennie
  • Példa: iif(eq(variables['Build.Reason'], 'PullRequest'), 'ManagedDevOpsPool', 'Azure Pipelines') a "ManagedDevOpsPool" értéket adja vissza, amikor a pipeline egy kérelemre válaszul fut.

Csatlakozz

  • Ö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ő kerül a tömb egyes elemei közé. 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 rendszertelen, kis- és nagybetűkre érzéketlen összehasonlítása
  • Példa: le(2, 2) (igaz értéket ad vissza)

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
  • Visszaadja egy sztring kisbetűs megfelelőjét.
  • Példa: lower('FOO') visszaadja foo

l

  • 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 rendszertelen, kis- és nagybetűkre érzéketlen ö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 rendszertelen, kis- és nagybetűkre érzéketlen összehasonlítása
  • Példa: ne(1, 2) (igaz értéket ad vissza)

nem

  • Kiértékeli True, ha a paraméter False
  • Minimális paraméterek: 1. Maximális paraméterek: 1
  • Az értéket logikai értékké alakítja kiértékelés céljából
  • Példa: not(eq(1, 2)) (igaz értéket ad vissza)

nincs benne

  • 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 rendszertelen, kis- és nagybetűkre érzéketlen összehasonlítása
  • Rövidzárlatok az első találat 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
  • Logikai értékké alakít paramétereket kiértékelés céljából
  • Rövidzárlat az első True után
  • 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): visszaadja a-t, ahol b minden példányát c-vel helyettesítették
  • Példa: replace('https://www.tinfoilsecurity.com/saml/consume','https://www.tinfoilsecurity.com','http://server') (visszaadja http://server/saml/consume)

oszt

  • 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ó karakterlánc.
  • A második paraméter az elválasztó karakterek
  • Visszaad egy részsztringekből álló tömböt. 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 }}

kezdődik

  • 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 alakít át sztringgé kiértékeléshez
  • Kis- és nagybetűket figyelmen kívül hagyó ordinális összehasonlítás
  • Példa: startsWith('ABCDE', 'AB') (igaz értéket ad vissza)

igazít

  • A paramétert kezdő és záró szóközök nélkül adja vissza
  • Minimális paraméterek: 1. Maximális paraméterek: 1
  • Példa: trim(' variable ') "változót" 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
  • Visszaadja a karakterlánc nagybetűs változatát.
  • 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
  • Logikai értékké alakít paramétereket kiértékelés céljából
  • 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 True az érték (még akkor is, ha megszakítás ellenére). Megjegyzés: Egy kritikus hiba továbbra is megakadályozhatja egy feladat futását. Ha például a források lekérése sikertelen volt.

Visszavont

  • Megadja True értéket, ha a folyamatot megszakították.

sikertelen

  • Egy lépés az alábbi(nak) 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és esetén 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 adja True eredményül, ha a függőségi gráf összes korábbi feladata sikeres vagy részben sikeres volt.
    • 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ékeléskor False értéket ad, ha a folyamatot megszakítják.

sikerültVagyKudarcotVallott

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

  • Feladat esetén:

    • Argumentumok nélkül a kiértékelés True eredményez, függetlenül attól, hogy a függőségi gráf bármely feladata sikeres vagy sikertelen volt-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(), kivéve hogy a False akkor kerül kiértékelésre, amikor a folyamat megszakad.

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 változóértékek feltételes hozzárendeléséhez vagy a tevékenységek bemeneteinek beállításához használható if . Feltételesen is futtathat egy lépést, ha teljesül egy feltétel.

Az elseif és else záradékok az Azure DevOps 2022-től kezdve érhetők el, és nem elérhetők az Azure DevOps Server 2020 és az Azure DevOps korábbi verziói számára.

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}}

Feladatbevitel 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'

Feltételes lépés 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(z) each kulcsszóval végigiterálhatja az objektumtípusú paramétereket.

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 kontextus dependencies néven ismert a feladatok és szakaszok számára, é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'))

munka közti függőség (ugyanabban a fázisban)

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 eltérő fázisban a job során.

  • 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 másik szakaszban lévő üzembehelyezési folyamatnál 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 a különböző fázisban található erőforrást tartalmazó üzembe helyezési feladat kimeneti változójára 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.

Szakaszok közötti függőségek

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
  }
}

Megjegyzé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 szakasz, A és B, található. Az A szakasz rendelkezik a feltétellel false, és ennek következtében soha nem fog futni. A B fázis akkor fut le, ha az A fázis eredménye Succeeded, SucceededWithIssues, vagy 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 shouldruntrue B 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

Megjegyzés

Alapértelmezés szerint a csővezeték minden szakasza a YAML-fájlban közvetlenül előtte lévő szakasztó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.

Feladatok közötti 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 condition: false 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 vagy sikeresen teljesült (b feladat), vagy át lett ugrva (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 különböző szakaszokban

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 feladat ki van hagyva. 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 build_job üzembe helyezési folyamat runTests -re true van állítva. Figyelje meg, hogy a szótárhoz használt kulcs a 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 az foo elemen szűrt tömbként működjön, majd válassza ki a id tulajdonságot.

Ez a következőt adja vissza:

[ 1, 2, 3 ]

típuskonverzió

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 az True és False értékek 1 és 0 értékekké lesznek konvertálva a kifejezés kiértékelésekor. 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)

Ha a kifejezést az egyenértékűség kiértékelésére használja, az eq() értékek implicit módon számokká lesznek konvertálva (false a számokra 0 és true a számokra 1).

variables:
  trueAsNumber: $[eq('true', true)] # 1 vs. 1, True
  falseAsNumber: $[eq('false', true)] # 0 vs. 1, False

steps:
- script: echo $(trueAsNumber)
- script: echo $(falseAsNumber)

Ebben a következő példában az értékek variables.emptyString és az üres sztring egyaránt üres sztringké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ó Boole-változó Nulla Szám Sztring Verzió
boolean - - Igen Igen -
Nulla Igen - Igen Igen -
Szám Igen - - Igen Részleges
Sztring Igen Részleges Részleges - Részleges
Verzió Igen - - Igen -

Boole-változó

Számozni:

  • False → 0
  • True → 1

Karakterláncra

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

Nulla

  • Logikai értékre: False
  • Számozás: 0
  • Szövegre: '' (az üres karakterlánc)

Szám

  • Logikai képletté: 0 → False, minden más szám → True
  • A verziónak nullánál nagyobbnak kell lennie, és tartalmaznia kell nem nulla tizedesrészt. Kisebbnek kell lennie, mint az Int32.MaxValue (decimális összetevő).
  • Sztringgé alakítja a számot, ezres elválasztó és tizedesjel nélkül.

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 Int32.TryParse használatával futtatja, és a következő szabályokat alkalmazza: 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 által nem lehet támogatni. Milyen lehetőségekkel bővíthetem a Pipelines funkcionalitását?

A Pipeline testre szabható egy kifejezést tartalmazó szkripttel. Ez a kódrészlet például veszi a BUILD_BUILDNUMBER változót, és Bash-sel osztja fel. Ez a szkript két új változót ad ki, $MAJOR_RUN a fő futtatási számra és $MINOR_RUN a kisebb futtatási számra. A két változót ezután arra használjuk, hogy két pipeline változót hozzunk létre, $major és $minor a task.setvariable függvény segítségével. 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)"