Trabajo avanzado con arrays

1. Array del tipo string

Bueno, y brevemente me gustaría contarte sobre el array del tipo string.

Como ya dijimos, un array puede ser de cualquier tipo. Así que puedes crear un array del tipo string. Así se vería el código si tuviéramos que escribir un programa que "lee 10 líneas desde el teclado y las muestra en pantalla en orden inverso".

string[] array = new string[10];	// Creamos un objeto-array de 10 elementos
for (int i = 0; i < 10; i++)		// Bucle de 0 a 9
{
   array[i] = Console.ReadLine();	// Leemos una línea del teclado y la guardamos en la celda del array
}
for (int i = 9; i >= 0; i--)		// Bucle de 9 a 0
{
    Console.WriteLine(array[i]);	// Mostramos en pantalla la celda correspondiente del array
}

¡El código casi no cambió! Solo tuvimos que cambiar el tipo int por string al crear el array. ¡Por lo demás, todo igualito!

2. Array del tipo string en memoria

Y otro dato útil. Mira estas 3 imágenes:

Imagen 1. Cómo se coloca el objeto string en memoria:

Fíjate que el texto de la string no se guarda directamente en la variable: para él se reserva un bloque aparte de memoria. Y en la variable del tipo string se guarda la dirección (referencia) al objeto con el texto.

Imagen 2. Cómo se coloca un array de enteros en memoria:

Esta imagen ya la viste antes.

Imagen 3. Cómo se coloca en memoria un array de strings:

A la izquierda vemos la variable-array del tipo string[] (guarda la dirección del objeto-array).
En el medio — el objeto-array del tipo string.
Y a la derecha — los objetos-string, que guardan algún texto.

En las celdas del objeto-array del tipo string no se guardan los textos en sí, sino sus direcciones (referencias). Igual que en las variables del tipo string se guardan las direcciones de los textos.

3. Inicialización rápida de arrays en C#

Los arrays son súper útiles, así que los desarrolladores de C# intentaron hacer el trabajo con ellos lo más cómodo posible. Y lo primero que hicieron fue simplificar la inicialización del array, es decir, meterle valores iniciales.

Porque muchas veces, además de los datos que el programa lee de algún lado, necesita también sus propios datos internos. Por ejemplo, necesitamos guardar en un array las longitudes de todos los meses. Así podría verse ese código:

int[] months = new int[12];
months[0] = 31; // enero
months[1] = 28; // febrero
months[2] = 31; // marzo
months[3] = 30; // abril
months[4] = 31; // mayo
months[5] = 30; // junio
months[6] = 31; // julio
months[7] = 31; // agosto
months[8] = 30; // septiembre
months[9] = 31; // octubre
months[10] = 30; // noviembre
months[11] = 31; // diciembre

Pero hay una forma más corta de escribirlo — gracias a los creadores de C#:

// longitudes de los meses del año
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

¡Puedes simplemente enumerar todos los valores del array separados por comas!

Guay, ¿no? Pero eso no es todo.

Resulta que el compilador puede determinar el tipo del contenedor (objeto-array) según el tipo de la variable-array. Y para saber la longitud del array — simplemente cuenta cuántos elementos hay entre llaves.

Por eso este código se puede escribir aún más corto:

// longitudes de los meses del año
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

¿A que mola? 🙂

A esto se le llama "inicialización rápida de arrays". Por cierto, funciona no solo para int...

// nombres de los meses del año
string[] months = { "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"};

4. Bucle foreach

Recorrer todos los elementos de un array es tan común que para eso inventaron un bucle especial(!). Se llama foreach. Y se escribe así:

foreach (int score in scores)
{
    Console.WriteLine($"Puntos: {score}");
}
        

Aquí el bucle recorre los elementos solo — sin ningún índice manual. No puedes cambiar los elementos directamente (solo están disponibles para lectura en el bucle), pero es súper cómodo para simplemente "dar una vuelta" por el array.

