Aber sobald ich eine falsche Ip eintippe die nicht vorhanden ist, braucht mein Script sehr lange bist das Kästchen rot wird.
Sehr lange = 4s?
Das wäre der standardmäßige timeout für die Ping-Funktion.
Aber sobald ich eine falsche Ip eintippe die nicht vorhanden ist, braucht mein Script sehr lange bist das Kästchen rot wird.
Sehr lange = 4s?
Das wäre der standardmäßige timeout für die Ping-Funktion.
Ich habe früher alles auf meinem alten 15" Thinkpad gemacht.
Seit ca. 2 Jahren bin ich quasi komplett auf ein Surface 4 Pro (12,3") umgestiegen und mache alles damit, obwohl ich weiter mein Thinkpad nehmen könnte.
Von der Displaygröße ist es ok, da die Auflösung ziemlich hoch ist (2.736 × 1.824 Pixel).
Drunter würde ich mit der Displaygröße aber nicht mehr gehen.
Sprich: Ja ich kann da super programmieren drauf und es ist vor allem sehr portabel.
Aber: Die Anstecktastatur ist nur dann dein Freund, wenn man einen Tisch hat (in der Bahn z.B. prima durch das Umklapptablett am Sitz).
Dann kann ich auch super tippen obwohl ich von einer Thinkpadtastatur verwöhnt bin.
Auf dem Schoß jedoch ist es überhaupt nicht schön.
Hier wäre ein Notebook in entsprechender Größe mit festen Scharnieren die weitaus bessere Wahl.
Was du dir aus dem Kopf schlagen solltest: Reine Touchbedienung.
Ich hab mehrmals Anläufe hierzu genommen und das Surfache sollte ja quasi das Vorzeigeprodukt für die Touchbedienung unter Windows sein aber ich muss dennoch das Fazit ziehen:
Windows ist für Touch schlicht nicht hinreichend optimiert.
Insbesondere wenn man, wie ich, viel mit Shortcuts arbeitet, steigt das Wutlevel exponentiell an, sobald man mit Touch arbeiten muss.
Da sind die anderen Betriebssysteme schlicht weiter meiner Meinung nach.
Tja und wenn ich dann höre, dass du im Auto programmieren willst, dann würde ich dir eher zu einem schlanken Netbook oder convertible raten.
Denn so kannst du auch mit einer vernünftigen Tastatur auf dem Schoß arbeiten.
Inhaltlich ist es schon so würde ich sagen (falls ich gemeint sein sollte)
Ich überlege halt ob man das kürzen und vereinfachen kann indem man einfach sagt, dass das HKLM64 nur für x86-Programme Relevanz hat.
Dann umgeht man evtl. die längere Auflistung.
Ich traue dir da aber mehr Fähigkeiten für eine verständliche Ausformulierung zu als mir.
Von daher würde ich mich eher an deine Vorstellungen halten.
Eine normale Msgbox wäre blockierend. Heißt: Das Skript würde während dieser Anzeige nicht weitersuchen.
Es gibt durchaus nichtblockierende Varianten aber die müsste man dann halt auch einzeln wegklicken.
Vielleicht wäre SplashTextOn() eher etwas für dich (Beispiel in der Hilfe hierzu ansehen wie man den Text aktualisieren kann).
Dort könnte man z.B. den jeweils aktuellen Ordner ausgeben.
Nein mir ist keine Funktionalität bekannt um per Direktzugriff die Werte zu ändern.
Ich stand bei meinerJSON-UDF vor genau der selben Problematik, weswegen ich daher extra eine Funktion hierfür geschrieben habe.
Das ganze sieht in dem Fall dann so aus:
Es geht um die 81 - nicht die 78.
Bei 81 ist es zweischneidig, da diese selbst eine Quadratzahl ist.
Es muss hier daher definiert werden ob die aktuelle oder die nächsthöhere Quadratzahl zurückgegeben werden soll.
Und BugFix´Skript löst es durch die tatsächlich nächsthöhere Zahl - die 10.
Ich habe eben mal in dem FileWrite Abschnitt den Parameter in '";"' geändert. Hochkommas sind da.
FileWrite("merged.csv", _Array2CSV($aMerged, Default, '";"'))
Ne das wird so nicht funktionieren. Zumindest nicht, wenn du Werte mit Zeilenumbrüchen oder Anführungszeichen hast.
Und in deinem Beispiel war dies so.
Denn auf die Art hättest du doppelte Anführungszeichen am Wertanfang und das wäre nicht csv-konform.
Im Grunde ist es nicht viel Code um deinen String wie von dir gewollt zusammenzubauen
; 2D-Array in String konvertieren
Global $sOut = ""
For $i = 0 To UBound($aMerged) - 1
; 1. Spalte gesondert einfügen (sonst müsste man das letzte Semikolon am Ende entfernen)
$sOut &= '"' & StringReplace($aMerged[$i][0], '"', '""') & '"'
; Die restlichen Spaltenwerte schreiben und dabei darauf achten, dass Anführungszeichen escaped werden
For $j = 1 To UBound($aMerged, 2) - 1
$sOut &= ';"' & StringReplace($aMerged[$i][$j], '"', '""') & '"'
Next
$sOut &= @CRLF
Next
; den letzten Zeilenumbruch entfernen
$sOut = StringTrimRight($sOut, 2)
; in Datei schreiben
FileDelete("merged.csv")
FileWrite("merged.csv", $sOut)
Alles anzeigen
SOLVE-SMART
Schöne und womöglich bessere Lösung, da einfacher zu verstehen anstatt sich wie bei mir durch alle Spalten einzeln kämpfen zu müssen. ![]()
Eins ist mir noch aufgefallen. Bei einigen Datensätzen ist noch ein Hochkomma " im Merged drin.
Wie ich sagte, sind Zeilenumbrüchen innerhalb von Einzelwerten in csv nur dann erlaubt, wenn diese Werte in Hochkomma eingeschlossen werden.
Die Hochkomma müssen also zwangsläufig erscheinen wenn du Werte schreiben willst, welche Zeilenumbrüche enthalten.
Könnte man denn auch wieder die Texttrennzeichen "" mit in die Merge einfügen?
Nicht mit der _Array2CSV() bisher. Aktuell habe ich eine umfangreichere UDF in Arbeit, welche auch diese Funktionalitäten hier mit beinhaltet. Dort wird das dann mit drin sein als Switch.
Musst dir hierfür also was eigenes schreiben, was aber kein großes Problem ist, wenn du das 2D-Array schon vorliegen hast.
Bei deinen Dateien die du zuletzt hochgeladen hast stimmt etwas noch nicht.
In der einen Datei ist ein Header - in der anderen nicht.
Ich habe mich daher mal an die ursprünglichen @Tab-getrennten Daten gehalten und folgendes gebastelt:
#include "parseCSV.au3"
; Beide CSV-Dateien in 2D-Array einlesen
$aCSV1 = _parseCSV('results-0.csv', True, False, @TAB)
$aCSV2 = _parseCSV('results-1.csv', True, False, @TAB)
; Zeilen angleichen falls doch unterschiedlich
If UBound($aCSV2) < UBound($aCSV1) Then Redim $aCSV2[UBound($aCSV1)][UBound($aCSV2, 2)]
If UBound($aCSV1) < UBound($aCSV2) Then Redim $aCSV1[UBound($aCSV2)][UBound($aCSV1, 2)]
; Array für merged-Daten dimensionieren
Local $aMerged[UBound($aCSV1)][UBound($aCSV1, 2) + UBound($aCSV2, 2)]
; Daten von beiden CSV-Arrays in Merged-Array übertragen
; Zeilenweise durchgehen
For $i = 0 To UBound($aCSV1) - 1
; Erst die Daten vom 1. Array
For $j = 0 To UBound($aCSV1, 2) - 1
$aMerged[$i][$j] = $aCSV1[$i][$j]
Next
; Nun die Daten vom 2. Array
Local $iOffset = $j
For $j = 0 To UBound($aCSV2, 2) - 1
$aMerged[$i][$j+$iOffset] = $aCSV2[$i][$j]
Next
Next
; Kombinierte Daten wieder in eine CSV mit @Tab als Separator speichern^
FileDelete("merged.csv")
FileWrite("merged.csv", _Array2CSV($aMerged, Default, @TAB))
; Zum Schluss nochmal anzeigen
_ArrayDisplay($aMerged, "kombinierte CSVs", "1:", 64, "|", _ArrayToString(_ArrayExtract($aMerged,0,0)))
Alles anzeigen
Edit: Und wenn du deinen alten, rein zeilenbasierten Ansatz weiterverfolgen willst, könntest du das Einlesen der Datei folgendermaßen gestalten damit dir die Zeilenumbrüche in den Werten nicht mehr wehtun:
Zeilenumbrüche in Werten sind bei CSV erlaubt, wenn der Wert in Anführungszeichen steht.
_FileReadToArray() kann dies nicht (und behauptet ja auch nirgends das csv-Format zu unterstützen).
Daher gibt es spezielle Funktionen zum Einlesen von CSV-Daten, welche auch mit soetwas klarkommen:
>>CSV-UDF<<
Wenn ich im bereits lauffähigen Script mit "Run" arbeiten möchte, müßte ich also über eine Schleife die Anzahl der ZipAufrufe steuern. Über die Id des Prozesses könnte das bestimmt gehen.
Sehe ich das richtig ?
Exakt so!
Mal ein beispielhafter Grundaufbau hierfür:
; Die Parameter, welche abgearbeitet werden sollen
Global $aParams[] = [4,6,1,4,9,1,9,3,2,6,7,9,10,2,3,6,2,1,7,8,3,7,1,2]
; Anzahl parallel laufender Prozesse
; hierfür wird die Anzahl der CPU-Kerne verwendet (nur vom 1. Prozessor, falls mehrere verbaut wären)
Global Const $N = Int(ObjGet("winmgmts:\\localhost\root\CIMV2").ExecQuery("SELECT NumberOfCores FROM Win32_Processor", "WQL", 0).ItemIndex(0).NumberOfCores)
; Alle Prozess-IDs der laufenden Prozesse in einem Array:
Global $aPIDs[$N]
; Arbeite Jobs ab
Global $iNextParamIndex = 0, $bFertig, $i
Do
; Variable, mit deren Hilfe das Ende der Abarbeitung geprüft wird
$bFertig = True
; den nächsten freien Slot suchen, falls einer frei ist
For $i = 0 To Ubound($aPIDs) - 1
; Slot belegt - daher diesen überspringen
If ProcessExists($aPIDs[$i]) Then
$bFertig = False
ContinueLoop
EndIf
; keine weiteren abzuarbeitenden Dinge mehr (alle Parameter abgearbeitet)
If $iNextParamIndex >= UBound($aParams) Then ContinueLoop
; Prozess in diesem Slot starten
$aPIDs[$i] = _macheWasMitDenInputs($aParams[$iNextParamIndex])
$bFertig = False
; auf nächsten Abarbeitungsparameter setzen
$iNextParamIndex += 1
Next
; kleine Verschnaufpause für die CPU
Sleep(100)
; solange bis alle Prozesse abgearbeitet wurden
Until $bFertig
; eine Funktion welche was mit dem jeweiligen Input aus $aParams macht
; muss eine Prozess-ID zurückgeben!
Func _macheWasMitDenInputs($vInput)
Return Run(StringFormat( _
'"%s" /c timeout /t %d /nobreak', _
@ComSpec, $vInput _
))
EndFunc
Alles anzeigen
Es gibt eine ziemlich klare Ansage, dass keinerlei Featurerequests oder Bugreports zum Thema Maps zu stellen sind: Autoit documentation
Und das Thema dot Notation wird schon gleich mal ganz ausgespart in der Dokumentation.
Ich gebe einem Ticket welches nun ausgerechnet beide Tabuthemen verbindet daher eine Lebenszeit von unter einer Planck-Zeit.
Edit: Tja schau an - Tickets gibt es dazu also doch. Da scheint die klare Warnung ja doch nicht so klar gewesen zu sein
Keine Lösung - lediglich ein Workaround:
Nutzt hier jemand die Beta und kann sagen, ob das dort gefixed ist?
Mir ist keine Beta bekannt, welche neueren Datums wäre als die derzeitige Produktivversion 3.3.16.1
Es könnten also maximal nicht veröffentlichte Alphas sein wo nur ein paar wenige Zugriff haben. water könnte einer dieserjenigen sein.
Edit: Tja genauso war es dann wohl auch
Naja script-breaking wäre es ja nicht, da es die Funktion _StringSplit() bisher nicht gibt.
Ich persönlich würde die auch nicht zusammenmischen wollen, da die Trennung was nun gerade wirklich gemacht wird über den Funktionsnamen eher ersichtlich als über einen Parameter ganz hinten.
Aber das ist schlicht Geschmackssache.
Wenn sich jemand aus dem Code eine entsprechende _StringSplit() bauen möchte, kann er das ja machen - der Code ist ja keine Raketentechnik.
Es geht ja auch ausschließlich um eigenen Code, da wir eh keinen Einfluss auf die AutoIt-Funktionen selbst haben.
Von daher hat hier jeder alle Freiheiten.
1. Frage: Wo kommen diese Pfadangaben her? Du musst ja irgendwo definieren welche Ordner bearbeitet werden.
2.
Dazu nutze ich einen externen Packer über CLI (Command Line Interface) mit "RunWait"
Wenn es nur der Aufruf ist - warum dann RunWait und nicht Run()? Mit letzterem hättest du nämlich deine Parallelität.
3. Wenn hingegen noch hinterher mit AutoIt-Code da an den Ordner weitergearbeitet wird, dann müsstest du dies natürlich entsprechend behandeln.
Eine Möglichkeit wäre wie von dir vorgeschlagen, dass Skript aufzuteilen und die Unteraufgabe einer Ordnerbehandlung als eigenen Prozess auszuführen.
Dort musst du dich halt um die Übergabe der Pfadangaben kümmern und da würde ich dir raten den Weg der Aufrufparameter weiterzugehen. Als Austauschspeicher würden auch Dateien gehen oder direkt ein shared-Memory aber das wird dann zu aufwendig und unübersichtlich und da das Subprogramm ja lediglich die Pfade benötigt, kann man die auch ziemlich problemlos einfach dem Programm übergeben.
Eine weitere Möglichkeit wäre, das Skript in einen Master und einen Slave-Teil einzuteilen.
Ob das derzeit laufende Skript der Master oder ein Slave ist, kann man z.B. über _Singleton lösen oder über einen Aufrufparameter für die Slave-Teile.
Dann braucht man nicht 2 verschiedene Skripte.
Oder du arbeitest ganz normal mit einem einzigen Skript weiter aber rufst die zip.exe halt parallel auf wie oben beschrieben.
Dann lässt du eine Dauerschleife laufen, die für jede Prozess-ID der Run-Aufrufe prüft ob diese schon abgeschlossen wurden und falls ja, dann entsprechend die Restarbeiten hierzu auszuführen.
Wenn das alles Aufgaben sind die vom Kommandozeileninterpreter erledigt werden können (Programm aufrufen, Datei kopieren, Ordner löschen klingt für mich so), dann kannst du das auch alles in einen kombinierten Aufruf packen wobei die einzelnen Subbefehle per & verknüpft werden (von AutoIt aufgerufen musst du hierbei an das @ComSpec denken). Auf die Art kannst du von AutoIt per Run mehrere solche Jobs parallel starten.
Aber wie gesagt: Die Grundfrage für uns wäre eigentlich eher 1.: Wo kommen die Pfadangaben her.
Im Grunde ist das nix großes - daher keine extra UDF hierfür.
Worum geht es?: Mit StringRegExp können wir uns die Teile eines Strings zurückgeben, welche einem bestimmten Muster entsprechen. In anderen Sprachen gibt es jedoch noch einen weiteren Ansatz:
Dort kann man Strings anhand von Trennstrings trennen, deren Muster sich aus einem regulären Ausdruck ergibt.
Das kann je nach Anwendungsfall einfacher sein als sich ein Muster zu überlegen welches alles andere definiert.
Im Prinzip funktioniert es wie StringSplit - nur dass man anstatt einem Trennstring eben ein Trenn-Pattern angibt.
Hierfür dient nun folgende Funktion (kann sein dass soetwas schonmal ein anderer gemacht hat):
#include <Array.au3>
$sString = "Hello:world:foo://:bar"
$sPattern = ':(?!\/\/)'
$aSplit = _regex_split($sString, $sPattern)
_ArrayDisplay($aSplit)
; #FUNCTION# ====================================================================================================================
; Name ..........: _regex_split
; Description ...: separates a string of separators described by a regular expression.
; The separators are not part of the result strings.
; Syntax ........: _regex_split($sString, $sSplitPattern)
; Parameters ....: $sString - string, which should be split
; $sSplitPattern - regular expression which defines the separation pattern.
; Return values .: 1D-Array containing the substrings split based on the separators.
; Author ........: AspirinJunkie
; Modified ......: 2023-03-06
; Example .......: $aSplit = _regex_split("Hello:world:foo://:bar", ':(?!\/\/)')
; ===============================================================================================================================
Func _regex_split($sString, $sSplitPattern)
; map to be able to add elements dynamically
Local $mSubStrings[]
Local $aCut, $iOffset = 1, $iStart, $nLen
Do
; find next separator
$aCut = StringRegExp($sString, $sSplitPattern, 1, $iOffset)
If @error Then ExitLoop
$iStart = @extended
$nLen = StringLen($aCut[0])
; append substring to result map
MapAppend($mSubStrings, StringMid($sString, $iOffset, $iStart - $iOffset - $nLen))
$iOffset = $iStart + $nLen - 1
Until @error
; prepare the return array
Local $aRet[UBound($mSubStrings) + 1]
; transfer all values from the map to the array
For $i = 0 To UBound($mSubStrings) - 1
$aRet[$i] = $mSubStrings[$i]
Next
; don't forget the part after the last separator
$aRet[UBound($aRet) - 1] = StringTrimLeft($sString, $iStart - 1)
Return $aRet
EndFunc
Alles anzeigen
Edit:
Nach etwas Überlegen ist mir ein Ansatz eingefallen, welcher wohl in allen Belangen (Codegröße, Ausführungsgeschwindigkeit, Verständlichkeit) der obige Version überlegen ist.
Ich würde daher dazu raten eher diese Funktion zu verwenden:
#include <Array.au3>
$sString = "Hello:world:foo://:bar"
$sPattern = ':(?!\/\/)'
$aSplit = _regex_split($sString, $sPattern)
_ArrayDisplay($aSplit)
; #FUNCTION# ====================================================================================================================
; Name ..........: _regex_split
; Description ...: separates a string of separators described by a regular expression.
; The separators are not part of the result strings.
; Syntax ........: _regex_split($sString, $sSplitPattern)
; Parameters ....: $sString - string, which should be split
; $sSplitPattern - regular expression which defines the separation pattern.
; $dFlag - Flag for StringSplit()
; Return values .: 1D-Array containing the substrings split based on the separators.
; Author ........: AspirinJunkie
; Modified ......: 2023-03-23
; Example .......: $aSplit = _regex_split("Hello:world:foo://:bar", ':(?!\/\/)')
; ===============================================================================================================================
Func _regex_split($sString, Const $sSplitPattern, Const $dFlag = 3)
Return StringSplit( _
StringRegExpReplace($sString, $sSplitPattern, Chr(0)), _
Chr(0), $dFlag)
EndFunc
Alles anzeigen
Am besten ist es wohl, wenn du entsprechende Helfertools wie z.B. regex101.com verwendest.
Ich kenne die js-Funktion split in dem Zusammenhang nicht, vermute aber, dass die die Zeichen haben will an denen gematcht wird.
Hierfür wäre mein Vorschlag folgendes Pattern: :(?!\/\/)
Man kann es hingegen auch anders betrachten und anstatt am jeweiligen Match zu splitten einfach alles was nicht Trennzeichen ist matchen.
Hierfür könnte das Pattern dann so aussehen: (?:[^:]+|:(?=\/\/))+
Ich hatte keine Ahnung, dass das nur mit den Hex-Zahlen geht. Ich probierte es mit den DEZ zahlen und da kam nur Murks.
Natürlich geht das auch mit Dezimalzahlen.
Die hast du aber nicht genommen. Ich habe die Unicode-Codes der Zeichen angegeben.
Du hingegen hast die ASCII-Codes 124, 47, 45 und 92 verwendet.
Die dezimalen Unicode-Codes für diese Zeichen, welche so nicht im ASCII-Bereich existieren lauten hingegen 9474 (0x2502), 9585 (0x2571), 9472 (0x2500), 9586 (0x2572)
Du hast doch im Kommentar schon die richtigen Unicode-Nummern der Zeichen mit angegeben.
Nur im Code selbst verwendest du hingegen nur die Zeichen aus dem ANSI-Bereich.
Ändere mal deinen Switch-Teil folgendermaßen und verwende unten ChrW() anstatt Chr():