C# Language
Gemeenschappelijke stringbewerkingen
Zoeken…
Een string splitsen op specifiek karakter
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?"]
Substrings van een gegeven string krijgen
string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"
Substring retourneert de tekenreeks omhoog uit een bepaalde index, of tussen twee indexen (beide inclusief).
Bepaal of een string begint met een gegeven reeks
string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false
Een string zoeken binnen een string
Met behulp van de System.String.Contains kunt u achterhalen of een bepaalde string binnen een string bestaat. De methode retourneert een boolean, true als de string anders false bestaat.
string s = "Hello World";
bool stringExists = s.Contains("ello"); //stringExists =true as the string contains the substring
Ongewenste tekens bijsnijden aan het begin en / of einde van strings.
String.Trim()
string x = " Hello World! ";
string y = x.Trim(); // "Hello World!"
string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"
String.TrimStart() en String.TrimEnd()
string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' ); // "{(Hi"
Een string opmaken
Gebruik de methode String.Format() om een of meer items in de tekenreeks te vervangen door de tekenreeksrepresentatie van een opgegeven object:
String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar
Een reeks strings samenvoegen tot een nieuwe
var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);
//joined = "Foo, Bar, Fizz, Buzz"
Een string opvullen tot een vaste lengte
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)
Construeer een string uit Array
De String.Join methode helpt ons om een string uit array / lijst met tekens of string te construeren. Deze methode accepteert twee parameters. De eerste is het scheidingsteken of het scheidingsteken waarmee u elk element in de array kunt scheiden. En de tweede parameter is de array zelf.
String van char array :
string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);
Uitgang : a,b,c als we het delimiter wijzigen in "" wordt de uitvoer abc .
String uit List of char :
string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);
Uitgang : a|b|c
String uit List of Strings :
string delimiter = " ";
List<string> stringList = new List<string>() { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringList);
Output : Ram is a boy
String uit array of strings :
string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);
Uitgang : Ram_is_a_boy
Formatteren met behulp van ToString
Meestal gebruiken we de methode String.Format voor het formatteren, de .ToString wordt meestal gebruikt voor het converteren van andere typen naar een tekenreeks. We kunnen het formaat opgeven samen met de ToString-methode tijdens de conversie, dus we kunnen een extra opmaak vermijden. Laat me uitleggen hoe het met verschillende types werkt;
Geheel naar opgemaakte string:
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"
dubbele naar opgemaakte 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 opmaken met 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"
X-tekens krijgen aan de rechterkant van een string
Visual Basic heeft de functies Links, Rechts en Mid die tekens uit de reeks Links, Rechts en Midden van een tekenreeks retourneren. Deze methoden bestaan niet in C #, maar kunnen worden geïmplementeerd met Substring() . Ze kunnen worden geïmplementeerd als een uitbreidingsmethode zoals de volgende:
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 );
}
}
Deze uitbreidingsmethode kan als volgt worden gebruikt:
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"
Controleren op lege tekenreeks met String.IsNullOrEmpty () en 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
Een teken krijgen bij een specifieke index en de tekenreeks opsommen
U kunt de methode Substring gebruiken om een willekeurig aantal tekens uit een string op een willekeurige locatie te krijgen. Als u echter slechts een enkel teken wilt, kunt u de tekenreeksindexer gebruiken om een enkel teken op een bepaalde index te krijgen, zoals u doet met een array:
string s = "hello";
char c = s[1]; //Returns 'e'
Merk op dat het type rendement char tegenstelling tot de Substring werkwijze waarbij een retourneert string type.
U kunt ook de indexer gebruiken om de tekens van de tekenreeks te doorlopen:
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
**********/
Converteer decimaal getal naar binair, octaal en hexadecimaal formaat
Gebruik base 2 om het decimale getal naar het binaire formaat te converteren
Int32 Number = 15; Console.WriteLine(Convert.ToString(Number, 2)); //OUTPUT : 1111Gebruik basis 8 om het decimale getal om te zetten in een octaal formaat
int Number = 15; Console.WriteLine(Convert.ToString(Number, 8)); //OUTPUT : 17Gebruik base 16 om het decimale getal naar een hexadecimaal formaat te converteren
var Number = 15; Console.WriteLine(Convert.ToString(Number, 16)); //OUTPUT : f
Een string splitsen door een andere string
string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);
Resultaat:
["dit", "is", "een", "compleet", "zin"]
Een string correct omkeren
Meestal moeten mensen een string omdraaien en doen dit min of meer zo:
char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);
Wat deze mensen echter niet beseffen, is dat dit eigenlijk verkeerd is.
En ik bedoel niet vanwege de ontbrekende NULL-controle.
Het is eigenlijk verkeerd omdat een Glyph / GraphemeCluster uit meerdere codepunten (ook wel tekens) kan bestaan.
Om te zien waarom dit zo is, moeten we ons eerst bewust zijn van het feit wat de term 'karakter' eigenlijk betekent.
Karakter is een overbelaste term die veel dingen kan betekenen.
Een codepunt is de atomaire informatie-eenheid. Tekst is een reeks codepunten. Elk codepunt is een nummer dat volgens de Unicode-standaard betekenis krijgt.
Een grapheme is een reeks van een of meer codepunten die worden weergegeven als een enkele grafische eenheid die een lezer herkent als een enkel element van het schrijfsysteem. Zowel a als ä zijn bijvoorbeeld grafemen, maar ze kunnen uit meerdere codepunten bestaan (bijv. Ä kan twee codepunten zijn, een voor het basisteken a gevolgd door een voor de diaresis; maar er is ook een alternatieve, oudere, enkele code punt dat dit grafeme voorstelt). Sommige codepunten maken nooit deel uit van een grapheme (bijv. De niet-joiner met nulbreedte of directionele overschrijvingen).
Een glyph is een afbeelding, meestal opgeslagen in een lettertype (wat een verzameling glyphs is), gebruikt om grafemen of delen daarvan weer te geven. Lettertypen kunnen meerdere glyphs samenstellen in één representatie, bijvoorbeeld, als bovenstaande ä een enkel codepunt is, kan een font ervoor kiezen om dat als twee afzonderlijke, ruimtelijk overlappende glyphs weer te geven. Voor OTF bevatten de GSUB- en GPOS-tabellen van het lettertype substitutie- en positioneringsinformatie om dit te laten werken. Een lettertype kan ook meerdere alternatieve glyphs bevatten voor hetzelfde grapheme.
Dus in C # is een personage eigenlijk een CodePoint.
Wat betekent dat als je gewoon een geldige string als Les Misérables omkeert, die er zo uit kan zien
string s = "Les Mise\u0301rables";
als een reeks tekens, krijg je:
selbaŕesiM seL
Zoals u ziet, ligt het accent op het R-teken in plaats van het e-teken.
Hoewel string.reverse.reverse de oorspronkelijke string oplevert als je beide keren de char array omkeert, is dit soort omkering zeker NIET het omgekeerde van de oorspronkelijke string.
U hoeft alleen elke GraphemeCluster om te keren.
Dus als je het goed doet, draai je een string als volgt om:
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);
}
En - oh vreugde - je zult je realiseren dat als je het op deze manier correct doet, het ook werkt voor Aziatische / Zuid-Aziatische / Oost-Aziatische talen (en Frans / Zweeds / Noors, enz.) ...
Een string vervangen binnen een string
Met de methode System.String.Replace kunt u een deel van een string vervangen door een andere string.
string s = "Hello World";
s = s.Replace("World", "Universe"); // s = "Hello Universe"
Alle exemplaren van de zoekreeks worden vervangen.
Deze methode kan ook worden gebruikt om een deel van een string te verwijderen met behulp van het veld String.Empty :
string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"
Het hoofdlettergebruik van tekens binnen een tekenreeks wijzigen
De klasse System.String ondersteunt een aantal methoden om tussen hoofdletters en kleine letters in een string te converteren.
-
System.String.ToLowerInvariantwordt gebruikt om een String-object terug te zetten dat is omgezet in kleine letters.
-
System.String.ToUpperInvariantwordt gebruikt om een String-object terug te zetten dat is geconverteerd naar hoofdletters.
Opmerking: De reden om de invariante versies van deze methoden te gebruiken, is om te voorkomen dat onverwachte cultuurspecifieke letters worden geproduceerd. Dit wordt hier in detail uitgelegd.
Voorbeeld:
string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"
Merk op dat u ervoor kunt kiezen om een specifieke cultuur op te geven bij het converteren naar kleine letters en hoofdletters met behulp van de methoden String.ToLower (CultureInfo) en String.ToUpper (CultureInfo) .
Voeg een reeks strings samen in een enkele string
Met de methode System.String.Join kunt u alle elementen in een reeks array samenvoegen met behulp van een opgegeven scheidingsteken tussen elk element:
string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"
String-aaneenschakeling
String-aaneenschakeling kan worden gedaan met behulp van de methode System.String.Concat , of (veel eenvoudiger) met de operator + :
string first = "Hello ";
string second = "World";
string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"
In C # 6 kan dit als volgt worden gedaan:
string concat = $"{first},{second}";