Codeblöcke [ERLEDIGT]

[Manfred]

Na gut, dann eröffne ich ein neues Thema (sammel ich also doch Punkte)

Die Sache mit den Codeblöcken ist folgende.....

Ich verstehe sie einfach nicht.

Kleine Dinge, wie diese hier-> aProt := ASORT(aProt,,, {|x,y| x[F_DATE] < y[F_DATE]}) sind ja nachvollziehbar.

Soweit ich aber gelesen habe, sollen die komplette Do WHILE Strukturen ersetzen.

Aus der Erklärungen die in der Hilfe sind, werde ich nicht schlau.

Gruß

Manfred

[Martin Altmann]

Hallo Manfred,

Kleine Dinge, wie diese hier-> aProt := ASORT(aProt,,, {|x,y| x[F_DATE] < y[F_DATE]}) sind ja nachvollziehbar.

Soweit ich aber gelesen habe, sollen die komplette Do WHILE Strukturen ersetzen.

nun - genau das macht doch auch Dein Beispiel :?:
Du "loopst" über Dein komplettes Array und sortierst die Einträge nach der Spalte F_DATE aufsteigend.
Das ganze geht natürlich auch noch wesentlich verschachtelter, so dass die Codeblöcke erst richtig zur Geltung kommen:

Code: Alles auswählen

asort( ptag,,, {|aX,aY| iif( aX[ 1 ] <> aY[ 1 ], aX[1] < aY[1], iif( aX[ 2 ] <> aY[ 2 ], aX[2] < aY[2], aX[ 3 ] < aY[ 3 ] ) ) } )

Dies macht folgendes:
Das Array wird nach der ersten Spalte aufsteigend sortiert. Bei gleichen Einträgen in der ersten Spalte, werden diese nach der zweiten Spalte aufsteigend sortiert. Gibt es Einträge, die in der ersten und zweiten Spalte gleich sind, so werden sie nach der dritten Spalte aufsteigend sortiert.
Beispiel: Eine Liste mit Deinen Kunden. Das Array ptag enthält {Ort, PLZ, Kundenname, und_noch_beliebige_weitere_Spalten}
Deine Ausgabe nach dem o.g. Sort wäre also nach Orten sortiert, innerhalb der Orte nach Postleitzahlen und innerhalb gleicher Postleitzahlregionen nach Kundennamen.

Viele Grüße,
Martin

[Manfred]

Hi Martin,

na gut, dann mal anders herum:

Wenn ein fertiger Codeblock steht und das Ergebnis zu sehen ist, dann kann ich es einigermaßen nachvollziehen, warum, weshalb, weswegen.

Ich habe aber keinen Plan, mein evtl. Problem in einen Codeblock zu schreiben. Da liegt bei mir das Verständnisloch. Was wird warum wo reingeschrieben. Was kommt immer/jedesmal/in dem Fall zwischen ||, was kommt dahinter? Was macht ||? Warum macht es das ?

Mag jetzt irgendwie blöd klingen, aber ich habe irgendwie eine Mauer, vor die ich in dem Fall renne.

Gruß

Manfred

[Martin Altmann]

Hallo Manfred,
aah - OK.
Also: ein Codeblock ist immer nach dem Schema { |...| .... } aufgebaut.
Zwischen den beiden || stehen einfach die Variablen, die Du später (hinter den || ) in den Anweisungen verwenden willst.
In meinem Beispiel brauche ich zwei Variablen, die ich miteinander vergleichen will. Da ich ja ein Array verarbeite, steht jede Variable für jeweils ein Element des Arrays - einer kompletten Zeile bei mehrdimensionalen Arrays!
Hinter den beiden || steht die aufzurufende Funktion oder die abzuarbeitende Sequenz - sollen Funktionen bzw. Sequenzen aufgerufen werden, so sind sie jeweils durch ein ; voneinander getrennt.
In meinem Beispiel habe ich ein verschachteltes IF-ELSE-ENDIF-Konstrukt - da ich es ja in Funktionsweise schreiben muß, ist es als IIF-Konstrukt eingesetzt. Je nach zutreffender Bedingung bekommt das Asort das für die beiden gerade zu vergleichenden Elemente zutreffende Kriterium zum sortieren übergeben.

Viele Grüße,
Martin

[Manfred]

Hallo Martin,

Hallo Manfred,
aah - OK.
Also: ein Codeblock ist immer nach dem Schema { |...| .... } aufgebaut.
Zwischen den beiden || stehen einfach die Variablen, die Du später (hinter den || ) in den Anweisungen verwenden willst.

Bis hierhin ist alles klar.

In meinem Beispiel brauche ich zwei Variablen, die ich miteinander vergleichen will. Da ich ja ein Array verarbeite, steht jede Variable für jeweils ein Element des Arrays - einer kompletten Zeile bei mehrdimensionalen Arrays!

