Problem mit einer For-To-Next-Schleife. (Verstaendisprobleme)

bankesbusters

hallo zusammen,

ich verstehe es nicht. manuell bekomme ich (nach vielen experimenten) eigentlich einiges hin, aber sobald ich den Prozess vereinfachen will, gerate ich aufgrund meines unverstaendnisses immer wieder an die grenzen der machbarkeit. ich moechte es begreifen, aber ich verstehe nicht wo die fehler ueberhaupt entstehen und da liegt das problem. die For-To-Next-Schleife ist wirklich (fuer mich persoenlich) noch sehr schwer zu verstehen.

also: nachdem ich gestern eine frage hatte zu Chr() und viel hierzu probiert habe, sah das ganze dann (funktionierend) so aus:

Code

Global $nummern2[5][3] = [[72,87,84],[69,79,79],[76,82,68],[76,76,65],[79,68,89]]
Global $pre = "Chr("
Global $back =")"
_ArrayDisplay($nummern2)
$nummern2[0][0] = $pre & $nummern2[0][0] & $back
$nummern2[0][0] = Execute($nummern2[0][0])
$nummern2[0][1] = $pre & $nummern2[0][1] & $back
$nummern2[0][1] = Execute($nummern2[0][1])
$nummern2[0][2] = $pre & $nummern2[0][2] & $back
$nummern2[0][2] = Execute($nummern2[0][2])
$nummern2[1][0] = $pre & $nummern2[1][0] & $back
$nummern2[1][0] = Execute($nummern2[1][0])
$nummern2[2][0] = $pre & $nummern2[2][0] & $back
$nummern2[2][0] = Execute($nummern2[2][0])
$nummern2[3][0] = $pre & $nummern2[3][0] & $back
$nummern2[3][0] = Execute($nummern2[3][0])
$nummern2[4][0] = $pre & $nummern2[4][0] & $back
$nummern2[4][0] = Execute($nummern2[4][0])
$nummern2[1][1] = $pre & $nummern2[1][1] & $back
$nummern2[1][1] = Execute($nummern2[1][1])
$nummern2[2][1] = $pre & $nummern2[2][1] & $back
$nummern2[2][1] = Execute($nummern2[2][1])
$nummern2[3][1] = $pre & $nummern2[3][1] & $back
$nummern2[3][1] = Execute($nummern2[3][1])
$nummern2[4][1] = $pre & $nummern2[4][1] & $back
$nummern2[4][1] = Execute($nummern2[4][1])
$nummern2[1][2] = $pre & $nummern2[1][2] & $back
$nummern2[1][2] = Execute($nummern2[1][2])
$nummern2[2][2] = $pre & $nummern2[2][2] & $back
$nummern2[2][2] = Execute($nummern2[2][2])
$nummern2[3][2] = $pre & $nummern2[3][2] & $back
$nummern2[3][2] = Execute($nummern2[3][2])
$nummern2[4][2] = $pre & $nummern2[4][2] & $back
$nummern2[4][2] = Execute($nummern2[4][2])
_ArrayDisplay($nummern2)

Alles anzeigen

nun, soweit so gut. also auf geht es, das geschaffte dann in eine For-To-Next-Schleife zu legen und wie immer scheitert es jedes mal daran. das ist bestimmt total einfach, aber fuer mich ist es unglaublich schwer nachzuvollziehen was die Schleife wo und wann genau macht und wieso. mein versuch (klappt nicht) sah dann so aus:

Code

For $y = 0 To UBound($nummern2) - 1
    For $z = 0 To UBound($nummern2) - 1
    $nummern2[$y][$z] = $pre & $nummern2[$y][$z] & $back
    $nummern2[$y][$z] = Execute($nummern2[$y][$z])
    Next
Next

aber dann habe ich nochmal etliche videos (tutorials) geschaut viele variationen probiert und selbst das einfachste tutorial liess sich nicht umsetzen:

Code

For $y = 0 To UBound($nummern2) - 1
    ConsoleWrite($nummern2[$y] & @CRLF)
Next

da kommt dann direkt folgende fehlermeldung:

Code

