Beiträge von Yjuq

Happy Pseudo Birthday!

Wenn du jetzt vor hast die UDF zu verwenden, dann würde ich wieder komplett anders arbeiten.
Das andere waren quasi nur Workarounds da ja AutoIt OOP nativ eben nicht kann.

Sobald du den Baum aber mit OOP umsetzen willst, stehen dir da wieder andere Ansätze zur Verfügung.
Da würde ein String und OOP einfach keinen Sinn machen.

Zu der eigentlichen Frage:
Die Funktion gibt dir ja einen String zurück, welcher in jeder Zeile ein Suffix mit der Suchtiefe enthält. Neue Knotenpunkte einzufügen ist ja relativ einfach. Dafür kannst du die Funktion _StringInsert() nutzen. Um Knotenpunkte zu löschen reicht es ja einfach die entsprechende Zeile aus dem String zu nehmen: StringReplace(). Die entsprechende Zeile musst du jedoch vorab suchen. Da bietet sich StringRegExp() an (Je nach Suchkriterien). Natürlich kannst du auch alles in einem Rutsch mit StringRegExpReplace() erledigen.

Vielleicht wäre es an der Stelle einmal sinnvoll zu erwähnen, wie du dir genau das vorgestellt hast. Was soll dem Baum zugefügt werden, und was gelöscht?

Uff, welche Schwierigkeiten meinst du?
Ich persönlich komme mit der UDF blendend zurecht.

Tatsächlich gibt es für AutoIt ein Workaround, welches bedingt OOP zulässt. Ist zwar etwas aufwendiger zu schreiben, hat jedoch die gleiche Logik als ob du mit Objekten arbeiten würdest. Den deutschen Thread dazu findest du hier: AutoItObject - OOP für AutoIt

Ja. das mit dem ausloggen geht einem auf die Nerven. KA wie lange es dauert bis man gekickt wird.

€dit: Ach ich sehe gerade, du hattest damals den Thread auch schon gefunden.

Schöne Idee
AutoIt bietet seit neusten die Möglichkeit Funktionen in Variablen abzulegen.
Guckst du:

$hMsg = MsgBox
$hMsg(0, '', '')

Das bietet die Möglichkeit die Funktion "direkt" zu übergeben und auf die Call Funktion zu verzichten.
Finde ich persönlich besser. Nur mal so als Hinweis am Rande.

Ja, der String muss dann immer neu erstellt werden. Aber ich wette darauf dass es deutlich schneller ist als mit Array's in Array's zu hantieren.
Die Stringfunktionen bringen in AutoIt Skripten (wenn richtig eingesetzt) meist immer einen ordentlichen Schub.
Welche Stringfunktion jetzt für was am besten geeignet ist, muss man mal ausprobieren.
Kann ich so direkt nicht sagen.

Bitteschön

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

ConsoleWrite(_PowerShell_Command('get-process | sort-object ProcessName'))

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Func _PowerShell_Command($sCommand)
Local $iPID = Run(StringFormat('"%s" "%s"', 'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe', $sCommand), @ScriptDir, @SW_HIDE, 0x2)
Local $sOut

Do
$sOut &= StdoutRead($iPID)
Until @error

StdioClose($iPID)
Return $sOut
EndFunc

; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

Zitat von FKFK

Hi, damit lässt sich einiges machen. Vielen Dank Du hast ja das Skript in verschiedene Bereiche durch +++ aufgeteilt. Dazu könnte ich dir auch #region und #endregion empfehlen und mit Strg+T räumt ein automatisches Clean-Up programm das Skript auf: Es fügt Tabs vor den Befehlen ein und entfernt überflüssige, damit sie an der richtigen Stelle stehen, fügt Leerzeichen hinzu bei den Gleichheitszeichen etc. Gibt einige nützliche Funktionen. Was ich besonders hilfreich finde: Es legt eine Backup-Kopie des Skripts in einem Unterordner an bei jedem Durchlauf.

