1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. AspirinJunkie

Beiträge von AspirinJunkie

  • Globale Variablen - besser vermeiden

    • AspirinJunkie
    • 4. Januar 2011 um 15:30

    Assembler wird in der Regel ebenfalls strukturiert programmiert.
    Ich denke Andy geht es darum dass hier dass Schlüsselwort implizit (aber nicht explizit...) als böse beschrieben wird.
    Was natürlich Quatsch ist (sonst gäbe es dieses Schlüsselwort ja gar nicht).
    Wer kleine Skripte schreibt die kleine Aufgaben übernehmen mit ein paar hundert Zeilen dem kann das natürlich Wurscht sein.
    Es ist eher eine Vorbereitung für größere Projekte wo man sich viel mehr an gewisse Programmierprinzipien halten sollte wenn man nicht vor sehr großen Problemen stehen will.
    Dieses hier gehört dazu.
    Auch muss man zwischen Konstanten und Variablen unterscheiden.
    Sie erfüllen 2 unterschiedliche Zwecke.
    Eine Strukturdefinition für einen DLL-Call welcher in verschiedenen Funktionen benutzt wird sollte natürlich global definiert werden (Redundanzminimierung).
    Allerdings als Konstante. Keine Funktion wird diesen Wert ändern oder überschreiben - geht ja auch gar nicht.
    Das kann aber durchaus bei globalen Variablen passieren - und das ist das hier beschriebene Problem.
    Damit, und ich denke darum ging es Andy, Einsteiger in die Programmierung nicht unnötig verwirrt werden nochmal zusammengefasst:

    Globale Variablen sollten, vor allem bei größeren Projekten wo die Übersicht abhanden kommen kann, nicht unnötig eingesetzt werden.
    Wenn man sie dennoch einsetzt sollte man sich schon Gedanken machen ob diese Verwendung im Skript gerade wirklich sinnvoll ist und vielleicht nicht vermieden werden könnte bzw. sollte.
    Wer nur kleine Skripte alleine schreibt dem kann das in der Regel fast egal sein da es dort sehr unwahrscheinlich zu den angesprochenen Problemen kommt.

    Kurzum als Faustregel:
    Wenn man die Wahl hat dann die lokale Deklaration von Variablen der globalen vorziehen - aber keine Kopfstände deswegen vollführen.

    Ich hoffe auf dieses Fazit können wir uns einvernehmlich einigen.

  • Globale Variablen - besser vermeiden

    • AspirinJunkie
    • 4. Januar 2011 um 12:52
    Zitat von Andy

    Jede Funktion in der Windows-API benutzt globale Variablen. Globale Variablen schwirren reihenweise durch jedes Programm.

    In erster Linie schwirren da keine Variablen sondern Konstanten rum.
    Und diese dienen nicht zum Datenaustausch sondern zur Definition der Schnittstellen der einzelnen Programmteile.
    Diese sollen natürlich im gesamten Programm bekannt sein.
    Hier geht es aber um Variablen welche nur aus Bequemlichkeit global sind und ihren Zweck nur für Codebereiche erfüllen wo sie genauso intern deklariert werden könnten.
    Die Grundaussage ist auch nicht "keine globalen Variablen verwenden" sondern "globale Variablen vermeiden wenn es mit vertretbaren Aufwand machbar ist".

  • Globale Variablen - besser vermeiden

    • AspirinJunkie
    • 4. Januar 2011 um 12:06
    Zitat von Andy

    Solange ich weiss was ich tue, kann ich globale Variablen für ALLES verwenden. Punkt.


    Solange du weißt was du tust kannst du auch statt normaler Variablennamen $1, $2, $3 usw. verwenden.
    Solange du weißt was du tust kannst du auch alles ohne Einrückung schreiben.
    Solange du weißt was du tust kannst du deinen Code auch komplett schreiben ohne ihn in Funktionen zu modularisieren.
    Kannst du alles machen - wenn du weißt was du tust.
    Ab einem gewissen Code-Umfang und wenn Teile des Codes woanders her kommen wirst du es dann aber nicht mehr wissen.
    Und nur darum geht es bei dieser Empfehlung.
    Es ist kein Gesetz das dich dazu zwingt - es ist ein Prinzip welches diesen möglichen Fehler von vornherein vermeidet anstatt sich darauf zu verlassen immer im Kopf zu haben was im gesamten Code passiert.
    Daher handelt es sich auch um eine Empfehlung mit welcher sich man das Leben leichter machen kann.
    Wenn du das nicht willst - mach es nicht.
    Aber dieses Prinzip hat durchaus seine Berechtigung und sollte nicht einfach als Mumpitz abgetan werden.
    Auch als Einzelprogrammierer mit etwas größeren Projekten (wenn man nach einem Jahr ein Skript erweitert weiß man nicht mehr aus dem Stehgreif was man alles für globale Variablen verwendet hat).

    Zitat von nuts

    Aber wie macht ihr das dann z.B. mit einer aufwendigen Main GUI?


    Ich persönlich würde da weiterhin globale Variablen nehmen - diese aber natürlich so eindeutig wie möglich benannt.
    Es sollen ja nicht um jeden Preis globale Variablen entfernt werden - nur wenn der damit verbundene Aufwand vertretbar ist.
    Und in diesem Fall, wenn ich das GUI öfter in vielen verschiedenen Funktionen brauchen sollte würde ich das als zu großen Aufwand für mich betrachten.
    BugFix Vorschlag mit dem Array halte ich auf der einen Seite für gut da man da an jede Funktion die es brauch direkt alle GUI-Daten direkt als Parameter übertragen kann.
    Andererseits denke ich für mich dass ich schnell den Überblick verlieren würde da ich mit den Indizes durcheinander kommen würde.
    Dann würde man sich eine neue potentielle Fehlerquelle schaffen nur um eine andere zu vermeiden.
    Also in dem Fall würde ich persönlich weiter die globalen Variablen nehmen - aber wenn jemand für sich eine andere bessere Möglichkeit zur Organisation findet (wie BugFix mit seinem Array) ist das natürlich auch ok.
    Aber nochmal: Nicht um wirklich jeden Preis globale Variablen vernichten!
    So kann man sich den Code schnell noch viel umständlicher und unübersichtlicher machen als einem lieb ist.
    Bei der Empfehlung hier geht es nur um globale Variablen welche mit VERTRETBAREN Aufwand vermieden werden könnten - nicht mehr.

  • Performancediskussionen

    • AspirinJunkie
    • 3. Januar 2011 um 19:43

    Wie meinst du das die Unterschiede bei den Case-Sensitive und Case-InSensitive vom Sprachumfang herkommen?
    Das Case-InSensitive generell langsamer ist als Case-Sensitive ist ja noch vollkommen logisch.
    Bei Case-Sensitive wird einfach nur Buchstabe für Buchstabe verglichen ob es der selbe ist.
    Bei Case-Insensitive muss zusätzlich bei jedem Buchstaben nachgeschlagen werden was der entsprechende Groß bzw. Kleinbuchstabe dazu ist.
    Wie du sagtest dass der extreme Unterschied der Case-Insensitive-Suche zwischen AHK und AU3 von einer schlechten Implementierung dieser herrührt haben wir auch schon vermutet und dies scheint ja auch ziemlich offensichtlich.
    Interessant ist allerdings eher die Frage ob der generelle Unterschied zwischen AHK und AU3 eher an der speziellen Implementierung der StringSuch-Funktionen liegt oder direkt an den jeweiligen Interpretern.

  • Eindimensionaler Array mit FileListToArray

    • AspirinJunkie
    • 3. Januar 2011 um 18:41

    Du erzeugst ein Array welches in einem einzigen Element als Element ein Array hat.
    Dies ist KEIN 2D-Array welches du mit $Array[1][0] ansprechen kannst.
    Dies hängt damit zusammen wie ein 2D-Array im Speicher realisiert wird.
    Du musst also das Unterarray erst in eine Zwischenvariable auslesen um damit zu arbeiten:

    Spoiler anzeigen
    [autoit]

    #include <File.au3>
    Global $alist[1000]

    [/autoit] [autoit][/autoit] [autoit]

    $alist[1] = _FileListToArray(@DesktopCommonDir, "*", 1)
    $aArray = $aList[1]

    [/autoit] [autoit][/autoit] [autoit]

    MsgBox(0,"",$aArray[0])

    [/autoit]
  • Performancediskussionen

    • AspirinJunkie
    • 3. Januar 2011 um 18:21

    Hier nochmal meine beiden Testskripte (Sorry wenn das AHK-Skript bisschen merkwürdig aussehen sollte - hab noch nichts mit AHK bisher gemacht):

    Messskripte
    AHK
    Code
    SetBatchLines, -1 ; Schaltet den "Turbo" ein
    SetFormat, FloatFast, 0.15 ; 15 Nachkommastellen für Floats
    
    
    Chars := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    StringSplit, Chars, Chars
    Len := StrLen(Chars)
    String := "`r`n"
    
    
    Loop, %Len% {
       I := A_Index
       Loop, %Len% {
          J := A_Index
          Loop, %Len% {
             K := A_Index
             String .= Chars%I% . Chars%J% . Chars%K% . "`r`n"
          }
       }
    }
    Find := "ZAB"
    
    
    Loops := 100000
    
    
    ;Zeitdauer der Loop-Schleife bestimmen welche die Zeitmessung mit verfälscht:
    iLoopT := A_TickCount
    Loop, %Loops%	{
    }
    iLoopT := Round((A_TickCount - iLoopT), 4)
    
    
    
    
    StringCaseSense, Off
    iT := A_TickCount
    Loop, %Loops%	{
    	InStr(String, "`r`n" . Find . "`r`n")
    }
    iT := Round((A_TickCount - iT - iLoopT) / Loops, 3)
    MsgBox, 0, CaseSense Off:, %iT%  ms
    
    
    iT := A_TickCount
    Loop, %Loops%	{
    	InStr(String, "`r`n" . Find . "`r`n", 1)
    }
    iT := Round((A_TickCount - iT - iLoopT) / Loops, 3)
    MsgBox, 0, CaseSense On:, %iT%  ms
    
    
    StringCaseSense, Locale
    iT := A_TickCount
    Loop, %Loops%	{
    	InStr(String, "`r`n" . Find . "`r`n", 1)
    }
    iT := Round((A_TickCount - iT - iLoopT) / Loops, 3)
    MsgBox, 0, CaseSense Locale:, %iT%  ms
    Alles anzeigen
    AU3
    [autoit]

    $Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    $aChars = StringSplit($Chars, "", 2)
    $Len = StringLen($Chars)
    $String = @CRLF

    [/autoit] [autoit][/autoit] [autoit]

    For $I = 0 To $Len - 1
    For $J = 0 To $Len - 1
    For $K = 0 To $Len - 1
    $String &= $aChars[$I] & $aChars[$J] & $aChars[$K] & @CRLF
    Next
    Next
    Next

    [/autoit] [autoit][/autoit] [autoit]

    $Find = "ZAB"

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    Global $N = 10000, $iT0, $iT1, $iT2

    [/autoit] [autoit][/autoit] [autoit]

    ;Zeitdauer der For-Schleife bestimmen welche in der Zeitmessung mitwirkt
    $iTFor = TimerInit()
    For $i = 1 To $N

    [/autoit] [autoit][/autoit] [autoit]

    Next
    $iTFor = TimerDiff($iTFor)

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    ; Messung mit Parameter 0
    $iT0 = TimerInit()
    For $I = 1 To $N
    StringInStr($String, $Find, 0)
    Next
    $iT0 = (TimerDiff($iT0) - $iTFor) / $N
    ConsoleWrite("StringInStr(,,0): " & Round($iT0, 3) & "ms" & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    ; Messung mit Parameter 1
    $iT1 = TimerInit()
    For $I = 1 To $N
    StringInStr($String, $Find, 1)
    Next
    $iT1 = (TimerDiff($iT1) - $iTFor) / $N
    ConsoleWrite("StringInStr(,,1): " & Round($iT1, 3) & "ms" & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    ; Messung mit Parameter 2
    $iT2 = TimerInit()
    For $i = 1 To $N
    StringInStr($String, $Find, 2)
    Next
    $iT2 = (TimerDiff($iT2) - $iTFor) / $N
    ConsoleWrite("StringInStr(,,2): " & Round($iT2, 3) & "ms" & @CRLF)

    [/autoit]


    Hiermit komme ich dann auf folgende Ergebnisse (diesmal auf meinem Thinkpad):

    Messergebnisse
    Code
    ------- AHK -----------------
    CaseSense Off:		0.358  ms
    CaseSense On:		0.142  ms
    CaseSense Locale:	3.944  ms
    
    
    -------- AU3 ------------------------------
    StringInStr(,,0)(CaseSense Off)	: 22.687 ms
    StringInStr(,,1)(CaseSense On)	: 0.712  ms
    StringInStr(,,2)(CaseSense Off)	: 10.876 ms


    Ich konnte deine Ergebnisse also unabhängig nachvollziehen und deine Fazits mittragen.

    Zitat

    Dass in AU3 case-insensitive mehr Zeit benötigt als case-insensitive-locale, ist für mich aber überhaupt nicht nachvollziehbar.

    Der einzige Punkt den ich bei mir nicht reproduzieren konnte.

    Zitat

    Der These, dass AHK schneller sein muss, weil AU3 den umfangreicheren Interpreter hat, kann ich mich nicht anschließen. Die klare Sprachstruktur von AU3 sollte eher ein Vorteil sein.

    Nun für den Mensch mag die Sprachstruktur klarer sein - für die Maschine muss es das nicht.
    AutoIt muss auch ein vielfaches mehr an Funktionen nachschlagen weil der Umfang deutlich größer ist.
    Allerdings möchte ich mich hier nicht zu weit aus dem Fenster lehnen da ich selbst keine Interpreter programmiere ( ;) ).
    Ich weiß es schlicht und ergreifend nicht und kann daher nur Mutmaßungen anstellen was mir als Begründung alles logisch erscheint.

  • Globale Variablen - besser vermeiden

    • AspirinJunkie
    • 3. Januar 2011 um 13:24

    Globale Variablen bieten auf mehrere Arten potentielle Fehlerquellen welche mit ihrer Vermeidung auch vermieden werden: >>Klickmich<<

    Zitat von Wikipedia

    Globale Variablen sind scheinbar bequem, weil sie im ganzen Programm sichtbar sind. Es ist nicht notwendig, sie beim Aufruf einer Funktion als Parameter zu übergeben. Sie werden aber auch leicht zur Fehlerquelle, wenn man zum Beispiel eine globale Variable versehentlich oder sogar bewusst für verschiedene Zwecke benutzt.
    Auch kann es passieren, dass man eine lokale Variable mit dem Namen der globalen Variablen verwendet, von dem man annimmt, dass er im Programm bisher noch nicht benutzt wurde. Wenn es diesen Namen aber schon als Variable mit passendem Typ gibt (sofern dieser überhaupt vom Compiler und / oder vom Laufzeitsystem geprüft wird), dann wird deren Wert unkontrolliert überschrieben und umgekehrt. Ein schwer zu findender Fehler ist oft die Folge.
    Erfahrene Entwickler verwenden globale Variablen nur auf modularer Ebene und ausschließlich dann, wenn es sich nur durch unangemessen hohen Aufwand vermeiden ließe,


    Gerade in C++ bei welchem man seine Programme stark modularisiert und auch Bibliotheken von außen verwendet ohne diesen Code zu kennen kann es besonders schnell zu derartigen Problemen kommen. Desweiteren verletzen sie das Prinzip der Kapselung welches eine vernünftige Modularisierung erst ermöglicht.

  • Delta Bravo 0 Tango Tango - Dortmunder Amateurfunkempfänger

    • AspirinJunkie
    • 3. Januar 2011 um 12:34

    Eine Webseite gehostet in den USA und damit außerhalb des deutschen Rechtsraumes? - ja und?
    Und auch in Deutschland gibt es genügend Webseiten deren Inhalte gegen deutsches Recht verstoßen.
    Die Tatsache das es andere machen lässt unsere Zweifel an der Rechtmäßigkeit aber doch nicht verschwinden.

    Die Seite welche du verlinkst scheint ja, wie du nun sagst, rechtmäßig zu sein - daher brauchen wir auch nicht mehr über den Polizeifunk zu diskutieren.

    Edit: Auf die Chicago-Police kannst du gerne verlinken - die hat mit dem TKG ja nichts zu tun.

  • Delta Bravo 0 Tango Tango - Dortmunder Amateurfunkempfänger

    • AspirinJunkie
    • 3. Januar 2011 um 12:22

    Bitte lesen: >>Rechtssprechung zu Polizeifunk<<

    Zitat

    Es ist jedoch noch nicht strafbar, wenn unbeabsichtigt der Polizeifunk empfangen wurde (z.B. per Suchlauf zufällig auf Polizeifunk gestoßen). Wenn aber weiter mitgehört und der Polizeifunk erkannt wird, ist die Strafbarkeit gegeben. (Bay.ObLG, Beschluss vom 9.2.1999 - 4 St RR 7/99 - Begründung).

    Dieses Urteil ignoriert die Ansicht das zum Abhören auch das Aufzeichen gehört.

    oder auch >>hier<<

    Zitat

    Das TKG wurde zuletzt im Jahre 2004 geändert. Aus dem § 85 wurde nun der § 89 und aus dem § 95 der § 148. Die Kernaussage, "Abhören des Polizeifunks ist strafbar" stimmt jedoch noch immer.


    Und weiter will ich auch nicht rumstreiten ob es nach deiner oder meiner Auslegung strafbar ist oder nicht - sobald auch nur Zweifel bestehen dass es sich um eine Straftat handeln KÖNNTE hat das hier in diesem Forum nichts mehr zu suchen!

  • Delta Bravo 0 Tango Tango - Dortmunder Amateurfunkempfänger

    • AspirinJunkie
    • 3. Januar 2011 um 12:10

    Du "glaubst"?!?
    Es handelt sich hierbei, wenn es so ist, um einen Straftatbestand!
    Und du verlässt dich auf dein "Glauben"?!?

    Edit: Ich hoffe du hast Recht.
    Aber dann kündige es doch nicht reißerisch als Polizeifunkempfänger an.

    Edit2: Ok - auch geändert.

  • Delta Bravo 0 Tango Tango - Dortmunder Amateurfunkempfänger

    • AspirinJunkie
    • 3. Januar 2011 um 12:03

    Damit kann man den Polizeifunk abhören?
    Wenn ja - dann sofort raus mit dem Skript aus diesem Forum und folgendes lesen:
    §89 Telekommunikationsgesetz
    Und dann das:
    § 148 Telekommunikationsgesetz

  • Ordnerinhalte auslesen

    • AspirinJunkie
    • 3. Januar 2011 um 09:44

    Du brauchst eigentlich nur noch FileFindFirstFile() und FileFindNextFile().
    Als Grundgerüst zum fertig bauen:

    Spoiler anzeigen
    [autoit]

    #include <ComboConstants.au3>
    #include <GUIConstantsEx.au3>

    [/autoit] [autoit][/autoit] [autoit]

    Global $sQuellordner, $sZielordner, $sDateiTyp

    [/autoit] [autoit][/autoit] [autoit]

    $hGUI = GUICreate("Bilder einlesen...", 615, 440, 246, 152)
    $ctrlOrdnerwahl = GUICtrlCreateButton("Ordnerwahl", 440, 36, 119, 49)
    $ctrlStart = GUICtrlCreateButton("Start", 444, 220, 115, 61)
    $ctrlAnzeige = GUICtrlCreateCombo("Anzeige", 444, 180, 117, 25, BitOR($CBS_DROPDOWN, $CBS_AUTOHSCROLL))
    GUICtrlSetData(-1, "jpg|png")
    $ctrlAblage = GUICtrlCreateButton("Ablageordner", 440, 96, 119, 49)
    $ctrlQuelle = GUICtrlCreateInput("Quelle", 48, 52, 381, 21)
    $ctrlLabel1 = GUICtrlCreateLabel("Quellordner", 48, 28, 58, 17)
    $ctrlLabel2 = GUICtrlCreateLabel("Zielordner", 48, 88, 51, 17)
    $ctrlZiel = GUICtrlCreateInput("Ziel", 48, 108, 385, 21)
    $ctrlLabel3 = GUICtrlCreateLabel("Welche Formate sollen gelesen werden?", 232, 188, 196, 17)
    GUISetState(@SW_SHOW)

    [/autoit] [autoit][/autoit] [autoit]

    While 1
    Switch GUIGetMsg()
    Case $GUI_EVENT_CLOSE
    Exit

    [/autoit] [autoit][/autoit] [autoit]

    Case $ctrlOrdnerwahl
    $sQuellordner = FileSelectFolder("Bitte Ordner wählen", "", Default, @ScriptDir)
    If @error Then Exit
    GUICtrlSetData($ctrlQuelle, $sQuellordner)

    Case $ctrlAblage
    $sZielordner = FileSelectFolder("Bitte neuen Ordner wählen", "", Default, @ScriptDir)
    If @error Then Exit
    GUICtrlSetData($ctrlZiel, $sZielordner)

    Case $ctrlStart
    $sDateiTyp = GUICtrlRead($ctrlAnzeige)

    [/autoit] [autoit][/autoit] [autoit]

    If MsgBox(4, "", "Sollen alle " & $sDateiTyp & " Dateien eingelesen werden?") = 6 Then

    [/autoit] [autoit][/autoit] [autoit]

    $hFFFF = FileFindFirstFile($sQuellordner & '\*.' & $sDateiTyp) ;Erzeuge SuchHandle um Dateisuche zu starten
    If $hFFFF = -1 Then
    MsgBox(0, "Fehler", "Keine " & $sDateiTyp & "-Dateien im Quellordner gefunden")
    ContinueLoop
    EndIf

    [/autoit] [autoit][/autoit] [autoit]

    Do ;Endlosschleife
    $sDatei = FileFindNextFile($hFFFF) ; hole den nächsten passenden Dateinamen
    If @error Then ExitLoop ; gehe raus wenn es keine passenden Dateien mehr gibt

    [/autoit] [autoit][/autoit] [autoit]

    MsgBox(0, "Beispiel", "FileMove( " & $sQuellordner & '\' & $sDatei & ", " & $sZielordner & "\" & $sDatei & " )")
    Until 0

    FileClose($hFFFF) ;Handle wieder schließen
    Else
    MsgBox(4096, "Abbruch", "Daten wurden nicht eingelesen")
    EndIf
    EndSwitch
    WEnd

    [/autoit]
  • Auslesen was nach Doppelpunkt kommt

    • AspirinJunkie
    • 3. Januar 2011 um 07:04
    Zitat von ProblemUser

    ich habe ein Array der Sachen behält bei den etwas deklariert wurde. Beispiel:

    [autoit]

    $array[1] = "Name: ProblemUser Geschlecht: Männlich"

    [/autoit]


    Vorher war es in einer TXT so gestanden:

    [autoit]

    Name: ProblemUser
    Geschlecht: Männlich

    [/autoit]


    Was ist mit den Zeilenumbrüchen passiert?
    Wie kommt die Textdatei, ohne Zeilenumbrüche getrennt, zusammen in ein Array-Element.
    Wenn du die txt zeilenweise verarbeitest ist die Sache ganz schnell mit StringSplit() abgehandelt.
    Aber auch so wäre es mit StringSplit machbar.
    Man müsste halt von der StringSplit-Rückgabe nur jedes 2. Element nehmen.

    Zitat von ProblemUser

    Vorher war es in einer TXT so gestanden

    Im Süden gilt Stillstand als Bewegung... ;)

  • "@comspec" wichtiger befehl wird nicht ausgeführt!

    • AspirinJunkie
    • 3. Januar 2011 um 06:26
    Zitat von Baron1977

    und das Skript geht es geht mir darum das er den Namen General Notifiction nicht aus schreibt. weil er die leerzeile nicht mit nimmt.


    Sag mal testest du auch was man dir vorschlägt?
    Das dein Beispielstring nicht funktionieren kann ist logisch da vor General 1 Doppeltes Anführungszeichen im String steht - damit wird das eigentliche Umschließen von General Notification wieder außer Kraft gesetzt.
    Dass du es falsch formatiert hast siehst du sofort wenn du es in einer Msgbox ausgibst.
    Wie du es dann richtig formatierst hat dir hingegen AutoBert schon mehr als mundgerecht vorgekaut.

  • "@comspec" wichtiger befehl wird nicht ausgeführt!

    • AspirinJunkie
    • 2. Januar 2011 um 22:53
    Zitat von Baron1977

    mit dem Msgbox brauche ich nicht schauen da ich denn pfard ja weiß er soll das ganze wort mit nehmen und nicht das eine weg lassen.

    Dein Problem ist die Stringformatierung - doppelte Anführungszeichen im Endstring die du laut deiner Sollangabe nicht haben willst.
    Würdest du innerhalb von 2s mit ner Msgbox sofort sehen.
    Aber mach ruhig weiter so - beim nächsten String wirst du wieder vor dem selben Problem stehen....

    Warum auch einfach mal kurz testen was einem andere als Vorschlag zur Selbsthilfe machen....

  • "@comspec" wichtiger befehl wird nicht ausgeführt!

    • AspirinJunkie
    • 2. Januar 2011 um 22:33

    Du scheinst bisschen Probleme zu haben den String zu formatieren.
    Bevor du weiter mit Run/RunWait einfach wild ein paar Strings einträgst empfehle ich dir, dir einfach mal den String mit ner Msgbox oder ähnlichem auszugeben damit du siehst was die RunWait-Funktion dann als Übergabeparameter von dir erhält.
    Beispiel für den 1. String:

    [autoit]

    MsgBox(0,"", @COMSPEC & ' /c "c:\growlnotify.com /a:Teamviewer /r:""General Notification"" "')

    [/autoit]
  • Komplexeres? schnelles durchsuchen größerer Arrays

    • AspirinJunkie
    • 2. Januar 2011 um 11:39
    Zitat von Großvater

    Anmerkung 1: Die Funktion StringInStr() scheint nicht optimal umgesetzt zu sein.

    Zitat von Großvater

    Ergebnisse:
    Schlechtestes AHK Ergebnis bei 10 abwechselnd mit AU3 gestarteten Durchläufen: 156 ms
    Bestes AU3 Ergebnis bei 10 abwechselnd mit AHK gestarteten Durchläufen: 1512 ms


    Hab mir deswegen auch nochmal AutoHotkey besorgt um das ganze nachzuvollziehen.
    Hab die Zeitmessung etwas umgebaut so dass die Timer-Fehler gesenkt werden und folgendes sind nun meine Ergebnisse (auf nem Netbook):

    Ergebnisse Zeitvergleich Au3-AHK
    Code
    Not Case-Sensitive
    	AHK: 	2,68ms
    	AU3:	33,69ms
    
    Case-Sensitive: 
    	AHK:	0,96ms
    	AU3:	1,45ms


    Die Case-Sensitive-Aufrufe wurden bei Au3-StringInStr mit dem 3.Parameter=2 gemacht.
    Die Funktionen wurden dabei 10.000x bzw. 1.000x aufgerufen um Streuungen auszugleichen.
    Diese Ergebnisse scheinen deine Vermutung, dass die StringInStr-Funktion nicht optimal umgesetzt wurde, zu bestätigen.
    Wir können das sogar weiter eingrenzen:
    Die Implementierung der Case-InSensitive Methode ist ziemlich langsam implementiert.
    Sobald das ganze nicht Case-Sensitive ist sind die Ergebnisse zufriedenstellend.
    Das AHK da immer noch schneller ist, ist bekannt und liegt ja am umfangreicheren Interpreter von Au3.
    Aber es liegen dann keine Welten mehr dazwischen.

    Wie im anderen Thread vorgeschlagen kannst du die Stringsuche auch in eine Dll auslagern wenn sie dermaßen zeitkritisch für dich ist oder die Au3-Entwickler mal darauf hinweisen ob sie sich die Implementierung der Groß und Kleinschreibung nicht nochmal anschauen sollten... ;)

  • Globale Variablen - besser vermeiden

    • AspirinJunkie
    • 31. Dezember 2010 um 18:43

    An der Aussage ändert sich auch nichts.
    Nur die hier vorgestellten Vorschläge um dies zu erreichen führen nicht zu diesem Ziel.

  • Globale Variablen - besser vermeiden

    • AspirinJunkie
    • 31. Dezember 2010 um 14:02
    Zitat von floschlo
    [autoit]

    Global $Var
    ;Das ist doch das selbe wie:
    $Var
    ;oder?????(solange das hier nicht in einer Funktion steht)

    [/autoit]


    Nicht ganz - es ist gleichbedeutend mit Dim $Var
    Und da wird kontextabhängig entschieden.
    Sobald man außerhalb einer Funktion Variablen deklariert ist es eigentlich Wurst als was sie deklariert werden - sie sind immer Global.
    Erst sobald sie innerhalb einer Funktion benutzt werden unterscheiden sie sich.
    Dabei ist nur bei Global und Local sicher was passiert - bei Dim entscheidet es sich ob es außerhalb eine globale Variable dieses Namens gibt:

    Spoiler anzeigen
    [autoit]

    Global $Test = 10

    [/autoit] [autoit][/autoit] [autoit]

    ConsoleWrite("Globale Variable $Test: " & $Test & @CRLF)
    TestLocal()
    ConsoleWrite("Globale Variable $Test nach Aufruf der Funktion Test(): " & $Test & @CRLF)
    TestDim()
    ConsoleWrite("Globale Variable $Test nach Aufruf der Funktion TestDim(): " & $Test & @CRLF)

    [/autoit] [autoit][/autoit] [autoit]

    Func TestLocal()
    Local $Test = 1
    ConsoleWrite("Lokale Variable $Test: " & $Test & @CRLF)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func TestDim()
    Dim $Test = 2
    ConsoleWrite("Lokale Variable $Test: " & $Test & @CRLF)
    EndFunc

    [/autoit]

    Daher ist der hier vorgestellte Workaround, freundlich ausgedrückt, Quatsch.
    Anstatt globale Variablen zu vermeiden kommt sogar noch eine weitere hinzu.
    Alle Variablen welche hier mit Enum deklariert werden (implizit: Dim Enum) bleiben global und man hat zusätzlich nun noch das Array.
    Warum das auch übersichtlicher sein soll ist mir dabei auch nicht klar da statt einfach den Variablennamen hinzuschreiben muss nun die gleiche Variable als Index eines Arrays eingesetzt werden.
    Also ich weiß nicht warum $aGui[$guiMain] übersichtlicher sein soll als $guiMain ?
    Auch die weiter unten vorgestellte Variable $myVar ist weiterhin global - da kann man noch so viel Local schreiben wie man will.
    Solange die Variable nicht in einer Funktion deklariert wird ist sie implizit global.

    Also zusammenfassend: Nimm Abstand von diesem "Workaround". Statt globale Variablen zu vermeiden kommen sogar zusätzliche dazu und die Übersicht leidet auch darunter.

  • Schittpunkt von Kreis und Grade

    • AspirinJunkie
    • 30. Dezember 2010 um 17:17
    Zitat von Andy

    Lässt den Fall m=unendlich => Gerade parallel zur y-Achse einfach wegfallen ^^


    Wenn du es hinbekommst diesen Fall in der analytischen Form y=mx+n numerisch (!) auszudrücken kannst du diesen Fall auch mit meiner Funktion behandeln.... ;)
    Ernsthaft: Meine Eingabeparameter basieren auf der Linearen Funktionsform (y=mx+n). Dort gibt es den Fall das m = unendlich ist nicht da in dem Fall einem x mehrere Funktionswerte zugewiesen werden was der Definition einer Funktion widerspricht.
    Bei dir jedoch ist dieser Fall möglich da du ja als Parameter die 2-Punkt-Form verwendest.
    Also brauch ich den Fall gar nicht abfangen da er durch die Auswahl meiner Parameter gar nicht auftreten kann :P

    Zitat von Andy

    Aber dein udf-Header ist wirklich viel schöner als meiner

    Hab ich mit >>DescribeIt<< von Seuobou (oder so ähnlich - komme mit der Vokalfolge nicht klar ;) ) gemacht.
    Schönes Tool

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™