No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Formas de recorrer arreglos

17/32
Recursos

Adem谩s de recorrer un arreglo con la sentencia while podemos encontrar:

  • La sentencia do while donde a diferencia de while se va a ejecutar primero el c贸digo y luego va a verificar si la condici贸n es v谩lida.
  • La sentencia for.
  • La sentencia foreach.

Aportes 47

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

El bucle ForEach fue principalmente hecho para recorrer arrays

al medir el tiempo de ejecuccion es mucha la diferencia.


PS C:\Users\Raziel214\Documents\GitHub\COREESCUELA> dotnet run
Nombre: "Copia:JOHN'S SCHOOL", Tipo: Primaria
,Pais: Colombia,Ciudad: cali
#############
Nombre101,Id 24f57c62-efe0-4788-a616-36ddc9f3c3de
Nombre201,Id 9ca95e12-dc0a-4c21-9d18-425ad2c556ae
Nombre301,Id 0b109791-5c1a-40be-8d92-746e89dfd0fe
4.2076
#############
Nombre101,Id 24f57c62-efe0-4788-a616-36ddc9f3c3de
Nombre201,Id 9ca95e12-dc0a-4c21-9d18-425ad2c556ae
Nombre301,Id 0b109791-5c1a-40be-8d92-746e89dfd0fe
0.8204

Los separadores tambi茅n se pueden hacer de la siguiente forma:

string separador = String.Concat(Enumerable.Repeat("=", 20));

En este caso 鈥淓numerable鈥 es una funci贸n de Linq, por lo que tenemos que agregar esto:

using System.Linq;

Sino, tambi茅n podemos hacerlo de la siguiente forma:

string separador2 = new string ('*', 20);

Y despu茅s solamente las ejecutamos con el WriteLine:

Console.WriteLine(separador2);
Console.WriteLine(separador);

En mi opinion, tratar de hacer el codigo mas 鈥渟imple鈥 o 鈥渓egible鈥, a veces lo complica mas, yo pienso que el codigo mas simple o legible es el que puede leer una persona que no sea necesariamente experto en el lenguaje.

Si lo dejan el Do while con (contador++ <arregloCursos.Legth)

 private static void ImprimirCursosDoWhile(Curso[] arregloCursos)
        {
            int contador = 0;
            do
            {
                Console.WriteLine($"Nombre {arregloCursos[contador].Nombre}, Id {arregloCursos[contador].UniqueId}");
            } while (contador++ < arregloCursos.Length);
        }

Al final le indicara que no encontr贸 la 煤ltima posici贸n y que se sali贸 del arreglo, debido a que cuando contador=2 es < que arregloCursos.Legth y vuelve a hacer una vuelta extra pero ahora es contador=3; debido a que le sumo 1 despu茅s de hacer la comparaci贸n, y el arreglo ya no tiene posici贸n 3 por eso hay que tener cuidado de donde se coloca el contador++ como bien mencion贸 el profesor.

**Dato interesante: ** En el For Each Juan Carlos decidi贸 usar VAR como el tipo de cada uno de los elementos en el arreglo. Esto es posible porque VAR es mas general y recibe mas tipos de datos/objetos.

foreach (var curso in cursoArreglo)
            {
                Console.WriteLine($"{curso.nombre}, {curso.id}");
            }

Pero tambi茅n es posible usar el tipo de la variable que ya sabes que se encuentra dentro del arreglo, en este caso el tipo Curso. Quedando de esta manera:

foreach (Curso curso in cursoArreglo)
            {
                Console.WriteLine($"{curso.nombre}, {curso.id");
            }

Importante decir que con do鈥hile, lo que esta dentro del do se ejecuta al menos una vez SIEMPRE, sin importar la condicion de while.

Rename Symbol F2 para cambiar los demas lugares donde se llama un metodo.

Si que me est谩 agradando la manera de entender las diferencias y en que casos podemos utilizar un arreglo.

En el DoWhile si escribimos incrementando el contador dentro del While pero haciendo el incremento despu茅s de que se ejecute la pregunta el c贸digo arroja un error porque el contador va a valer 3 y al querer ejecutar el array de m谩ximo 2 va a fallar.