Ja, ist mir bereits bekannt. In den 3 Jahren die ich hier schon verbringe habe ich mir jedoch einen eigenen Programmierstil entwickelt. Die Verwendung von #region und #endregion finde ich persönlich nicht so schön, deshalb unterteile ich einzelne Sektionen lieber wie in meinen Skript gezeigt. Zudem zerstört Tidy (Strg+T) schonmal meine Codeeinrückungen. Ich nutze auch schonmal 2 Leerzeichen zwischendurch und die werden einfach durch ein Tab ersetzt. Das stört mich, da kümmer ich mich doch lieber Manuell um alles.

Zitat von FKFK

Gibt es eine Funktion, die Items an eine festgelegte Position im Tree hinzufügt oder löscht? Bei der Einfüge-/Lösch-Operation müsste ja manchmal der ganze Baum umgeschrieben werden oder?

Nein, die Funktion habe ich noch nicht geschrieben. Ob es dazu schon im Netz eine gibt, weiß ich nicht.
Bei den Array-Tree ist es ziemlich aufwendig neue Daten hinzuzufügen oder alte zu löschen. Daher bietet es sich an einfach einen String zu nehmen, da mit den String Funktionen eigentlich schnell & einfach einzelne Knoten geändert, hinzugefügt oder gar gelöscht werden können. Gleiches gilt auch für Dictionarys (Je nachdem wie man den Baum als Dictionary umsetzt).

Zitat von FKFK

Ich würde gerne einrichten, dass nur bestimmte Objekte als Item in den Tree aufgenommen werden, z.B. nur Ordner und Vernküpfungen. Ist es sinnvoller dies durch eine Regel-Funktion zu entscheiden oder durch eine Untersuchung des fertigen Strings?

Es ist sicherlich sinnvoller direkt eine Regelung festzulegen. Dies hinterher zu löschen ist einfach Zeitaufwendiger. Du gehst quasi den ganzen Baum schon direkt durch beim Erstellen. Warum dann nicht auch direkt schon die Daten filtern? Hinterher NOCHMAL den Baum abzuklappern wäre einfach nur Zeitverschwendung, und davon haben wir Menschen zu wenig.

Genau das macht der codeschnipsel den ich dir da gegeben habe. Nach 300ms (egal ob Taste noch gedrückt ist oder nicht) wird der Code in der Abfrage ausgeführt. Danach wird die Schleife verlassen.

Gesendet von meinem HTC Desire HD A9191 mit Tapatalk 2

Alina:
Ich bezog mich auf folgenden Thread: Anfängerfrage - Schleife in Autoit Skript?

rexderruede:
Gewöhne es dir bitte an hier im Forum für AutoIt Quelltext folgendes Format zu verwenden:

[autoit]Code[/autoit]

So lässt sich das einfach besser lesen.

Zitat

Hab mich hier mal durchs forum geklickt. Es ist ja sagenhaft was man alles machen kann.

Ja, die Kunst des Programmierens besteht eigentlich nur darin, seine abstrakten Gedanken logisch sinnvoll als Quelltext zu Verfassen. Der Rest ist eigentlich wie Vokabeln lernen. Wissen was welcher Befehl macht und wie jedes Schlüsselwort arbeitet.

Zitat

Nur leider tue ich mich sehr schwer mit dem verstehen.

Das macht überhaupt nichts. Wenn ich mal durch meine ersten Beiträge hier im Forum blättere, merke ich wie dumm ich mich damals angestellt habe.

Zitat

Ich habe gemerkt dass ich gut nachbauen kann wenn ich vorlagen habe an denen ich mich orientieren kann.

Für den Anfang ist das wohl noch okay, aber wenn du ernsthaft programmieren möchtest, musst du versuchen selber die Dinge (auch ohne Vorlage) hin zu bekommen. Aber wie gesagt: Als Anfänger ist das vollkommen Okay und hilft enorm beim erlernen! Hab ich auch so gemacht.

