Ejercicio: Uso de los métodos auxiliares IndexOf() y LastIndexOf() de la cadena

25 minutos

En este ejercicio, usamos los métodos IndexOf() y LastIndexOf() para buscar las posiciones de caracteres y subcadenas dentro de una cadena determinada.

`IndexOf()` y `LastIndexOf`

El método .IndexOf() devuelve el índice de la primera aparición de un carácter o subcadena especificados dentro de una cadena determinada. El método .LastIndexOf() devuelve la posición del índice de la última aparición de un carácter o cadena dentro de una cadena determinada. Los métodos Indexof() y LastIndexOf() devuelven -1 si no se encuentra el carácter o la cadena.

Seleccione y elimine todas las líneas de código del editor de Visual Studio Code.

Actualice el código en el editor de Visual Studio Code de la siguiente manera:

string message = "hello there!";

int first_h = message.IndexOf('h');
int last_h = message.LastIndexOf('h');

Console.WriteLine($"For the message: '{message}', the first 'h' is at position {first_h} and the last 'h' is at position {last_h}.");

Guarde el archivo de código y use Visual Studio Code para ejecutar el código. Debería ver la siguiente salida:
```
For the message: 'hello there!', the first 'h' is at position 0 and the last 'h' is at position 7.
```
La salida identifica la primera "h" en la cadena "hello there!" en la posición 0 y la última "h" en la posición 7.

Recuperar la última aparición de una subcadena

Aumentará la complejidad de la variable message mediante la adición de varios conjuntos de paréntesis y, después, se escribirá código para recuperar el contenido dentro del último conjunto de paréntesis.

Seleccione y elimine todas las líneas de código del editor de Visual Studio Code.

Actualice el código en el editor de Visual Studio Code de la siguiente manera:

string message = "(What if) I am (only interested) in the last (set of parentheses)?";
int openingPosition = message.LastIndexOf('(');

openingPosition += 1;
int closingPosition = message.LastIndexOf(')');
int length = closingPosition - openingPosition;
Console.WriteLine(message.Substring(openingPosition, length));

Guarde el archivo de código y use Visual Studio Code para ejecutar el código. Debería ver la siguiente salida:
```
set of parentheses
```
La clave de este ejemplo es el uso de LastIndexOf(), que puede utilizar para obtener las posiciones de los últimos paréntesis de apertura y cierre.

Nota:

El código de ejemplo anterior solo se ejecuta sin errores porque la cadena message contiene pares de paréntesis con formato correcto. Pero el código es frágil y genera errores cuando no hay un par de paréntesis, o bien cuando los últimos paréntesis no forman un par de apertura y cierre.

Recuperar todas las instancias de subcadenas entre paréntesis

Esta vez, actualizará message para tener tres conjuntos de paréntesis y escribirá código para extraer cualquier texto dentro de los paréntesis. Puede volver a usar partes del trabajo anterior, pero tiene que agregar una instrucción while para recorrer en iteración la cadena hasta que se detecten, extraigan y muestren todos los conjuntos de paréntesis.

Actualice el código en el editor de Visual Studio Code de la siguiente manera:

string message = "(What if) there are (more than) one (set of parentheses)?";
while (true)
{
    int openingPosition = message.IndexOf('(');
    if (openingPosition == -1) break;

    openingPosition += 1;
    int closingPosition = message.IndexOf(')');
    int length = closingPosition - openingPosition;
    Console.WriteLine(message.Substring(openingPosition, length));

    // Note the overload of the Substring to return only the remaining 
    // unprocessed message:
    message = message.Substring(closingPosition + 1);
}

Guarde el archivo de código y use Visual Studio Code para ejecutar el código. Debería ver la siguiente salida:
```
What if
more than
set of parentheses
```
Dedique un minuto a observar la última línea de código dentro del bucle while, extraída en el código siguiente:
```
message = message.Substring(closingPosition + 1);
```
Cuando se usa Substring() sin especificar un parámetro de entrada de longitud, devolverá todos los caracteres después de la posición inicial que se especifica. Con la cadena que se está procesando, message = "(What if) there are (more than) one (set of parentheses)?", es ventajoso eliminar el primer conjunto de paréntesis (What if) del valor de message. Lo que queda se procesa después en la siguiente iteración del bucle while.
Dedique un minuto a tener en cuenta lo que sucede durante la iteración final del bucle while, cuando solo permanece el carácter ? final.

El código siguiente direcciona el final de la cadena:
```
int openingPosition = message.IndexOf('(');
if (openingPosition == -1) break;
```
El método IndexOf() devuelve -1 si no encuentra el parámetro de entrada en la cadena. Simplemente se comprueba el valor -1 y break fuera del bucle.

Trabajar con diferentes tipos de conjuntos de símbolos con `IndexOfAny()`

Esta vez, busque varios símbolos de caracteres diferentes, no solo un conjunto de paréntesis mediante .IndexOfAny().

