Cadenas de texto (string)

Una cadena es un fragmento de texto. Por lo general, consta de 2 caracteres o más, ya que si es solo uno, debería considerar usar un char en su lugar. Sin embargo, las cadenas también pueden estar vacías o incluso nulas, ya que es un tipo de referencia. Una cadena se puede declarar como los otros tipos de datos con los que ya hemos trabajado:

string s;

O si desea asignarle un valor de inmediato:

string name = "John Doe";

Cualquier cosa dentro de un conjunto de comillas dobles en C # se considera una cadena, como en el ejemplo anterior: rodear uno o varios caracteres entre comillas dobles se usa para decirle al compilador que las cosas entre ellas deben interpretarse como una cadena en lugar de (Por ejemplo, palabras claves y comandos)

Strings es inmutable.

En C#, las cadenas son inmutables, es decir, una vez que son creadas, no se pueden cambiar. Bajo esta lógica, es obvio pensar que no son muy prácticas para el uso diario, pero por suerte el Framework nos ayuda con todo esto. En lugar de tener que seguir declarando nuevas cadenas para realizar cambios, simplemente se crea una nueva cadena para cada vez que cambie la existente. Esto lo convierte en un proceso impecable, pero también puede hacer que su código sea menos eficiente sin que lo notes. Aquí hay un ejemplo para ilustrarlo:

string numbers = "";
for (int i = 0; i < 10000; i++)
    numbers += i.ToString();

En este caso, hacemos un bucle 10.000 veces, cada vez que agregamos el índice actual a la cadena. Con el conocimiento que acaba de adquirir, ahora sabe que en lugar de alterar la cadena existente para incluir el último número, se crea una nueva cadena y luego se asigna a la variable anterior, dejando que el framework limpie el valor anterior. ¡Y esto sucede 10.000 veces! En cambio, generalmente se recomienda usar un llamado StringBuilder si sabe que va a construir una cadena en varias operaciones:

StringBuilder numbers = new StringBuilder();
for (int i = 0; i < 10000; i++)
    numbers.Append(i);
Console.WriteLine(numbers.ToString());

Operaciones básicas de strings.

Habiendo dicho todo eso acerca de que las cadenas son inmutables, aún te encontrarás manipulando y trabajando mucho con cadenas simples, y no te preocupes por eso, a menos que estés trabajando dentro de un bucle gigante, ¡probablemente no sea un problema! Estas son algunas de las cosas básicas que puede hacer con cadenas:

Puede concatenate dos o más cadenas simplemente "agregándolas" (usando el operador suma):

string name = "John" + " " + "Doe";

Por supuesto, puede hacer lo mismo con las variables, donde combina cadenas con comillas dobles y variables que son cadenas o que se pueden convertir en cadenas (utilizando el método ToString () que se encuentra en todos los objetos). Sin embargo, una forma más "limpia" de hacerlo es con el método Format que se encuentra en la clase String:

string name = "John Doe";
int age = 42;
string userString = String.Format("{0} is {1} years old and lives in {2}", name, age, "New York");

Observe cómo uso marcadores de posición numerados ({0}, {1} etc.) y luego proporcione los valores para él como parámetros para el método. ¡Solo recuerda que los índices y la cantidad de marcadores de posición deben coincidir con los parámetros que pasas!

La propiedad Length le permite verificar la longitud actual de una cadena, p.e. para fines de validación. La propiedad Longitud también es muy útil en combinación con otras propiedades y métodos, p.e. los métodos Substring () y IndexOf () . El método Substring le permite recuperar una parte de la cadena, mientras que el método IndexOf le permite encontrar el primer índice de un char / string dado. Permítanme ilustrar con un ejemplo:

string name = "John Doe";
int indexOfSpace = name.IndexOf(' ') + 1;
string lastName = name.Substring(indexOfSpace, name.Length - indexOfSpace);
Console.WriteLine(lastName);

