Java Optional: تجنّب null و NullPointerException

المشكلة التي يحلّها Optional

الدالة التي قد لا تملك إجابة كان أمامها دائمًا خيار محرج في Java: أن تُعيد null وتأمل أن يتذكّر المستدعي الفحص. وهو في العادة لا يتذكّر، فتكون النتيجة NullPointerException يظهر بعيدًا عن الدالة التي أعادت null.

‏Optional<T> صندوق صغير إمّا أن يحتوي قيمة وإمّا أن يكون فارغًا صراحةً. فبإعادة Optional<User> بدلًا من User، تقول الدالة للمستدعي "قد لا يجد هذا شيئًا" في توقيعها ذاته - ويوجّهه المترجِم نحو معالجة تلك الحالة.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> found = Optional.of("Ada");
        Optional<String> missing = Optional.empty();

        System.out.println(found.isPresent());   // true
        System.out.println(missing.isPresent());  // false
    }
}

إنشاء Optional

هناك ثلاث دوال مصنع، واختيار الصحيحة منها مهم:

• ‏Optional.of(value) - يجب أن تكون القيمة غير null، وإلّا رمى NullPointerException على الفور.
• ‏Optional.ofNullable(value) - فارغ إن كانت القيمة null، وحامل لها فيما عدا ذلك. استخدمه لتغليف شيء قد يكون null.
• ‏Optional.empty() - optional فارغ.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // يُعيد null

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false، دون استثناء

        // Optional.of(maybeNull) كان سيرمي NullPointerException هنا
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

من الأخطاء الشائعة اللجوء إلى Optional.of(x) مع قيمة قد تكون null - فذلك يُفسد الغرض ويرمي الاستثناء نفسه الذي كنت تحاول تجنّبه. وعند الشكّ، استخدم ofNullable.

قراءة القيمة بأمان

ما إن يصبح بحوزتك optional، يكون الهدف إخراج القيمة دون افتراض وجودها. الأداة الفظّة هي get()، وينبغي ألّا تستخدمها تقريبًا أبدًا:

Optional<String> name = Optional.empty();
String value = name.get();   // يرمي NoSuchElementException - مجرد NPE متنكّر

بدلًا من ذلك، وفّر قيمة بديلة أو تفاعل مع وجود القيمة. يُعيد orElse قيمة افتراضية عند الفراغ؛ ويُشغّل ifPresent شيفرة فقط عندما توجد قيمة:

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Grace");
        Optional<String> blank = Optional.empty();

        System.out.println(name.orElse("anonymous"));   // Grace
        System.out.println(blank.orElse("anonymous"));  // anonymous

        name.ifPresent(n -> System.out.println("Hello, " + n));
        blank.ifPresent(n -> System.out.println("never prints"));
    }
}

استخدم orElseGet(supplier) بدلًا من orElse حين يكون بناء القيمة الافتراضية مكلفًا - فالـ supplier لا يُنفَّذ إلّا إذا كان الـ optional فارغًا فعلًا. أمّا وسيط orElse فيُقيَّم دائمًا، حتى حين لا يكون لازمًا.

‏orElseThrow لـ "يُفترض أن يوجد هذا"

أحيانًا يكون الفراغ خطأً حقًّا - قيمة إعداد مطلوبة، أو مستخدم يُفترض وجوده في قاعدة البيانات. يحوّل orElseThrow الـ optional الفارغ إلى استثناء واضح من اختيارك:

import java.util.Optional;

public class Main {
    static Optional<Integer> parsePort(String raw) {
        try {
            return Optional.of(Integer.parseInt(raw));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        int port = parsePort("8080")
            .orElseThrow(() -> new IllegalStateException("port must be a number"));
        System.out.println("listening on " + port);

        try {
            parsePort("nope")
                .orElseThrow(() -> new IllegalStateException("port must be a number"));
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
        }
    }
}

هذا أوضح في القراءة بكثير من كتلة if (opt.isPresent())، ويجعل الفشل صريحًا عند النقطة التي يحدث فيها.

التحويل باستخدام map و filter

العائد الحقيقي هو التسلسل. يطبّق map دالةً على القيمة فقط إن كانت موجودة ويترك الـ optional الفارغ فارغًا - فتحوّل دون أن تلمس null إطلاقًا. ويُسقط filter القيمة إن لم تجتَز اختبارًا.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> raw = Optional.of("  Coddy  ");

        String result = raw
            .map(String::trim)          // "Coddy"
            .filter(s -> !s.isEmpty())  // أبقِ غير الفارغ فقط
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

        System.out.println(result);  // CODDY

        // الـ optional الفارغ يمرّ دون أن يُمَسّ - لا NPE ولا تفرّعات
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

إن كانت دالة التحويل نفسها تُعيد Optional، فاستخدم flatMap بدلًا من map لتتجنّب Optional<Optional<T>> المربك. وهذا يعكس تمييز map/flatMap الذي رأيته مع الـ streams - فالـ Optional يتصرّف إلى حدّ كبير كأنه stream من عنصر واحد أو لا عنصر.

أين ينتمي Optional (وأين لا)

‏Optional مصمَّم ليكون نوعًا مُعادًا للدوال التي قد لا تنتج نتيجة بصورة مشروعة - والأمثلة النموذجية هي Stream.findFirst() وعمليات البحث على نمط Map والتحليل (parsing). استخدمه هناك فتوثّق واجهة برمجتك ثغراتها بنفسها.

وهو ليس مخصّصًا لـ:

• الحقول. فهو غير قابل للتسلسل (serializable) ويضيف كائنًا لكل حقل. استخدم مراجع عادية وتحقّق في الباني (constructor).
• معاملات الدالة. إذ يضطر المستدعي عندئذٍ إلى تغليف الوسائط بـ Optional.of(...)، وهو أكثر ضجيجًا من تحميل زائد (overload) أو معامل يقبل null.
• المجموعات. أعِد List فارغة، لا Optional<List>. فالمجموعة الفارغة تعني أصلًا "لا شيء".

حين يُعامَل بوصفه نوعًا مُعادًا، يحوّل Optional أخطاء null الصامتة إلى تنبيهات في وقت الترجمة لمعالجة الحالة المفقودة.

التالي: الاستثناءات

يعالج Optional حالة "قد لا توجد قيمة" اليومية بنظافة، لكن بعض حالات الفشل استثنائية حقًّا - ملف لا يُفتح، شبكة تنقطع، مدخل يتعذّر تحليله. تنمذج Java تلك الحالات بالاستثناءات، وذلك هو موضوع الصفحة التالية.