Domino 9 und frühere Versionen > ND9: Entwicklung

Sichtbarkeit von Outline-Einträgen von Benutzer festlegen lassen

<< < (2/3) > >>

Peter Klett:
@Username ist aber kein Mehrfachwert, *= nutzt man, um zwei Mehrfachwerte miteinander zu vergleichen (schadet aber auch nichts, wenn es sich um einen einfachen Wert handelt, dann vergisst man es nicht)

Folgendes habe ich gerade getestet

Einfachwert gegen Mehrfachwert, kein Unterschied
"b" = "a" : "b" : "c"   -> @True     "b" *= "a" : "b" : "c"   -> @True
"b" = "d" : "e" : "f"   -> @False     "b" *= "d" : "e" : "f"   -> @False

auch umgekehrt kein Unterschied
"a" : "b" : "c" = "b"   -> @True     "a" : "b" : "c" *= "b"   -> @True
"d" : "e" : "f" = "b"   -> @False     "d" : "e" : "f" *= "b"   -> @False

Mehrfachwerte gegeneinander
"a" : "b" = "a" : "b" : "c"   -> @True     "a" : "b" *= "a" : "b" : "c"   -> @True
"a" : "b" = "d" : "e" : "f"   -> @False     "a" : "b" *= "d" : "e" : "f"   -> @False
"b" : "e" = "a" : "b" : "c"   -> @False     "b" : "e" *= "a" : "b" : "c"   -> @True
"b" : "e" = "d" : "e" : "f"   -> @True     "b" : "e" *= "d" : "e" : "f"   -> @True

Die rote Zeile gibt ein m.E. falsches Ergebnis, bei Mehrfachwerten auf beiden Seiten sollte man unbedingt *= verwenden.

ronka:
Zur Information *= ist einen Listen vergleichsoperator.

Wenn ein Element vor den vergleicher gleich ist an ein Element danach ist das Ergebnis True.

In der Formel sprache ist ALLES eine Liste, auch ein einzelnes element ist einen Liste, deshalb kann mann a auch als a[0] ansprechen.

In Lotusscript ist das anders.

Deshalb ist der linie mit den Roten inhalt mit den "nur" = zeichen aber nicht falsch. Dort wird einen Liste mit einen Liste verglichen, und die beide Listen sind nicht identisch, das allerdings die zeile drunter ( "b" : "e" = "d" : "e" : "f"   -> @True ) angibt, finde ich erstaunlich, weil eigentlich musste der nach operator auch False anzeigen. Hier dürfte den Teilstring eigentlich kein True zurück geben, wäre meine mathematische denkweise wenigstens.

Trotzdem, im Normalfall schadet der nutzung des *= nichts, ausser mann kontrolliert explizit auf Listen bezogen würde. Dort ist dann auch den Reinfolge noch zuberücksichtigen.

Tode:
@Peter: Wegen "falsches Ergebnis"... Dazu muss man wissen, wie die Formelsprache intern Listen vergleicht.

Zwei Listen werden intern immer so verglichen:

1. Schritt: Listen gleich lang machen. Wenn beide Listen unterschiedlich viele Elemente haben, dann wird bei der kürzeren Liste das letzte Element so oft wiederholt, bis beide Listen gleich lang sind.

Vergleicht man also "a" mit "b" : "c" : "a", dann wird intern die erste "Liste" auf "a" : "a" : "a" verlängert.

aus "b" : "e" im Vergleich mit "a" : "b" : "c" wird dann also "b" : "e" : "e".

2. Schritt: Beim normalen "="- Operator werden nun die Werte "Zeilenweise" verglichen: Der erste mit dem ersten, der zweite mit dem zweiten, usw. Ergibt sich dabei EIN Match, ist der Vergleich @True:

Im ersten Beispiel also:
"a" = "b"
"a" = "c"
"a" = "a" ---> @True

Im zweiten:
"b" = "a"
"e" = "b"
"e" = "c"

==> Kein Treffer, also @False

Der Permutationsoperator "*=" führt einen Vergleich JEDES Elements der Liste mit JEDEM Element der anderen Liste durch.
Im zweiten Beispiel finden also folgende Vergleiche statt:

"b" = "a"
"b" = "b" --> @True
"b" = "c"
"e" = "a"
"e" = "b"
"e" = "c"

Bei langen Listen bedeutet das eine MENGE Vergleiche...

Das ist übrigens auch der Grund, warum der Vergleich einer Liste mit einem Einzelwert immer @True liefert, wenn der Wert mindestens einmal in der Liste ist.

Diese Art des Vergleiches ist übrigens auch die Ursache, warum

a != b was anderes liefert als !(a = b)... a != b ist bei zwei Listen, bei denen nicht alle Elemente identisch sind, immer @True, während !(a = b) nur dann @True ist, wenn KEINES der Elemente aus a mit b übereinstimmt...

ronka:
Yep, den listen gleich lang machen ist dabei der Trick.

Jetzt ein wenig off-Topic, aber durchaus auch nutzlich.

Den kann mann auch für das erstellen von einen Präfix oder Suffix sehr schon verwenden.

Strassen := "Lang" : "Kurz" : "mittel";
MitSuffix := Strassen + "weg";
MitPräfix := "Am " +  Strassen;

Liefert dann für MitSuffix "Langweg" : "Kurzweg" : "mittelweg"

mit Präfix "Am Lang" : "Am Kurz" : "Am mittel"

Und bei misschungen Formen dann
Gesamt := ( "Bei " : "Am " ) + Strassen ;

Bringt das "Bei Lang" : "Am Kurz" : "Am mittel"

Ich habe solche "Spielchen" auch real schon eingesetzt für bestimmte kontrollen, z.B. beim @Implode und @Explode sind diesen dingen sehr sinnvoll einsetzbar wenn mann einen spezifischen inhalt irgendwo suchen muss aber nicht durch alle einzelne elementen gehen möchte.

Peter Klett:
@Torsten: Danke, so tief hatte ich mir da noch nie Gedanken gemacht ;) , ist dann aber logisch.

Enthält ein Vergleichswert nur ein Element, könnte man auf "*" verzichten, sollte man aber nicht, weil man es sonst vergisst (wie ich meistens ...), es sei denn, man will wirklich absolute Gleichheit überprüfen, bei der auch die Reihenfolge relevant ist

Navigation

[0] Themen-Index

[#] Nächste Seite

[*] Vorherige Sete