C# Language
Allgemeine Zeichenkettenoperationen
Suche…
Einen String nach bestimmten Zeichen aufteilen
string helloWorld = "hello world, how is it going?";
string[] parts1 = helloWorld.Split(',');
//parts1: ["hello world", " how is it going?"]
string[] parts2 = helloWorld.Split(' ');
//parts2: ["hello", "world,", "how", "is", "it", "going?"]
Teilstrings einer gegebenen Zeichenfolge abrufen
string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"
Substring gibt den String aus einem bestimmten Index oder zwischen zwei Indizes (beide inklusive) zurück.
Bestimmen Sie, ob eine Zeichenfolge mit einer angegebenen Sequenz beginnt
string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false
Einen String innerhalb eines Strings finden
Mit dem System.String.Contains Sie herausfinden, ob eine bestimmte Zeichenfolge in einer Zeichenfolge vorhanden ist. Die Methode gibt einen booleschen Wert zurück, true, wenn die Zeichenfolge vorhanden ist, andernfalls false.
string s = "Hello World";
bool stringExists = s.Contains("ello"); //stringExists =true as the string contains the substring
Abschneiden unerwünschter Zeichen am Anfang und / oder Ende von Zeichenfolgen.
String.Trim()
string x = " Hello World! ";
string y = x.Trim(); // "Hello World!"
string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"
String.TrimStart() und String.TrimEnd()
string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' ); // "{(Hi"
Eine Zeichenfolge formatieren
Verwenden Sie die String.Format() Methode, um ein oder mehrere Elemente in der Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts zu ersetzen:
String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar
Ein String-Array zu einem neuen zusammenfügen
var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);
//joined = "Foo, Bar, Fizz, Buzz"
Auffüllen einer Zeichenfolge auf eine feste Länge
string s = "Foo";
string paddedLeft = s.PadLeft(5); // paddedLeft = " Foo" (pads with spaces by default)
string paddedRight = s.PadRight(6, '+'); // paddedRight = "Foo+++"
string noPadded = s.PadLeft(2); // noPadded = "Foo" (original string is never shortened)
Konstruieren Sie einen String aus Array
Die String.Join Methode hilft uns beim String.Join einer Zeichenfolge aus einem Array / einer Liste von Zeichen oder einer Zeichenfolge. Diese Methode akzeptiert zwei Parameter. Der erste ist das Trennzeichen oder das Trennzeichen, das Ihnen hilft, jedes Element im Array zu trennen. Der zweite Parameter ist das Array selbst.
Zeichenfolge aus dem char array :
string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);
Ausgabe : a,b,c Wenn wir das delimiter als "" ändern, wird die Ausgabe zu abc .
Zeichenfolge aus der List of char :
string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);
Ausgabe : a|b|c
String aus der List of Strings :
string delimiter = " ";
List<string> stringList = new List<string>() { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringList);
Ausgabe : Ram is a boy
array of strings aus einem String- array of strings :
string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);
Ausgabe : Ram_is_a_boy
Formatierung mit ToString
Normalerweise verwenden wir die String.Format Methode zum Formatieren. Der .ToString wird normalerweise zum Konvertieren anderer Typen in eine Zeichenfolge verwendet. Wir können das Format zusammen mit der ToString-Methode angeben, während die Konvertierung stattfindet. So können wir eine zusätzliche Formatierung vermeiden. Lassen Sie mich erklären, wie es mit verschiedenen Typen funktioniert.
Ganzzahl für formatierte Zeichenfolge:
int intValue = 10;
string zeroPaddedInteger = intValue.ToString("000"); // Output will be "010"
string customFormat = intValue.ToString("Input value is 0"); // output will be "Input value is 10"
doppelt zu formatierter String:
double doubleValue = 10.456;
string roundedDouble = doubleValue.ToString("0.00"); // output 10.46
string integerPart = doubleValue.ToString("00"); // output 10
string customFormat = doubleValue.ToString("Input value is 0.0"); // Input value is 10.5
DateTime mit ToString formatieren
DateTime currentDate = DateTime.Now; // {7/21/2016 7:23:15 PM}
string dateTimeString = currentDate.ToString("dd-MM-yyyy HH:mm:ss"); // "21-07-2016 19:23:15"
string dateOnlyString = currentDate.ToString("dd-MM-yyyy"); // "21-07-2016"
string dateWithMonthInWords = currentDate.ToString("dd-MMMM-yyyy HH:mm:ss"); // "21-July-2016 19:23:15"
X-Zeichen von der rechten Seite einer Zeichenfolge abrufen
Visual Basic verfügt über Left-, Right- und Mid-Funktionen, die Zeichen von Left, Right und Middle einer Zeichenfolge zurückgeben. Diese Methoden sind in C # nicht vorhanden, können jedoch mit Substring() implementiert werden. Sie können als Erweiterungsmethoden wie die folgenden implementiert werden:
public static class StringExtensions
{
/// <summary>
/// VB Left function
/// </summary>
/// <param name="stringparam"></param>
/// <param name="numchars"></param>
/// <returns>Left-most numchars characters</returns>
public static string Left( this string stringparam, int numchars )
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative numchars being passed
numchars = Math.Abs( numchars );
// Validate numchars parameter
if (numchars > stringparam.Length)
numchars = stringparam.Length;
return stringparam.Substring( 0, numchars );
}
/// <summary>
/// VB Right function
/// </summary>
/// <param name="stringparam"></param>
/// <param name="numchars"></param>
/// <returns>Right-most numchars characters</returns>
public static string Right( this string stringparam, int numchars )
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative numchars being passed
numchars = Math.Abs( numchars );
// Validate numchars parameter
if (numchars > stringparam.Length)
numchars = stringparam.Length;
return stringparam.Substring( stringparam.Length - numchars );
}
/// <summary>
/// VB Mid function - to end of string
/// </summary>
/// <param name="stringparam"></param>
/// <param name="startIndex">VB-Style startindex, 1st char startindex = 1</param>
/// <returns>Balance of string beginning at startindex character</returns>
public static string Mid( this string stringparam, int startindex )
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative startindex being passed
startindex = Math.Abs( startindex );
// Validate numchars parameter
if (startindex > stringparam.Length)
startindex = stringparam.Length;
// C# strings are zero-based, convert passed startindex
return stringparam.Substring( startindex - 1 );
}
/// <summary>
/// VB Mid function - for number of characters
/// </summary>
/// <param name="stringparam"></param>
/// <param name="startIndex">VB-Style startindex, 1st char startindex = 1</param>
/// <param name="numchars">number of characters to return</param>
/// <returns>Balance of string beginning at startindex character</returns>
public static string Mid( this string stringparam, int startindex, int numchars)
{
// Handle possible Null or numeric stringparam being passed
stringparam += string.Empty;
// Handle possible negative startindex being passed
startindex = Math.Abs( startindex );
// Handle possible negative numchars being passed
numchars = Math.Abs( numchars );
// Validate numchars parameter
if (startindex > stringparam.Length)
startindex = stringparam.Length;
// C# strings are zero-based, convert passed startindex
return stringparam.Substring( startindex - 1, numchars );
}
}
Diese Erweiterungsmethode kann wie folgt verwendet werden:
string myLongString = "Hello World!";
string myShortString = myLongString.Right(6); // "World!"
string myLeftString = myLongString.Left(5); // "Hello"
string myMidString1 = myLongString.Left(4); // "lo World"
string myMidString2 = myLongString.Left(2,3); // "ell"
Suchen nach leerem String mithilfe von String.IsNullOrEmpty () und String.IsNullOrWhiteSpace ()
string nullString = null;
string emptyString = "";
string whitespaceString = " ";
string tabString = "\t";
string newlineString = "\n";
string nonEmptyString = "abc123";
bool result;
result = String.IsNullOrEmpty(nullString); // true
result = String.IsNullOrEmpty(emptyString); // true
result = String.IsNullOrEmpty(whitespaceString); // false
result = String.IsNullOrEmpty(tabString); // false
result = String.IsNullOrEmpty(newlineString); // false
result = String.IsNullOrEmpty(nonEmptyString); // false
result = String.IsNullOrWhiteSpace(nullString); // true
result = String.IsNullOrWhiteSpace(emptyString); // true
result = String.IsNullOrWhiteSpace(tabString); // true
result = String.IsNullOrWhiteSpace(newlineString); // true
result = String.IsNullOrWhiteSpace(whitespaceString); // true
result = String.IsNullOrWhiteSpace(nonEmptyString); // false
Ein Zeichen an einem bestimmten Index abrufen und die Zeichenfolge auflisten
Sie können die Substring Methode verwenden, um an einer beliebigen Stelle eine beliebige Anzahl von Zeichen aus einer Zeichenfolge Substring . Wenn Sie jedoch nur ein einzelnes Zeichen wünschen, können Sie den String-Indexer verwenden, um ein einzelnes Zeichen an einem bestimmten Index zu erhalten, wie Sie es bei einem Array tun:
string s = "hello";
char c = s[1]; //Returns 'e'
Beachten Sie, dass der Rückgabetyp char , im Gegensatz zur Substring Methode, die einen string Typ zurückgibt.
Sie können den Indexer auch verwenden, um die Zeichen der Zeichenfolge zu durchlaufen:
string s = "hello";
foreach (char c in s)
Console.WriteLine(c);
/********* This will print each character on a new line:
h
e
l
l
o
**********/
Konvertieren Sie die Dezimalzahl in das Binär-, Oktal- und Hexadezimal-Format
Um die Dezimalzahl in ein Binärformat umzuwandeln, verwenden Sie Basis 2
Int32 Number = 15; Console.WriteLine(Convert.ToString(Number, 2)); //OUTPUT : 1111Um die Dezimalzahl in das Oktalformat umzuwandeln, verwenden Sie die Basis 8
int Number = 15; Console.WriteLine(Convert.ToString(Number, 8)); //OUTPUT : 17Um eine Dezimalzahl in ein Hexadezimalformat zu konvertieren, verwenden Sie die Basis 16
var Number = 15; Console.WriteLine(Convert.ToString(Number, 16)); //OUTPUT : f
Einen String durch einen anderen String teilen
string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);
Ergebnis:
["dies", "ist", "ein", "vollständig", "Satz"]
Zeichenkette richtig umkehren
Meistens, wenn Leute eine Zeichenkette umkehren müssen, tun sie es mehr oder weniger so:
char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);
Was diese Leute jedoch nicht erkennen, ist, dass dies tatsächlich falsch ist.
Und ich meine nicht wegen des fehlenden NULL-Checks.
Es ist eigentlich falsch, weil ein Glyph / GraphemeCluster aus mehreren Codepunkten (auch als Zeichen) bestehen kann.
Um zu verstehen, warum dies so ist, müssen wir uns zunächst der Tatsache bewusst sein, was der Begriff "Charakter" eigentlich bedeutet.
Charakter ist ein überladener Begriff, der viele Dinge bedeuten kann.
Ein Codepunkt ist die atomare Informationseinheit. Text ist eine Folge von Codepunkten. Jeder Codepunkt ist eine Zahl, die vom Unicode-Standard eine Bedeutung erhält.
Ein Graphem ist eine Folge von einem oder mehreren Codepunkten, die als eine einzige grafische Einheit angezeigt werden, die ein Lesegerät als ein einzelnes Element des Schreibsystems erkennt. Zum Beispiel sind sowohl a als auch ä Grapheme, sie können jedoch aus mehreren Codepunkten bestehen (z. B. kann ä zwei Codepunkte sein, einer für das Basiszeichen a, gefolgt von einem für die Diaresis), es gibt aber auch einen alternativen, älteren Code Punkt, der dieses Diagramm darstellt). Einige Codepunkte sind niemals Teil eines Graphems (z. B. Nicht-Joiner mit Nullbreite oder Richtungsüberschreibungen).
Eine Glyphe ist ein Bild, das normalerweise in einer Schrift (die eine Sammlung von Glyphen ist) gespeichert wird und zur Darstellung von Graphemen oder Teilen davon dient. Schriften können mehrere Glyphen zu einer einzigen Darstellung zusammensetzen. Wenn der obige ä ein einzelner Codepunkt ist, kann ein Zeichensatz diese als zwei separate, räumlich überlagerte Glyphen darstellen. Bei OTF enthalten die GSUB- und GPOS-Tabellen der Schriftart Ersetzungs- und Positionierungsinformationen, damit dies funktioniert. Ein Zeichensatz kann auch mehrere alternative Glyphen für dasselbe Graphem enthalten.
In C # ist ein Zeichen also eigentlich ein CodePoint.
Das bedeutet, wenn Sie nur eine gültige Zeichenfolge wie Les Misérables umkehren, die so aussehen kann
string s = "Les Mise\u0301rables";
Als Folge von Zeichen erhalten Sie:
selbaŕesiM seL
Wie Sie sehen, liegt der Akzent auf dem R-Zeichen anstelle des E-Zeichens.
Obwohl string.reverse.reverse die ursprüngliche Zeichenfolge ergibt, wenn Sie beide Male das Zeichen-Array umkehren, ist diese Art der Umkehrung definitiv NICHT die Umkehrung der ursprünglichen Zeichenfolge.
Sie müssen nur jedes GraphemeCluster umkehren.
Wenn Sie dies richtig machen, kehren Sie eine Zeichenfolge folgendermaßen um:
private static System.Collections.Generic.List<string> GraphemeClusters(string s)
{
System.Collections.Generic.List<string> ls = new System.Collections.Generic.List<string>();
System.Globalization.TextElementEnumerator enumerator = System.Globalization.StringInfo.GetTextElementEnumerator(s);
while (enumerator.MoveNext())
{
ls.Add((string)enumerator.Current);
}
return ls;
}
// this
private static string ReverseGraphemeClusters(string s)
{
if(string.IsNullOrEmpty(s) || s.Length == 1)
return s;
System.Collections.Generic.List<string> ls = GraphemeClusters(s);
ls.Reverse();
return string.Join("", ls.ToArray());
}
public static void TestMe()
{
string s = "Les Mise\u0301rables";
// s = "noël";
string r = ReverseGraphemeClusters(s);
// This would be wrong:
// char[] a = s.ToCharArray();
// System.Array.Reverse(a);
// string r = new string(a);
System.Console.WriteLine(r);
}
Und - oh Freude - Sie werden feststellen, wenn Sie es richtig machen, funktioniert es auch für asiatische / südasiatische / ostasiatische Sprachen (und Französisch / Schwedisch / Norwegisch usw.) ...
Ersetzen eines Strings innerhalb eines Strings
Mit der Methode System.String.Replace können Sie einen Teil einer Zeichenfolge durch eine andere Zeichenfolge ersetzen.
string s = "Hello World";
s = s.Replace("World", "Universe"); // s = "Hello Universe"
Alle Vorkommen der Suchzeichenfolge werden ersetzt.
Diese Methode kann auch zum Entfernen eines Teils einer Zeichenfolge verwendet werden, indem das Feld String.Empty wird:
string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"
Ändern der Groß- / Kleinschreibung von Zeichen in einem String
Die System.String Klasse unterstützt eine Reihe von Methoden zum Konvertieren zwischen Groß- und Kleinbuchstaben in einer Zeichenfolge.
-
System.String.ToLowerInvariantwird verwendet, um ein in Kleinbuchstaben konvertiertes String-Objekt zurückzugeben.
-
System.String.ToUpperInvariantwird verwendet, um ein in Großbuchstaben konvertiertes String-Objekt zurückzugeben.
Anmerkung: Der Grund für die Verwendung der invarianten Versionen dieser Methoden besteht darin, die Erzeugung unerwarteter kulturspezifischer Buchstaben zu verhindern. Dies wird hier ausführlich erklärt .
Beispiel:
string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"
Beachten Sie, dass Sie beim Konvertieren in Klein- und Großbuchstaben eine bestimmte Kultur angeben können , indem Sie die Methoden String.ToLower (CultureInfo) und String.ToUpper (CultureInfo) verwenden.
Verketten Sie ein String-Array zu einem String
Die System.String.Join Methode ermöglicht die Verkettung aller Elemente in einem String-Array unter Verwendung eines angegebenen Trennzeichens zwischen jedem Element:
string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"
String-Verkettung
Zeichenfolgenverkettung kann mithilfe der Methode System.String.Concat oder (viel einfacher) mit dem Operator + werden:
string first = "Hello ";
string second = "World";
string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"
In C # 6 kann dies wie folgt durchgeführt werden:
string concat = $"{first},{second}";