Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript

Pętle i iteracje

12 min czytania ·
W tej lekcji11

W Parku Jurajskim rutynowe zadania muszą być wykonywane regularnie i powtarzalnie: sprawdzanie ogrodzenia każdego wybiegu co godzinę, monitorowanie wszystkich kamer bezpieczeństwa, aktualizacja statusu zdrowia każdego dinozaura. Ręczne wykonywanie tych czynności byłoby żmudne i podatne na błędy.

Podobnie w JavaScript, pętle pozwalają na automatyczne i efektywne wykonywanie powtarzalnych operacji. Zamiast pisać ten sam kod wielokrotnie, możemy użyć pętli do wykonania go dla wielu elementów lub określoną liczbę razy.

Pętla for

Pętla for jest jedną z najpopularniejszych pętli w JavaScript. Składa się z trzech części: inicjalizacji, warunku i wyrażenia aktualizującego.

// Podstawowa struktura pętli for
for (inicjalizacja; warunek; aktualizacja) {
  // Blok kodu do wykonania
}

W praktyce w Parku Jurajskim, możemy użyć pętli for do automatyzacji rutynowych zadań:

// Sprawdzanie stanu zdrowia każdego dinozaura w sektorze
let dinozaury = ["Tyranozaur", "Velociraptor", "Triceratops", "Stegozaur", "Brachiozaur"];

for (let i = 0; i < dinozaury.length; i++) {
  console.log(`Sprawdzanie stanu zdrowia: ${dinozaury[i]}`);
  // Kod sprawdzający stan zdrowia konkretnego dinozaura...
}

// Wynik:
// Sprawdzanie stanu zdrowia: Tyranozaur
// Sprawdzanie stanu zdrowia: Velociraptor
// Sprawdzanie stanu zdrowia: Triceratops
// Sprawdzanie stanu zdrowia: Stegozaur
// Sprawdzanie stanu zdrowia: Brachiozaur

// Monitoring kamer bezpieczeństwa
for (let kamera = 1; kamera <= 10; kamera++) {
  console.log(`Sprawdzanie kamery #${kamera}`);
  // Kod analizujący obraz z kamery...
}

// Generowanie raportu dziennego za ostatnie 7 dni
for (let dzień = 1; dzień <= 7; dzień++) {
  console.log(`Generowanie raportu za dzień #${dzień}`);
  // Kod generujący raport za konkretny dzień...
}

Pętla for ma trzy główne elementy:

  1. Inicjalizacja (np. let i = 0) - wykonywana raz, przed rozpoczęciem pętli
  2. Warunek (np. i < dinozaury.length) - sprawdzany przed każdą iteracją; pętla kończy się, gdy warunek zwraca false
  3. Aktualizacja (np. i++) - wykonywana po każdej iteracji

Pętla for...of

Pętla for...of to nowsza i bardziej elegancka forma pętli, która pozwala na iterację po elementach kolekcji (tablice, stringi, mapy, sety, itp.) bez potrzeby śledzenia indeksów.

// Struktura pętli for...of
for (let element of kolekcja) {
  // Blok kodu do wykonania dla każdego elementu
}

Pętla for...of jest szczególnie przydatna, gdy interesują nas same elementy, a nie ich indeksy:

// Sprawdzanie stanu zdrowia każdego dinozaura przy użyciu for...of
let dinozaury = ["Tyranozaur", "Velociraptor", "Triceratops", "Stegozaur", "Brachiozaur"];

for (let dinozaur of dinozaury) {
  console.log(`Sprawdzanie stanu zdrowia: ${dinozaur}`);
  // Kod sprawdzający stan zdrowia konkretnego dinozaura...
}

// Sprawdzanie poziomu zapasów różnych rodzajów pokarmu
let zapasyPokarmu = {
  mięso: 500, // kg
  liście: 1200, // kg
  owoce: 300, // kg
  ryby: 200 // kg
};

// Uwaga: for...of nie działa bezpośrednio na obiektach, ale możemy użyć Object.entries()
for (let [rodzajPokarmu, ilość] of Object.entries(zapasyPokarmu)) {
  console.log(`Pokarm: ${rodzajPokarmu}, Ilość: ${ilość} kg`);

  if (ilość < 300) {
    console.log(`UWAGA: Niski poziom zapasów ${rodzajPokarmu}! Należy uzupełnić.`);
  }
}

