Uttryck

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

En annan vanlig användning av uttryck är att definiera variabler. Uttryck kan utvärderas vid kompilering eller vid körning. Kompilera tidsuttryck kan användas var som helst. körningsuttryck kan användas i variabler och villkor. Körningsuttryck är avsedda som ett sätt att beräkna innehållet i variabler och tillstånd (exempel: 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> ]

Skillnaden mellan körnings- och kompileringstidsuttryckssyntaxer är främst vilken kontext som är tillgänglig. I ett kompileringsuttryck (${{ <expression> }}) har du åtkomst till parameters och statiskt definierat variables. I ett körningsuttryck ($[ <expression> ]) har du åtkomst till fler variables men inga parametrar.

I det här exemplet anger ett körningsuttryck värdet $(isMain)för . En statisk variabel i ett kompileringsuttryck anger värdet $(compileVar)för .

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

sammansmälta

• Utvärderar parametrarna i ordning (från vänster till höger) och returnerar det första värdet som inte är lika med null eller tom sträng.
• Inget värde returneras om parametervärdena alla är null- eller tomma strängar.
• Minsta parametrar: 2. Maxparametrar: N
• Exempel: coalesce(variables.couldBeNull, variables.couldAlsoBeNull, 'literal so it always works')

convertToJson

• Ta ett komplext objekt och mata ut det som JSON.
• Minsta parametrar: 1. Maxparametrar: 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) }}

Skriptutdata:

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

räknare

• Den här funktionen kan bara användas i ett uttryck som definierar en variabel. Det kan inte användas som en del av ett villkor för ett steg, ett jobb eller en fas.
• Utvärderar ett tal som ökas med varje körning av en pipeline.
• Parametrar: 2. prefix och seed.
• Prefix är ett stränguttryck. Ett separat värde för räknaren spåras för varje unikt prefixvärde. Ska prefix använda UTF-16 tecken.
• Seed är startvärdet för räknaren

Du kan skapa en räknare som automatiskt ökas med en i varje körning av pipelinen. När du definierar en räknare anger du en prefix och en seed. Här är ett exempel som visar detta.

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)

Värdet minor för i exemplet ovan i den första körningen av pipelinen är 100. I den andra körningen är den 101, förutsatt att värdet major för fortfarande är 1.

Om du redigerar YAML-filen och uppdaterar värdet för variabeln major till 2 blir värdet minor 100 i nästa körning av pipelinen. Efterföljande körningar ökar räknaren till 101, 102, 103, ...

Senare, om du redigerar YAML-filen och anger värdet major för tillbaka till 1, återupptas värdet för räknaren där den slutade för prefixet. I det här exemplet återupptas den vid 102.

Här är ett annat exempel på hur du ställer in en variabel som ska fungera som en räknare som börjar vid 100, ökas med 1 för varje körning och återställs till 100 varje dag.

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

Här är ett exempel på att ha en räknare som behåller ett separat värde för PR:er och CI-körningar.

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

Räknare är begränsade till en pipeline. Med andra ord ökas dess värde för varje körning av pipelinen. Det finns inga räknare med projektomfattning.

format

• Utvärderar de avslutande parametrarna och infogar dem i den inledande parametersträngen
• Minsta parametrar: 1. Maxparametrar: N
• Exempel: format('Hello {0} {1}', 'John', 'Doe')
• Använder anpassade .NET-datum- och tidsformatsspecificerare för datumformatering (yyyy, , yyMM, M, dd, d, f) ffKHHHmmmsssffff
• Exempel: format('{0:yyyyMMdd}', pipeline.startTime). I det här fallet pipeline.startTime är en särskild objektvariabel för datumtid.
• Fly genom att fördubbla klammerparenteser. Till exempel: format('literal left brace {{ and literal right brace }}')

anslut

• Sammanfogar alla element i den högra parametermatrisen, avgränsade med den vänstra parametersträngen.
• Minsta parametrar: 2. Maxparametrar: 2
• Varje element i matrisen konverteras till en sträng. Komplexa objekt konverteras till en tom sträng.
• Om rätt parameter inte är en matris är resultatet rätt parameter konverterad till en sträng.

I det här exemplet läggs ett semikolon till mellan varje objekt i matrisen. Parametertypen är ett objekt.

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

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

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

nedre

• Konverterar ett sträng- eller variabelvärde till alla gemener
• Minsta parametrar: 1. Maxparametrar 1
• Returnerar gemener som motsvarar en sträng
• Exempel: lower('FOO') returnerar foo

ersätt

