Las cadenas (string en inglés) representan a los textos que usamos dentro de nuestro programa. Ya hemos visto las variables de tipo string, donde podemos almacenar cualquier texto, ahora veremos como se comporta la clase String, la cual tiene un conjunto de métodos (funcionalidades) que nos van a permitir manipular cualquier texto que el usuario ingrese (o bueno, cualquier texto que tengamos en nuestro programa). ¿Cómo diferenciamos la clase del tipo de dato? Es sencillo, para declarar una variable tipo string, usaremos la «s» minúscula, y para llamar a la clase, usaremos la «S» mayúscula.
string myName;
bool value = String.IsNullOrEmpty(myName);
En la primera línea, declaramos una variable de tipo string, y en la segunda, llamamos a la clase String y usamos el método «IsNullOrEmpty» para evaluar si la variable es nula o vacía (esto como resultado da «true» porque la variable myName está vacía).
También debemos tener en cuenta que cada letra del texto (incluido los espacios y caracteres especiales) representan un espacio de memoria, que está representado con un índice y empieza desde cero. Por ejemplo, vamos a analizar la palabra caramelo.
| C | A | R | A | M | E | L | O |
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
Con este ejemplo podemos determinar que el índice 6, representa la letra L de la palabra caramelo. Ahora vamos a hacer lo mismo con una frase.
| H | O | L | A | M | U | N | D | O | |
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
Igual que el ejemplo anterior, podemos determinar que el índice 4 representa un espacio en blanco.
Esto es importante entender ya que la principal manera de manipular los textos es a través de los índices.
Substring (int indiceInicial, int tamaño)
El método Substring me permite extraer un texto a partir de otro texto más grande o de igual tamaño. Por ejemplo, de la frase «Hola Mundo», podemos extraer la palabra «Mundo» de la siguiente manera:
string mySentence = "Hola Mundo";
string mySubstring = mySentence.Substring(5);
Console.WriteLine("Resultado: " + mySubstring);
// Resultado: Mundo
Lo primero que hacemos es declarar una variable para almacenar la palabra «Hola Mundo». Luego, a la variable mySentence le aplicamos substring para extraer la palabra mundo, y le pasamos como parámetro inidiceInicial el número 5, que según el cuadro anterior, es dónde inicia la palabra «Mundo».
Si sólo queremos extraer la palabra «Mun», vamos a usar el otro parámetro llamado tamaño, para decirle al método substring, que me extraiga una palabra a partir del índice 5, y del tamaño de tres posiciones.
string mySentence = "Hola Mundo";
string mySubstring = mySentence.Substring(5, 3);
Console.WriteLine("Resultado: " + mySubstring);
// Resultado: Mun
Como se habrán dado cuenta, el parámetro tamaño es opcional, puedo enviarlo solamente si lo necesito, esto se llama sobrecarga de un método y es un concepto que vamos a ver más adelante.
IndexOf y LastIndexOf (char value, int startIndex)
Estos métodos nos permiten buscar un carácter (un tipo de dato Char) dentro de una palabra. Lo podemos buscar desde el inicio de la palabra hacia el final, o en viceversa.
// indexOf
string mySentence = "Las flores amarillas";
int firstPositionL = mySentence.IndexOf('l');
Console.WriteLine("La posición de la primera l es: " + firstPositionL);
// La posición de la primera l es: 5
// lastIndexOf
string mySentenceLast = "Las flores amarillas";
int lastPositionL = mySentenceLast.LastIndexOf('l');
Console.WriteLine("La posición de la última l es: " + lastPositionL);
// La posición de la última l es: 17
Recuerda que las variables de tipo de dato Char (o carácter) se encierran entre comillas simples, y los string (o cadenas) se encierran entre comillas dobles. Por otro lado, el método diferencia mayúsculas de minúsculas, por esa razón, el IndexOf ignora la «L» inicial.
Otro parámetro importante de estos métodos es el startIndex (o índice inicial), el cual me va a permitir buscar la letra ( o el carácter) a partir de esa posición. Vamos a ver como funciona con las siguientes líneas de código.
// indexOf
string mySentence = "Las flores amarillas";
int firstPositionL = mySentence.IndexOf('l', 6);
Console.WriteLine("La posición de la primera l a partir de la posición 6 es: " + firstPositionL);
// La posición de la primera l a partir de la posición 6 es: 16
// lastIndexOf
string mySentenceLast = "Las flores amarillas";
int lastPositionL = mySentenceLast.LastIndexOf('l', 16);
Console.WriteLine("La posición de la última l a partir de la posición 16 es: " + lastPositionL);
// La posición de la última l a partir de la posición 16 es: 16
En el primer ejemplo, vamos a buscar la primera l a partir del índice 6 hacia adelante, y en el segundo ejemplo, vamos a buscar la primera l que encontremos, pero buscando desde el final hacia atrás. Coincidentemente, la posición de aquella l es 16.
ToUpper y ToLower
Estos dos métodos me permiten convertir mi texto a mayúsculas o minúsculas respectivamente. A continuación veremos como funciona.
// ToUpper
string mySentence = "Las cerezas rojas";
string mySentenceUpper = mySentence.ToUpper();
Console.WriteLine("La oración en mayúsculas es: " + mySentenceUpper);
// La oración en mayúsculas es: LAS CEREZAS ROJAS
// ToLower
string mySentencTwo = "Las cerezas rojas";
string mySentenceLower = mySentencTwo.ToLower();
Console.WriteLine("La oración en minúsculas es: " + mySentenceLower);
// La oración en minúsculas es: las cerezas rojas
Trim, TrimStart, TrimEnd
El método Trim cualquier espacio en blanco que esté al inicio y al final de tu texto. TrimStart solo elimina los espacios en blanco del inicio, y TrimEnd hace lo mismo, pero desde el final.
// Trim
string mySentence = " Las cerezas rojas ";
string trimValue = mySentence.Trim();
string mySentenceTwo = " Las flores rojas ";
string trimStartValue = mySentenceTwo.TrimStart();
string mySentenceThree = " Las flores amarillas ";
string trimEndValue = mySentenceThree.TrimEnd();
Console.WriteLine("Primera Oración: " + trimValue);
// Primera Oración: Las cerezas rojas
Console.WriteLine("Segunda Oración: " + trimStartValue);
// Segunda Oración: Las flores rojas
Console.WriteLine("Tercera Oración: " + trimEndValue);
// Tercera Oración: Las flores amarillas
Replace (string oldValue, string newValue)
Con Replace podemos reemplazar toda una palabra (o solo una letra) de una oración. El método pide como parámetros dos cadenas (o string) o dos carácteres (o Chars). En el primer parámetro vas a enviar la palabra o letra que vas a reemplazar, y en el segundo parámetro vas a enviar el nuevo valor.
string mySentence = "Las flores azules";
string replaceSentence = mySentence.Replace("azules", "rojas");
string replaceChar = mySentence.Replace('a', 'e');
Console.WriteLine("Cambiando una palabra de la oración: " + replaceSentence);
// Cambiando una palabra de la oración: Las flores rojas
Console.WriteLine("Cambiando una letra de la oración: " + replaceChar);
// Cambiando una letra de la oración: Les flores ezules
StartsWith y EndsWith (string value)
Con StartsWith validamos si mi texto empieza por la letra o palabra que envíe en el parámetro value. Con EndsWith validamos si el texto termina con la letra o palabra que envíe en el parámetro value. Estos métodos me devuelven un valor booleano (verdadero o falso).
string mySentence = "El perro cariñoso";
bool startValue = mySentence.StartsWith('A');
bool endValue = mySentence.EndsWith("oso");
Console.WriteLine("¿La oración empieza con A?: " + startValue);
// ¿La oración empieza con A?: False
Console.WriteLine("¿La oración termina con oso?: " + endValue);
// ¿La oración termina con oso?: True
Equals y Contains
Equal me permite comparar dos textos, y este me devolverá un valor booleano (verdadero o falso) según el resultado de la comparación. Contains me ayuda a validar si una palabra o letra existe dentro de mi texto, de igual manera, me devolverá un valor booleano (verdadero o falso) según el resultado de la validación.
string mySentence = "Hola Mundo";
string mySentenceTwo = "hola mundo";
string searchValue = "Mundo";
bool equalsValue = mySentence.Equals(mySentenceTwo);
bool containsValue = mySentence.Contains(searchValue);
Console.WriteLine("¿Las palabras " + mySentence + " y " + mySentenceTwo + " son iguales?: " + equalsValue);
// ¿Las palabras Hola Mundo y hola mundo son iguales?: False
Console.WriteLine("¿La palabra " + searchValue + " existe dentro del texto " + mySentence + "?: " + containsValue);
// ¿La palabra Mundo existe dentro del texto Hola Mundo?: True
PadRight y PadLeft (int tamañoTotal, char letraCompletar)
Estos métodos me permiten completar con la letra deseada (parámetro letraCompletar) una palabra, ya sea desde la izquierda o desde la derecha. Normalmente usamos estos métodos para completar con ceros un documento de identidad, para guardarlo correctamente en la base de datos, o para manipular archivos de texto planos (bloc de notas .txt).
string mySentence = "LUIS";
string rpadValue = mySentence.PadRight(20, 'S');
string lpadValue = mySentence.PadLeft(10, 'H');
Console.WriteLine("Completando con S a la derecha hasta completar 20 de tamaño: " + rpadValue);
// Completando con S a la derecha hasta completar 20 de tamaño: LUISSSSSSSSSSSSSSSSS
Console.WriteLine("Completando con H a la izquierda hasta completar 10 de tamaño: " + lpadValue);
// Completando con H a la izquierda hasta completar 10 de tamaño: HHHHHHLUIS
Split (char letraSeparadora)
Con split podemos cortar una palabra en tantas veces se repita la letraSeparadora. Por ejemplo, si queremos cortar la palabra «Hola Mundo», por el espacio en blanco, esta palabra se dividirá en dos. Este método retorna un arreglo de tipo string. Un arreglo es un tipo de dato estructurado que me permite almacenar múltiples valores, más adelante profundizaremos en el tema.
string mySentence = "El televisor es muy grande";
string [] splitArray = mySentence.Split(' ');
Console.WriteLine("Separando el texto " + mySentence + " por el espacio.");
// Separando el texto El televisor es muy grande por el espacio.
Console.WriteLine("Primera palabra: " + splitArray[0]);
// Primera palabra: El
Console.WriteLine("Segunda palabra: " + splitArray[1]);
// Segunda palabra: televisor
Console.WriteLine("Tercera palabra: " + splitArray[2]);
// Tercera palabra: es
Console.WriteLine("Cuarta palabra: " + splitArray[3]);
// Cuarta palabra: muy
Console.WriteLine("Quinta palabra: " + splitArray[4]);
// Quinta palabra: grande
Aún hay algunos cuantos métodos más, pero no son tan usados, desde mi punto de vista. Te he listado los métodos más útiles y los que más vas a utilizar en el mundo profesional. Ahora vamos a resolver los siguientes ejercicios aplicando la clase String y los métodos estudiados.
Ejercicio 1. Solicita al usuario que ingrese su nombre completo (Dos nombres y dos apellidos) y genérale su correo corporativo de Clase13.com. La regla para crear el correo es la siguiente: primera letra del primer nombre, primera letra del segundo nombre, dos primeras letras del primer apellido y dos primeras letras del segundo apellido, todo en minúscula. Consideramos solo 4 palabras, no apellidos compuestos ni nada por el estilo, para no hacer el ejercicio tan complejo.
using System;
namespace Cadenas2
{
class Program
{
static void Main(string[] args)
{
// Creamos nuestras variables para almancenar los nombres y los apellidos.
string firstName;
string secondName;
string lastName;
string secondLastName;
string letterFirstName;
string letterSecondName;
string letterLastName;
string letterSecondLastName;
string corporateEmail;
// Creamos una constante para almacenar el dominio de nuestra empresa.
const string dominio = "@clase13.com";
// Solicitamos su nombre completo al usuario.
Console.WriteLine("Ingrese su primer nombre: ");
firstName = Console.ReadLine();
Console.WriteLine("Ingrese su segundo nombre: ");
secondName = Console.ReadLine();
Console.WriteLine("Ingrese su primer apellido: ");
lastName = Console.ReadLine();
Console.WriteLine("Ingrese su segundo apellido: ");
secondLastName = Console.ReadLine();
// Validamos que no hayan espacios en blanco al comienzo o al final.
firstName = firstName.Trim();
secondName = secondName.Trim();
lastName = lastName.Trim();
secondLastName = secondLastName.Trim();
// Ahora comenzaremos a crear el correo corporativo.
// Para los nombres, realizaremos un substring
// Empezando desde la priemra letra y obteniendo un solo carácter
letterFirstName = firstName.Substring(0,1);
letterSecondName = secondName.Substring(0,1);
// Para los apellidos es lo mismo, pero obtendremos dos carácteres.
letterLastName = lastName.Substring(0,2);
letterSecondLastName = secondLastName.Substring(0,2);
// Ahora concatenamos todo.
corporateEmail = letterFirstName + letterSecondName + letterLastName + letterSecondLastName + dominio;
// Convertimos a minúsculas el correo.
// Podemos reutilizar la variable de la siguiente manera.
corporateEmail = corporateEmail.ToLower();
// Finalizamos imprimiendo el correo corporativo.
Console.WriteLine("Su correo corporativo de Clase 13 es: " + corporateEmail);
}
}
}
Dentro del código está todo explicado, ahora vamos a ejecutar para ver si funciona.
Si te salió como a mí, ¡Felicidades! Vamos por un ejercicio más.
Ejercicio 2. Crea un programa que cuente cuantas letras «a» hay en un texto ingresado por el usuario.
Para este ejercicio vamos a usar una propiedad de la clase String llamada Length, la cual me devuelve el tamaño de la palabra, por ejemplo, el Length de la palabra «araña» es 5. ¿Qué es una propiedad? Es información que almacenan las clases, datos importantes que podemos disponer para utilizarlos en nuestro código. Este tema también lo profundizaremos más adelante, ya que nosotros mismos podremos crear nuestras propiedades.
using System;
namespace Cadenas3
{
class Program
{
static void Main(string[] args)
{
// Iniciamos declarando las variables que vamos a utilizar.
string userText;
string newUserText;
int lengthTextBefore;
int lengthTextAfter;
int totalLetterA;
// Solicitamos el texto al usuario.
Console.WriteLine("Ingrese el texto que desee analizar: ");
userText = Console.ReadLine();
// Validamos que no haya espacios en blanco al inicio o al final del texto.
userText = userText.Trim();
// Convertimos a minúscula para que nuestra búsqueda sea más exacta.
userText = userText.ToLower();
// Lo primero que vamos a hacer es contar cuantas letras tiene el texto
// Y lo vamos a almacenar en la variable lengthTextBefore
lengthTextBefore = userText.Length;
// La propiedad Length me devuelve el tamaño de cualquier variable string.
// Ahora vamos a reemplazar todas las letras "a" por espacios vacíos.
// Vamos a usar la propiedad Replace y lo almacenamos en otra variable.
newUserText = userText.Replace("a", "");
// Al hacer un Replace de la letra A por un espacio vacío, vamos a eliminar todas las letras A del texto
// Y ese texto se va a reducir en tamaño.
// Para hallar el total de letras "a", vamos a restar el tamaño del texto antes de quitar la letra "a" con el nuevo texto sin la letra "a"
// La diferencia será la cantidad de letras "a" que tiene el texto ingresado por el usuario.
lengthTextAfter = newUserText.Length;
// Restamos tamaño anterior con el nuevo tamaño
totalLetterA = lengthTextBefore - lengthTextAfter;
// Imprimimos la información.
Console.WriteLine("La cantidad total de letras A del texto es: " + totalLetterA);
}
}
}
Ahora vamos a ejecutar nuestro programa para saber si funciona.
Probamos con varios ejemplos y ¡funciona! Ahora te toca a ti.
Ejercicio 3. Crea un programa que cuente cuantas vocales hay en un texto ingresado por el usuario.
Ejercicio 4. Crea un programa que cuente cuantas palabras hay en un texto ingresado por el usuario.
Ejercicio 5. Crea un programa que genere un correo electrónico corporativo con las siguientes reglas. Primera letra del primera nombre, dos últimas letras del segundo nombre, y las tres primeras letras de los dos apellidos.
Espero que el contenido de esta clase te haya servido de mucho, y si aún tienes dudas, o algo no está claro, déjanos tu comentario para tenerlo en cuenta y explayarnos un poco más (o corregir) en caso sea necesario.
Nos sería de mucha ayuda que compartas el contenido si te ha gustado y te invitamos a seguirnos en nuestras redes sociales de Clase13, estamos en Facebook, Instagram y Twitter como @Clase13lat, de esa manera te enterarás de las últimas novedades de manera rápida. También te invito a seguirme en Instagram como @rodolfopenia donde estaré subiendo contenido adicional para complementar la clase.
CLASE 13 