// Wynik:
// Pokarm: mięso, Ilość: 500 kg
// Pokarm: liście, Ilość: 1200 kg
// Pokarm: owoce, Ilość: 300 kg
// Pokarm: ryby, Ilość: 200 kg
// UWAGA: Niski poziom zapasów ryby! Należy uzupełnić.

Pętla for...in

Pętla for...in jest przeznaczona do iteracji po właściwościach obiektu. Zwraca nazwy kluczy (właściwości) obiektu.

// Struktura pętli for...in
for (let klucz in obiekt) {
  // Blok kodu do wykonania dla każdego klucza
}

Przykład użycia w Parku Jurajskim:

// Analiza danych o dinozaurze
let tyranozaur = {
  gatunek: "Tyrannosaurus Rex",
  wiek: 12,
  waga: 8000, // kg
  długość: 12, // m
  wysokość: 5.6, // m
  prędkość: 27, // km/h
  poziomAgresji: "Bardzo wysoki"
};

// Wypisanie wszystkich informacji o dinozaurze
for (let cecha in tyranozaur) {
  console.log(`${cecha}: ${tyranozaur[cecha]}`);
}

// Sprawdzenie, które cechy dinozaura przekraczają wartości bezpieczeństwa
let limityBezpieczeństwa = {
  waga: 5000, // kg
  prędkość: 25, // km/h
  poziomAgresji: "Wysoki"
};

for (let parametr in limityBezpieczeństwa) {
  if (tyranozaur[parametr] > limityBezpieczeństwa[parametr] ||
      (parametr === "poziomAgresji" && tyranozaur[parametr] === "Bardzo wysoki")) {
    console.log(`UWAGA: Parametr ${parametr} przekracza wartości bezpieczeństwa!`);
  }
}

// Wynik:
// UWAGA: Parametr waga przekracza wartości bezpieczeństwa!
// UWAGA: Parametr prędkość przekracza wartości bezpieczeństwa!
// UWAGA: Parametr poziomAgresji przekracza wartości bezpieczeństwa!

Ważna uwaga: Pętla for...in iteruje po wszystkich właściwościach obiektu, w tym dziedziczonych. Jeśli chcemy ograniczyć się tylko do własnych właściwości obiektu, możemy użyć metody hasOwnProperty():

for (let cecha in tyranozaur) {
  if (tyranozaur.hasOwnProperty(cecha)) {
    console.log(`${cecha}: ${tyranozaur[cecha]}`);
  }
}

Różnice między for...of i for...in

Ważne jest, aby zrozumieć różnicę między tymi dwoma typami pętli:

  • for...of - iteruje po wartościach elementów kolekcji (tablice, stringi, itp.)
  • for...in - iteruje po nazwach właściwości (kluczach) obiektu
let dinosaurNames = ["T-Rex", "Raptor", "Triceratops"];

// for...of (wartości)
for (let name of dinosaurNames) {
  console.log(name); // "T-Rex", "Raptor", "Triceratops"
}

// for...in (indeksy/klucze)
for (let index in dinosaurNames) {
  console.log(index); // "0", "1", "2"
  console.log(dinosaurNames[index]); // "T-Rex", "Raptor", "Triceratops"
}

Pętla while

Pętla while wykonuje blok kodu, dopóki określony warunek jest prawdziwy. W przeciwieństwie do pętli for, pętla while ma tylko warunek.

// Struktura pętli while
while (warunek) {
  // Blok kodu do wykonania
}

W Parku Jurajskim, pętla while może być używana do procesów, które nie mają z góry określonej liczby iteracji:

// System monitorowania temperatury inkubatora jaj
let temperatura = 37.5; // stopnie Celsjusza
let docelowaTemperatura = 38.2;
let przyrostTemperatury = 0.1;

console.log("Rozpoczęcie procesu podgrzewania inkubatora...");

while (temperatura < docelowaTemperatura) {
  console.log(`Aktualna temperatura: ${temperatura.toFixed(1)}°C`);
  temperatura += przyrostTemperatury;
  // Kod do symulacji upływu czasu...
}

console.log(`Osiągnięto docelową temperaturę: ${temperatura.toFixed(1)}°C`);

// System monitorowania poziomu zasilania
let poziomZasilania = 100; // procent
let krytycznyPoziom = 20;
let spadekZasilania = 5;