private static void ImprimirCursosWhile(Curso[] arregloCursos)
    {
      int contador = 0;
      do
      {
        Console.WriteLine($"Nombre {arregloCursos[contador].Nombre}, Id {arregloCursos[contador].UniqueId}");
        //contador ++;
      } while (contador++ < arregloCursos.Length);

**Prefijo: ** ++contador (primero se asigna el valor de incremento para posteriormente realizar la operaci贸n).
**Posfijo: ** contador ++ (se realiza la operaci贸n y luego se suma para almacenarse el valor).

Hola. El profesor menciona que el foreach a nivel de memoria cambia bastante. 驴Alguien sabe los detalles t茅cnicos de esta diferencia que menciona el profesor?

using System.Runtime.Serialization.Json;
// See https://aka.ms/new-console-template for more information
using CoreEscuela.Entidades;

Console.WriteLine("Hello, World!");
Escuela es = new Escuela("Escuela Basicas",1995,TiposEscuela.Primaria);

Curso cursos1 = new Curso();
cursos1.Nombre="Pruebas";
cursos1.Jornada =TiposJornada.Mana帽a;


var curso2 = new Curso()
{
    Nombre = "102",
    Jornada = TiposJornada.Tarde
};

var arrayCursos = new Curso[3];

arrayCursos[0] = new  Curso(){
    Nombre = "301",
    Jornada = TiposJornada.Noche
} ;

var cursos2 = new Curso(){
    Nombre="302",
    Jornada = TiposJornada.Noche
};
arrayCursos[1] = cursos2;

arrayCursos[2] = new Curso(){
    Nombre = "303",
    Jornada = TiposJornada.Noche
};

Console.WriteLine(es.Nombres);
Console.WriteLine("=======================================");
Console.WriteLine(cursos1.Nombre + "," + cursos1.Jornada + "," + cursos1.CursoId);
Console.WriteLine($"{curso2.Nombre} , {curso2.Jornada} , {curso2.CursoId}");
ImprimirCurosNoche(arrayCursos);

void ImprimirCurosNoche(Curso[] arrayCursos)
{
    foreach(var curso in arrayCursos){
        Console.WriteLine($"Nombre: {curso.Nombre} , Jornada: {curso.Jornada}, Id: {curso.CursoId}");
    }
}

=======================================
Pruebas,Mana帽a,822e56fd-7c1e-45f6-a37a-4b067228164f
102 , Tarde , faf3d262-8aa0-42f4-9ce9-2961b1dcd96d
Nombre: 301 , Jornada: Noche, Id: d688bd51-b520-4e7a-8668-ac1f337e5ccf
Nombre: 302 , Jornada: Noche, Id: a28efa44-6a98-4ce5-90f6-c568e854dedc
Nombre: 303 , Jornada: Noche, Id: 8c5d2f53-d9e3-4d9c-9363-5ddd03105272

La diferencia entre while y do while es que en el do while siempre se ejecutar谩 al menos una vez. Por m谩s que de entrada la condici贸n sea false, se ejecutar谩 una vez el c贸digo que se encuentra dentro del bucle.

<code> 

private static void imprimirCursos(curso[] arregloCursos)
        {
            // Formas de recorrer un arreglo

            // con for
             for (int i = 0; i < arregloCursos.Length; i++)
                {
                    Console.WriteLine($"Nombre del curso: {arregloCursos[i].nombre} Jornada: {arregloCursos[i].jornada} ID: {arregloCursos[i].uniqueId}");
                }

            // con foreach
            foreach (var curso in arregloCursos)
            {
                if (curso != null)
                {
                    Console.WriteLine($"Nombre del curso: {curso.nombre} Jornada: {curso.jornada} ID: {curso.uniqueId}");
                }
            }

            // con while

            int indice = 0;
            while (indice < arregloCursos.Length)
            {
                Console.WriteLine($"Nombre del curso: {arregloCursos[indice].nombre} Jornada: {arregloCursos[indice].jornada} ID: {arregloCursos[indice].uniqueId}");
                indice++;
            }

            // con do while

            indice = 0;
            do
            {
                Console.WriteLine($"Nombre del curso: {arregloCursos[indice].nombre} Jornada: {arregloCursos[indice].jornada} ID: {arregloCursos[indice].uniqueId}");
                indice++;
            } while (indice < arregloCursos.Length);

        }

Este curso esta genial, de hecho uno de los mejores, lastima no este en la ruta principal

Yo us茅 un foreach

<code> 
static void Imprimir(Curso[] array)
{
    foreach (var arreglo in array)
    {
        Console.WriteLine($"ID: {arreglo.ID} Nombre: {arreglo.Nombre}");
    }
}

Muy bien

Recorriendo Arreglos.

foreach (Curso curso in array)
 {
      Console.WriteLine($"\n{curso}");
 }

Para que en la impresi贸n podemos identificar cada uno de los diferentes recorridos:

            System.Console.WriteLine("============ Normal");
            Console.WriteLine(escuela);
            System.Console.WriteLine("============ While");
            imprimirCursosWhile(arregloCursos);
            System.Console.WriteLine("============ Do While");
            imprimirCursosDoWhile(arregloCursos);
            System.Console.WriteLine("============ For");
            imprimirCursosFor(arregloCursos);
            System.Console.WriteLine("============ For Each");
            imprimirCursosForEach(arregloCursos);

Muy satisfecho, del curso

Falta poco

Y si?

public void Imprimir(){
            System.Console.WriteLine($"  {Nombre}  | {UniqueId}");
        }

a la clase objeto y en el programa lo invocamos

while (contador < arregloCursos.Length)
            {
                arregloCursos[contador].Imprimir();
                contador++;
            }
<h1>El resultado quedar铆a as铆</h1> <h1>Curso | UniqueID
101 | 0d1c784f-d6d6-4fc6-9180-b453bb111ecb
201 | 9bd48aed-12e0-4b48-be7c-b1566e741328
301 | 840921fa-8ddd-4dd0-aa9b-ef92b6a45afa</h1>

En este caso para poder recorrer los arreglos se puede hacer de la siguiente manera

<for (type var : array) 
{ 
    statements using var;
}
is equivalent to:

for (int i=0; i<arr.length; i++) 
{ 
    type var = arr[i];
    statements using var;
}>

Excelente!
While
DoWhile
For
Foreach

Se podr铆a escribir tambi茅n como LinQ

private static void ImprimirCursos(Curso[] arregloCursos)
{
	arregloCursos.ToList().ForEach(s => Console.WriteLine(string.Format("{0} | {1}", s._nombre, s._uniqueId)));
}

Esta es mi manera de recorrer el arreglo
for (int i = 0; i <= arregloCursos.Length; i++)
{
Console.WriteLine("Curso: " + arregloCursos[i].nombre
+ "\nUid: " + arregloCursos[i].uid);
}

Buenas clases

Esta es mi manera de recorrer el arreglo
for (int i = 0; i <= arregloCursos.Length; i++)
{
Console.WriteLine("Curso: " + arregloCursos[i].nombre
+ "\nUid: " + arregloCursos[i].uid);
}

Tipos de Sentencias para recorrer una array:

  • Do while: a diferencia del while , en esta sentencia el codigo de ejecuta simpre 1 vez, y luego se comprueba la condici贸n

  • For: una forma mas compacta de while y mas legible, el inconveniente es que puede ser mas sencillo equivocarse a la hora de escribir el codigo.

  • ForEach: la mas fiable y legible es el for.

do{}while se usa cuando queremos una iteracion como minimo,

Muy buena explicaci贸n de como recorrer los arreglos genial!!!

escuela.TipoEscuela = TipoEscuela.Primaria;
            Console.WriteLine(escuela);
            Console.WriteLine("=============");
            ImprimirCursosWhile(arregloCursos);
            Console.WriteLine("=============");
            ImprimirCursosDoWhile(arregloCursos);
            Console.WriteLine("=============");
            ImprimirCursosFor(arregloCursos);
            Console.WriteLine("=============");
            ImprimirCursosForeach(arregloCursos);
        }

        private static void ImprimirCursosFor(Curso[] arregloCursos)
        {
            for(int i = 0; i < arregloCursos.Length; i++)
            {
                Console.WriteLine($"Nombre{arregloCursos[i].Nombre}, Id {arregloCursos[i].UniqueId}");
            }
        }

        private static void ImprimirCursosDoWhile(Curso[] arregloCursos)
        {
             int contador = 0;
            do
            {
                Console.WriteLine($"Nombre{arregloCursos[contador].Nombre}, Id {arregloCursos[contador].UniqueId}");
                contador = contador + 1;
            }while(contador < arregloCursos.Length);
        }

        private static void ImprimirCursosWhile(Curso[] arregloCursos)
        {
            int contador = 0;
            while(contador < arregloCursos.Length)
            {
                Console.WriteLine($"Nombre{arregloCursos[contador].Nombre}, Id {arregloCursos[contador].UniqueId}");
                contador = contador + 1;
            }

        }
        private static void ImprimirCursosForeach(Curso[] arregloCursos)
        {
           foreach(var curso in arregloCursos)
           {
                Console.WriteLine($"Nombre{curso.Nombre}, Id {curso.UniqueId}");
           }
        }```

Buena aclaraci贸n entre el For y el ForEach

Es interesante comentar que a nivel de programaci贸n si las sentencias de comparaci贸n o de bucles solo tiene una instrucci贸n se puede prescindir de los corchetes, as铆:

    foreach (Curso c in arregloCursos)
                Console.WriteLine(c.Nombre + "," + c.UniqueId);

Muy buena clase! Creando marcador ahora! jaja

Muy buena explicaci贸n sobre como recorrer un arreglo de diferentes formas

Adem谩s de recorrer un arreglo con la sentencia while podemos encontrar:

La sentencia do while donde a diferencia de while se va a ejecutar primero el c贸digo y luego va a verificar si la condici贸n es v谩lida.
La sentencia for.
La sentencia foreach.

鉂わ笍

Console.WriteLine("===========While=============");
ImprimirCursosWhile(arrayCursos);
Console.WriteLine("===========DoWhile===========");
ImprimirCursosDoWhile(arrayCursos);
Console.WriteLine("===========ForEach============");
ImprimirCursosForEach(arrayCursos);
Console.WriteLine("============For==============");
ImprimirCursosFor(arrayCursos);
        
        private static void ImprimirCursosWhile(Curso[] arrayCursos)
        {
            int contador = 0;
            while (contador < arrayCursos.Length){
                Console.WriteLine($"{arrayCursos[1].Nombre},{arrayCursos[1].Id}");
                contador++;
            }
        }

        private static void ImprimirCursosDoWhile(Curso[] arrayCursos)
        {
            int contador = 0;
            do{
                Console.WriteLine($"{arrayCursos[1].Nombre},{arrayCursos[1].Id}");
                contador++;
            } while (contador < arrayCursos.Length);
        }

        private static void ImprimirCursosForEach(Curso[] arrayCursos)
        {
            foreach (var curso in arrayCursos)
                Console.WriteLine($"{curso.Nombre},{curso.Id}");
        }

        private static void ImprimirCursosFor(Curso[] arrayCursos)
        {
            for(int contador=0; contador < arrayCursos.Length; contador++)
                Console.WriteLine($"{arrayCursos[contador].Nombre},{arrayCursos[contador].Id}");
        }

Me encanta el foreach

private static void printCursosForEach(Curso[] cursosCreados)
        {
            foreach (var item in cursosCreados)
            {
                Console.WriteLine($"Nombre {item.Name} \nID {item.IdCourse}");
            }                            
        }```
 static void ImprimirCursosFor( Curso[] Arreglo){
                for (int i=0; i<= Arreglo.Length; i++){
                    Console.WriteLine($"Nombre{Arreglo[i].Nombre} , Id{Arreglo[i].UniqueId}");
                }
            }

Interesante

Esta clase esta en los comentarios de la clase anterior 馃敟馃敟 Aunque hacia falta la explicaci贸n del profesor, Genial

Buen铆sima explicaci贸n, en la universidad jam谩s comprend铆 sobre los array porque se me hac铆an super complicados por lo que utilizaba listas, pero despu茅s de 5 a帽os, en esta clase entiendo y de una forma sencilla.

Gracias Juan Carlos.

private static void ImprimirCursos(Curso[] cursos)
{
	 cursos.AsEnumerable().ToList().ForEach(curso =>
         {
                Console.WriteLine(string.Format("Id: {0}, Nombre: {1}", 				 
		curso.Id, curso.Nombre));
	});
}