Explicación rápida: definimos un nombre, luego usamos el método IndexOf () para encontrar la primera posición de un carácter de espacio. Luego usamos el método Substring () para obtener todo después del carácter de espacio al proporcionar una posición de inicio y una longitud.

Otro método genial de ayuda en la clase String es el método Replace (). Le permite tomar una cadena y luego ejecutar una operación de búsqueda / reemplazo, como esta:

string name = "John Doe";
Console.WriteLine(name.Replace("John", "Jane"));

El método Replace() no es estricto en absoluto: si la cadena que está buscando (el primer parámetro) no está presente, entonces no sucederá nada (no se lanzan excepciones ni nada de eso). Si está presente, se reemplazará con el segundo parámetro. Sin embargo, si desea verificar antes de reemplazar, puede usar el método Contains() :

string name = "John Doe";
if (name.Contains("John"))
    Console.WriteLine(name.Replace("John", "Jane"));
else
    Console.WriteLine("John was not found!");

A veces, desea saber si una cadena comienza o termina con un carácter o cadena específicos. Para eso, la clase String puede ayudarlo con los métodos StartsWith () y EndsWith () , que funciona tal como lo indica el nombre:

string name = "John Doe";
if ((name.StartsWith("John")) && (name.EndsWith("Doe")))
    Console.WriteLine("Hello, Mr. Doe!");

Hay incluso más métodos geniales de String, y definitivamente hay más formas de usarlos que los ilustrados en estos ejemplos cortos. Si desea saber más al respecto, eche un vistazo a la MSDN documentation for the String class.

Cadenas literales y escapes

Al definir una cadena, pronto verá que ciertos caracteres tienen propósitos especiales. El ejemplo más importante de esto es la comilla doble, ya que se usa para marcar el inicio y el final de una cadena en el compilador, ¿cómo puede usarla dentro de su cadena? La respuesta más simple a esto es escapar, donde le indica al compilador que un carácter especial debe ser tratado literalmente en lugar de su función habitual. Aquí hay un ejemplo:

Console.WriteLine("What do you mean by \"Hello, world\" ??");

Cuando se ejecuta, el resultado se verá así:

What do you mean by "Hello, world" ??

En otras palabras, simplemente usamos barras invertidas antes de una comilla doble, para indicar que este NO es el final de la cadena, sino que, en realidad, queremos una comilla doble. Entonces ... ¿qué pasa si realmente queremos una barra diagonal inversa y no solo usarla para escapar de otro char? Bueno, entonces también tendrás que escapar de eso, con otra barra invertida:

Console.WriteLine("Right here \\ Right now");

Resultando:

Right here \ Right now

La razón es que la barra invertida no solo se usa para escapar de las comillas dobles, también se usa para prefijar un rango de caracteres para darles significados especiales. Por ejemplo, \ n es una nueva línea, \ t es un carácter de tabulación y así sucesivamente. Puede encontrar una buena lista de secuencias de escape here.

Cadenas literales

Como alternativa a todo este escape, puede usar una cadena literal. Es como una declaración de cadena normal, pero con el prefijo @, y dentro de ella, todos los caracteres se tratan literalmente:

Console.WriteLine(@"In a verbatim string \ everything is literal: \n & \t");

La salida se verá igual que la entrada:

In a verbatim string \ everything is literal: \n & \t

Solo hay una excepción a esta regla: todavía se debe escapar una comilla doble, pero eso tiene bastante sentido, porque de lo contrario, ¿cómo sabría el compilador si está tratando de terminar la cadena o no? Sin embargo, en una cadena literal, una comilla doble no se escapa con una barra diagonal inversa, sino con otra comilla doble, como esta:

Console.WriteLine(@"What do you mean by ""Hello, world"" ??");

El resultado se ve así:

What do you mean by "Hello, world" ??

Resumen

Los strings son IMPORTANTÍSIMOS para todos los programadores: es probable que realice algún tipo de procesamiento de cadenas durante la mayor parte del tiempo que pasó escribiendo código. Afortunadamente, C # tiene todas las herramientas que necesitará para hacerlo, como he tratado de ilustrar en este artículo.