console.log("Monitorowanie poziomu zasilania po awarii głównego generatora...");

while (poziomZasilania > krytycznyPoziom) {
  console.log(`Poziom zasilania: ${poziomZasilania}%`);
  poziomZasilania -= spadekZasilania;
  // Kod do symulacji upływu czasu...
}

console.log(`ALARM! Krytyczny poziom zasilania: ${poziomZasilania}%`);
console.log("Uruchamianie protokołu awaryjnego...");

Pętla do...while

Pętla do...while jest podobna do pętli while, ale z jedną kluczową różnicą: blok kodu jest zawsze wykonywany przynajmniej raz, zanim warunek zostanie sprawdzony.

// Struktura pętli do...while
do {
  // Blok kodu do wykonania
} while (warunek);

Ta pętla jest przydatna, gdy chcemy, aby kod został wykonany co najmniej raz, niezależnie od warunku:

// Procedura uruchamiania systemu bezpieczeństwa
let systemSprawny = false;
let liczbaProb = 0;
let maksymalnaLiczbaProb = 3;

do {
  console.log("Próba uruchomienia systemu bezpieczeństwa...");
  liczbaProb++;

  // Symulacja losowości działania systemu
  systemSprawny = Math.random() > 0.5; // 50% szans na sukces

  if (systemSprawny) {
    console.log("System bezpieczeństwa uruchomiony pomyślnie!");
  } else {
    console.log(`Uruchomienie systemu nie powiodło się. Próba ${liczbaProb} z ${maksymalnaLiczbaProb}.`);
  }

} while (!systemSprawny && liczbaProb < maksymalnaLiczbaProb);

if (!systemSprawny) {
  console.log("KRYTYCZNY BŁĄD: System bezpieczeństwa nie może zostać uruchomiony. Konieczna interwencja techniczna!");
}

// Procedura ewakuacji
let pozostaliLudzie = 100;

do {
  console.log(`Pozostało ${pozostaliLudzie} osób do ewakuacji.`);
  // Symulacja ewakuacji - każda iteracja to jedna grupa ewakuowanych
  let wielkośćGrupy = Math.floor(Math.random() * 20) + 10; // 10-29 osób
  pozostaliLudzie -= wielkośćGrupy;

  // Upewniamy się, że nie otrzymamy ujemnej liczby
  if (pozostaliLudzie < 0) pozostaliLudzie = 0;

  console.log(`Ewakuowano grupę ${wielkośćGrupy} osób.`);

} while (pozostaliLudzie > 0);

console.log("Wszyscy zostali ewakuowani. Obiekt jest pusty.");

Przerwanie i kontynuacja pętli: break i continue

JavaScript oferuje dwie specjalne instrukcje do kontrolowania przebiegu pętli:

  • break - natychmiast przerywa pętlę i wychodzi z niej
  • continue - przerywa bieżącą iterację i przechodzi do następnej

Przykład użycia break

// Poszukiwanie uszkodzonej sekcji ogrodzenia
let sekcjeOgrodzenia = [
  { id: 1, status: "sprawna" },
  { id: 2, status: "sprawna" },
  { id: 3, status: "uszkodzona" },
  { id: 4, status: "sprawna" },
  { id: 5, status: "sprawna" }
];

let znalezionoUszkodzenie = false;

for (let i = 0; i < sekcjeOgrodzenia.length; i++) {
  console.log(`Sprawdzanie sekcji #${sekcjeOgrodzenia[i].id}...`);

  if (sekcjeOgrodzenia[i].status === "uszkodzona") {
    console.log(`UWAGA! Znaleziono uszkodzoną sekcję #${sekcjeOgrodzenia[i].id}!`);
    console.log("Wysyłanie zespołu naprawczego...");
    znalezionoUszkodzenie = true;
    break; // Przerywamy pętlę, gdy znaleźliśmy uszkodzenie
  }
}

if (!znalezionoUszkodzenie) {
  console.log("Wszystkie sekcje ogrodzenia są sprawne.");
}

// Wynik:
// Sprawdzanie sekcji #1...
// Sprawdzanie sekcji #2...
// Sprawdzanie sekcji #3...
// UWAGA! Znaleziono uszkodzoną sekcję #3!
// Wysyłanie zespołu naprawczego...

