C# Language
Vanliga strängoperationer
Sök…
Dela en sträng efter specifik karaktär
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?"]
Skaffa underlag av en given sträng
string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"
Substring returnerar strängen upp från ett givet index, eller mellan två index (båda inklusive).
Bestäm om en sträng börjar med en given sekvens
string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false
Hitta en sträng i en sträng
Med hjälp av System.String.Contains du ta reda på om det finns en viss sträng i en sträng. Metoden returnerar en boolean, sann om strängen finns annars falsk.
string s = "Hello World";
bool stringExists = s.Contains("ello"); //stringExists =true as the string contains the substring
Trimma oönskade karaktärer från början och / eller slutet av strängar.
String.Trim()
string x = " Hello World! ";
string y = x.Trim(); // "Hello World!"
string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"
String.TrimStart() och String.TrimEnd()
string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' ); // "{(Hi"
Formatera en sträng
Använd String.Format() för att ersätta ett eller flera objekt i strängen med strängrepresentationen av ett specificerat objekt:
String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar
Gå med i en rad strängar till en ny
var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);
//joined = "Foo, Bar, Fizz, Buzz"
Polstring av en sträng till en fast längd
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)
Konstruera en sträng från Array
Metoden String.Join hjälper oss att konstruera en sträng Från matris / lista med tecken eller sträng. Denna metod accepterar två parametrar. Den första är avgränsaren eller separatorn som hjälper dig att separera varje element i matrisen. Och den andra parametern är Array själv.
Sträng från char array :
string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);
Utgång : a,b,c om vi ändrar delimiter som "" kommer utgången att bli abc .
Sträng från List of char :
string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);
Utgång : a|b|c
Sträng från 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
Sträng från array of strings :
string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);
Utgång : Ram_is_a_boy
Formatera med ToString
Vanligtvis använder vi String.Format metoden för formateringsändamål, .ToString används vanligtvis för att konvertera andra typer till sträng. Vi kan specificera formatet tillsammans med ToString-metoden medan konverteringen äger rum, så vi kan undvika ytterligare formatering. Låt mig förklara hur det fungerar med olika typer;
Heltal till formaterad sträng:
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"
dubbel till formaterad sträng:
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
Formatera DateTime med 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"
Få x tecken från höger sida av en sträng
Visual Basic har vänster-, höger- och mittenfunktioner som returnerar tecken från vänster, höger och mitten av en sträng. Dessa metoder finns inte i C #, men kan implementeras med Substring() . De kan implementeras som en förlängningsmetod som följande:
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 );
}
}
Denna förlängningsmetod kan användas enligt följande:
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"
Kontrollera om det är tomt String med String.IsNullOrEmpty () och 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
Skaffa en char på ett specifikt index och räkna upp strängen
Du kan använda Substring metoden för att få valfritt antal tecken från en sträng på en given plats. Men om du bara vill ha ett enstaka tecken kan du använda strängen indexeraren för att få ett enda tecken på ett givet index som du gör med en matris:
string s = "hello";
char c = s[1]; //Returns 'e'
Lägg märke till att returtypen är char , till skillnad från Substring metoden som returnerar en string .
Du kan också använda indexeraren för att iterera igenom tecknen i strängen:
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
**********/
Konvertera decimalantal till binärt, oktalt och hexadecimalt format
För att konvertera decimalnummer till binärt format använder du bas 2
Int32 Number = 15; Console.WriteLine(Convert.ToString(Number, 2)); //OUTPUT : 1111För att konvertera decimalnummer till oktalt format använder du bas 8
int Number = 15; Console.WriteLine(Convert.ToString(Number, 8)); //OUTPUT : 17För att konvertera decimalnummer till hexadecimalt format använder du bas 16
var Number = 15; Console.WriteLine(Convert.ToString(Number, 16)); //OUTPUT : f
Dela en sträng med en annan sträng
string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);
Resultat:
["detta", "är", "en", "fullständig", "mening"]
Riktigt vända en sträng
De flesta gånger när människor måste vända en sträng gör de det mer eller mindre så här:
char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);
Men vad dessa människor inte inser är att detta faktiskt är fel.
Och jag menar inte på grund av den saknade NULL-kontrollen.
Det är faktiskt fel eftersom en Glyph / GraphemeCluster kan bestå av flera kodpunkter (aka. Tecken).
För att se varför det är så måste vi först vara medvetna om vad begreppet "karaktär" faktiskt betyder.
Karaktär är en överbelastad term än vad som kan betyda många saker.
En kodpunkt är atomens informationsenhet. Text är en sekvens av kodpunkter. Varje kodpunkt är ett tal som ges betydelse med Unicode-standarden.
Ett diagram är en sekvens av en eller flera kodpunkter som visas som en enda, grafisk enhet som en läsare känner igen som ett enda element i skrivningssystemet. Till exempel är både a och ä grafema, men de kan bestå av flera kodpunkter (t.ex. ä kan vara två kodpunkter, en för baskaraktäret och följt av en för diaresis; men det finns också en alternativ, äldre, enskild kod punkt som representerar detta diagram). Vissa kodpunkter är aldrig en del av något diagram (t.ex. nollbredd utan förbindning, eller riktningsöverskridande).
En glyph är en bild, vanligtvis lagrad i ett teckensnitt (som är en samling av glyfer), som används för att representera diagram eller delar därav. Teckensnitt kan komponera flera glyfer i en enda representation, till exempel om ovanstående ä är en enda kodpunkt, kan ett teckensnitt välja att göra det som två separata, rumsligt överlagda glyfer. För OTF innehåller typsnittets GSUB- och GPOS-tabeller substitutions- och positionsinformation för att detta ska fungera. Ett teckensnitt kan också innehålla flera alternativa glyfer för samma grafeme.
Så i C # är en karaktär faktiskt en CodePoint.
Vilket betyder, om du bara vänder en giltig sträng som Les Misérables , vilket kan se ut så här
string s = "Les Mise\u0301rables";
som en sekvens av tecken får du:
selbaŕesiM seL
Som ni ser är accenten på R-karaktären istället för e-karaktären.
Även om string.reverse.reverse ger den ursprungliga strängen om du båda gångerna vänder på char-arrayen, är denna typ av reversering definitivt INTE motsatsen till den ursprungliga strängen.
Du måste bara vända varje GraphemeCluster.
Så om du gör det korrekt, vänder du en sträng som denna:
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);
}
Och - åh glädje - du kommer att inse att om du gör det på rätt sätt så fungerar det också för asiatiska / sydasiatiska / östasiatiska språk (och franska / svenska / norska, etc.) ...
Byta ut en sträng i en sträng
Med hjälp av System.String.Replace metoden kan du ersätta en del av en sträng med en annan sträng.
string s = "Hello World";
s = s.Replace("World", "Universe"); // s = "Hello Universe"
Alla förekomster av söksträngen ersätts.
Den här metoden kan också användas för att ta bort en del av en sträng med fältet String.Empty :
string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"
Ändra fallet med tecken i en sträng
System.String stöder ett antal metoder för att konvertera mellan stora och små bokstäver i en sträng.
-
System.String.ToLowerInvariantanvänds för att returnera ett String-objekt konverterat till gemener.
-
System.String.ToUpperInvariantanvänds för att returnera ett String-objekt konverterat till versaler.
Anmärkning: Anledningen till att använda de invarianta versionerna av dessa metoder är att förhindra att man producerar oväntade kulturspecifika bokstäver. Detta förklaras här i detalj .
Exempel:
string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"
Observera att du kan välja att ange en specifik kultur när du konverterar till små och stora versaler genom att använda metoderna String.ToLower (CultureInfo) och String.ToUpper (CultureInfo) i enlighet därmed.
Sammanfoga en rad strängar i en enda sträng
Metoden System.String.Join gör det möjligt att sammanfoga alla element i en strängarray med hjälp av en specificerad separator mellan varje element:
string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"
Strängen sammankoppling
String Concatenation kan göras med hjälp av System.String.Concat metoden, eller (mycket lättare) med hjälp av + -operatören:
string first = "Hello ";
string second = "World";
string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"
I C # 6 kan detta göras enligt följande:
string concat = $"{first},{second}";