Auch verstanden. (Zumindest in der Darbietung)

Hinter den beiden || steht die aufzurufende Funktion oder die abzuarbeitende Sequenz - sollen Funktionen bzw. Sequenzen aufgerufen werden, so sind sie jeweils durch ein ; voneinander getrennt.

Aha, und hier geht es los. Das ich Funktionen damit aufrufen kann, war mir auch klar. Heißt das, ich kann x-beliebig viele mit ";" getrennte Funktionen aufrufen ? Werden die jetzt nacheinander aufgerufen?
Aber mit jedem EVAL Durchlauf immer wieder.. Ich glaube da habe ich im Moment die Bremse..

[Martin Altmann]

Hallo Manfred,

Aha, und hier geht es los. Das ich Funktionen damit aufrufen kann, war mir auch klar. Heißt das, ich kann x-beliebig viele mit ";" getrennte Funktionen aufrufen ?

Jup!

Werden die jetzt nacheinander aufgerufen?

Jup!

Aber mit jedem EVAL Durchlauf immer wieder..

Nochmal Jup!

Viele Grüße,
Martin

[Manfred]

Hi Martin,

na gut, dann muß ich mir mal etwas basteln und es nochmals probieren, ob ich jetzt besser damit klar komme.

Wenn nicht, dann werde ich nochmals nachfragen.

Danke erst einmal

[Tom]

Hallo, Martin, hallo, Manfred.

Zwischen den beiden || stehen einfach die Variablen, die Du später (hinter den || ) in den Anweisungen verwenden willst.

Das ist nicht ganz richtig. Bei Codeblöcken, die in Xbase-Klassen, aber auch in anderen Bereichen Methoden bzw. Slots als Callbacks zugeordnet sind, bestimmt die Klasse, welche Parameter an den Codeblock übergeben werden. Dieser Parameter kann dann zwischen den || referenziert werden, sofern er gebraucht wird. Ein gutes Beispiel hierfür sind die :resize-Slots (Methode resize()) der Klasse XbpWindow. Die Docs sagen, daß der Slot so auszusehen hat:

Code: Alles auswählen

:resize := {| aOldSize, aNewSize, self | ... }

Und das bedeutet, daß ihm als Parameter die alte Größe, die neue Größe und das Fensterobjekt selbst übergeben werden. Wenn ich diese Informationen im nachfolgenden Codeblock, der genaugenommen nur eine Liste von Anweisungen (Achtung: Keine Befehle verwenden!) ist, verwenden will, besetze ich ihn entsprechend:

Code: Alles auswählen

:resize := {| a1, a2, o | ... }

Dann kann ich die beiden Arrays mit den Größen oder das Fensterobjekt selbst (o) im nachfolgenden Codeblock beliebig manipulieren. Außerdem, und da hat Martin recht, kann ich die Parameterliste ergänzen, um lokale Variablen zu definieren, die ich im Codeblock benutzen will. Diese Variablen müßten dann dem definierten Parameterbereich folgen:

Code: Alles auswählen

:resize := {| a1, a2, o, i, j, k | ... }

[Manfred]

Hi,

ich setze die Frage nochmal hier hinter, weil sie wohl ein wenig damit zu tun hat:

Kann ich das hier noch vereinfachen?

Code: Alles auswählen

for I := 1 TO LEN(array)
    eval(führeaus())
next

kann ich die For next Schleife durch irgendwas im eval() ersetzen, also, dass ich eval irgendwie mitteile, wie oft es ausgeführt werden soll?

[Tom]

Hallo, Manfred.

Der Code sieht ein bißchen seltsam aus. Ich nehme an, daß Deine Funktion "fuehreaus()" einen Codeblock zurückliefert?

Eval() evaluiert einen Codeblock ein einziges Mal. Das ist hilfreich, wenn man zum Beispiel Codeblöcke verschachteln will oder wenn man Codeblöcke in Variablen gespeichert hat:

Code: Alles auswählen

bBlock := {||machediesunddas()}
...
Eval(bBlock) // an zig Stellen

Wenn Du einen Codeblock n Male ausführen willst, wobei n entweder die Länge eines Arrays ist oder die Anzahl der Datensätze einer Tabelle, die einer Bedingung genügen, benutzt Du AEval() (erster Fall) oder DbEval() (zweiter Fall). Wie gesagt, Eval() evaluiert einen Codeblock ein einziges Mal.

Ergänzung: Eval() hat auch noch einen ganz besonderen Zweck, man kann mit Hilfe dieser wunderbaren Funktion nämlich ziemlich leicht sog. "data driven"-Applikationen bauen. Da Codeblöcke (als Text) zum Beispiel auch in Tabellen gespeichert werden können, kann man auf diese Art Code ausführen, der in Datenbanken steht.

