Wie man den Beginn eines Strings mit PowerShell überprüft

1. Verwendung des logischen Operators -like, um den Anfang einer Zeichenfolge in PowerShell zu überprüfen
2. Verwendung des logischen Operators -clike, um den Anfang einer Zeichenfolge in PowerShell zu überprüfen
3. Verwendung der Funktion StartsWith(), um den Anfang einer Zeichenfolge in PowerShell zu überprüfen
4. Vergleich mit Substring, um den Anfang einer Zeichenfolge in PowerShell zu überprüfen
5. Fazit

Es könnte Fälle geben, in denen wir auf einen Anwendungsfall stoßen, der Funktionalität erfordert, um zu überprüfen, ob eine Zeichenfolgenvariable mit einem Zeichen oder einer Zeichenfolge beginnt. Die Überprüfung, ob eine Zeichenfolge mit einem bestimmten Zeichen oder einer Zeichenfolge beginnt, ist eine gängige Praxis beim Erstellen von Skripten und auch in Windows PowerShell relativ einfach zu schreiben.

Dieser Artikel zeigt, wie man den Anfang einer Zeichenfolgenvariable mit verschiedenen Methoden in Windows PowerShell überprüft.

Verwendung des logischen Operators -like, um den Anfang einer Zeichenfolge in PowerShell zu überprüfen

In PowerShell ist der logische Operator -Like ein leistungsfähiges Werkzeug für die Mustererkennung. Wenn er verwendet wird, um den Anfang einer Zeichenfolge zu überprüfen, ermöglicht er flexible Vergleiche basierend auf Platzhaltern.

Standardmäßig ignoriert der Operator -Like die Groß- und Kleinschreibung. Wenn wir jedoch logische Operatoren verwenden, muss er mit einem Platzhalter-Sternchen (*) verbunden sein.

Code:

 powershellCopy$strVal = 'Hello World'
if ($strVal -like 'hello*') {
    Write-Host "Your string starts with hello."
}
else {
    Write-Host "Your string does not start with hello."
}

Ausgabe:

 textCopyYour string starts with hello.

Im Code initialisieren wir eine Zeichenfolgenvariable, $strVal = 'Hello World'. Dann verwenden wir den Operator -like, um zu überprüfen, ob die Zeichenfolge ($strVal) mit dem Präfix 'hello' beginnt.

Der Operator -like ermöglicht die Mustererkennung mit Platzhaltern, und in diesem Fall steht das Sternchen (*) für null oder mehr Zeichen. Die Bedingung prüft, ob die Zeichenfolge mit dem Muster 'hello*' übereinstimmt.

In diesem Fall ist die Bedingung wahr, und die Ausgabe ist Ihre Zeichenfolge beginnt mit hello.

Verwendung des logischen Operators -clike, um den Anfang einer Zeichenfolge in PowerShell zu überprüfen

Der Operator -clike in PowerShell wird verwendet, um einen Groß- und Kleinschreibung empfindlichen Vergleich von Zeichenfolgen durchzuführen. Er überprüft, ob eine Zeichenfolge einem bestimmten Muster entspricht, ähnlich wie der Operator -like, aber er ist groß- und kleinschreibungsempfindlich.

Das bedeutet, dass der Operator -clike nur True zurückgibt, wenn die Groß- und Kleinschreibung der Zeichen in der Zeichenfolge genau mit der Groß- und Kleinschreibung der Zeichen im Muster übereinstimmt. Wir können den Operator -cLike verwenden, um einen groß- und kleinschreibungsempfindlichen Vergleich durchzuführen.

Code:

 powershellCopy$strVal = 'Hello World!'
if ($strVal -clike 'h*') {
    Write-Host "Your string starts with lowercase h."
}
else {
    Write-Host "Your string starts with uppercase H."
}

Ausgabe:

 textCopyYour string starts with uppercase H.

In diesem Code initialisieren wir eine Zeichenfolgenvariable, $strVal, mit dem Wert 'Hello World!'. Wir verwenden den Operator -clike, der für den groß- und kleinschreibungsempfindlichen Vergleich von Zeichenfolgen verwendet wird, um zu überprüfen, ob die Zeichenfolge mit dem Kleinbuchstaben 'h' beginnt.

Die Bedingung prüft, ob die Zeichenfolge in groß- und kleinschreibungsempfindlicher Weise mit dem Muster 'h*' übereinstimmt. Da die Bedingung falsch ist, was darauf hinweist, dass die Zeichenfolge mit einem Großbuchstaben 'H' beginnt, geben wir aus Ihre Zeichenfolge beginnt mit Großbuchstaben H.

Denken Sie daran, der Operator -clike ist groß- und kleinschreibungsempfindlich, daher wird er keine Übereinstimmung mit Zeichenfolgen finden, wenn die Groß- und Kleinschreibung der Zeichen nicht genau übereinstimmt. Wenn wir einen groß- und kleinschreibungsunempfindlichen Vergleich durchführen möchten, können wir stattdessen den Operator -like verwenden.

Verwendung der Funktion StartsWith(), um den Anfang einer Zeichenfolge in PowerShell zu überprüfen

Wir können auch die String-Erweiterungsfunktion des .NET-Frameworks namens StartsWith() verwenden, um zu überprüfen, ob eine Zeichenfolge mit einer bestimmten Zeichenfolge beginnt.

Die Funktion StartsWith() in PowerShell ist eine Methode, um zu überprüfen, ob eine Zeichenfolge mit einem bestimmten Präfix beginnt. Die Funktion StartsWith() ist eine integrierte Methode für Zeichenfolgen in PowerShell, die einen Booleschen Wert zurückgibt, der angibt, ob die gegebene Zeichenfolge mit dem angegebenen Teilstring beginnt.

