Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# VariableCheck
<a name="rule-reference-VariableCheck"></a>

Wenn Sie eine Bedingung erstellen, können Sie die `VariableCheck` Regel hinzufügen. Dieser Abschnitt enthält eine Referenz zu den Regelparametern. Weitere Informationen zu Regeln und Bedingungen finden Sie unter[Wie funktionieren die Stufenbedingungen?](concepts-how-it-works-conditions.md).

Sie können die `VariableCheck` Regel verwenden, um eine Bedingung zu erstellen, bei der die Ausgabevariable mit einem angegebenen Ausdruck verglichen wird. Die Regel besteht die Prüfung, wenn der Variablenwert die Regelkriterien erfüllt, z. B. wenn der Wert gleich oder größer als eine angegebene Ausgabevariable ist.

**Topics**
+ [Art der Regel](#rule-reference-VariableCheck-type)
+ [Konfigurationsparameter](#rule-reference-VariableCheck-config)
+ [Beispiel für eine Regelkonfiguration](#rule-reference-VariableCheck-example)
+ [Weitere Informationen finden Sie auch unter](#rule-reference-VariableCheck-links)

## Art der Regel
<a name="rule-reference-VariableCheck-type"></a>
+ Kategorie: `Rule`
+ Eigentümer: `AWS`
+ Anbieter: `VariableCheck`
+ Version: `1`

## Konfigurationsparameter
<a name="rule-reference-VariableCheck-config"></a>

**Operator**  
Erforderlich: Ja  
Der Operator, der angibt, welche Operation für die Variablenprüfung ausgeführt werden soll.  
Im folgenden Beispiel wird die Ausgabevariable für den Repository-Namen daraufhin überprüft, ob sie gleich ist`MyDemoRepo`.  

```
        "configuration": {
            "Variable": "#{SourceVariables.RepositoryName}",
            "Value": "MyDemoRepo",
            "Operator": "EQ"
        },
```
Die folgenden Operatoren stehen zur Verfügung, um einen Ausdruck wie folgt zu erstellen.  
+ **Gleich** — Wählen Sie diesen Operator, um zu überprüfen, ob die Variable dem Zeichenkettenwert entspricht.

  **CLI-Parameter:** `EQ`
+ **Enthält** — Wählen Sie diesen Operator, um zu überprüfen, ob die Variable den Zeichenkettenwert als Teilstring enthält.

  **CLI-Parameter:** `CONTAINS`
+ **Entspricht** — Wählen Sie diesen Operator, um zu überprüfen, ob die Variable einem bestimmten Regex-Ausdruck als Zeichenkettenwert entspricht. 

  Alle regulären Ausdrücke CodePipeline entsprechen der Java-Regex-Syntax. Eine umfassende Beschreibung der Java Regex-Syntax und ihrer Konstrukte finden Sie unter [java.util.regex.Pattern](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html).

  **CLI-Parameter:** `MATCHES`
+ **Entspricht nicht** — Wählen Sie diesen Operator, um zu überprüfen, ob die Variable nicht dem Zeichenkettenwert entspricht.

  **CLI-Parameter:** `NE`

**Variable**  
Erforderlich: Ja  
Die zu überprüfenden Pipeline-Variablen.

**Wert**  
Erforderlich: Ja  
Der Wert für den Ausdruck, gegen den geprüft werden soll.  
Im folgenden Beispiel wird die Ausgabevariable für den Repository-Namen daraufhin überprüft, ob sie gleich ist`MyDemoRepo`.  

```
        "configuration": {
            "Variable": "#{SourceVariables.RepositoryName}",
            "Value": "MyDemoRepo",
            "Operator": "EQ"
        },
```

Im folgenden JSON-Beispiel werden zwei separate Regeln definiert, eine für eine `EQ` (equals) -Anweisung, die das Repository überprüft, und den Branch-Namen, formatiert als \$1 \$1. SourceVariables RepositoryName\$1 und eine davon überprüft `CONTAINS` die als \$1 \$1formatierte Ausgabevariable der Commit-Nachricht. SourceVariables CommitMessage\$1 gegen den angegebenen Wert „update“.

```
  "beforeEntry": {
                    "conditions": [
                        {
                            "result": "FAIL",
                            "rules": [
                                {
                                    "name": "MyVarCheckRule",
                                    "ruleTypeId": {
                                        "category": "Rule",
                                        "owner": "AWS",
                                        "provider": "VariableCheck",
                                        "version": "1"
                                    },
                                    "configuration": {
                                        "Operator": "EQ",
                                        "Value": "MyDemoRepo",
                                        "Variable": "#{SourceVariables.RepositoryName}"
                                    },
                                    "inputArtifacts": [],
                                    "region": "us-east-1"
                                },
                                {
                                    "name": "MyVarCheckRuleContains",
                                    "ruleTypeId": {
                                        "category": "Rule",
                                        "owner": "AWS",
                                        "provider": "VariableCheck",
                                        "version": "1"
                                    },
                                    "configuration": {
                                        "Operator": "CONTAINS",
                                        "Value": "update",
                                        "Variable": "#{SourceVariables.CommitMessage}"
                                    },
                                    "inputArtifacts": [],
                                    "region": "us-east-1"
                                }
                            ]
                        }
                    ]
                }
            }
        ],
```

## Beispiel für eine Regelkonfiguration
<a name="rule-reference-VariableCheck-example"></a>

------
#### [ YAML ]

```
- name: MyVariableCheck
  ruleTypeId:
    category: Rule
    owner: AWS
    provider: VariableCheck
    version: '1'
  configuration:
    Variable: "#{SourceVariables.RepositoryName}"
    Value: MyDemoRepo
    Operator: EQ
  inputArtifacts: []
  region: us-west-2
```

------
#### [ JSON ]

```
"rules": [
    {
        "name": "MyVariableCheck",
        "ruleTypeId": {
            "category": "Rule",
            "owner": "AWS",
            "provider": "VariableCheck",
            "version": "1"
        },
        "configuration": {
            "Variable": "#{SourceVariables.RepositoryName}",
            "Value": "MyDemoRepo",
            "Operator": "EQ"
        },
        "inputArtifacts": [],
        "region": "us-west-2"
    }
]
```

------

## Weitere Informationen finden Sie auch unter
<a name="rule-reference-VariableCheck-links"></a>

Die folgenden verwandten Ressourcen können Ihnen bei der Arbeit mit dieser Regel helfen.
+ [Tutorial: Erstellen Sie eine Regel zur Überprüfung variabler Variablen für eine Pipeline als Eingabebedingung](tutorials-varcheckrule.md)— Dieser Abschnitt enthält ein Tutorial mit Schritten zum Erstellen einer Bedingung bei der Eingabe mit einer Regel zur Überprüfung von Variablen.
+ [Variablen-Referenz](reference-variables.md)— Dieser Abschnitt enthält Referenzinformationen und Beispiele für Pipeline-Variablen.
+ Weitere Informationen zu Regeln und Bedingungen finden Sie unter [[RuleTypeId](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_RuleTypeId.html)Bedingung](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_Condition.html) und [RuleExecution](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_RuleExecution.html)im *CodePipeline API-Leitfaden*.