• Returnerar en ny sträng där alla instanser av en sträng i den aktuella instansen ersätts med en annan sträng
• Minsta parametrar: 3. Maxparametrar: 3
• replace(a, b, c): returnerar en, med alla instanser av b ersatta av c
• Exempel: replace('https://www.tinfoilsecurity.com/saml/consume','https://www.tinfoilsecurity.com','http://server') (returnerar http://server/saml/consume)

dela

• Delar upp en sträng i delsträngar baserat på de angivna avgränsande tecknen
• Minsta parametrar: 2. Maxparametrar: 2
• Den första parametern är strängen som ska delas
• Den andra parametern är de avgränsande tecknen
• Returnerar en matris med delsträngar. Matrisen innehåller tomma strängar när avgränsande tecken visas i följd eller i slutet av strängen
• Exempel:

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

• Exempel på användning av split() med replace():

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

övre

• Konverterar ett sträng- eller variabelvärde till alla versaler
• Minsta parametrar: 1. Maxparametrar 1
• Returnerar versaler som motsvarar en sträng
• Exempel: upper('bah') returnerar BAH

Du kan använda if, elseifoch else -satser för att villkorligt tilldela variabelvärden eller ange indata för aktiviteter. Du kan också villkorligt köra ett steg när ett villkor uppfylls.

Du kan använda if för att villkorligt tilldela variabelvärden eller ange indata för aktiviteter. Du kan också villkorligt köra ett steg när ett villkor uppfylls.

elseif Satserna och else är tillgängliga från och med Azure DevOps 2022 och är inte tillgängliga för Azure DevOps Server 2020 och tidigare versioner av Azure DevOps.

Villkorligt ange indata för en aktivitet

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'

Kör ett steg villkorligt

Om det inte finns någon variabeluppsättning, eller om foo värdet för inte matchar if villkoren, körs -instruktionen else . Här returnerar värdet foo för true i villkoret elseif .

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"

Varje nyckelord

Du kan använda nyckelordet each för att loopa igenom parametrar med objekttypen.

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

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

Dessutom kan du iterera genom kapslade element i ett objekt.

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

Beroenden

Uttryck kan använda beroendekontexten för att referera till tidigare jobb eller faser. Du kan använda beroenden för att:

• Referera till jobbstatusen för ett tidigare jobb
• Referera till fasstatusen för en tidigare fas
• Referensutdatavariabler i föregående jobb i samma fas
• Referera till utdatavariabler i föregående steg i en fas
• Referera till utdatavariabler i ett jobb i en tidigare fas i följande steg

Kontexten anropas dependencies för jobb och faser och fungerar ungefär som variabler. Om du refererar till en utdatavariabel från ett jobb i en annan fas kallas stageDependencieskontexten .

Om du har problem med att utdatavariabler har citattecken (' eller ") i dem kan du läsa den här felsökningsguiden.

Översikt över beroendesyntax

Syntaxen för att referera till utdatavariabler med beroenden varierar beroende på omständigheterna. Här är en översikt över de vanligaste scenarierna. Det kan finnas tillfällen då alternativ syntax också fungerar.

Det finns också olika syntaxer för utdatavariabler i distributionsjobb beroende på distributionsstrategin. Mer information finns i Distributionsjobb.

Beroenden mellan steg till steg

Strukturellt är objektet dependencies en karta över jobb- och fasnamn till results och outputs. Uttryckt som JSON skulle det se ut så här:

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

Använd den här formen för dependencies att mappa i variabler eller kontrollera villkor på en stegnivå.

I det här exemplet finns det två steg, A och B. Steg A har villkoret false och körs aldrig som ett resultat. Steg B körs om resultatet av steg A är Succeeded, SucceededWithIssueseller Skipped. Steg B körs eftersom steg A hoppades över.

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

Faser kan också använda utdatavariabler från en annan fas. I det här exemplet finns det också två steg. Steg A innehåller ett jobb, A1, som anger en utdatavariabel shouldrun till true. Steg B körs när shouldrun är true. Eftersom shouldrun är true, körs steg B.

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

Jobb till jobbberoenden inom en fas

På jobbnivå i en enda fas dependencies innehåller data inte information på stegnivå.

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

I det här exemplet finns det tre jobb (a, b och c). Jobb a hoppas alltid över på grund av condition: false. Jobb b körs eftersom det inte finns några associerade villkor. Jobbet c körs eftersom alla dess beroenden antingen lyckas (jobb b) eller hoppas över (jobb a).

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

I det här exemplet beror jobb B på en utdatavariabel från jobb A.

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

Jobb till jobbberoenden mellan olika faser

På jobbnivå kan du också referera till utdata från ett jobb i ett tidigare skede. Detta kräver att kontexten stageDependencies används.

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

I det här exemplet körs jobbet B1 om jobbet A1 hoppas över. Jobb B2 kontrollerar värdet för utdatavariabeln från jobb A1 för att avgöra om den ska köras.

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

Om ett jobb är beroende av en variabel som definierats av ett distributionsjobb i en annan fas är syntaxen annorlunda. I följande exempel körs jobbet run_tests om distributionsjobbet build_job är inställt runTests på true. Observera att nyckeln som används för outputs ordlistan är 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:
        ...

Utdatavariabler för distributionsjobb

Om en fas är beroende av en variabel som definierats av ett distributionsjobb i en annan fas är syntaxen annorlunda. I följande exempel beror fasen test på distributionsinställningen build_job shouldTest till true. Observera att i steget condition test build_job visas två gånger.

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

I exemplet ovan refererar villkoret till en miljö och inte en miljöresurs. Om du vill referera till en miljöresurs måste du lägga till miljöresursnamnet i beroendevillkoret. I följande exempel refererar villkoret till en miljöresurs för virtuella datorer med namnet 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