C# Language
Operazioni stringhe comuni
Ricerca…
Divisione di una stringa in base a un carattere specifico
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?"]
Ottenere sottostringhe di una determinata stringa
string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"
Substring riporta la stringa in alto da un dato indice, o tra due indici (entrambi inclusi).
Determina se una stringa inizia con una determinata sequenza
string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false
Trovare una stringa all'interno di una stringa
Usando System.String.Contains puoi scoprire se una stringa particolare esiste all'interno di una stringa. Il metodo restituisce un valore booleano, vero se la stringa esiste altrimenti false.
string s = "Hello World";
bool stringExists = s.Contains("ello"); //stringExists =true as the string contains the substring
Ritaglio di caratteri indesiderati su inizio e / o fine di archi.
String.Trim()
string x = " Hello World! ";
string y = x.Trim(); // "Hello World!"
string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"
String.TrimStart() e String.TrimEnd()
string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' ); // "{(Hi"
Formattazione di una stringa
Utilizzare il metodo String.Format() per sostituire uno o più elementi nella stringa con la rappresentazione stringa di un oggetto specificato:
String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar
Unire una serie di stringhe in una nuova
var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);
//joined = "Foo, Bar, Fizz, Buzz"
Riempimento di una stringa a una lunghezza fissa
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)
Costruisci una stringa da Array
Il metodo String.Join ci aiuterà a costruire una stringa da array / elenco di caratteri o stringa. Questo metodo accetta due parametri. Il primo è il delimitatore o il separatore che ti aiuterà a separare ogni elemento dell'array. E il secondo parametro è la matrice stessa.
Stringa dal char array :
string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);
Uscita : a,b,c se cambiamo il delimiter come "" allora l'uscita diventerà abc .
Stringa da List of char :
string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);
Uscita : a|b|c
Stringa dall'elenco List of Strings :
string delimiter = " ";
List<string> stringList = new List<string>() { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringList);
Uscita : Ram is a boy
Stringa da array of strings :
string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);
Uscita : Ram_is_a_boy
Formattazione usando ToString
Di solito stiamo usando il metodo String.Format per scopi di formattazione, il .ToString viene solitamente utilizzato per convertire altri tipi in stringa. Possiamo specificare il formato insieme al metodo ToString mentre la conversione è in corso, quindi possiamo evitare una formattazione aggiuntiva. Lasciami spiegare come funziona con diversi tipi;
Intero alla stringa formattata:
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"
da doppio a stringa formattata:
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
Formattazione di DateTime usando 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"
Ottenere caratteri x dal lato destro di una stringa
Visual Basic dispone di funzioni Left, Right e Mid che restituiscono caratteri da sinistra, destra e centrale di una stringa. Questi metodi non esistono in C #, ma possono essere implementati con Substring() . Possono essere implementati come metodi di estensione come il seguente:
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 );
}
}
Questo metodo di estensione può essere utilizzato come segue:
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"
Verifica della stringa vuota utilizzando String.IsNullOrEmpty () e 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
Ottenere un carattere a un indice specifico ed enumerare la stringa
È possibile utilizzare il metodo Substring per ottenere qualsiasi numero di caratteri da una stringa in qualsiasi posizione specifica. Tuttavia, se vuoi solo un singolo carattere, puoi usare l'indicizzatore di stringhe per ottenere un singolo carattere in un dato indice come fai con un array:
string s = "hello";
char c = s[1]; //Returns 'e'
Si noti che il tipo restituito è char , a differenza del metodo Substring che restituisce un tipo di string .
Puoi anche usare l'indicizzatore per scorrere i caratteri della stringa:
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
**********/
Converti numero decimale in formato binario, ottale ed esadecimale
Per convertire il numero decimale in formato binario utilizzare la base 2
Int32 Number = 15; Console.WriteLine(Convert.ToString(Number, 2)); //OUTPUT : 1111Per convertire il numero decimale in formato ottale, usa la base 8
int Number = 15; Console.WriteLine(Convert.ToString(Number, 8)); //OUTPUT : 17Per convertire il numero decimale in formato esadecimale utilizzare la base 16
var Number = 15; Console.WriteLine(Convert.ToString(Number, 16)); //OUTPUT : f
Divisione di una stringa con un'altra stringa
string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);
Risultato:
["questo", "è", "un", "completo", "frase"]
Invertire correttamente una stringa
La maggior parte delle volte in cui le persone devono invertire una stringa, lo fanno più o meno così:
char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);
Tuttavia, ciò di cui queste persone non si rendono conto è che questo è in realtà sbagliato.
E non intendo per il controllo NULL mancante.
In realtà è sbagliato perché un Glyph / GraphemeCluster può consistere in diversi codepoint (ovvero personaggi).
Per capire perché è così, dobbiamo prima essere consapevoli del fatto che cosa significhi in realtà il termine "personaggio".
Il carattere è un termine sovraccarico che può significare molte cose.
Un punto di codice è l'unità atomica di informazioni. Il testo è una sequenza di punti di codice. Ogni punto di codice è un numero a cui viene assegnato il significato dallo standard Unicode.
Un grafema è una sequenza di uno o più punti di codice che vengono visualizzati come una singola unità grafica che un lettore riconosce come un singolo elemento del sistema di scrittura. Ad esempio, sia a che ä sono grafemi, ma possono essere costituiti da più punti di codice (ad esempio ä possono essere due punti di codice, uno per il carattere base uno seguito da uno per la diaresi, ma c'è anche un codice alternativo, legacy, singolo punto che rappresenta questo grafema). Alcuni punti di codice non fanno mai parte di alcun grafema (es. Il non-falegname a larghezza zero o gli override direzionali).
Un glifo è un'immagine, solitamente memorizzata in un font (che è una raccolta di glifi), usata per rappresentare grafemi o parti di essi. I caratteri possono comporre più glifi in una singola rappresentazione, ad esempio, se quanto sopra ä è un singolo punto di codice, un font può scegliere di renderlo come due glifi separati, spazialmente sovrapposti. Per OTF, le tabelle GSUB e GPOS del font contengono informazioni di sostituzione e posizionamento per far funzionare questo. Un font può contenere più glifi alternativi per lo stesso grafema.
Quindi in C #, un personaggio è in realtà un CodePoint.
Il che significa, se si inverte una stringa valida come Les Misérables , che può assomigliare a questo
string s = "Les Mise\u0301rables";
come sequenza di caratteri, otterrai:
selbaêsMe seL
Come puoi vedere, l'accento è sul carattere R, invece del carattere e.
Sebbene string.reverse.reverse restituisca la stringa originale se entrambe le volte invertite il char array, questo tipo di inversione NON è sicuramente l'opposto della stringa originale.
Dovrai invertire solo ciascun GraphemeCluster.
Quindi, se fatto correttamente, si inverte una stringa come questa:
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);
}
E - oh gioia - ti renderai conto che se lo fai correttamente, funzionerà anche per le lingue asiatico / sud-asiatico / est asiatico (e francese / svedese / norvegese, ecc.) ...
Sostituzione di una stringa all'interno di una stringa
Utilizzando il metodo System.String.Replace , è possibile sostituire parte di una stringa con un'altra stringa.
string s = "Hello World";
s = s.Replace("World", "Universe"); // s = "Hello Universe"
Tutte le occorrenze della stringa di ricerca vengono sostituite.
Questo metodo può anche essere utilizzato per rimuovere parte di una stringa, utilizzando il campo String.Empty :
string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"
Modifica del caso di caratteri all'interno di una stringa
La classe System.String supporta un numero di metodi per la conversione tra caratteri maiuscoli e minuscoli in una stringa.
-
System.String.ToLowerInvariantviene utilizzato per restituire un oggetto String convertito in lettere minuscole.
-
System.String.ToUpperInvariantviene utilizzato per restituire un oggetto String convertito in maiuscolo.
Nota: la ragione per utilizzare le versioni invarianti di questi metodi è impedire la produzione di lettere impreviste specifiche della cultura. Questo è spiegato qui in dettaglio .
Esempio:
string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"
Si noti che è possibile scegliere di specificare una cultura specifica durante la conversione in lettere minuscole e maiuscole utilizzando i metodi String.ToLower (CultureInfo) e String.ToUpper (CultureInfo) di conseguenza.
Concatena una serie di stringhe in una singola stringa
Il metodo System.String.Join consente di concatenare tutti gli elementi in una matrice di stringhe, utilizzando un separatore specificato tra ciascun elemento:
string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"
Concatenazione di stringhe
String La concatenazione può essere eseguita utilizzando il metodo System.String.Concat o (molto più semplice) utilizzando l'operatore + :
string first = "Hello ";
string second = "World";
string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"
In C # 6 questo può essere fatto come segue:
string concat = $"{first},{second}";
