C# Language
Operaciones de cadena comunes
Buscar..
Dividir una cadena por carácter específico
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?"]
Obtención de subcadenas de una cadena dada
string helloWorld = "Hello World!";
string world = helloWorld.Substring(6); //world = "World!"
string hello = helloWorld.Substring(0,5); // hello = "Hello"
Substring devuelve la cadena hacia arriba desde un índice dado, o entre dos índices (ambos inclusive).
Determine si una cadena comienza con una secuencia dada
string HelloWorld = "Hello World";
HelloWorld.StartsWith("Hello"); // true
HelloWorld.StartsWith("Foo"); // false
Encontrar una cadena dentro de una cadena
Usando System.String.Contains puedes averiguar si una cadena en particular existe dentro de una cadena. El método devuelve un valor booleano, verdadero si la cadena existe, de lo contrario es falso
string s = "Hello World";
bool stringExists = s.Contains("ello"); //stringExists =true as the string contains the substring
Recorte de caracteres no deseados fuera del inicio y / o final de las cadenas.
String.Trim()
string x = " Hello World! ";
string y = x.Trim(); // "Hello World!"
string q = "{(Hi!*";
string r = q.Trim( '(', '*', '{' ); // "Hi!"
String.TrimStart() y String.TrimEnd()
string q = "{(Hi*";
string r = q.TrimStart( '{' ); // "(Hi*"
string s = q.TrimEnd( '*' ); // "{(Hi"
Formatear una cadena
Use el método String.Format() para reemplazar uno o más elementos en la cadena con la representación de la cadena de un objeto especificado:
String.Format("Hello {0} Foo {1}", "World", "Bar") //Hello World Foo Bar
Unir una serie de cadenas en una nueva
var parts = new[] { "Foo", "Bar", "Fizz", "Buzz"};
var joined = string.Join(", ", parts);
//joined = "Foo, Bar, Fizz, Buzz"
Relleno de una cuerda a una longitud fija
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)
Construye una cadena de Array
El método String.Join nos ayudará a construir una cadena de matriz / lista de caracteres o cadena. Este método acepta dos parámetros. El primero es el delimitador o el separador que le ayudará a separar cada elemento de la matriz. Y el segundo parámetro es el propio Array.
Cadena de la char array :
string delimiter=",";
char[] charArray = new[] { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charArray);
Salida : a,b,c si cambiamos el delimiter como "" entonces la salida se convertirá en abc .
Cadena de la List of char :
string delimiter = "|";
List<char> charList = new List<char>() { 'a', 'b', 'c' };
string inputString = String.Join(delimiter, charList);
Salida : a|b|c
Cadena de la List of Strings :
string delimiter = " ";
List<string> stringList = new List<string>() { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringList);
Salida : Ram is a boy
Cadena de la array of strings :
string delimiter = "_";
string[] stringArray = new [] { "Ram", "is", "a","boy" };
string inputString = String.Join(delimiter, stringArray);
Salida : Ram_is_a_boy
Formateo utilizando ToString
Por lo general, String.Format método String.Format para formatear, el .ToString se usa generalmente para convertir otros tipos en cadenas. Podemos especificar el formato junto con el método ToString mientras se lleva a cabo la conversión, por lo que podemos evitar un formato adicional. Déjame explicarte cómo funciona con diferentes tipos;
Entero a la cadena formateada:
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"
doble a la cadena con formato:
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
Formato de DateTime utilizando 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"
Obtención de x caracteres del lado derecho de una cadena
Visual Basic tiene funciones Izquierda, Derecha y Media que devuelven caracteres desde la izquierda, derecha y centro de una cadena. Estos métodos no existen en C #, pero pueden implementarse con Substring() . Se pueden implementar como métodos de extensión como los siguientes:
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 );
}
}
Este método de extensión se puede utilizar de la siguiente manera:
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"
Comprobación de cadenas vacías utilizando String.IsNullOrEmpty () y 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
Obtener un char en un índice específico y enumerar la cadena
Puede usar el método de Substring para obtener cualquier número de caracteres de una cadena en cualquier ubicación. Sin embargo, si solo desea un solo carácter, puede usar el indexador de cadena para obtener un solo carácter en cualquier índice dado como lo hace con una matriz:
string s = "hello";
char c = s[1]; //Returns 'e'
Observe que el tipo de retorno es char , a diferencia del método de Substring que devuelve un tipo de string .
También puede usar el indexador para iterar a través de los caracteres de la cadena:
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
**********/
Convertir número decimal a formato binario, octal y hexadecimal
Para convertir un número decimal a formato binario usa base 2
Int32 Number = 15; Console.WriteLine(Convert.ToString(Number, 2)); //OUTPUT : 1111Para convertir un número decimal a formato octal, use base 8
int Number = 15; Console.WriteLine(Convert.ToString(Number, 8)); //OUTPUT : 17Para convertir un número decimal a formato hexadecimal, use base 16
var Number = 15; Console.WriteLine(Convert.ToString(Number, 16)); //OUTPUT : f
Dividir una cadena por otra cadena
string str = "this--is--a--complete--sentence";
string[] tokens = str.Split(new[] { "--" }, StringSplitOptions.None);
Resultado:
["este", "es", "a", "completo", "oración"]
Invertir correctamente una cadena
La mayoría de las veces cuando las personas tienen que revertir una cadena, lo hacen más o menos así:
char[] a = s.ToCharArray();
System.Array.Reverse(a);
string r = new string(a);
Sin embargo, lo que estas personas no se dan cuenta es que esto está realmente mal.
Y no me refiero a que falte el cheque NULL.
En realidad es incorrecto porque un Glyph / GraphemeCluster puede constar de varios puntos de código (también conocidos como caracteres).
Para ver por qué esto es así, primero debemos ser conscientes del hecho de lo que realmente significa el término "carácter".
Carácter es un término sobrecargado que puede significar muchas cosas.
Un punto de código es la unidad atómica de información. El texto es una secuencia de puntos de código. Cada punto de código es un número que tiene el significado de la norma Unicode.
Un grafema es una secuencia de uno o más puntos de código que se muestran como una unidad gráfica única que un lector reconoce como un elemento único del sistema de escritura. Por ejemplo, tanto a como ä son grafemas, pero pueden constar de múltiples puntos de código (por ejemplo, ä pueden ser dos puntos de código, uno para el carácter base a seguido de uno para la diaresis; pero también hay un código alternativo, heredado, único). punto que representa este grafema). Algunos puntos de código nunca forman parte de ningún grafema (p. Ej., El no-ensamblador de ancho cero o las anulaciones direccionales).
Un glifo es una imagen, generalmente almacenada en una fuente (que es una colección de glifos), utilizada para representar grafemas o partes de ellos. Las fuentes pueden componer múltiples glifos en una sola representación, por ejemplo, si el ä anterior es un solo punto de código, una fuente puede elegir convertir eso como dos glifos separados, superpuestos espacialmente. Para OTF, las tablas GSUB y GPOS de la fuente contienen información de sustitución y posicionamiento para que esto funcione. Una fuente también puede contener múltiples glifos alternativos para el mismo grafema.
Así que en C #, un personaje es en realidad un CodePoint.
Lo que significa que, si solo inviertes una cadena válida como Les Misérables , que puede verse así
string s = "Les Mise\u0301rables";
como secuencia de caracteres, obtendrás:
selbaŕesiM seL
Como puede ver, el acento está en el carácter R, en lugar del carácter e.
Aunque string.reverse.reverse producirá la cadena original si ambas veces invierte la matriz char, este tipo de inversión definitivamente NO es lo contrario de la cadena original.
Tendrá que revertir cada GraphemeCluster solamente.
Entonces, si se hace correctamente, invierte una cadena como esta:
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);
}
Y, oh, alegría, te darás cuenta si lo haces correctamente de esta manera, también funcionará para los idiomas de Asia / Sudeste Asiático / Asia Oriental (y Francés / Sueco / Noruego, etc.) ...
Reemplazar una cadena dentro de una cadena
Usando el método System.String.Replace , puedes reemplazar parte de una cadena con otra cadena.
string s = "Hello World";
s = s.Replace("World", "Universe"); // s = "Hello Universe"
Todas las apariciones de la cadena de búsqueda se reemplazan.
Este método también se puede usar para eliminar parte de una cadena, utilizando el campo String.Empty :
string s = "Hello World";
s = s.Replace("ell", String.Empty); // s = "Ho World"
Cambiando el caso de los personajes dentro de una cadena
La clase System.String admite varios métodos para convertir caracteres en mayúsculas y minúsculas en una cadena.
-
System.String.ToLowerInvariantse usa para devolver un objeto String convertido a minúsculas.
-
System.String.ToUpperInvariantse usa para devolver un objeto String convertido a mayúsculas.
Nota: la razón para usar las versiones invariables de estos métodos es evitar la producción de letras inesperadas específicas de la cultura. Esto se explica aquí en detalle .
Ejemplo:
string s = "My String";
s = s.ToLowerInvariant(); // "my string"
s = s.ToUpperInvariant(); // "MY STRING"
Tenga en cuenta que puede elegir especificar una Cultura específica al convertir a minúsculas y mayúsculas utilizando los métodos String.ToLower (CultureInfo) y String.ToUpper (CultureInfo) en consecuencia.
Concatenar una matriz de cadenas en una sola cadena
El método System.String.Join permite concatenar todos los elementos en una matriz de cadenas, utilizando un separador especificado entre cada elemento:
string[] words = {"One", "Two", "Three", "Four"};
string singleString = String.Join(",", words); // singleString = "One,Two,Three,Four"
Concatenacion de cuerdas
La concatenación de cadenas se puede hacer usando el método System.String.Concat , o (mucho más fácil) usando el operador + :
string first = "Hello ";
string second = "World";
string concat = first + second; // concat = "Hello World"
concat = String.Concat(first, second); // concat = "Hello World"
En C # 6 esto se puede hacer de la siguiente manera:
string concat = $"{first},{second}";