Zitat

Wie das mit den Schleifen läuft weis ich ja nun auch

Super, die wirst du für dein Problem auch brauchen!

Zitat

Vllt könntest mir hier nochmal helfen.

Stimmt, ich habe genug drum herum geredet. Klar helfe ich dir - Also:

Du weißt doch sicherlich dass die _IsPressed() Funktion ein "True" entgegen spuckt, wenn du eine bestimmte Taste gedrückt hast.
Und du weißt bestimmt auch, dass eine While-Schleife solange arbeitet, bis der Ausdruck im Kopf falsch (also "False") ist.
Wenn nicht,... Schau dir Schleifen unbedingt nochmal an! Ansonsten kannst du weiter lesen.

Jetzt kommen eigentlich nur noch die Timer Funktionen hinzu.
TimerDiff() gibt dir dabei die verstrichende Zeit in Millisekunden zurück, seitdem die TimerInit() Funktion das letzte mal aufgerufen wurde.
Da es in einen Programm schonmal mehrere TimerInit() Aufrufe geben kann, bekommst du von der TimerInit() Funktion eine Art ID.
Diese speicherst du in einer Variable ab, damit die TimerDiff() Funktion weiß, welches TimerInit() du meinst.

Kurzes Beispiel:

; Versuch erst einmal das hier zu verstehen
$hTOne = TimerInit()
Sleep(1000)
$hTTwo = TimerInit()
Sleep(1000)
ConsoleWrite(TimerDiff($hTTwo) & @CRLF)
Sleep(1000)
ConsoleWrite(TimerDiff($hTOne) & @CRLF)

Nun kommen die Schleifen und _IsPressed() ins Spiel.
Zuerst musst du ja ermitteln ob die gewünschte Taste gedrückt wurde.
Also eine normale Abfrage:

If _IsPressed('20') Then
; Code
EndIf

Da du die Zeit messen möchtest fehlt dir also ein TimerInit() Aufruf:

If _IsPressed('20') Then
$hTimer = TimerInit()
EndIf

Jetzt kommt dein eigentliches Problem. Du willst dass etwas ausgeführt wird, sobald die Leertaste länger als 0.3 Sekunden gedrückt wurde.
Dafür musst du ja permament abfragen, ob die Leertaste schon losgelassen wurde.
Das kannst du mit einer weiteren Schleife realisieren:

If _IsPressed('20') Then
$hTimer = TimerInit()
While _IsPressed('20') ; Solange ausführen wie Taste noch gedrückt ist
WEnd
EndIf

Soa, baust du jetzt noch eine If-Abfrage ein, kannst du dann abfragen ob die Taste schon länger als 0.3 Sekunden gedrückt ist:

If _IsPressed('20') Then
$hTimer = TimerInit()
While _IsPressed('20')
If TimerDiff($hTimer) >= 300 Then
; Code der ausgeführt werden soll
ExitLoop
EndIf
WEnd
EndIf

Ist ja doch ein wenig lang geworden. Aber ich möchte dass du das auch verstehst und nicht nur Copy & Paste nutzt.
Falls noch Fragen da sind, kannst du gerne nachfragen!

Alina, du hast ihn leider missverstanden. Er möchte abfragen ob die Leertaste länger als 0.3 Sekunden gedrückt wurden ist.

Soa, jetzt guckst du mal in den einen Thread wo ich dir geantwortet habe. Mit ein wenig nachdenken klappt das auch dann. Sieh dir vor allem die Stelle an, wo ich mit den Timer Funktionen gearbeitet habe.

Gesendet von meinem HTC Desire HD A9191 mit Tapatalk 2

Hallo, ich hab bisher einmal einen "String Tree" und "Array Tree" umgesetzt.
Im Anhang findest du eine code.au3 und die dazugehörige UDF Tree.au3.