Przykład użycia continue

// Sprawdzanie stanu zdrowia dinozaurów, pomijając te, które są w trakcie badań
let dinozaury = [
  { nazwa: "Rex", gatunek: "Tyranozaur", dostępny: true },
  { nazwa: "Blue", gatunek: "Velociraptor", dostępny: false }, // W trakcie badań
  { nazwa: "Spike", gatunek: "Stegozaur", dostępny: true },
  { nazwa: "Cera", gatunek: "Triceratops", dostępny: false }, // W trakcie badań
  { nazwa: "Bronty", gatunek: "Brontozaur", dostępny: true }
];

console.log("Rozpoczęcie codziennych badań kontrolnych...");

for (let i = 0; i < dinozaury.length; i++) {
  if (!dinozaury[i].dostępny) {
    console.log(`Dinozaur ${dinozaury[i].nazwa} (${dinozaury[i].gatunek}) jest już w trakcie badań. Pomijam.`);
    continue; // Przechodzimy do następnej iteracji, pomijając resztę kodu w tej iteracji
  }

  console.log(`Przeprowadzanie badania dinozaura ${dinozaury[i].nazwa} (${dinozaury[i].gatunek})...`);
  console.log("Badanie zakończone. Stan zdrowia: dobry.");
}

// Wynik:
// Rozpoczęcie codziennych badań kontrolnych...
// Przeprowadzanie badania dinozaura Rex (Tyranozaur)...
// Badanie zakończone. Stan zdrowia: dobry.
// Dinozaur Blue (Velociraptor) jest już w trakcie badań. Pomijam.
// Przeprowadzanie badania dinozaura Spike (Stegozaur)...
// Badanie zakończone. Stan zdrowia: dobry.
// Dinozaur Cera (Triceratops) jest już w trakcie badań. Pomijam.
// Przeprowadzanie badania dinozaura Bronty (Brontozaur)...
// Badanie zakończone. Stan zdrowia: dobry.

Pętle zagnieżdżone

Pętle mogą być także zagnieżdżane jedna w drugiej, co jest przydatne przy pracy z danymi wielowymiarowymi:

// Sprawdzanie stanu ogrodzeń we wszystkich sektorach Parku Jurajskiego

// Tablica dwuwymiarowa: [sektor][sekcja_ogrodzenia]
let statusOgrodzeń = [
  // Sektor 1
  [
    { id: "1A", stan: "sprawne" },
    { id: "1B", stan: "sprawne" },
    { id: "1C", stan: "uszkodzone" }
  ],
  // Sektor 2
  [
    { id: "2A", stan: "sprawne" },
    { id: "2B", stan: "sprawne" },
    { id: "2C", stan: "sprawne" }
  ],
  // Sektor 3
  [
    { id: "3A", stan: "sprawne" },
    { id: "3B", stan: "uszkodzone" },
    { id: "3C", stan: "sprawne" }
  ]
];

console.log("Rozpoczęcie inspekcji ogrodzeń we wszystkich sektorach...");

for (let i = 0; i < statusOgrodzeń.length; i++) {
  console.log(`\nInspekcja sektora ${i + 1}:`);

  let wszystkieSprawne = true;

  for (let j = 0; j < statusOgrodzeń[i].length; j++) {
    let sekcja = statusOgrodzeń[i][j];
    console.log(`  Sekcja ${sekcja.id}: ${sekcja.stan}`);

    if (sekcja.stan === "uszkodzone") {
      wszystkieSprawne = false;
      console.log(`  UWAGA: Sekcja ${sekcja.id} wymaga naprawy!`);
    }
  }

  if (wszystkieSprawne) {
    console.log(`  Wszystkie ogrodzenia w sektorze ${i + 1} są sprawne.`);
  } else {
    console.log(`  W sektorze ${i + 1} wykryto uszkodzone ogrodzenia.`);
  }
}

