C# Language
Typowe operacje na łańcuchach
Szukaj…
Dzielenie łańcucha według określonego znaku
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?"]
Pobieranie podłańcuchów danego ciągu
string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"
Substring zwraca łańcuch od określonego indeksu lub między dwoma indeksami (oba włącznie).
Określ, czy ciąg zaczyna się od określonej sekwencji
string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false
Znajdowanie ciągu w ciągu
Za pomocą System.String.Contains możesz dowiedzieć się, czy dany ciąg istnieje w ciągu. Metoda zwraca wartość logiczną, prawda, jeśli łańcuch istnieje w innym przypadku fałsz.
string s = "Hello World";
bool stringExists = s.Contains("ello"); //stringExists =true as the string contains the substring
Przycinanie niechcianych znaków poza początkiem i / lub końcem ciągów znaków.
String.Trim()
string x = " Hello World! ";
string y = x.Trim(); // "Hello World!"
string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"
String.TrimStart() i String.TrimEnd()
string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' ); // "{(Hi"
Formatowanie ciągu
Użyj metody String.Format() , aby zastąpić jeden lub więcej elementów w ciągu ciągiem reprezentującym określony obiekt:
String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar
Łączenie tablicy ciągów w nowy
var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);
//joined = "Foo, Bar, Fizz, Buzz"
Wypełnienie sznurka do ustalonej długości
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)
Skonstruuj ciąg z tablicy
Metoda String.Join pomoże nam zbudować ciąg Z tablicy / listy znaków lub ciągu. Ta metoda akceptuje dwa parametry. Pierwszy to separator lub separator, który pomoże ci oddzielić każdy element w tablicy. Drugim parametrem jest sama tablica.
Ciąg char array z char array :
string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);
Wyjście : a,b,c jeśli zmienimy delimiter na "" wówczas wyjście stanie się abc .
Ciąg z List of char :
string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);
Wyjście : a|b|c
Ciąg z List of Strings :
string delimiter = " ";
List<string> stringList = new List<string>() { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringList);
Wyjście : Ram is a boy
Ciąg z array of strings :
string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);
Wyjście : Ram_is_a_boy
Formatowanie za pomocą ToString
Zwykle używamy metody String.Format do celów formatowania, .ToString jest zwykle używany do konwersji innych typów na ciąg. Możemy określić format wraz z metodą ToString podczas konwersji, więc możemy uniknąć dodatkowego formatowania. Pozwól mi wyjaśnić, jak to działa z różnymi typami;
Liczba całkowita do sformatowanego łańcucha:
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"
podwój do sformatowanego łańcucha:
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
Formatowanie daty i godziny za pomocą ToString
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"
Pobieranie x znaków z prawej strony ciągu
Visual Basic ma funkcje Left, Right i Mid, które zwracają znaki z lewej, prawej i środkowej części łańcucha. Te metody nie istnieją w C #, ale można je zaimplementować za pomocą Substring() . Można je zaimplementować jako metody rozszerzenia, takie jak:
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 );
}
}
Tej metody rozszerzenia można użyć w następujący sposób:
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"
Sprawdzanie pustego ciągu za pomocą String.IsNullOrEmpty () i 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
Uzyskiwanie znaku przy określonym indeksie i wyliczanie łańcucha
Możesz użyć metody Substring , aby uzyskać dowolną liczbę znaków z ciągu w dowolnej lokalizacji. Jeśli jednak chcesz tylko jednego znaku, możesz użyć indeksu ciągów, aby uzyskać pojedynczy znak w dowolnym indeksie, tak jak w przypadku tablicy:
string s = "hello";
char c = s[1]; //Returns 'e'
Zauważ, że typ zwracany jest char , w przeciwieństwie do metody Substring , która zwraca typ string .
Za pomocą indeksu można także iterować po ciągach znaków:
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
**********/
Konwertuj liczbę dziesiętną na format binarny, ósemkowy i szesnastkowy
Aby przekonwertować liczbę dziesiętną na format binarny, użyj podstawy 2
Int32 Number = 15; Console.WriteLine(Convert.ToString(Number, 2)); //OUTPUT : 1111Aby przekonwertować liczbę dziesiętną na format ósemkowy, użyj podstawy 8
int Number = 15; Console.WriteLine(Convert.ToString(Number, 8)); //OUTPUT : 17Aby przekonwertować liczbę dziesiętną na format szesnastkowy, użyj podstawy 16
var Number = 15; Console.WriteLine(Convert.ToString(Number, 16)); //OUTPUT : f
Dzielenie łańcucha na inny łańcuch
string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);
Wynik:
[„this”, „is”, „a”, „complete”, „zdanie”]
Poprawnie odwraca ciąg
W większości przypadków ludzie muszą odwrócić ciąg znaków, robią to mniej więcej tak:
char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);
Jednak ludzie ci nie zdają sobie sprawy, że tak naprawdę jest to złe.
I nie mam na myśli z powodu braku czeku NULL.
Jest to w rzeczywistości złe, ponieważ klaster Glyph / GraphemeCluster może składać się z kilku punktów kodowych (zwanych także znakami).
Aby zrozumieć, dlaczego tak się dzieje, musimy najpierw wiedzieć, co tak naprawdę oznacza termin „charakter”.
Charakter to przeciążony termin, który może znaczyć wiele rzeczy.
Punkt kodowy to atomowa jednostka informacji. Tekst jest sekwencją punktów kodowych. Każdy punkt kodowy jest liczbą, która ma znaczenie określone przez standard Unicode.
Grafem jest sekwencja jednego lub więcej punktów kodowych, które są wyświetlane jako pojedyncza jednostka graficzna, którą czytelnik rozpoznaje jako pojedynczy element systemu zapisu. Na przykład zarówno a, jak i ä są grafemami, ale mogą składać się z wielu punktów kodowych (np. Ä mogą być dwoma punktami kodowymi, jednym dla znaku podstawowego, a następnie drugim dla diurezy; ale jest też alternatywa, starszy, pojedynczy kod punkt reprezentujący ten wykres). Niektóre punkty kodowe nigdy nie są częścią żadnego grafemu (np. Nie-łącznik o zerowej szerokości lub przesłonięcia kierunkowe).
Glif to obraz, zwykle przechowywany w czcionce (która jest zbiorem glifów), służący do przedstawiania grafemów lub ich części. Czcionki mogą składać się z wielu glifów w jedną reprezentację, na przykład, jeśli powyższy ä jest pojedynczym punktem kodowym, czcionka może zdecydować się na renderowanie go jako dwóch oddzielnych, nałożonych przestrzennie glifów. W przypadku OTF tabele GSUB i GPOS czcionki zawierają informacje o podstawieniu i pozycjonowaniu, aby to zadziałało. Czcionka może również zawierać wiele alternatywnych glifów dla tego samego grafemu.
Tak więc w języku C # znak jest w rzeczywistości CodePoint.
Co oznacza, że po prostu odwrócisz prawidłowy ciąg znaków, taki jak Les Misérables , który może wyglądać tak
string s = "Les Mise\u0301rables";
jako sekwencja znaków otrzymasz:
SelbaŕesiM seL
Jak widać, akcent znajduje się na znaku R zamiast znaku e.
Chociaż string.reverse.reverse zwróci oryginalny ciąg, jeśli za każdym razem odwrócisz tablicę char, ten rodzaj odwrócenia zdecydowanie NIE jest odwrotnością oryginalnego ciągu.
Musisz odwrócić tylko każdy GraphemeCluster.
Tak więc, jeśli wykonane poprawnie, odwraca ciąg taki jak ten:
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);
}
I - och, radość - zdasz sobie sprawę, że jeśli zrobisz to w ten sposób poprawnie, zadziała również w językach azjatyckich / południowoazjatyckich / wschodnioazjatyckich (i francuskim / szwedzkim / norweskim itp.) ...
Zastępowanie ciągu w ciągu
Za pomocą metody System.String.Replace można zastąpić część ciągu innym ciągiem.
string s = "Hello World";
s = s.Replace("World", "Universe"); // s = "Hello Universe"
Wszystkie wystąpienia ciągu wyszukiwania zostaną zastąpione.
Tej metody można również użyć do usunięcia części ciągu za pomocą pola String.Empty :
string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"
Zmiana wielkości liter w ciągu znaków
Klasa System.String obsługuje wiele metod konwersji między wielkimi i małymi literami w ciągu.
-
System.String.ToLowerInvariantsłuży do zwracania obiektu String przekonwertowanego na małe litery.
-
System.String.ToUpperInvariantsłuży do zwracania obiektu String przekonwertowanego na wielkie litery.
Uwaga: Powodem użycia niezmiennej wersji tych metod jest zapobieganie tworzeniu nieoczekiwanych liter specyficznych dla kultury. Wyjaśniono to tutaj szczegółowo .
Przykład:
string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"
Zauważ, że możesz wybrać określoną kulturę podczas konwersji na małe i wielkie litery, używając odpowiednio metod String.ToLower (CultureInfo) i String.ToUpper (CultureInfo) .
Połącz tablicę ciągów w pojedynczy ciąg
Metoda System.String.Join pozwala na konkatenację wszystkich elementów w tablicy łańcuchów przy użyciu określonego separatora między każdym elementem:
string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"
Łączenie ciągów
Łączenie łańcuchów można wykonać za pomocą metody System.String.Concat lub (znacznie łatwiej) za pomocą operatora + :
string first = "Hello ";
string second = "World";
string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"
W C # 6 można to zrobić w następujący sposób:
string concat = $"{first},{second}";