.IndexOfAny() notifica el índice de la primera aparición de cualquier carácter en una matriz de caracteres proporcionada. El método devuelve -1 si no se encuentran todos los caracteres de la matriz de caracteres.

En el ejemplo siguiente, se devuelve el índice del primer carácter encontrado de los caracteres "a", "e" o "i".

Actualice el código en el editor de Visual Studio Code de la siguiente manera:

string message = "Hello, world!";
char[] charsToFind = { 'a', 'e', 'i' };

int index = message.IndexOfAny(charsToFind);

Console.WriteLine($"Found '{message[index]}' in '{message}' at index: {index}.");

Guarde el archivo de código y use Visual Studio Code para ejecutar el código.

Debería ver la siguiente salida:
```
Found 'e' in 'Hello, world!' at index: 1.
```
Actualizará la cadena message mediante la adición de distintos tipos de símbolos como corchetes [] y llaves {}. Para buscar varios símbolos simultáneamente, use .IndexOfAny(). Busque con .IndexOfAny() para devolver el índice del primer símbolo de la matriz openSymbols que se encuentra en la cadena message.

Actualice el código en el editor de Visual Studio Code de la siguiente manera:

string message = "Help (find) the {opening symbols}";
Console.WriteLine($"Searching THIS Message: {message}");
char[] openSymbols = { '[', '{', '(' };
int startPosition = 5;
int openingPosition = message.IndexOfAny(openSymbols);
Console.WriteLine($"Found WITHOUT using startPosition: {message.Substring(openingPosition)}");

openingPosition = message.IndexOfAny(openSymbols, startPosition);
Console.WriteLine($"Found WITH using startPosition {startPosition}:  {message.Substring(openingPosition)}");

Guarde el archivo de código y use Visual Studio Code para ejecutar el código.

Debería ver la siguiente salida:

Searching THIS message: Help (find) the {opening symbols}
Found WITHOUT using startPosition: (find) the {opening symbols}
Found WITH using startPosition 5:  (find) the {opening symbols}

Dedique un minuto a revisar el código que acaba de escribir.

Ha usado .IndexOfAny()sin y, a continuación, con, la sobrecarga de posición inicial.

Ahora que ha encontrado un símbolo de apertura, debe encontrar su símbolo de cierre correspondiente.

Actualice el código en el editor de Visual Studio Code de la siguiente manera:

string message = "(What if) I have [different symbols] but every {open symbol} needs a [matching closing symbol]?";

// The IndexOfAny() helper method requires a char array of characters. 
// You want to look for:

char[] openSymbols = { '[', '{', '(' };

// You'll use a slightly different technique for iterating through 
// the characters in the string. This time, use the closing 
// position of the previous iteration as the starting index for the 
//next open symbol. So, you need to initialize the closingPosition 
// variable to zero:

int closingPosition = 0;

while (true)
{
    int openingPosition = message.IndexOfAny(openSymbols, closingPosition);

    if (openingPosition == -1) break;

    string currentSymbol = message.Substring(openingPosition, 1);

    // Now  find the matching closing symbol
    char matchingSymbol = ' ';

    switch (currentSymbol)
    {
        case "[":
            matchingSymbol = ']';
            break;
        case "{":
            matchingSymbol = '}';
            break;
        case "(":
            matchingSymbol = ')';
            break;
    }

    // To find the closingPosition, use an overload of the IndexOf method to specify 
    // that the search for the matchingSymbol should start at the openingPosition in the string. 

    openingPosition += 1;
    closingPosition = message.IndexOf(matchingSymbol, openingPosition);

    // Finally, use the techniques you've already learned to display the sub-string:

    int length = closingPosition - openingPosition;
    Console.WriteLine(message.Substring(openingPosition, length));
}

Dedique unos minutos a examinar el código anterior y a leer los comentarios que ayudan a explicar el código.
Continúe examinando el código y busque la siguiente línea de código mediante IndexOf() para definir closingPosition:
```
closingPosition = message.IndexOf(matchingSymbol, openingPosition);
```
La variable closingPosition se usa para buscar la longitud pasada al método Substring() y para buscar el siguiente valor openingPosition:
```
int openingPosition = message.IndexOfAny(openSymbols, closingPosition);
```
Por ese motivo, la variable closingPosition se define fuera del ámbito de bucle while y se inicializa en 0 para la primera iteración.
Guarde el archivo de código y use Visual Studio Code para ejecutar el código. Debería ver la siguiente salida:
```
What if
different symbols
open symbol
matching closing symbol
```

Resumen

Hay dos aspectos importantes que se deben tener en cuenta:

LastIndexOf() devuelve la última posición de un carácter o una cadena dentro de otra cadena.
IndexOfAny() devuelve la primera posición de una matriz de char dentro de otra cadena.

Comentarios

¿Le ha resultado útil esta página?

Ejercicio: Uso de los métodos auxiliares IndexOf() y LastIndexOf() de la cadena

Comprobación de conocimientos

Comentarios