// Wynik:
// Rozpoczęcie inspekcji ogrodzeń we wszystkich sektorach...
//
// Inspekcja sektora 1:
//   Sekcja 1A: sprawne
//   Sekcja 1B: sprawne
//   Sekcja 1C: uszkodzone
//   UWAGA: Sekcja 1C wymaga naprawy!
//   W sektorze 1 wykryto uszkodzone ogrodzenia.
//
// Inspekcja sektora 2:
//   Sekcja 2A: sprawne
//   Sekcja 2B: sprawne
//   Sekcja 2C: sprawne
//   Wszystkie ogrodzenia w sektorze 2 są sprawne.
//
// Inspekcja sektora 3:
//   Sekcja 3A: sprawne
//   Sekcja 3B: uszkodzone
//   UWAGA: Sekcja 3B wymaga naprawy!
//   Sekcja 3C: sprawne
//   W sektorze 3 wykryto uszkodzone ogrodzenia.

Pętle nieskończone i jak ich unikać

Pętla nieskończona to pętla, która nigdy się nie kończy, ponieważ jej warunek zakończenia nigdy nie jest spełniony. W Parku Jurajskim, pętla nieskończona w systemie bezpieczeństwa mogłaby prowadzić do katastrofy, podobnie jak w programowaniu może powodować zawieszenie aplikacji lub zużycie wszystkich zasobów.

Oto przykład pętli nieskończonej:

// UWAGA: To jest pętla nieskończona! Nie uruchamiaj tego kodu!
while (true) {
  console.log("To się będzie wyświetlać w nieskończoność!");
}

// Inny przykład pętli nieskończonej:
for (let i = 0; i >= 0; i++) {
  console.log(i); // To będzie liczyć w nieskończoność!
}

Aby uniknąć pętli nieskończonych:

  1. Upewnij się, że warunek zakończenia pętli jest osiągalny
  2. Zawsze aktualizuj zmienne używane w warunku pętli
  3. Rozważ dodanie dodatkowego warunku wyjścia (np. licznik iteracji)
  4. Używaj instrukcji break jako zabezpieczenia
// Bezpieczniejsza wersja z limitem iteracji
let maksymalnaLiczbaIteracji = 1000;
let licznikIteracji = 0;

// Przykład bezpiecznego monitorowania
while (monitorujPark()) {
  // Kod monitorowania parku...

  licznikIteracji++;
  if (licznikIteracji >= maksymalnaLiczbaIteracji) {
    console.log("Osiągnięto maksymalną liczbę iteracji. Przerwanie pętli.");
    break;
  }
}

function monitorujPark() {
  // Logika monitorowania...
  return true; // Normalnie zwracałoby true lub false w zależności od warunków
}

Praktyki i wzorce związane z pętlami

1. Wybór odpowiedniej pętli

  • for - gdy znasz dokładną liczbę iteracji lub pracujesz z indeksami
  • for...of - gdy chcesz iterować po elementach kolekcji (tablice, stringi)
  • for...in - gdy chcesz iterować po właściwościach obiektu
  • while - gdy warunek zakończenia zależy od zewnętrznych czynników
  • do...while - gdy chcesz, aby kod wykonał się przynajmniej raz

2. Optymalizacja pętli

// Nieoptymalna pętla - długość tablicy jest przeliczana w każdej iteracji
for (let i = 0; i < dinozaury.length; i++) {
  // Kod...
}

// Zoptymalizowana pętla - długość tablicy jest przeliczana tylko raz
for (let i = 0, len = dinozaury.length; i < len; i++) {
  // Kod...
}

3. Wczesne wyjście z pętli

// Wczesne wyjście z pętli po znalezieniu pierwszego pasującego elementu
function znajdźDinozaura(nazwa) {
  for (let dinozaur of bazaDinozaurów) {
    if (dinozaur.nazwa === nazwa) {
      return dinozaur; // Natychmiastowy zwrot po znalezieniu
    }
  }
  return null; // Brak pasującego dinozaura
}

4. Unikanie modyfikacji licznika pętli wewnątrz pętli

// Niebezpieczne - modyfikowanie licznika wewnątrz pętli
for (let i = 0; i < 10; i++) {
  console.log(i);
  if (i === 5) {
    i = 8; // Przeskakujemy część iteracji - to może być mylące
  }
}

// Lepsze podejście - użyj instrukcji continue lub break
for (let i = 0; i < 10; i++) {
  if (i > 5 && i < 9) {
    continue; // Przeskakujemy iteracje 6, 7, 8
  }
  console.log(i);
}

Podsumowanie