==> Array variable has incorrect number of subscripts or subscript dimension range exceeded.:
ConsoleWrite($nummern2[$y] & @CRLF)
ConsoleWrite(^ ERROR

ich kann da nun eigentlich keinen error erkennen, denn $nummern2 ist global und beim syntaxcheck kommen keine fehler.

auch habe ich das dann mit anderen buchstaben versucht, aber alles lief ins _nichts_. was ich nun braeuchte ist ein nachvollziehbares beispiel wann und wie ich eine For-To-Next-Schleife einsetzen kann und das sowohl fuer 1D-Arrays als auch fuer 2D-Arrays. Es ist so frustrierend und jetzt weiss ich auch warum ich damals wieder eine schoepferische pause eigelegt habe. ich komme meinem plan zwar jedes mal ein oder zwei schritte naeher, aber der tunnel ist noch dunkel und lang.

kann mir jemand da irgendwie weiterhelfen mit einem verstaendlichen praktischen beispiel wie die For-To-Next-Schleife unter welchen bedingungen funktioniert, damit ich dann nicht immer so laecherliche fragen stellen muss.

danke im voraus.

beste gruesse

bankesbusters

*nachtrag*

also nach weiteren 'experimenten' habe ich hiermit dann endlich die loesung die ich haben wollte erzielt:

Code

Global $nummern3[5][3] = [[72,87,84],[69,79,79],[76,82,68],[76,76,65],[79,68,89]]
_ArrayDisplay($nummern3, "num 3")
Global $iRows = UBound($nummern3, $UBOUND_ROWS); total number of rows
Global $iCols = UBound($nummern3, $UBOUND_COlUMNS); total number of columns
Global $iDims = UBound($nummern3, $UBOUND_DIMENSIONS); total number of dinemsions
For $y = 0 To $iRows - 1
    For $z = 0 To $iCols - 1
        $nummern3[$y][$z] = $pre & $nummern3[$y][$z] & $back
        $nummern3[$y][$z] = Execute($nummern3[$y][$z])
    Next
Next
_ArrayDisplay($nummern3, "num 3 - 2")

Alles anzeigen

bleibt nur noch die frage: warum der vorherige code (der eigentlich extakt inhaltlich der gleiche ist) nicht funktioniert:

Code

Global $nummern3[5][3] = [[72,87,84],[69,79,79],[76,82,68],[76,76,65],[79,68,89]]
_ArrayDisplay($nummern3, "num 3")

For $y = 0 To UBound($nummern3) - 1
   For $z = 0 To UBound($nummern3) - 1
   $nummern3[$y][$z] = $pre & $nummern3[$y][$z] & $back
   $nummern3[$y][$z] = Execute($nummern3[$y][$z])
   Next
Next
_ArrayDisplay($nummern3, "num 3 - 2")

es muss etwas mit UBound zu tun haben, aber genau was und warum verstehe ich nicht?

gruss

BananaJoe

Du hast ein 2-dimensionales Array, Dein ConsoleWrite will aber auf ein 1-Dimensionales Array zugreifen. Daher der Fehler

Änder es so ab:

For $i = 0 To UBound($nummern2) -1
ConsoleWrite($nummern2[$i][0] & @CRLF)
Next

Dann wird die erste Spalte (Arrays sind 0-basiert) ausgegeben.

Nachtrag: bezieht sich auf Deine Ursprungsfrage - nicht auf Deinen Nachtrag

**Kanashius**

Hier einmal eine Ausführliche Erklärung der For-Schleife und deiner Schwierigkeiten:

AutoIt

; Wenn du das Array direkt zuweist musst du die Größe nicht angeben, die leitet sich aus der Zuweisung automatisch ab
Local $arNumbers = [[72,87,84], [69,79,79], [76,82,68], [76,76,65], [79,68,89]]

; Die Größe kann mit Ubound abgefragt werden. Der erste Parameter ist das Array und der zweite die Dimension (Standard, wenn nicht angegeben ist 1)
ConsoleWrite("2D-Array size: $arNumbers["&UBound($arNumbers)&"]["&UBound($arNumbers, 2)&"]"&@crlf)

; Eine For-Schleife definiert eine Variable, die mit jedem durchlauf verändert wird (normal um 1 erhöht) und das solange, bis die Variable einen Wert erreicht.
; Dabei wird der Start und das Ende angegeben (Hier ist 0 der Start und 10 das Ende).
ConsoleWrite("-----------"&"For Loop 1"&"-----------"&@crlf)
For $i=0 To 10
	ConsoleWrite("Iteration: "&$i&@crlf)
Next

; Durch das angeben von Step kann auch festgelegt werden, um wie viel sich die Variable verändern soll.
ConsoleWrite("-----------"&"For Loop 2"&"-----------"&@crlf)
For $i=2 To 10 Step 2
	ConsoleWrite("Iteration: "&$i&@crlf)
Next

; Die Werte können dabei auch negativ sein.
ConsoleWrite("-----------"&"For Loop 3"&"-----------"&@crlf)
For $i=10 To -10 Step -2
	ConsoleWrite("Iteration: "&$i&@crlf)
Next

; Das kann man dann auch nutzen, um über ein Array zu iterieren.
; Da der Index (das zwischen den []) für den Zugriff auf ein Array bei 0 anfängt ist der letzte Index dementsprechend die Größe des Arrays-1
; Hier starten wir also bei 0 und wollen bis 3 gehen um alle 4 Werte im Array auszugeben. 0 ist der Anfang und die Größe des Arrays ist 4 ( Ubound($ar1DExample) ).
; Es soll aber nicht von 0 bis 4, sondern nur von 0 bis 3 iteriert werden, weil der Index 4 nicht existiert (Array variable has incorrect number of subscripts...).
; Also nehmen wir die Größe und ziehen 1 ab: Ubound($ar1DExample)-1, was deshalb das Ziel der For-Schleife ist.
ConsoleWrite("-----------"&"Iterate Array 1"&"-----------"&@crlf)
Local $ar1DExample = [11,22,33,44]
For $i=0 To UBound($ar1DExample)-1 Step 1
	ConsoleWrite("Access $ar1DExample["&$i&"]: "&$ar1DExample[$i]&@crlf)
Next

; Wollen wir jetzt das 2D-Array von oben ($arNumbers) iterieren, müssen wir also erst eine For-Schleife für den ersten Index schreiben und dann für den zweiten Index.
; Also bleibt die äußere For-Schleife genauso wie vorher, aber bei der zweiten (inneren) For-Schleife brauchen wir eine andere Variable und das Ziel ist auch nicht mehr
; die Größe der ersten Dimension ( UBound($arNumbers) ), sondern die Größe der zweiten Dimension ( UBound($arNumbers, 2) ).
; Das war übrigens auch der Fehler, der dir bei deinem Beispiel passiert ist.
; Du bist sowohl bei der ersten loop, als auch bei der zweiten von 0 bis 4 iteriert, statt bei der inneren Schleife von 0 bis 2 zu iterieren.
; Deshalb kam dann auch die Fehlermeldung, dass du auf Werte außerhalb des Arrays zugreifen willst.
; Das Problem bei dem anderen Beispiel aus deinem Post ist, dass du auf $nummern2[$y] zugreifen willst.
; Die Variable $nummern2 ist aber ein 2D-Array, du MUSST also den zweiten Index angeben ( $nummern2[$y][$z] ), ansonsten bekommst du die Fehlermeldung:
; Array variable ... subscript dimension range exceeded.
ConsoleWrite("-----------"&"Iterate Array 2"&"-----------"&@crlf)
; Local $arNumbers = [[72,87,84], [69,79,79], [76,82,68], [76,76,65], [79,68,89]]
For $i=0 To UBound($arNumbers)-1 Step 1
	For $j=0 To UBound($arNumbers, 2)-1 Step 1
		ConsoleWrite("Access $arNumbers["&$i&"]["&$j&"]: "&$arNumbers[$i][$j]&@crlf)
	Next
Next

; Das gleiche gilt auch für 3D-Arrays. Einfach eine Weitere For-Schleife, die über die dritte Dimension iteriert.
ConsoleWrite("-----------"&"Iterate Array 3"&"-----------"&@crlf)
Local $ar3DExample = [[[1, 2, 3], [7, 8, 9]], [[10, 20, 30], [70, 80, 90]]]
For $i=0 To UBound($ar3DExample)-1 Step 1
	For $j=0 To UBound($ar3DExample, 2)-1 Step 1
		For $k=0 To UBound($ar3DExample, 3)-1 Step 1
			ConsoleWrite("Access $ar3DExample["&$i&"]["&$j&"]["&$k&"]: "&$ar3DExample[$i][$j][$k]&@crlf)
		Next
	Next
Next

; Ich bin mir auch nicht sicher, warum du in deinem Beispiel das ganze als String umschreiben und dann mit Execute ausführen willst.
; Das sorgt nur für unnötig viele Operationen.
; Du kannst einfach iterieren und die Funktion für jede Variable aufrufen.
ConsoleWrite("-----------"&"Array - Int to Char"&"-----------"&@crlf)
Local $arChars[UBound($arNumbers)][UBound($arNumbers, 2)]
Local $arWords[UBound($arNumbers)]
Local $sSentence = ""
For $i=0 To UBound($arNumbers)-1 Step 1

	Local $sWord = ""

	; Iteriere Buchstaben
	For $j=0 To UBound($arNumbers, 2)-1 Step 1
		$arChars[$i][$j] = Chr($arNumbers[$i][$j])
		ConsoleWrite("Access ["&$i&"]["&$j&"]: "&$arNumbers[$i][$j]&" >> "&$arChars[$i][$j]&@crlf)
		$sWord &= $arChars[$i][$j]
	Next

	$arWords[$i] = $sWord
	ConsoleWrite("Access $arWords["&$i&"]: "&$arWords[$i]&@crlf)

	$sSentence &= $arWords[$i]
	; Füge Leerzeichen hinzu, wenn es nicht das letzte Wort ist
	If $i<UBound($arNumbers)-1 Then $sSentence &= " "
Next
ConsoleWrite("Sentence: "&$sSentence&@crlf)


; Kommen wir zum wichtigsten, wenn du solche Probleme selbst lösen möchtest:
; Lass dir alle Infos ausgeben.
; Ein paar ConsoleWrite ausgaben der Variablen würden dir das Problem zeigen
ConsoleWrite("-----------"&"Problemsolving"&"-----------"&@crlf)
Global $nummern2[5][3] = [[72,87,84],[69,79,79],[76,82,68],[76,76,65],[79,68,89]]
Global $pre = "Chr("
Global $back =")"
For $y = 0 To UBound($nummern2) - 1
    For $z = 0 To UBound($nummern2) - 1
		ConsoleWrite("Access: $nummern2["&$y&"]["&$z&"]: ")
		ConsoleWrite($nummern2[$y][$z]&@CRLF)
		$nummern2[$y][$z] = $pre & $nummern2[$y][$z] & $back
		$nummern2[$y][$z] = Execute($nummern2[$y][$z])
    Next
Next
; Die Fehlermeldung folgt auf der Ausgabe => Access: $nummern2[0][3]
; Dabei ist 3 größer als $nummern2[5][3] die Größe-1 der zweiten Dimension (3-1=2)

Alles anzeigen

Ich hoffe, das hilft dir weiter

bankesbusters

hallo,

vielen dank Kanashius.

das war in der tat hilfreich. anhand dessen habe ich wie eine art 'nachschlagewerk' womit ich mich dann beschaeftigen kann um zu verstehen wie und wo fehler sind. ich denke das wird mir sicher ein wenig weiterhelfen. also hätte es funktioniert wenn ich vorher das ganze als 2D-Array deklariert haette:

Code

For $z = 0 To UBound($nummern2) - 1 ; <<<------------ so ist falsch, da auch dritte dimension (3D-Array) deklariert wird obwohl nur 2D-Array ist!
For $z = 0 To UBound($nummern2, 2) - 1 ; <<<------------ so ist RICHTIG, da durch die angabe der "2" auf ein 2D-Array beschränkt wird!

das ist sehr hilfreich.

ich weiss die zeit und mühe wirklich zu schätzen. vielen vielen dank.

gruss

BananaJoe

Schau Dir doch einmal das Array-Tutorial von Bugfix an: http://www.bug-fix.info/array_tut.htm

**Kanashius**

Hey, bakesbusters,

Das Ergebnis ist richtig (Die Verwendung von For $z = 0 To UBound($nummern2, 2) - 1 ), das warum ist aber komplett falsch.
Es hat garnichts mit 3D-Arrays zu tun, es wird auch nichts deklariert.
UBound ist einfach eine Funktion, die die Anzahl der Elemente im Array ausgibt.
Bei einem 1D-Array ist das wie eine Liste, wo UBound($arData) die Anzahl der Elemente in der Liste zurückgibt:

Code

Local $arData = ["Erstes Element", "Zweites Element", "Drittes Element"]
1. Erstes Element	=> $arData[0]
2. Zweites Element	=> $arData[1]
3. Drittes Element	=> $arData[2]
Ubound($arData) gibt also 3 zurück

Ein 2D-Array ist dagegen wie eine Tabelle, wo Ubound($arData) die Anzahl der Zeilen zurückgibt und Ubound($arData, 2) die Anzahl der Spalten.

Code

Local $arData[3][2] = [["Zeile 1 Spalte 1", "Zeile 1 Spalte 2"], ["Zeile 2 Spalte 1", "Zeile 2 Spalte 2"], ["Zeile 3 Spalte 1", "Zeile 3 Spalte 2"]]
+-----------------------------------+----------------------------------+
|  Zeile 1 Spalte 1 ($arData[0][0]) | Zeile 1 Spalte 2 ($arData[0][1]) |
+-----------------------------------+----------------------------------+
|  Zeile 2 Spalte 1 ($arData[1][0]) | Zeile 2 Spalte 2 ($arData[1][1]) |
+-----------------------------------+----------------------------------+
|  Zeile 3 Spalte 1 ($arData[2][0]) | Zeile 3 Spalte 2 ($arData[2][1]) |
+-----------------------------------+----------------------------------+
Ubound($arData) gibt also 3 zurück, weil es 3 Zeilen gibt
Ubound($arData) gibt also 2 zurück, weil es 2 Spalten gibt

Als "Deklaration" bezeichnet man übrigens nur die Angabe ("Deklaration") der Variable. Also z.B.:

Code

Local $sData
Local $arData[2][3]

Dabei wird nur festgelegt, dass es die Variable gibt (und in den meisten Sprachen auch welchen Typ sie hat, also wie viel Arbeitsspeicher sie benötigt). Dabei wird auch die Größe des Arrays angegeben.

Als "Definition" oder "Zuweisung" wird es bezeichnet, wenn man einer Variable dabei einen Wert zuweist:

Code

Local $sData = "Ein schöner String"
Local $arData = ["Ein", "schönes", "Array"]

Dabei kann man z.B. die Größen-Angabe des Arrays weglassen, weil der Compiler sich die Größe durch die Zuweisung direkt selbst ableiten kann.

Ubound verändert das Array also überhaupt nicht. Es liest nur die Größe aus und gibt sie zurück, damit man damit weiterarbeiten kann.

bankesbusters

ja, das array-tutorial kannte ich schon. das war nicht schlecht. ich glaube mein problem bei den tutorials ist auf eine kleinigkeit zu reduzieren:

die tutorials gehen so vor, dass sie zu dir sagen: "das ist eine gabel, das ist ein messer und das ist ein loeffel ... hier ist das essen ... viel glueck!"

das heisst, grundlegendes (aufbau/struktur) wird erklaert/gezeigt, aber irgendwelche fiktiven 'probleme' wie zum beispiel ein vergleich zwischen zwei gleichen und/oder zwei ungleichen arrays werden nicht gezeigt oder erklaert. sprich es geht nie um 'beispielhafte' projekte die gerade anfaenger gut gebrauchen koennten. und dann werden die tutorials meist simpel gehalten, denn es ist wahrscheinlich schwer ein dickes brett leicht verstaendlich zu erklaeren.

wenn ich ein tutorial machen wuerde, (dazu bin ich noch viel zu weit von dem verstaendnis der funktionsweise entfernt) dann wuerde ich versuchen mir etwas vorzunehmen, was den anfaenger vielleicht ein wenig ueberfordert, aber ihm langfristig etwas bringt, da er daraus etwas lernt und mitnimmt was vielleicht irgendwann mal an anderer stelle wertvoll sein koennte. vielleicht kommt genau dieser anfaenger dann nochmal zurueck und schaut sich das tutorial ein zweites mal an, wenn er an dieser stelle steckt, wo er es mal braucht. ich glaube ich wuerde ein tutorial machen wo abseits der grundfunktionsweise von For-To-Next-Schleifen eben auch mal verschachtelte For-To-Next-Schleifen mit If And Then Else ElseIf EndIf um zu veranschaulichen wie verdammt maechtig ein array sein kann und wie nuetzlich es immer wieder in so vielen stellen sein koennte.

auf jeden fall waere mein tutorial ein projekt und nicht nur schemenhafte vorschlaege oder randnotizen. ein echtes projekt, wo am ende der user etwas 'erschaffen' hat, was er nutzen kann, oder auch nicht.

ich fand zum beispiel die kommentare in Kanashius seinem post wirklich wertvoll, weil sie machten mir klar mit hilfestellungen wo das problem in meinem script lag und zusaetzlich habe ich noch gelernt, dass ich mit consolewrite() noch weitere ueberpruefungen machen kann, was mir vorher gar nicht so klar war. zuguterletzt hat er auch noch an meinem vorhaben etwas moniert wo er sagte, dass ich unnoetige prozesse mache, die anders eleganter loesbar waeren mit weniger rechenleistung oder speicherplatzbedarf. das bringt mir schon echt viel, weil ich dann vergleichen kann, was wie warum hier oder da besser oder anders ist und das ganze an einem 'projekt' anschaulich erklaert bekomme. das ist so genial. es ist nicht nur hilfe, sondern hilfe mit dem zusatz 'hey, es geht auch anders und ggf. besser als du denkst' ... ich weiss nicht ob ihr eine vorstellung davon habt, wie hilfreich das für anfänger ist. das ist wirklich toll. ... noch toller wird es dann noch, wenn ich das ganze ausbaue und anpasse und in ein anderes script (wegen mir ein testscript) einbauen kann und es trotzdem funktioniert. das ist ungemein zufriedenstellend, weil es echte erfolgserlebnisse gibt, weil du es dann als anfaenger oder user auch wirklich mehr oder weniger verstanden hast.

so viel zu dem thema.

gruss