El compilador convierte el código del bucle foreach en el siguiente código:

for (int i = 0; i < scores.Length; i++)
{
    int score = scores[i];
    Console.WriteLine($"Puntos: {score}");
}
        

Así que nada de magia. Pero ahora queda claro por qué no puedes cambiar los elementos del array usando la variable score.

Vamos a escribir otro ejemplo: vamos a encontrar la suma de todos los puntos.

int sum = 0;
foreach (int score in scores)
{
    sum += score;
}
Console.WriteLine($"Suma de todos los puntos: {sum}");
        

¿Cuándo usar qué bucle?

• Si necesitas el índice o quieres modificar elementos — usa el bucle for.
• Si solo quieres recorrer los valores — foreach es más rápido y limpio.

5. Indexación desde el final: operador ^

Desde hace un tiempo en C# puedes obtener elementos desde el final del array. Antes, si querías el último elemento del array — escribías algo como:

int lastScore = scores[scores.Length - 1];
        

Ahora es mucho más fácil. Solo tienes que poner el operador ^ delante del índice, y empieza a contar desde el final:

int lastScore = scores[^1];        // Último elemento
int penultimate = scores[^2];      // Penúltimo elemento
        

• ^1 — es el primero desde el final (el último).
• ^2 — el segundo desde el final.

Visualización

score[^1] = 17, score[^2] = 22 — fácil y claro.

¡Importante! Fíjate que los índices desde el final empiezan en 1, no en cero.

6. Rangos: operador .. (range)

A veces necesitas obtener un subarray del array original. En C# para eso puedes usar el operador especial de rango .. — es una forma corta y muy cómoda de pillar el "trozo" que necesitas del array.

A ese subarray a veces se le llama slice (del inglés "slice"), y se define por dos límites: inicio y fin.
Ojo: el límite derecho no se incluye en el resultado!

Cómo se ve

int[] scores = { 10, 15, 8, 22, 17 };
int[] top3 = scores[0..3]; // Pillamos los elementos del 0 al 2: {10, 15, 8}
        

• scores[0..3] — pillamos los elementos desde el índice 0 (incluido) hasta el índice 3 (NO incluido).
• El array final tendrá los elementos con índices 0, 1 y 2.

Atajos

Si no pones el límite izquierdo, pillas desde el principio:

int[] firstTwo = scores[..2]; // igual que scores[0..2], o sea {10, 15}
        

Si no pones el límite derecho, pillas hasta el final:

int[] fromThird = scores[2..]; // {8, 22, 17}
        

Índices negativos

Con el símbolo ^ puedes contar índices desde el final:

int[] lastTwo = scores[^2..]; // {22, 17}
        

Aquí ^2 — es "el segundo elemento desde el final".

También puedes pillar un rango "de tal a cual", usando índices negativos en ambos lados:

int[] mid = scores[1..^1]; // {15, 8, 22} (del segundo al penúltimo)
        

Qué hay que recordar

• El límite derecho nunca se incluye — o sea, si pones a..b, pillas todos los elementos desde a hasta b-1.
• Si pones límites que se salen del array, te saltará una excepción IndexOutOfRangeException.
• El slice — es un array nuevo, el original no cambia. Cualquier cambio en el nuevo array no afecta al original.

Ejemplos prácticos

int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
int[] arr = { 1, 2, 3, 4, 5, 6, 7 };

int[] start = arr[..3];      // {1, 2, 3}
int[] end = arr[^2..];       // {6, 7}
int[] middle = arr[2..5];    // {3, 4, 5}
int[] all = arr[..];         // {1, 2, 3, 4, 5, 6, 7} (copia completa)

2

Tarea

C# SELF, nivel 7, lección 2

Bloqueada

Uso de indexación desde el final y rangos

Uso de indexación desde el final y rangos

Abrir

2

Tarea

C# SELF, nivel 7, lección 2

Bloqueada

Reverso de un array de cadenas y subarrays

Reverso de un array de cadenas y subarrays

Abrir