[Manfred]

Hi Tom,

ich Doof. Genau, da sollte eigentlich ein Aeval hin. Werde ich gleich mal probieren. eval(array[1]) Dann dürfte das so klappen.

Manchmal fällt der Euro centweise....... tsetsetse

[Tom]

Hä?

Stehen in "array" Codeblöcke?

Und "eval(array[1])" müßte, wenn schon, "eval(array)" lauten. Oder nicht? Jedenfalls habe ich jetzt keine Peilung mehr, was Du eigentlich erreichen willst.

[brandelh]

Hallo Manfred,

ich denke ich weiß was du willst.

Code: Alles auswählen

aCode := {   {|| Mach1() } ,;
                    {|| Mach2() } ,;
                    {|| Mach3() } }

[color=red]statt ....[/color]

for x := 1 to len(aCode)
    eval( aCode[x] )
next

[color=red]willst du kein FOR NEXT:[/color]

aEval(aCode , {|aB| eval( aB ) } )

liege ich richtig ?

[Manfred]

Moin Tom,

ich habe gestern etwas hektisch geantwortet. Natürlich nicht so wie ich geschrieben hatte.
Man sollte erst das Gehirn einschalten und dann schreiben....
Es ist halt im Kopf, aber noch nicht so locker, dass ich es blind heraus richtig schreibe, bzw. mir sofort auffällt, wenn es Mist ist.

@Hubert,

das meinte ich. Aber gestern war es einfach irgendwie falsch rausgekommen.

[Manfred]

nochmal ein Brett vor dem Kopf

das klappt,

Code: Alles auswählen

nLen := LEN(::aStrukturerweitert)

FOR nI := 1 TO nLen
      aadd(::aStruktur, {::aStrukturerweitert[nI,1],;
                                  ::aStrukturerweitert[nI,2],;
                                  ::aStrukturerweitert[nI,3],;
                                  ::aStrukturerweitert[nI,4]})
next

das klappt nicht.

Code: Alles auswählen

AEval(::aStrukturerweitert,{|nI| AAdd(::aStruktur, {::aStrukturErweitert[nI,1],;
                                                           ::aStrukturErweitert[nI,2],;
                                                           ::aStrukturErweitert[nI,3],;
                                                           ::aStrukturErweitert[nI,4]})})

Kann man hier schon auf den 1.Blick einen Fehler entdecken, oder werden noch weitere Infos benötigt?

[brandelh]

nochmal ein Brett vor dem Kopf ...

was war nochmal der 1. Parameter von aEvals Codeblock ?

Genau, das Subarrayelement (hier die Strukturbeschreibung eines Feldes):

So - sollte - es klappen:

Code: Alles auswählen

AEval(::aStrukturerweitert,{|aStruErw| AAdd(::aStruktur, {aStruErw[1],;
                                                           aStruErw[2],;
                                                           aStruErw[3],;
                                                           aStruErw[4]})})

Aber Achtung, man könnte meinen das dies noch verkürzt werden kann auf:

Code: Alles auswählen

AEval(::aStrukturerweitert,{|aStruErw| AAdd(::aStruktur, aStruErw)}) [color=red]// FALSCH ![/color]

Da aber in diesem Fall nicht die 4 Elemente als neues Array, sondern nur ein Verweis auf das alte Array angehängt würde, wären Fehler sehr warscheinlich.

[Manfred]

hmhmhmhm,

ich dachte es wäre der Parameter, der hochgezählt wird.

Also habe ich das immer noch nicht richtig verstanden......

So ein Mist.

Also nochmal testen und verinnerlichen.

Danke Hubert, ich wußte es war mal wieder etwas saudoofes von mir.

[brandelh]

Hallo Manfred,

das ist auch in der Doku nicht richtig erklärt.
Nur in den Beispielen findet wan die Parameter des Codeblocks.
Dass dieser Codeblock als 2. Parameter den laufenden Index enthält, wusste ich z.B. nicht, bevor ich TOMs Message sah.

Das steht in einem der unteren Beispiele der online Hilfe.

aEval( aArray , { |aArrayZeile, nZeilenIndex| ... } )

Sollte ich es nur nicht gefunden haben, dürft ihr auf mich einprügeln

[Manfred]

Hi,

noch etwas zum Thema (denke ich mal)

Code: Alles auswählen

METHOD _interpret:initstruktur(objekt)

memvar oSysPara
       objekt:bDarst := {|| objekt:indexOhneArtikel(Upper(FIELD->bez))}
       objekt:aIndex := {;
                         {"ID" ,"Str(id,8,0)","ID",.F.},;
                         {"BEZ","Eval(oSysPara:bDarst)","Interpret",.F.};
                        }
