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

Kifejezések

  • Cikk

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 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-Z 0-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ó b a é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

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

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

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

Lt

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

A elseif záradékok az else Azure DevOps 2022-től kezdve érhetők el, és nem érhetők el az Azure DevOps Server 2020-hoz és az Azure DevOps korábbi verzióihoz.

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 results outputsté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 runTests true. Figyelje meg, hogy a szótárhoz használt kulcs az outputs build_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 shouldTest truefügg: . Figyelje meg, hogy a condition test 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 True False lesznek konvertálva 1 0 . 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 -
Nulla 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)"