Hallo, ich bin Steffen Winkler.

Was ich euch heute vorstellen will, ist etwas, was ich während der Arbeit schnell gemacht habe.

Einfach auf die Seebahn hochgeschoben habe und eigentlich nie darüber gesprochen habe.

Es gibt Momente, in denen man keine Objekte hat.

Du hast Methoden, die am Objekt nicht existieren und hast eine schöne Kette von Methoden aufgerufen.

Die bricht zwischendrin immer ab.

Dann muss man immer wieder neu anfangen und gucken, ob da eine Antef drin ist.

Dann habe ich mir gedacht, wir haben ja so etwas wie drei. Versuch es mal, die Schäne in einem Drei laufen zu lassen.

Das war meine erste Idee. Das funktioniert auch.

Da schmeißt man alle Fehler weg, die damit zusammenhängen.

Die richtigen Fehler, die man so hat, bleiben am Ende übrig.

Ich fülle hier mal einen Hasch und das Scalar, das ich rot gemacht habe, ist jetzt ziemlich wichtig.

Wenn er zwischendrin abbricht, weiß er natürlich nicht mehr, was außenrum im Kontext gefordert war.

Deswegen muss ich das dann in den richtigen Kontext wieder setzen.

Jetzt habe ich mir gedacht, das kann man irgendwie viel besser machen.

Dann habe ich mir dieses CallM als Methode angelegt.

Jetzt wieder das selbe. Ich kann auf mein Objekt, ruf ich nicht die Foo-Methode auf mit dem Parameter 1,

sondern ich nehme diese CallM und versuche mal Foo aufzurufen mit dem Parameter 1.

Wenn du da was kriegst, dann versuche bar aufzurufen mit dem 2.

Wenn da noch was rauskommt, wo du was drauf aufrufen kannst, dann mach das mit dem Buz mit den anderen zwei Parametern.

Das ist dann sozusagen das Value für den Bar-Key.

Das funktioniert. Meistens braucht man das nicht immer alles.

Da war der andere Gedanke, wie ist das eigentlich, wenn man gemischte Datenstrukturen hat?

Das ist so eine Array von Objekten und dann hat man wieder mal ein Objekt,

das man über einen Key erreicht oder irgendwie. Ich habe das mal alles bewusst hier durcheinander gemischt.

Ich habe in dieser Variante mit dem 3-Chain.

Dann ist natürlich bei den Arrays oder Hashes das Problem mit dieser Auto-Vivification.

Das kann man natürlich irgendwie alles abschalten. Es gibt da ein Modul dafür.

Aber es geht auch irgendwie schöner.

Ich ruf sozusagen die Methode Foo auf oder versuche das.

Ich versuche den existierenden Index zu finden, 0.

Ich ruf dann Bar auf, versuche den existierenden Key, das ist hier zwar eine Zahl, eine 2 aufzurufen

und versuche darauf dann mein Buz-Methode aufzurufen.

Das ist jetzt vollgespickt immer mit diesen Call Amps und Fetch.

Jetzt zeige ich euch aber mal, wie wir das tatsächlich im produktiven Code drin haben.

Hier in dem Fall, wir haben eine Location, die hat eine Adresse.

Dann wollen wir die Default-E-Mails haben und die alle, die aktiv sind.

Das ist ein Datenbankzugriff. Jetzt könnte es natürlich sein, dass wir gar keine E-Mails haben.

Also kann ich ja nicht mal einen Fürst aufrufen.

Aber ich kann es ja so schreiben.

Wenn irgendwas kommt, dann kann ich auch einen Fürst aufrufen.

Dann werde ich wahrscheinlich die Spalte-Adresse A erreichen.

Wenn das alles klappt, dann habe ich eine E-Mail-Adresse.

Noch ein anderes Beispiel.

Es gibt auch den Fall, dass hier auf der Adresse keine Customer-ID gibt.

Dann kann ich das auch so überspringen.

Das Modul ist eigentlich dazu geschrieben, dass der Code immer noch schön lesbar ist

und nicht laufend unterbrochen wird durch irgendwelche IFS oder irgendwelche Variablen,

die man zwischendurch zuweisen muss.

Hier noch ein anderes Beispiel, das ich habe.