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

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 17. November 2023 um 08:42

    Cool
    Das ist für mich das bisher eindrücklichste Beispiel was dieses "Konzept" alles für bizarre Seiteneffekte hervorruft.

    Langsam reift in mir der grobe Gedanke, wenn die AutoIt Devs sich in der Doku nicht festlegen wollen und dennoch weiter stur die Zahlenwerte ignorieren, dann muss diese Funktionalität eben evtl. durch eine UDF gewährleistet werden.
    Allein die Existenz einer solchen UDF würde den einen oder anderen darauf stoßen, dass hier ein Detail existiert, welches bisher nicht adäquat behandelt wurde.

    Gerade die fancy Gleitkommadarstellung in Hex wie in Python reizt mich schon die mal umzusetzen (auch wenn ich mir nicht wirklich vorstellen kann, dass das mal gebraucht wird).

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 17. November 2023 um 07:32

    Das ist wirklich eine gute Frage.

    Spontan hätte ich gesagt, das was meine _printHex() von weiter oben zurückgibt.

    Aber von der Funktionsbeschreibung her ist es dann doch nicht so eindeutig.


    Eigentlich fehlt es noch an der eindeutigen Beschreibung.
    Es wird in der Doku direkt auf Int und Binary abgestellt.
    Von daher wäre die Bitfolge dann doch was man eher erwarten würde.

    Ja du hast Recht - hier ist die Nummer nicht so klar.

    Andere Programmiersprachen sagen hingegen klar, dass die Funktion nur für Zahlenwerte gedacht ist und entsprechend auch die Zahlenwerte zurückgibt.

    So gibt z.B. ein hex(-14) in Python -0xe zurück.
    Die ziehen`s aber auch komplett durch und machen auch bei Gleitkommazahlen aus z.b. float.hex(-2.75) ein -0x1.6000000000000p+1.

    Also man kann es nicht eindeutig ableiten, da die Doku hierzu sich nicht hinreichend festlegt was zurückgegeben werden soll.

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 16. November 2023 um 18:25
    Zitat von Velted

    Eins habe ich noch vergessen:
    AutoIt MsgBox(0, "", Hex(-14))

    liefert zur Zeit FFFFFFF2. Das müsste dann auch angepasst werden.

    Stimmt auffallend.
    Dort ist die gleiche Vermischung aus Wert und Kodierung.

    Zitat von Velted

    Solange die Entwickler anderer Meinung bleiben, ist es sowieso egal.

    Genauso wird es kommen - entsprechende Erfahrung hierzu liegt reichlich vor.

    Zitat von Velted

    Die Konsequenz wäre auch für mich, "Hexadezimalzahlen" mit 8 Stellen und einem Wert >= 8 in der führenden Stelle immer als Int64 zu behandeln.

    Guter Vorschlag. Auf die Art bleibt es beim Interpreter weiterhin performant. :thumbup:

    Aber wird ja wie gesagt eh nicht umgesetzt.
    Die Alternative wäre hingegen in der Doku zu vermerken, dass die Hexnotation nicht für Zahlenwerte genommen wird sondern nur für Bitfolgen.

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 15. November 2023 um 23:16

    Du verlinkst einen Wikipedia-Artikel in dem 15x der Begriff "Hexadezimalzahl" verwendet wird - aber selbst behauptest du, dass es diese gar nicht gibt - soso.

    Man kann Zahlen in Systemen mit jeder beliebigen Basis verwenden.

    Das Dezimalsystem ist kein besonderes System sondern einfach nur das an was wir uns gewöhnt haben.

    Alle Mechanismen von Zahlensystemen lassen sich auf alle Basen gleich anwenden.
    Daher die Gegenfrage: Warum soll ausgerechnet das Dezimalsystem ganz anders behandelt werden als die anderen Systeme?

    Zumal auch das Dezimalsystem am Ende nur die Interfaceschicht darstellt, da die Kodierung eh ausschließlich im Binärsystem passiert.

    Letzter Versuch es anschaulich zu machen:

    AutoIt
    $dZahl = -10
    
    ConsoleWrite("Zahlenwert: " & _printHex($dZahl) & @CRLF)
    ConsoleWrite(StringFormat("Zahlenkodierung Int32: %s\n", Binary($dZahl)))
    ConsoleWrite(StringFormat("Zahlenkodierung Int64: %s\n", Binary(Number($dZahl,2))))
    
    
    Func _printHex($dNumber)
        ; printf (StringFormat) kann nur unsigned hex
        Return StringFormat("%s%#X", $dNumber < 0 ? "-" : "", $dNumber < 0 ? -$dNumber : $dNumber)
    EndFunc
    Alles anzeigen

    Und die Frage warum er das tun sollte oder nicht ist auch gar nicht relevant. Es geht um das dokumentierte Verhalten. Und davon weicht AutoIt immer noch ab - Punkt.
    Und nochmal: Warum soll es ausgerechnet das erwartbare logische Verhalten in AutoIt sein, wenn jede andere Sprache es genau so macht wie von mir beschrieben?

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 15. November 2023 um 19:10
    Zitat von Velted

    Ich weiß nicht, wie Du darauf kommst.

    Du hast immer noch nicht die Trennung verinnerlicht. Daher zitierst du einen Textfetzen, der den Anwendungsfall abdeckt den ich oben als zweiten Anwendungsfall für das Hexadezimalsystem bereits beschrieben habe - die textliche Darstellung von Bitfolgen.
    Es geht hier aber eben an der Stelle der Variablendefinition genau nicht um die Repräsentation von Bitfolgen sondern von Zahlenwerten.
    Dass die binäre Entsprechung des Zahlenwertes so in den Speicher geklatscht wird, ist ja eben der Fehler um den es geht.

    Zitat von Velted

    Die Hexwerte entsprechen den Bitfolgen im Speicher, nur die Reihenfolge der Bytes wird bei x86-Systemen intern gedreht.

    Das ist ja genau der Fehler. Es werden stur die Binärstellen der Zahl genommen und 1 zu 1 in Bits gepresst.
    Dabei wird aber ignoriert, dass die Bits in einem Speicherbereich liegen wo die Zahlen anders kodiert werden müssen.
    Bleiben wir doch bei Wikipedia und rechnen mal manuell: >>Umwandlung ins Dezimalsystem<<
    Wir nehmen die Zahl FFFFFFF216 und konvertieren sie nach diesem Schema ins Dezimalsystem. Was erhalten wir mit der Rechnung? Genau: 214748364810
    Komisch - nichts mit -14 oder sowas?
    Nun ist es aber so, dass die Zahl FFFFFFF216 und die Zahl 214748364810 exakt die gleiche Binärfolge haben.
    Wenn man dies also in Bits überführt, müsste bei einer Variablendefinition mit 2147483648 ergo auch -14 herauskommen, da wie gesagt exakt die gleiche Binärfolge da ist.
    Tut es aber nicht - warum? Weil die Devs dort bisschen mehr Sorgfalt mit den Wertebereichsabfragen für die Zahlenkodierung haben walten lassen.
    Und genau das ist das Versäumnis um das es hier geht.

    Es wird nicht der Zahlenwert beachtet sondern stur die Bitfolge.
    Also genau die Trennung von der ich die ganze Zeit schon rede.

    Wir könnten gerne diskutieren wenn in der AutoIt Hilfe stehen würde: Zahlen werden im Dezimalsystem notiert und Bitfolgen in hexadezimaler Notation.
    Stattdessen steht dort klipp und klar:

    Zitat

    Integers (whole numbers) can also be represented in hexadecimal notation by preceding the integer with 0x: e.g. 0x409 or 0x4fff.

    Ab dem Punkt verbietet es sich hexadezimale Notation und Dezimalnotation unterschiedlich zu behandeln.

    Und wie gesagt: Alle anderen dynamisch typisierenden Sprachen verwenden eben den Zahlenwert und klar nicht die Bitfolgenrepräsentation.
    Dort erhält man bei einer Variablendefinition mit 0xFFFFFFF2 als Wert für diese Zahl den korrekten Wert 2147483648 und eben nicht wie bei AutoIt -14.
    Also was macht AutoIt hier richtig was alle anderen falsch machen?

    Müssen wir jetzt ein Bug-Ticket bei Python, Javascript Ruby & Co. aufmachen weil die dort alle zu dämlich sind?

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 15. November 2023 um 15:33
    Zitat von Velted

    Doch, genau das ist ja das Problem.

    Für eine Folge von 32 Bits (0 .. 31) im Speicher gibt es nicht nur einen möglichen Wert, wenn die Bitstelle 31 gesetzt ist.

    Also immer noch nicht den Unterschied verinnerlicht.
    Die Hexadezimaldarstellung hat noch nichts - überhaupt nichts - mit Bits zu tun.

    Es ist einfach nur eine Form den Wert einer Zahl mit Zeichen (in dem Fall die Zeichen 0-F) darzustellen.

    Sie unterscheidet sich nicht von der Dezimaldarstellung oder den römischen Zahlen oder sonstwelchen Repräsentationen.

    Und das wichtigste hierbei ist: Es ist definiert wie ein bestimmter Zahlenwert in diesem System abgebildet wird.
    Eine Zahl im Hexadezimalsystem mit der Darstellung 0x8000000016 ist immer und ausschließlich der Zahlenwert 214748364810.

    Diesen Raum verlässt man in dem Moment wo man anfängt von Bits zu reden.
    Denn dann befinden wir uns in einer ganz anderen Ebene: der der Zahlenkodierung im Speicher.

    Es gibt im Hexadezimalsystem keine Vorzeichenbits - die gibt es nur in der speziellen Art und Weise der Zahlenkodierung nach ISO/IEC 10967.

    Der Umstand, dass hier alles durcheinander gewürfelt wird obwohl es klar abzugrenzende Gebiete sind, hängt primär damit zusammen, dass wir es auch in AutoIt gewohnt sind Bitfolgen hexadezimal zu notieren.
    Bei der Variablendefinition wird aber eben keine Bitfolge zugewiesen (das würde man nämlich stattdessen per Binary("0x80000000") machen) sondern es werden Zahlenwerte übergeben.

    So steht es in der Hilfe und genauso handhabt es AutoIt auch wenn man das Dezimalsystem verwendet.

    Nun sieht aber blöderweise die Binärfolge 0x80000000 genau gleich aus wie der Zahlenwert 0x8000000016.
    Beide definieren aber etwas gänzlich anderes.

    Und das ist es was die Verwirrung auslöst.
    Auch wenn beide Dinge gleich dargestellt werden - nämlich durch eine hexadezimale Entsprechung - gibt das eine eine Bitfolge im Speicher an, welche erst noch entsprechend interpretiert werden muss und das andere eine ganz normale Zahl wie man sie mit Zettel und Stift auch schreiben kann.

    Vielleicht wird dies etwas deutlicher wenn man es mal bildlich gegenüber stellt:

    AsInt32(Binary(0xFFFFFFF2)) = -0xE16

    Diese doppelte Verwendung des Hexadezimalsystems - einmal als Zahlenwertdefinition und einmal als Abbildung einer Bitfolge - führt dazu, dass dieses fälschlicherweise anders behandelt wird als die dezimale Darstellung.

    Machen wir es mal an einem Beispiel - folgende 3 Zahlenwerte sind alle gleich:

    FFFFFFF216 = 214748364810 = 111111111111111111111111111100102

    Wir sehen daran: Beide Zahlenwerte, sowohl mit der Basis 16 als auch der Basis 10 stellen die gleiche Binärzahl dar.
    Im UInt-System kann man diese Binärstellen direkt in Bits übersetzen.

    Und beide passen aufgrund des Vorzeichenbits nicht 1 zu 1 in ein Int32.

    Dennoch behandelt AutoIt die Dezimaldarstellung korrekt als Zahlenwert und verwendet ein Int64 für diese, während es die Hexadezimalzahl als Bitfolge interpretiert und versucht dessen Binärrepräsentation in Bits eines Int32 zu quetschen.

    Dabei stellen beide ein und dieselbe Zahl dar und würden ergo auch gleich kodiert werden müssen.
    Werden sie aber eben genau nicht.

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 15. November 2023 um 12:55
    Zitat von Velted

    Es gibt also keine 'unsigned integers'.

    Weswegen ein 32-Bit-Integer in AutoIt nicht das korrekte Format ist um Zahlen ab 2147483648 zu kodieren.

    Ab diesem Zahlenwert muss ergo auf Int64 ausgewichen werden.

    Das haben die Blitzmerker von AutoIt auch korrekt erkannt aber nur wenn man die Zahl dezimal notiert.

    Nur wenn sie hexadezimal angegeben wird, wird dies unterlassen.

    Zitat von Velted

    Es steht außer Zweifel, dass sich der Wert 0xFFFFFFF2 in 4 Bytes speichern lässt.

    Nur dann wenn die Kodierung 8 binäre Zahlenwertstellen besitzt. Und das ist nur bei UInt32 der Fall. Die hexadezimale Darstellung der Zahl 4294967282 ist 0xFFFFFFF2. Die hexadezimale Darstellung der Zahl -14 ist hingegen -0xE.

    Erst wenn es an die Kodierung dieser Zahl geht und man sich für Int32 entscheidet, erst dann ist die Binärfolge hierfür im Speicher 0xFFFFFFF2.

    Die hexadezimale Zahl 0xFFFFFFF2 kann sich ergo nicht in 4 Byte speichern lassen, wenn man Int32 als Kodierung verwendet, da damit dieser Zahlenbereich nicht abgedeckt wird.

    Zitat von Velted

    Das Absurde daran ist für mich, dass für die o.a. 'magnitude' nicht nur der Wert sondern auch die Länge der Hexbytefolge berücksichtigt wird, sodass vorangestellte Nullen den Wertetyp (Int32 / Int64) beeinflussen.

    Das ist nicht wirklich absurd sondern das Kernproblem der Sache.

    Wenn wir Code der Form $A = 123 schreiben dann geht der Parser/Interpreter hin und sieht: Aha - eine Variablendefinition. Der zugewiesene Wert entspricht dem Stringmuster eines Zahlenwertes. Nun muss er noch überlegen, welche interne Kodierung er hierfür nimmt.

    Das macht er im Falle der Dezimaldarstellung ganz korrekt indem er schaut ob der Zahlenwert noch im Int32-Wertebereich liegt oder darüber:

    AutoIt
    $dA = 2147483647
    $dB = 2147483648
    
    ConsoleWrite(StringFormat("% 12s = %-14d (%s)\n% 12s = %-14s (%s)\n", _
        "2^31 - 1",$dA, VarGetType($dA), _
        "2^31",$dB, VarGetType($dB) _
    ))

    Das ist sinnvoll und korrekt.

    Wenn man aber stattdessen die ebenfalls zulässige hexadezimale Notation wählt, dann geht der Parser/Interpreter komplett anders vor.
    Um zu prüfen, welche Kodierung er verwenden soll schaut er überhaupt nicht mehr auf den Zahlenwert sondern einfach auf die Stringlänge der Zahl im Quellcode.
    Ist es größer 8 (bzw. 10) dann Int64, ist es kleiner 8 dann Int32.

    Der Zahlenwert wird hierbei komplett außer Acht gelassen und das führt zu dem hier beschriebenen Phänomen:

    AutoIt
    $dA = 0x7FFFFFFF
    $dB = 0x80000000
    $dC = 0x000000001
    
    ConsoleWrite(StringFormat("% 12s = %-14s (%s)\n% 12s = %-14s (%s)\n% 12s = %-14s (%s)\n", _
        "0x7FFFFFFF",$dA, VarGetType($dA), _
        "0x80000000",$dB, VarGetType($dB), _
        "0x000000001",$dC, VarGetType($dC) _
    ))

    Alles was die Devs ändern müssten, wäre auch bei Hexadezimalnotation auf den Zahlenwert selbst zu prüfen anstatt auf die unsinnige Länge.

    Will den hier niemand den Unterschied zwischen Zahlenwert und Kodierung verstehen?

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 15. November 2023 um 10:13

    Na eben das zeigt ja, dass das Verhalten eben genau nicht konsistent ist.

    Man kann eine Variable mit einer Zahl vorbelegen.

    Hierfür hat man ausdrücklich die Wahl (siehe Hilfe) zwischen der Dezimaldarstellung und der Hexadezimaldarstellung.

    Wichtig: Es geht um die mathematische Darstellung einer Zahl nur mit jeweils unterschiedlichen Zahlensystembasen.

    Diese Darstellung ist unabhängig davon wie diese Zahl mal binär kodiert wird - also ob als Int32, UInt32, Int64 etc.

    Und jeder korrekte Zahlensystemkonverter der Welt macht aus 0x80000000 eben 2147483648. Einfach weil das Hexadezimalsystem nun mal so funktioniert.

    Jetzt sagt aber AutoIt: Ne im Bereich 0x80000000 bis 0xFFFFFFFF interpretieren wir das was der User eingibt aber anders: Wir nehmen hier an, dass der User die binäre Kodierung einer Int32-Zahl meint anstatt dem Zahlenwert.

    Das ist aber eben genau nicht konsistent, da sie dann konsequenterweise bei Eingabe von Zahlen im Dezimalsystem genauso verfahren müssten damit es konsistent ist. Sprich: gibt der User Zahlen im Bereich 2147483648 bis 4294967295 ein, gehen wir davon aus, dass der stattdessen die binäre Repräsentation in Int32 meint.

    Denn: Die Zahlenwerte sind exakt die gleichen nur andere Basis ( (FFFFFFFF)16 = (4294967295)10 ).

    Dennoch werden die Zahlen unterschiedlich interpretiert. Und davon steht nichts in der Doku.

    Ich bleibe dabei dass es ein Bug ist.

    Möchte man negative Zahlen, dann nimmt man den Vorzeichenoperator und fängt nicht an Nullen abzuzählen.

    Andere dynamisch typisierende Sprachen wie z.b. Python, Javascript und Ruby machen das übrigens korrekt im Gegensatz zu AutoIt.

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 15. November 2023 um 08:35

    Ticket wurde abgelehnt.

    Grund: Es wird nicht der Unterschied zwischen der mathematischen Hexadezimaldarstellung von Zahlen und der konkreten Kodierung von Zahlen in bestimmten Datentypen verstanden.

  • Sehr große Zahlen addieren führt zum falschen Ergebnis

    • AspirinJunkie
    • 3. November 2023 um 11:26
    Zitat von Velted

    Ob das ein Bug ist, müssen Andere entscheiden.

    Entscheiden kann ich nicht. Aber argumentieren.
    Und ich halte dies für einen Bug denn:
    Auf Speicherebene gepresst in eine 4-Byte-Stelle und interpretiert als 32-Bit-Wert, würde diese Bitfolge tatsächlich als -14 interpretiert.

    Die Aufgabe der Hex-Notation für Zahlen in AutoIt ist jedoch eine andere: Eingabe von Zahlenwerten im Hexadezimalsystem. Und an diesem Punkt ist der Datentyp, in welchem das mal kodiert werden noch völlig egal.

    Daher ist es ein Abweichen vom zu erwartenden Verhalten und für mich daher klar ein Bug.

    Ich bereite das mal als Ticket für den Issue-Tracker auf.

    Zitat von Velted

    Eine andere Möglichkeit habe ich auf die Schnelle nicht gefunden.

    Das ist erst einmal die schnellste und cleverste Variante. Ich bin nur auf die explizite Variante gekommen: $b = Dec("FFFFFFF2", 2)

    Edit: >>Ticket<< erstellt.

  • #RequireAdmin Programm im Autostart startet nicht

    • AspirinJunkie
    • 1. November 2023 um 11:02

    Er gibt keine Rechte mit. Er definiert lediglich mit welchen Rechten das Programm aufzurufen ist. Also eine Information und kein Recht.

    Wenn man In den Kompatibilitätseinstellungen auf "mit Admin Rechten starten" setzt, dann legt man nur fest, dass diese Rechte benötigt werden um das Programm zu starten. Ob man dies dann über die UAC-Abfrage befriedigt oder indem man es direkt von einem Admin-Konto aus aufruft ist egal. Zumindest der reine User kann das Programm so dann nicht mehr aufrufen.

    Würde man damit tatsächlich "die Rechte mitgeben" könnte man sich über den Dreh aus normalen Benutzerechten Admin-Rechte zaubern. Mehr gibt es dazu nicht zu sagen.

    Und jetzt lohnt es sich mal anzuschauen wo der Autostart-Ordner liegt. Auflösung: Er liegt im Verzeichnis des Benutzers. Die Programme dort werden also in dessen Kontext aufgerufen. Und wenn man Programme aufruft von einem Nutzer der die benötigten Rechte nicht besitzt dann ist halt Schluss.

    Daher der Ausweg mit der Aufgabenplanung, da man dort einen anderen Kontext für das Programm definieren kann.

    Es ist weiterhin wie ich sagte: Der falsche Benutzerkontext

  • #RequireAdmin Programm im Autostart startet nicht

    • AspirinJunkie
    • 1. November 2023 um 08:43

    Es hat mit "Virenquatsch" (ich vermute es war der Defender gemeint) schlicht nichts zu tun.
    Es geht darum in welchem Rechtekontext das Programm ausgeführt wird.
    Es ist schlicht genauso "mal wieder typisch Linux" und "mal wieder typisch Mac OS".

  • #RequireAdmin Programm im Autostart startet nicht

    • AspirinJunkie
    • 31. Oktober 2023 um 22:37

    Ich vermute ebenso, dass die erforderlichen Adminrechte hier Probleme verursachen.

    Könnte also sein, dass du auf eine andere Methode für den Autostart ausweichen musst: In der Aufgabenplanung kannst du ebenso Programme beim anmelden starten lassen. Dort kannst du auch die Rechte festlegen mit denen das Programm laufen soll.

  • Zeilen -1

    • AspirinJunkie
    • 31. Oktober 2023 um 14:52
    Zitat von Velted

    Nur wenn das letzte Bisschen Performanz herausgekitzelt werden muss, muss man weitere Fragen stellen.

    Wenn man das Grundproblem adäquat lösen möchte muss man weitere Fragen stellen.
    Die Frage ist doch: WOFÜR muss man die Anzahl dieser Zeilen zählen?
    Wenn man das weiß kann man sich evtl. die ganze Zählerei komplett sparen.
    Wir doktorn immer an Nebenkriegsschauplätzen rum die in den allermeisten Fällen komplett vermieden werden können, wenn man stattdessen das Grundproblem sinnvoll angeht.
    Daher stelle ich IMMER diese Nachfragen.

  • Zeilen -1

    • AspirinJunkie
    • 31. Oktober 2023 um 11:24

    Es ist halt eine klassische Alina-Aufgabenstellung:
    Man erhält eine bizarr anmutende Aufgabenstellung wo man sich fragt: Wo in welchem Zusammenhang taucht so ein Konstrukt auf und warum genau soll die Fragestellung die Lösung zu irgendeinem Problem sein?

    Das eigentliche Krux: Niemand - bis auf Alina - weiß um die Hintergründe zur Fragestellung.
    Keiner kennt die Ausgangslage, was für Daten das sind, wo sie herkommen und was für ein tatsächliches Problem gelöst werden soll - nichts.
    Auch auf Nachfrage verbleibt es auf dieser Ebene.

    Da alle hier dennoch Spaß am Tüfteln haben, machen wir uns dennoch fleißig daran die "Aufgabenstellung" mit Lösungswegen zu bedenken.
    Ich bin mir aber sicher, dass wenn wir die jeweils tatsächlichen Hintergründe mal erfahren würden dann kämen wir auf was völlig anderes (mutmaßlich viel besseres) hinaus.

    So hingegen trifft jeder seine Mutmaßung um eine Lösung für etwas zu präsentieren, was wohl bereits im Ansatz ganz anders angegangen werden könnte.

    Wir wissen fast nichts und müssen daher primär auf Mutmaßungen zurückgreifen. Ich mache dies mal exemplarisch:

    • Aufgabe: Anzahl der Zeilen zählen, welche 192 Zeichen lang sind
    • Alle Zeilen sind 192 Zeichen lang, nur die letzte Zeile kann weniger Zeichen enthalten
    • Als Zeilenumbruch wird @CRLF verwendet
    • @CRLF wird auch an die letzte Zeile angehangen, mindestens wenn sie 192 Zeichen lang ist
    • Alle verwendetenZeichen werden als 1 Byte-kodiert (also kein ä in UTF-8 oder sowas)
    • Es gibt kein BOM

    Wenn man diese Mutmaßungen aufstellt, dann wäre die kürzeste und weitaus schnellste Methode diese: $iCount = Floor(FileGetSize("test.txt") / 194).
    Aber es kann auch genauso völlig am Thema vorbeigehen.
    Das schadet im Grunde nicht, da wir alle damit meist viel Spaß haben beim gegenseitig Lösungen um die Ohren hauen.
    Aber tatsächlich ist es dann doch ziemlich unbefriedigend derart im Nebel zu stochern und zu wissen, dass man für das eigentliche Problem wohl eine weitaus bessere Herangehensweise entwickeln könnte, wenn man das eigentliche Problem denn kennen würde.

  • Zeilen -1

    • AspirinJunkie
    • 29. Oktober 2023 um 14:14
    Zitat von water

    Performance ist halt bei Tweaky's erstem Vorschlag besser.

    Zitat von Tweaky

    Mit _FileReadToArray() einlesen und dann mit StringLen() jede Zeile zählen.

    Bei der Variante ist die Performance schlechter als in Alinas Variante - zumindest nach meinen Tests (einfach ausführen):

    AutoIt
    #include <String.au3>
    #include <File.au3>
    
    
    #region create test file
    Global $N_testfile = 12000 ; number of lines
    Global $hTestFile = FileOpen("test.txt", 2)
    
    For $i = 1 To $N_testfile
        FileWriteLine($hTestFile, _StringRepeat("o", Random(191,192,1)))
    Next
    FileClose($hTestFile)
    ##EndRegion 
    
    
    #region performance comparison
    Global Const $N = 1e2 ; number of measures
    Global $iT, $f_Overhead
    
    ConsoleWrite(@CRLF & "            name             time       result" & @CRLF & "----------------------------------------------" & @CRLF)
    
    ; determine the overhead of loop [and optional other stuff]
    $iT = TimerInit()
    For $i = 1 To $N
    Next
    $f_Overhead = TimerDiff($iT)
    
    
    ; variant with _FileReadToArray
    $iT = TimerInit()
    For $i = 1 To $N
        Local $aFile, $iCount = 0
        _FileReadToArray("test.txt", $aFile)
        For $j = 1 To $aFile[0]
            If StringLen($aFile[$j]) = 192 Then $iCount += 1
        Next
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s:\t%10.6f ms\t% 6d\n", "_FileReadToArray", ($iT-$f_Overhead) / $N, $iCount))
    
    ; variant with FileReadLine
    $iT = TimerInit()
    For $i = 1 To $N
        Local $hFile = FileOpen("test.txt", 0), $iCount = 0, $sLine
    
        While 1
            $sLine = FileReadLine($hFile)
            If @error = -1 Then ExitLoop
            If StringLen($sLine) = 192 Then $iCount += 1
        WEnd
        FileClose($hFile)
    
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s:\t%10.6f ms\t% 6d\n", "FileReadLine", ($iT-$f_Overhead) / $N, $iCount))
    
    ; variant with FileReadToArray
    $iT = TimerInit()
    For $i = 1 To $N
        Local $iCount = 0
        Local $aFile = FileReadToArray("test.txt")
        For $j = 0 To @extended - 1
            If StringLen($aFile[$j]) = 192 Then $iCount += 1
        Next
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s:\t%10.6f ms\t% 6d\n", "FileReadToArray", ($iT-$f_Overhead) / $N, $iCount))
    
    
    ; variant with StringRegExpReplace
    $iT = TimerInit()
    For $i = 1 To $N
        StringRegExpReplace(FileRead("test.txt"), '(?m)^.{192}$', '')
        Local $iCount = @extended
    Next
    $iT = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s:\t%10.6f ms\t% 6d\n\n", "StringRegExpReplace", ($iT-$f_Overhead) / $N, $iCount))
    
    ##EndRegion 
    Alles anzeigen

    Was mich aber viel mehr interessiert:

    Zitat von Alina

    Ich habe eine Textdatei in der sind pro Zeile 192 Zeichen gesetzt, nur die letzte, die kann 192 oder weniger Zeilen lang sein.

    Warum möchtest du die Längen aller anderen Zeilen ermitteln wenn du doch bereits weißt, dass sie immer 192 Zeichen lang sind?!? :/

    Du interessierst dich doch offensichtlich nur für die Länge der letzten Zeile.

    Hierfür muss man doch aber gar nicht die ganze Datei durchgehen:

    AutoIt
    $iLen = StringLen(FileReadLine("test.txt", -1))
    MsgBox(0, "", "Länge der letzten Zeile: " & $iLen)
  • SSH Passwort falsch

    • AspirinJunkie
    • 9. Oktober 2023 um 14:44

    Folgendes könnte irrelevant für dich sein aber eventuell hilft es dir weiter:

    Passwörter bei Automatisierungen mitzugeben ist bewusst bei nahezu allen ssh Implementierungen unterbunden. Ja genau das scheinst du ja auch gar nicht zu tun - Ich weiß.

    Die Alternative hierzu lautet komplexe Keys auszutauschen. Auf dem client werden diese dann auch meist noch gesichert abgelegt.

    Bei Verwendung dieser Methode kann man z.b. openssh sagen, dass derjenige, welcher sich mit diesem Key angemeldet hat nur ganz bestimmte Befehle ausführen darf.

    Da du ja nur von einem Befehl sprichst, wollte ich darauf hinweisen. So kann ein User der sich mit dem bestimmten Key anmeldet eben nur das ausführen und sonst nichts - unabhängig davon, welche Rechte dieser User auf dem Server sonst hat.

    Der Schlüsselaustausch ist auch easy - google einfach mal nach ssh-copy-id.

    Wie gesagt: kann am Thema von dir vorbei gehen, da ich den zu Anwendungsfall ja nicht genau kenne.

  • JSON-UDF

    • AspirinJunkie
    • 9. Oktober 2023 um 09:34

    Ich kann dir nicht helfen.

    Poste ein Minimalskript, welches diesen Fehler reproduziert, dann können wir schauen woran es liegt.

  • Variable in Array-Namen möglich?

    • AspirinJunkie
    • 2. Oktober 2023 um 16:50
    Zitat von kilo

    das Zauberwort lautet (in AutoIt) offensichtlich "dynamische Variablenamen".

    [...]

    das gleiche möchte mit einem Arraynamen erreichen $Array($x)

    soll für den Namen / Bezeichner $Array1 stehen

    Sollen wir das so deuten, dass du immer noch herumrätselt wie man dies bewerkstelligt obwohl ich dir gleich zwei mal den exakten Namen der Funktion (inklusive Verlinkung auf die Hilfe hierzu) die genau dafür existiert, benannt habe?

    Weil gelöst scheint es für dich ja noch nicht zu sein und konkrete Fragen zu Eval() hast du auch keine gestellt.

  • Variable in Array-Namen möglich?

    • AspirinJunkie
    • 2. Oktober 2023 um 14:38
    Zitat von kilo

    Ich weiß auch nicht, was "schon einige Schritte zuvor

    eher unelegant gelöst wurde"? Ich habe nur BEISPIEL-Schleifen For-Next erstellt, um meine Fragestellung zu verdeutlichen ...

    Deine Beschreibung lautete, dass alle Daten aus ein und der selben Textdatei stammen (die aus einer pdf extrahiert wurde).
    Die Daten stehen also bereits in einer direkten Beziehung zueinander.
    Diese Beziehung löst du erst einmal wieder auf und hast - entsprechend deiner Beschreibung - dann auf einmal 3 unabhängige Arrays.
    Und nun versuchst du - mit Hilfe von dynamischen Variablennamen(!) - diese Daten wieder in eine Beziehung zu bringen.

    Machen wir es kurz: So ziemlich jeder mit ein bisschen fortgeschrittener Programmiererfahrung sieht sofort, dass dies definitv nicht der Königsweg sein wird.

    Aber ich bin hier auch raus weil ich noch weniger Lust habe Leute zu ihrem Glück zu zwingen.

    Ich biete lediglich Hilfe an - und diese besteht nicht lediglich daraus stupide deren Probleme bei bizarren Zwischenproblemen zu lösen.

    Für Tipps und Hinweise prinzipiell effektivere, übersichtlichere und sicherere Programme zu schreiben bist du, wie du glasklar artikuliert hast, nicht offen.
    Das habe ich akzeptiert und entsprechende User nerve ich dann auch nicht mehr mit Tipps.

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™