ja.
1. prüfen ob Anzahl der Elemente in beiden Arrays gleich sind
2.
- in einem temp. Array die beiden Array zusammenführen (Arrayappend)
- doppelte Werte entfernen (Arrayunique)
- Prüfen ob Anzahl der Werte im temp. Array gleich der Anzahl eines der Ausgangsarray ist
funktioniert nur, wenn es keine doppelten Werte in den Ausgangsarrays gibt! Ansonsten sind noch 2 zusätzliche temp. Arrays notwendig.
Gruß
Dirk
Oder:
sArray2=Join(Array2, " ,")
Forall Element In Array1
If Instr(Element, sArray2)=0 Then
'Nicht enthalten
End If
End Forall
... dann muss die Schleife aber auch noch andersherum durchlaufen werden, denn es fehlt die Prüfung ob auch alle Werte aus Array2 im Array 1 enthalten sind.
Die Schleifen brauchen mehr Zeit als Arrayunique und ArrayAppend.
Gruß
Dirk
stimmt. 
Erst mal eine kleine Hilfsfunktion:
Public Function LSContains(array As Variant, text As String, asSubstring As Integer, caseInsensitive As Integer) As Integer
'/**
' * returns if the array contains the text.
' *
' * @param array array to be searched for the text.
' * @param text text to be searched for.
' * @param asSubstring is it sufficent, if text is a substring of an entry?
' * @param caseInsensitive should the text be compared case-insensitive.
' * @return <code>true</code> if the array contains the text.
' *
' * @author Thomas Bahn <tbahn@assono.de>
' * @version 2006-06-27
' */
Dim normalizedText As String
Dim normalizedEntry As String
Dim i As Integer
normalizedText = text
If Not caseInsensitive Then ' case-insensitive -> compare uppercase
normalizedText = Ucase(normalizedText)
End If
If Not(Isarray(array)) Then ' array is no array
normalizedEntry = Cstr(array)
If Not caseInsensitive Then ' case-insensitive -> compare uppercase
normalizedEntry = Ucase(normalizedEntry)
End If
If asSubstring Then
LSContains = (Instr(normalizedEntry, normalizedText) > 0) ' found as substring
Else
LSContains = (normalizedEntry = normalizedText) ' equal strings?
End If
Exit Function
Else ' array is an array
For i = Lbound(array) To Ubound(array)
normalizedEntry = Cstr(array(i))
If Not caseInsensitive Then ' case-insensitive -> compare uppercase
normalizedEntry = Ucase(normalizedEntry)
End If
If asSubstring And (Instr(normalizedEntry, normalizedText) > 0) Then ' found as substring
LSContains = True
Exit Function
Elseif (normalizedEntry = normalizedText) Then ' equal entry found
LSContains = True
Exit Function
End If
Next
End If
LSContains = False ' not found until now -> text is not contained in array
End Function
Eine Prozedur zum Vergleichen könnte dann (wie Diali schrieb) erst einmal die Anzahl an Elementen vergleichen und dann bei identischer Anzahl das erste Array durchlaufen und für jeden Eintrag nachsehen, ob es im zweiten vorhanden ist.
Bei der ersten Abweichung weiß man schon, dass sie nicht gleich sind und kann die Funktion verlassen. Erlebt man das Ende der Schleife, so sind alle Elemente von ersten Array auch im zweiten.
Wenn doppelte Feldwerte möglich sind, muss man jetzt das gleiche noch einmal in die andere Richtung machen.
Was dann immer noch nicht unterschieden wird, ist folgender Fall:
["A", "B", "B"] und ["A", "A", "B"]
Wenn du das auch unterscheiden möchtest, müsstes du für beide Arrays einen "Zähler" aufbauen, also z. B. eine Liste. Beim Durchlaufen eines Arrays muss du dann für jeden Feldwert einen Listeneintrag mit dem Feldwert als Schlüssel und 1 als Wert erstellen bzw. den Wert um 1 erhöhen.
Danach dann beide Listen noch vergleichen...
HTH
Thomas
@deragon
Die Funktion gibt es doch schon über ArrayGetIndex.
Wieso da eine eigene programmieren ?
Du hast Recht, ich bin so an meine "Standard"-Funktionen gewöhnt...
Meine Funktion kann zusätzlich nach Teilstrings suchen und läuft auch unter Notes R5.
Ansonsten und für diesen Fall geht natürlich auch ArrayGetIndex.
Ciao
Thomas
Wieso lotusscript ?
@trim( @Replace ( Array1 ; Array2 ; "" ) ) -> ürbrig bleibt alle elemente die es in Array1 gibt, und nicht in Array2.
Einmal anders herum, und du weißt das von array2 nach array1 ebenso.
Evaluate kann das dann wieder zu LS funktionen umformen.
Mann - o - mann.. warum denkt jeder immer das lotusscript besser ist als formel sprache.. EINZEILER ist das in formelsprache.
Ronka
PS. Wenn mann es wirklich effektiv testen möchte, dann könnte mann noch ein schritt mehr machen, aber IMMER noch als einzeiler, auch wenn die nette formatierung etwas anders zeigt, ist alles hintereinander mit EIN evaluate zu machen.
@IF( @Elements(Array1) = @Elements(Array2);
. @If( @Elements( @Unique(Array1)) = @Elements(Array1);
. . @if( @trim( @Replace ( Array1 ; Array2 ; "" ) ) = "";
. . . @if( @trim( @Replace ( Array2 ; Array1 ; "" ) ) = "";
. . . . "Alles OK, identische listen";
. . . . "Error: Array2 hat mehr);
. . . "Error: Array1 hat mehr");
. . "Error: Array1 Hat doppelte werten" );
"Error: Anzahl Elemente nicht identisch")
ZitatMann - o - mann.. warum denkt jeder immer das lotusscript besser ist als formel sprache.. EINZEILER ist das in formelsprache.
Weil es im Anfangspost so gefordert war?
Aber hast Recht ein Evaluate im Script kann auch die Formel ausführen.
Gruß
Dirk
