early exit

Angol

Főnév

(informatika) A korai kilépés (angolul: early exit) egy olyan programozási technika, amelynek célja, hogy egy függvény, ciklus, vagy kódrészlet végrehajtását idő előtt megszakítsuk, amint elérjük a kívánt eredményt vagy felismerünk egy olyan állapotot, amely miatt a folytatás felesleges vagy hibás lenne.

Ahelyett, hogy a függvény végéig futnánk (vagy a ciklus végéig mennénk), egy return vagy break (esetleg continue) utasítással azonnal kilépünk, ha adott feltétel teljesül.

A technika célja:

a kód olvashatóságának növelése,
a felesleges számítások elkerülése,
a hibakezelés egyszerűsítése,
a kód strukturálásának javítása.

Early exit példák függvényekben

1️⃣ Egyszerű példa: `void` függvény korai kilépéssel

void printMessage(int value) {
    if (value < 0) {
        std::cout << "Value is negative." << std::endl;
        return;  // early exit: nem folytatjuk a kódot
    }
    std::cout << "Value is non-negative." << std::endl;
}

Mi történik itt?

Ha value negatív, kiírjuk az üzenetet, majd visszatérünk a main-be → a függvény nem fut tovább.
Ha value nem negatív, folytatjuk a cout sort.

Ez sokkal olvashatóbb, mint például így:

void printMessage(int value) {
    if (value < 0) {
        std::cout << "Value is negative." << std::endl;
    } else {
        std::cout << "Value is non-negative." << std::endl;
    }
}

A két verzió azonos eredményt ad, de az early exit gyakran csökkenti a kód beljebb tolását (indentáció), így olvashatóbb lesz.

2️⃣ Függvény, amely értéket ad vissza

int divide(int a, int b) {
    if (b == 0) {
        std::cerr << "Error: division by zero." << std::endl;
        return -1;  // early exit hibaértékkel
    }
    return a / b;
}

Itt, ha b == 0, akkor korán visszatérünk hibakóddal (például -1), hogy megelőzzük a hibás osztást.

3️⃣ Több exit egy függvényen belül

Nem csak egy early exit lehet egy függésben — néha több különböző “kilépési pontot” is beépítünk:

bool isValidPassword(const std::string& password) {
    if (password.length() < 8) return false;
    if (password.find("1234") != std::string::npos) return false;
    if (password == "password") return false;

    // Ha idáig eljutottunk, minden OK:
    return true;
}

Miért jó így?

Egyszerűbben követhető.
Nincs felesleges else blokk → nem kell “tovább cipelni” a logikát.
Gyorsabban kilépünk, ha valami nem felel meg.

Early exit ciklusokban

A ciklusokból is lehet korán kilépni:

1️⃣ `break` ciklusból

for (int i = 0; i < 10; ++i) {
    if (i == 5) {
        break;  // early exit a ciklusból
    }
    std::cout << i << " ";
}

Kimenet:

0 1 2 3 4

Amint i == 5, a break miatt a ciklus azonnal megszakad.

2️⃣ `continue` ciklusban

A continue nem szakítja meg a teljes ciklust, de kihagyja a ciklus aktuális iterációjának fennmaradó részét és megy a következőre.

for (int i = 0; i < 10; ++i) {
    if (i % 2 == 0) continue;  // ha páros, kihagyjuk
    std::cout << i << " ";
}

Kimenet:

1 3 5 7 9

Miért hasznos az early exit?

1️⃣ Egyszerűsíti a kódot

Kevesebb else ágat, kevesebb fésült logikát kell írni. Például hibakezelésnél gyakran “guard clause”-okat használunk:

void processData(int data) {
    if (data < 0) {
        std::cerr << "Invalid data." << std::endl;
        return;
    }

    // A lényegi feldolgozás innen indul
}

2️⃣ Csökkenti a felesleges számításokat

Ha már tudjuk, hogy valami hibás, vagy az eredményt korábban megtaláltuk, akkor nem pazaroljuk az időt további műveletekre.

3️⃣ Növeli a kód olvashatóságát

A kód olvasója (más fejlesztő vagy saját magad) hamar látja, hogy milyen kilépési feltételek vannak.

Mikor nem ajánlott?

Ha nagyon sok return van egy hosszú függvényben, a kód nehezebben tesztelhető.
Ha erőforrásokat kell felszabadítani (fájlzárás, dinamikus memória stb.), vigyázni kell → nem lépjünk ki úgy, hogy erőforrások nyitva maradnak. Megoldás: RAII használata (pl. std::unique_ptr, std::lock_guard).

Összefoglalás

👉 Early exit = tudatos korai kilépés egy függvényből vagy ciklusból.

Előnyök:

Egyszerűbb logika.
Kevesebb indentáció.
Gyorsabb futás hibás vagy nem releváns esetekben.
Jobb olvashatóság.

Formák:

Függvényben: return, return val;
Ciklusban: break, continue

Tipikus felhasználás:

Hibakezelés (guard clause)
Hibás bemenet szűrése
Gyors keresés eredmény megtalálásakor
Program logika egyszerűsítése

Óvatosan használandó, ha:

Erőforrás-felszabadításra kell figyelni.
Nagyon sok return bonyolítja a kódot.

További információk

early exit - Szótár.net (en-hu)
early exit - Sztaki (en-hu)
early exit - Merriam–Webster
early exit - Cambridge
early exit - WordNet
early exit - Яндекс (en-ru)
early exit - Google (en-hu)
early exit - Wikidata
early exit - Wikipédia (angol)