In der UDF wird lediglich eine Baumstruktur angelegt. Funktionen zum auslesen von Knotenpunkte etc. existieren noch nicht.
Hole ich aber alles noch nach, wollte quasi nur meinen "Fortschritt" dir mitteilen.

Kurz zu der UDF:
Die UDF hat 4 verschiedene Modi's zur Verfügung. 2 davon habe ich bereits umgesetzt, die anderen beiden sind ohne Funktion.
Um einen bestimmten Modus zu setzen, rufst du die Funktion _Tree_Mode($TREE_XXX) auf. Es sind bereits 4 Globale Variablen vordefiniert:
$TREE_STRING >> Gibt die Baumstruktur als String aus
$TREE_ARRAY >> Gibt die Baumstruktur als Array im Array aus
$TREE_DICTIONARY >> Gibt die Baumstruktur als Dictionary aus (existiert noch nicht)
$TREE_MAP >> Gibt die Baumstruktur als Map aus (existiert ebenfalls noch nicht, da wäre die AutoIt Version 3.3.13.6 (Beta) mindestens nötig)

Um nun eine Ordnerstruktur als Baumstruktur auszugeben, benutzt du die Funktion _Tree_Dir(Pfad mit abschließenden Backslash oder Slash!!! >> "\" or "/" <<, Suchtiefe)
Der Pfad muss halt mit einem Backslash oder Slash enden...
Bei der Suchtiefe kannst du angeben bis wie weit in die Ordner und Unterordner "geschaut" und abgespeichert werden soll.
Ist dieser -1, so werden alle Unterordner + Dateien aufgelistet.

Falls es Fragen gibt, immer fragen.
Am besten Code ansehen & verstehen und irgendwie ins eigene Projekt einbinden.

Achso, ich habe meine Taskleiste seit meinem ersten Rechner immer unten. Von daher wusste ich das nicht.

Zitat von BugFix

Ich glaube, ich bin der einzige Trottel, der in Software für andere immer eine Abfrage der Taskbarposition und -größe integriert.

Siehe meine Kernaussage:

Zitat von Make-Grafik

Am besten ist es, wenn man direkt die fixen Fensterpositionen (0|0) setzt wenn man mit den Makros @DesktopWidth und @DesktopHeigh arbeitet.Dann wird auch die Taskleiste komplett überdeckt.

Jetzt weißt du's besser und brauchst die Abfrage für die Taskbarposition nicht mehr!

Zitat von BugFix

Blende die Taskleiste einfach aus. Die Makros für Bildschirmgröße arbeiten sowieso nicht korrekt in Bezug auf die Position der Taskbar. Kannst ja die Größe auch fix vorgeben, wenn alle Desktop dieselbe Größe haben.

Das stimmt nicht so ganz. Die Makros funktionieren einwandfrei. Was tatsächlich Probleme macht ist die GUICreate() Funktion selber.
Diese Verschiebung kommt zur Stande, weil bei den Parameter für die Fensterposition -1 angegeben wurde.
Die Taskleiste wird bei der Berechnung auch berücksichtigt. Daher wird diese auch nur zur Hälfte überlappt.
Der andere Teil verschwindet oben aus dem Bildschirmrand.

Am besten ist es, wenn man direkt die fixen Fensterpositionen (0|0) setzt wenn man mit den Makros @DesktopWidth und @DesktopHeigh arbeitet.
Dann wird auch die Taskleiste komplett überdeckt.

LG. Make

Zur Lösung von schwierigen Algorithmen gehe ich immer folgendermaßen vor: (Wird dir auch bei
deinem Problem weiterhelfen ;D)

Schritt 1:
Zuerst überlege ich, was der Algorithmus genau wann machen soll. Ich lege einen Pseudocode an,
damit ich beim Programmieren die Logik hinter meinen erdachten Algorithmus nicht vergesse. Lässt
sich wunderbar auf dein Problem übertragen.

Wiederhole:
    Wenn [TAB] gedrückt wurde:
        > Taste [1] und [2] im Wechsel von 0.1 Sekunden drücken


    Wenn [SPACE] gedrückt wurde:
        > Leerlauf

    Wenn [F] gedrückt wurde:
        > Taste [3] drücken
        > Taste [4] drücken
        > Leerlauf

Damit hast du schonmal beinahe einen fertigen Code.

Schritt 2:
Nun überlegst du dir, welche Funktionen du benötigst um dein Ziel zu erreichen. Dabei gehst du
wieder deinen Pseudocode durch. Die Dokumentation ist dein Freund!

Hier die Liste an dem, was du so benötigst:

While-Schleife
If-Abfragen
Send() Funktion
_IsPressed() Funktion (in Misc.au3)
TimerInit() Funktion
TimerDiff() Funktion

Mit diesen Funktionen (abgesehen von Variablen und Operatoren) kommst du eigentlich sehr gut
zurecht. Jetzt nur ein wenig nachdenken.

Schritt 3:
Nun wird der Code Programmiert. Ich wollte dir lediglich eine Hilfestellung geben da du halt
noch Anfänger bist. Man lernt besser, wenn man es selber macht! Trotzdem habe ich dir hier im
unteren Spoiler den Code vorgekaut. Guck am besten nur rein wenn du absolut nicht weiter
kommst. Viel Spaß!

Wie meinst du das mit "Ordner untereinander verknüpfen"?
Normalerweise liegen in Ordner andere Ordner auf denen du zugreifen kannst.
Aber diese miteinander zu verknüpfen, keine Ahnung was du meinst.

Zum Glück verstehe ich aber worum es geht.
Da ich gerade viel zu viel Freizeit habe, setze ich mich mal ran.
(Hilft denn die UDF von BugFix nicht irgendwie weiter?)

Schon klar, aber für Ordnerstrukturen eher ungeeignet oder nicht?
Der einzige Zweck der mir gerade in den Sinn kommt ist, dass man in den Ordnerstrukturen nach bestimmten Dateien sucht.
Da wäre es doch sinnvoller einfach alle Pfade einzeln aufzulisten und die schnellen String Funktionen zu verwenden.
Alles in einer Baumstruktur zu hinterlegen und dann wieder jeden "Zweig" abzuklappern ist doch viel zu Zeit-Intensiv.

Deswegen meine Frage

Was möchtest du eigentlich mit der Baumstruktur erreichen?
Ich kann mir gerade keinen Reim draus machen wofür man dies bezüglich von Ordnerstrukturen gebrauchen kann.
Also, was soll dir das bringen wenn du diese als "Tree" vorliegen hast?

Wie hast du die denn in das Array hinein bekommen wenn du schon ArraySort genutzt hast

Wtf. MAGIC

Jetzt mal ernst, du sprichst diese einfach über ihren Index an: $Array[n]
Ist als ob du den Wert von ner stink normalen Variable abfragst

Gesendet von meinem HTC Desire HD A9191 mit Tapatalk 2

Ah Super!
Dankeschön

Wie meinst du das?
Es gibt in AutoIt die Möglichkeit Array's in Array's zu speichern.
Nachteil ist, dass du halt nicht direkt auf die einzelnen Elemente zugreifen kannst:

$aGlobal = _GetArr()

For $aO In $aGlobal
For $aT In $aO
ConsoleWrite($aT & @CRLF)
Next
Next

Func _GetArr()
Local $aLocal1[2]
Local $aLocal2[2]

$aLocal1[0] = 1
$aLocal1[1] = 2
$aLocal2[0] = $aLocal1
$aLocal1[0] = 3
$aLocal1[1] = 4
$aLocal2[1] = $aLocal1

Return $aLocal2
EndFunc

Ob es dafür eine UDF gibt, kp.
Ich habe zumindest bisher keine gesehen.