Pętle w JavaScript, podobnie jak rutynowe procedury w Parku Jurajskim, pozwalają na efektywne wykonywanie powtarzalnych operacji:

  1. for - do iteracji przez określoną liczbę powtórzeń
  2. for...of - do iteracji po elementach kolekcji
  3. for...in - do iteracji po właściwościach obiektu
  4. while - do wykonywania kodu, dopóki warunek jest prawdziwy
  5. do...while - do wykonywania kodu przynajmniej raz, a następnie dopóki warunek jest prawdziwy

Dodatkowo, instrukcje kontrolne:

  • break - przerywa całą pętlę
  • continue - przechodzi do następnej iteracji

Wybór odpowiedniej pętli zależy od konkretnego przypadku użycia, ale ogólnie należy dążyć do:

  • Używania najprostszej pętli odpowiedniej dla danego zadania
  • Optymalizowania pętli, szczególnie dla dużych kolekcji danych
  • Unikania pętli nieskończonych
  • Używania czytelnych nazw zmiennych i jasnej struktury kodu

W następnej lekcji przyjrzymy się funkcjom, które pozwalają na organizowanie kodu w wielokrotnie używalne bloki - niezbędne dla utrzymania porządku w tak złożonym systemie jak Park Jurajski.

Kod do tej lekcji: index.js
// Pętle w JavaScript - automatyzacja zadań w parku
// for, while, for...of, for...in

// === Pętla for ===
console.log("=== Pętla for: Patrol zagród ===");

let zagrody = ["T-Rex", "Raptor", "Triceratops", "Brachio", "Stego"];

for (let i = 0; i < zagrody.length; i++) {
  console.log("Zagroda " + (i + 1) + ": " + zagrody[i] + " - OK");
}

// === Pętla for...of ===
console.log("\n=== for...of: Karmienie ===");

for (const dino of zagrody) {
  console.log("Karmienie: " + dino);
}

// === Pętla for...in (dla obiektów) ===
console.log("\n=== for...in: Dane dinozaura ===");

const trex = {
  nazwa: "Tyrannosaurus Rex",
  waga: 7000,
  dieta: "mięsożerca",
  sektor: "A"
};

for (const klucz in trex) {
  console.log(klucz + ": " + trex[klucz]);
}

// === Pętla while ===
console.log("\n=== while: Skanowanie próbek ===");

let probki = 5;
while (probki > 0) {
  console.log("Skanowanie próbki nr " + probki + "...");
  probki--;
}
console.log("Skanowanie zakończone!");

// === do...while ===
console.log("\n=== do...while: Weryfikacja ===");

let proby = 0;
do {
  proby++;
  console.log("Próba weryfikacji nr " + proby);
} while (proby < 3);

// === break i continue ===
console.log("\n=== break i continue ===");

let dane = [10, 25, 0, 42, 15, -1, 30];

for (const wartosc of dane) {
  if (wartosc === -1) {
    console.log("Znaleziono wartość -1, przerywam!");
    break;
  }
  if (wartosc === 0) {
    console.log("Pomijam wartość 0...");
    continue;
  }
  console.log("Przetwarzam: " + wartosc);
}

// Twoje zadanie:
// 1. Użyj pętli for do wypisania liczb od 1 do 10
// 2. Użyj while do odliczania od 10 do 0
// 3. Użyj for...of do przejścia po tablicy

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Które trzy elementy zawiera nagłówek pętli for?

Zadania praktyczne w grze

  • Edytor kodu

    Zapisz w tablicy enclosures nazwy co najmniej trzech wybiegów. Za pomocą pętli wyświetl w konsoli komunikat z nazwą każdego wybiegu, np. 'Sprawdzam: Wybieg T-Rexa'.

  • Układanie w poziomie

    Ułóż elementy pętli for...of:

  • Edytor kodu

    Zapisz w tablicy dnaSamples nazwy gatunków z próbek DNA, np. ['Velociraptor', 'Triceratops', 'Velociraptor']. Przejdź po tablicy pętlą, policz próbki gatunku 'Velociraptor' i wyświetl wynik w konsoli.

  • Układanie w poziomie

    Ułóż elementy pętli for w prawidłowej kolejności:

  1. PytaniePętla for
  2. Zadanie z kodemPraktyka: Pętle
  3. Ułóż w kolejnościSkładnia pętli for...of
  4. Zadanie z kodemPraktyka: Przeszukiwanie bazy DNA
  5. Ułóż w kolejnościSkładnia pętli for

Przydatne artykuły