Code:

 powershellCopy$strVal = 'Hello World!'
if ($strVal.StartsWith('Hello')) {
    Write-Host 'Your string starts with hello.'
}
else {
    Write-Host 'Your string does not start with hello.'
}

Ausgabe:

 textCopyYour string starts with hello.

Im obigen Code überprüfen wir, ob die Zeichenfolgenvariable $strVal mit 'Hello' beginnt, indem wir die Methode StartsWith() verwenden. Da die Bedingung wahr ist, geben wir aus Ihre Zeichenfolge beginnt mit hello.

Die Funktion StartsWith akzeptiert auch ein weiteres Argument, mit dem wir nach groß- und kleinschreibungsempfindlichen Zeichen suchen können. Dieses Argument ist CurrentCultureIgnoreCase.

Wir verwenden die folgende Methode, wenn wir einen groß- und kleinschreibungsempfindlichen Vergleich durchführen möchten.

Code:

 powershellCopy$strVal = 'Hello world'
if ($strVal.StartsWith('hello', 'CurrentCultureIgnoreCase')) {
    Write-Host 'True'
}
else {
    Write-Host 'False'
}

Ausgabe:

 textCopyTrue

In diesem Code überprüfen wir, ob die Zeichenfolgenvariable $strVal mit 'hello' in einer groß- und kleinschreibungsunempfindlichen Weise beginnt, indem wir die Methode StartsWith() mit dem Parameter 'CurrentCultureIgnoreCase' verwenden. Da die Bedingung wahr ist, geben wir aus True.

Vergleich mit Substring, um den Anfang einer Zeichenfolge in PowerShell zu überprüfen

In diesem Ansatz wird die Funktion Substring() verwendet, um ein bestimmtes Präfix mit dem Anfangsabschnitt einer gegebenen Zeichenfolge zu vergleichen. Dieser Vergleich hilft dabei zu bestimmen, ob die Zeichenfolge mit der vordefinierten Zeichenfolge beginnt.

In PowerShell ermöglicht die Substring-Methode das Extrahieren eines Teils aus einer Zeichenfolge basierend auf dem angegebenen Startindex und der Länge. Indem wir diese Methode verwenden, können wir einen Teilstring aus der ursprünglichen Zeichenfolge gewinnen und dann mit einem gewünschten Präfix vergleichen, um zu überprüfen, ob die Zeichenfolge mit dieser bestimmten Zeichenfolge beginnt.

Grundsyntax:

 powershellCopy$substringToCompare = $strVal.Substring(0, $prefix.Length)

Parameter:

• $strVal - Dies ist die Variable, die die ursprüngliche Zeichenfolge enthält, aus der wir einen Teilstring extrahieren möchten.
• 0 - Die 0 ist der Startindex.
• $prefix.Length - Dies ist die Länge des auszustehenden Teilstrings. In unserem Beispiel ist es die Länge des Präfixes, das wir überprüfen möchten.
• $substringToCompare - Dies ist eine Variable, die das Ergebnis der Substring-Operation speichert. Sie enthält den aus der ursprünglichen Zeichenfolge extrahierten Teilstring.

Die obige Syntax erstellt im Wesentlichen einen Teilstring aus der ursprünglichen Zeichenfolge, beginnend von Anfang an, mit einer Länge, die der Länge des angegebenen Präfixes entspricht.

Code:

 powershellCopy$strVal = 'Hello World!'
$prefix = 'Hello'

if ($strVal.Substring(0, $prefix.Length) -eq $prefix) {
    Write-Output "String starts with $prefix"
}
else {
    Write-Output "String does not start with $prefix"
}

Ausgabe:

 textCopyString starts with Hello

In diesem Code haben wir eine Zeichenfolgenvariable, $strVal = 'Hello World!' und ein Präfix, $prefix = 'Hello'. Wir verwenden die Methode Substring(), um einen Teil der ursprünglichen Zeichenfolge beginnend ab Index 0 mit einer Länge zu extrahieren, die identisch mit der Länge des Präfixes ist.

Das Skript vergleicht dann diesen extrahierten Teilstring mit dem angegebenen Präfix unter Verwendung des Operators -eq. Da die Bedingung wahr ist, was darauf hinweist, dass die Zeichenfolge mit 'Hello' beginnt, geben wir aus Zeichenfolge beginnt mit Hello.

Fazit

Zusammenfassend hat dieser Artikel verschiedene Methoden gezeigt, um den Anfang einer Zeichenfolgenvariable in Windows PowerShell zu überprüfen. Wir haben die Verwendung des logischen Operators -like zur Mustererkennung erkundet, der seine Flexibilität mit Platzhaltern demonstriert.

Darüber hinaus haben wir den logischen Operator -clike für groß- und kleinschreibungsempfindliche Vergleiche behandelt. Außerdem haben wir die Funktion StartsWith() behandelt, die sowohl groß- als auch kleinschreibungsempfindliche sowie groß- und kleinschreibungsunempfindliche Überprüfungen verwendet, um zu bestimmen, ob die Zeichenfolge mit einem bestimmten Präfix beginnt.

Schließlich haben wir die Funktion Substring() als alternative Methode untersucht, die ihre Anwendung beim Vergleichen eines Teilstrings mit einer vordefinierten Zeichenfolge veranschaulicht und Ergebnisse basierend auf der Bewertung ausgibt. Diese Methoden bieten Vielseitigkeit für verschiedene Anwendungsfälle und verbessern die Fähigkeiten zum Vergleichen von Zeichenfolgen in PowerShell-Skripten.