Es gibt noch viele weitere gute Möglichkeiten um Strings bearbeiten oder untersuchen zu können. Ich möchte folgende Funktionen näher beschreiben Trim(). Dazu gehörten noch TrimStart() und TrimEnd(). Weiter geht es mit SubString(), Contains(), ToLower(), ToUpper(), StartsWith(), EndsWith().
Trim()
Trim eignet sich zum Entfernen von Leerzeichen (Spaces) am Anfang und Ende eines Strings. Sieht der String beispielsweise wie folgt aus: $String = “ Anfang und Ende „. Mit $String.Trim() werden die Leerzeichen vorne und hinten weggekürzt. Um den String dauerhaft ohne diese Leerzeichen darzustellen, muss der String sich selbst samt der Trim() Funktion zugewiesen werden. Das sähe dann so aus $String = $String.Trim(). Dies gilt auch für alle anderen Funktionen, wenn die Änderungen am String festgehalten werden sollen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
$string = " Anfang und Ende " Write-Host $string Write-Host $string.Trim() #Ausgabe # Anfang und Ende #Anfang und Ende ######################### #String ändern $string = $string.Trim() Write-Host $string #Ausgabe #Anfang und Ende |
TrimStart(), TrimEnd()
Mit TrimStart() lassen sich bestimmte Anfänge eines Strings entfernen, analog verhält es sich mit TrimEnd(). Das Ganze anhand eines kleinen Beispiels. Im Beispiel habe ich den DistinguishedName, kurz DN, meines Benutzers in einem String gespeichert. Dieser geht mit „CN=“ los. Möchte ich nun diesen Teil des Strings entfernen, könnte ich dies mit Remove() oder gar mit Replace() (vgl. PowerShell – 03 – Strings zerlegen) bewerkstelligen, aber ich werde es mit TrimStart() machen.
Warum nun mit TrimStart()? Ganz einfach, wenn mehre Variablen durch eine Schleife laufen und ich explizit Strings bearbeiten möchte die mit „CN=“ anfangen eignet sich nur diese Funktion. Remove() würde in jedem String die ersten drei Zeichen hemmungslos entfernen und Replace() würde an allen Stellen das „CN=“ entfernen. Ich möchte es aber nur am Anfang entfernen. Also muss ich mit TrimStart() arbeiten.
|
1 2 3 4 5 6 |
#TrimStart() $User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.TrimStart("CN=") #Ausgabe #Stefan.Rehwald,OU=Users,OU=intern |
Bei EndTrim() verhält dies sich analog zu TrimStart(). Im Beispiel möchte ich die Domain des Users entfernen.
|
1 2 3 4 5 6 |
#TrimEnd() $User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.TrimEnd(",OU=intern") #Ausgabe #CN=Stefan.Rehwald,OU=Users |
Das ist im Großen und Ganzen das Geheimnis um Trim() unter PowerShell. Kommen wir nun zu Substring().
Substring()
Bei Substring() wird die Stelle des Strings angeben ab der man beginnen möchte den String darzustellen. Substring() eignet sich nur um den String von links nach rechts zu verkürzen. Möchte ich, wie in meinem Beispiel das „CN=“ am Anfang weglassen, zähle ich die Stellen der Wegzulassenden Zeichen von links nach rechts, beginnend bei Eins.
Wieso zähle ich nicht wie üblich von Null aus? Ganz einfach, $String.Substring(0) steht für den kompletten Inhalt des Strings und würde somit auch den gesamten String darstellen. Zum besseren Verständnis das Ganze anhand eines Code-Beispiels.
|
1 2 3 4 5 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" write-host $User.Substring(0) #Ausgabe #"CN=Stefan.Rehwald,OU=Users,OU=intern" |
Gibt mal also $User.Substring(3) an, werden die ersten drei Zeichen weggeschnitten. steht. Weiter geht nach dem Code-Beispiel mit Contains().
|
1 2 3 4 5 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" write-host $User.Substring(3) #Ausgabe #Stefan.Rehwald,OU=Users,OU=intern |
Contains()
Die Funktion Contains() ist gut vergleichbar mit dem Parameter Match (vgl. PowerShell – 3.1 – Parameter match), allerdings gibt es bei Contains() keine Gegenpart wie etwa unmatch. Contains() gibt wie Match einen Boolean-Wert zurück. Der vielleicht wichtigste Unterschied zwischen Contains() und Match ist, dass Contains() Case Sensitiv ist und Match hingegen nicht. Im Code-Beispiel möchte ich wissen, ob der String meinen Namen Stefan enthält. Einmal suche ich nach Stefan und einmal nach stefan.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.Contains("Stefan") #Ausgabe #true ######################### $User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.Contains("stefan") #Ausgabe #false |
Wie zusehen ist, erb die Suche nach Stefan true und nach stefan eben false, da Contains() die Groß- und Kleinschreibung beachtet. Kommen wir nun zu ToLower() und ToUpper().
ToLower(), ToUpper()
Wie die Namen schon vermuten lassen, kann die Funktion ToLower() eine String komplett klein schreiben und die Funktion ToUpper() wandelt alle Buchstaben in die Großschreibweise. Das erste Code-Beispiel zeigt ToLower() im Einsatz.
|
1 2 3 4 5 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.ToLower() #Ausgabe #cn=stefan.rehwald,ou=users,ou=intern |
Hier noch ToUpper() in Aktion.
|
1 2 3 4 5 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.ToUpper() #Ausgabe #CN=STEFAN.REHWALD,OU=USERS,OU=INTERN |
Soweit so gut. Schwenken wir zu StartsWith() und EndsWith() anschließend werde ich zeigen, dass sich fast alle Funktionen beliebig in einer Zeile Code kombinieren lassen.
StartsWith(), EndsWith()
StartsWith() und EndsWith() geben jeweils einen Boolean-Wert aus. So wird ähnlich wie bei TrimStart() der Anfang des Strings untersucht, wieder analog zu TrimEnd() Und EndsWith(). Diese beiden Funktionen sind ebenfalls wie Contains() Case Sensitiv. Ich Prüfe im Code-Beispiel ob der String mit „CN=“ beginnt und einmal ob er mit „ern“ endet.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.StartsWith("CN=") #Ausgabe #true ######################### $User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.EndsWith("ern") #Ausgabe #true |
Beide Funktionen geben den Wert true aus, da die Anforderungen erfüllt wurden. Nun prüfe ich, ob der String am Anfang mit „Cn=“ beginnt und mit „Ou=intern“ endet.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.StartsWith("Cn=") #Ausgabe #false ######################### $User<strong> =</strong> "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.EndsWith("Ou=intern") #Ausgabe #false |
Beide Funktionen geben den Wert false aus, da diese Case Sensitiv sind. Kommen wir nun zum großen Mashup der einzelnen Funktionen. Fast alle Funktionen lassen sich wunderbar beliebig oft miteinander verschachteln. Eine Ausnahme stellen alle Funktionen dar, die einen Boolean-Wert zurückgeben. Diese lassen sich nicht kombinieren. Wie folgendes Beispiel zeigt.
|
1 2 3 4 5 |
$User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.ToUpper().StartsWith("CN=") #Ausgabe #true |
Nun noch einige mögliche Kombinationen, wobei das längst nicht alle sind. So sind wie im zweiten Code-Beispiel auch mehrfache Verkettungen möglich. Dieses Spiel kann sehr weit getrieben werden. Die Beispiele sollten einen guten Anreiz geben, was alles möglich ist.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
$User = " CN=Stefan.Rehwald,OU=Users,OU=intern " Write-Host $User.Trim().ToLower() #Ausgabe #cn=stefan.rehwald,ou=users,ou=intern ######################### $User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.ToUpper().Substring(3).Replace("=","*") #Ausgabe #STEFAN.REHWALD,OU*USERS,OU*INTERN ######################### $User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.Substring(10).ToLower() #Ausgabe #rehwald,ou=users,ou=intern ######################### $User = "CN=Stefan.Rehwald,OU=Users,OU=intern " Write-Host $User.Remove(26,10).Trim() #Ausgabe #CN=Stefan.Rehwald,OU=Users ######################### $User = "CN=Stefan.Rehwald,OU=Users,OU=intern" Write-Host $User.Split(",").ToUpper() #Ausgabe #CN=STEFAN.REHWALD OU=USERS OU=INTERN |
Ich hoffe die Funktionen ausreichend gut beschrieben zu haben und mit den Beispielen gute Möglichkeiten aufgezeigt zu haben, sodass die Funktionen auch praktisch eingesetzt werden können.
rewe
Böse Falle bei TrimStart (bzw. TrimEnd): Im Beispiel funktioniert das wie gewünscht, aber man sollte sich dessen bewußt sein, daß da kein String übergeben wird, sondern ein Array von Zeichen, d.h. im Zweifel wird da mehr abgeschnitten, als einem lieb ist.
Ciao
Sascha
Die Intention ist zwar sehr schön, aber sämtliche Beispiele sind extrem schlecht gewählt, weil stets ein sog. „Distingiushed Name“ bearbeitet wird. Das ist eine Eigenschaft von AD-Objekten und eben KEIN String und kann somit mit den vorgestellten Methoden auch nicht ohne weiteres bearbeitet werden.
Hallo Ronald,
der DN ist als String dem Objekt angefügt und lässt sich somit wie ein String verwerten. Alle Beispiele sind geprüft und funktionieren so wie sie aufgeführt sind. In meiner täglichen Arbeit manipuliere ich sehr oft Eigenschaften von AD-Objekte und dies ohne Konvertierungen. Gerne werde ich näheres morgen nochmal zum Thema niederschreiben.
Viele Grüße
Stefan