RETURN self

bDarst war mal zu Anfang in den Systemparametern deklariert. So wie es oben steht klappt es .

Jetzt habe ich es umgeändert, weil ich bDarst direkt der Klasse zugeordnet habe. Kommt sonst nirgends vor.

Das sieht dann jetzt so aus.

Code: Alles auswählen

METHOD _interpret:initstruktur(objekt)

       objekt:bDarst := {|| objekt:indexOhneArtikel(Upper(FIELD->bez))}
       objekt:aIndex := {;
                         {"ID" ,"Str(id,8,0)","ID",.F.},;
                         {"BEZ","Eval(objekt:bDarst)","Interpret",.F.};
                        }
RETURN self

Jetzt klappt es nicht mehr. Sobald der Index aufgebaut wird, kommt die Fehlermeldung das "objekt" nicht bekannt ist. Mit "self" ist es das gleiche. Hier versagt mein Wissen. Kann mir jemand helfen?

[brandelh]

Hallo Manfred,

kannst du dich an den Unterschied von PRIVATE / PUBLIC und LOCAL Variablen erinnern ?

Du speicherst einen Variablennamen in einen Text um ihn später irgendwann im Programm auszuführen. NUR memvar (PRIVATE / PUBLIC) Variablen sind dort bekannt. Die LOCAL wurden schon beim Compilieren von einem Namen in eine Speicherreferenz geändert.

Daher hast du oben auch eine MEMVAR Variable benutzt.

[Manfred]

Hi Hubert,

sicherlich, aber ich komme einfach nicht weiter, wie ich das jetzt gelöst bekomme. Ich habe etliche alte Tipps von Dir durchgesehen, aber im Moment habe ich ein Brett vor dem Kopf.

Ich habe auch etliches ausprobiert, aber ich denke mal, die falsche Richtung.

[brandelh]

Manfreds CODE:

Code: Alles auswählen

METHOD _interpret:initstruktur(objekt) //[color=red] <- objekt ist eine LOCAL[/color]
memvar oSysPara [color=red]<- oSysPara ist eine PRIVATE / Public [/color]
       objekt:bDarst := {|| objekt:indexOhneArtikel(Upper(FIELD->bez))} 
[color=red]in der oberen Zeile wird direkt ein Codeblock generiert (keine " -> kein & Operator, daher kann man hier auch LOCALs verwenden -> detached LOCALS[/color]
       objekt:aIndex := {;
                         {"ID" ,"Str(id,8,0)","ID",.F.},;
                         {"BEZ","Eval(oSysPara:bDarst)","Interpret",.F.};
                        }
[color=red]hier wird mit oSysPara ... eine PRIVATE / PUBLIC ... verwendet, dies geht da diese Variablen zur Laufzeit über den NAMEN angesprochen werden.[/color]
......
       objekt:aIndex := {;
                         {"ID" ,"Str(id,8,0)","ID",.F.},;
                         {"BEZ",[color=red]"Eval(objekt:bDarst)"[/color],"Interpret",.F.};
[color=red]hier versuchst du eine LOCAL als Referenz in einen String zu packen, das geht nicht  ![/color]

Es gibt 2 Lösungen (oder mehr ?)

1. Du kopierst den Inhalt von objekt:bDarst wieder in eine PRIVATE um bzw. gehst auf den alten Code zurück, wobei hier natürlich immer die Gefahr besteht, dass zur Laufzeit in objekt:bDarst schon was anderes steht als du in der PRIVATE gespeichert hast ...

2. Du löst den Inhalt in einen Codeblock auf z.B.

ALT :

Code: Alles auswählen

field Strasse, Ort
private SuchStrasse, SuchOrt, bSuch
SuchStrasse := "Weg"
SuchOrt := "Mainz"
bSuch := {|| Strasse = SuchStrasse .and. Ort = SuchOrt }

NEU - und besser:

Code: Alles auswählen

field Strasse, Ort
local SuchStrasse, SuchOrt, bSuch, cSuch
SuchStrasse := "Weg"
SuchOrt := "Mainz"
cSuch := "{|| DB->Strasse = '"+alltrim(SuchStrasse)+"' .and. "+;
                        DB->Ort = '"+alltrim(SuchOrt)+"' }" 
[color=red]// ich trenne dies immer, da ich so einfach den Text ansehen kann ![/color]
bSuch := &(cSuch)

Was nun bei dir besser passt, weiß ich auch nicht.

[Manfred]

Hi Hubert,

danke erstmal. Ich werde es bis auf weiteres wieder als Memvar machen. Es sollte übrigens bei der Memvar oSysPara:bDarst auch darunter oSysPara:bDarst und nicht objek:bDarst := {|| } heißen. Habe mich verschrieben.