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

  1. Um die Dezimalzahl in ein Binärformat umzuwandeln, verwenden Sie Basis 2

    Int32 Number = 15;
    Console.WriteLine(Convert.ToString(Number, 2));  //OUTPUT : 1111
    
  2. Um die Dezimalzahl in das Oktalformat umzuwandeln, verwenden Sie die Basis 8

    int Number = 15;
    Console.WriteLine(Convert.ToString(Number, 8));  //OUTPUT : 17
    
  3. Um 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.

Referenz:

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.

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


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow