Zeichenfolge finden in einer Textdatei und 'kopieren' in eine Variable zur Weiterverwendung

ugt100

Hallo zusammen,

irgendwie drehe ich mich immer wieder im Kreis und komme nicht weiter.

Folgendes 'Problem' habe ich:

Ich habe ein Log File das mehrmals am Tag geschrieben wird und immer unterschiedlich groß ist und auch unterschiedliche Inhalte hat.

Die letzten Zeichen des FIles liegen immer in der Form s.u. vor.

(Anmerkung: ‚¬|- diese Zeichenfolge kommt oft vor, sodass suchen nach dieser nicht das gewünschte Ergebnis bringt)

----> "‚¬|vX.YY.ZZZZ" <-----

Aus diesem 'String' benötige ich jetzt nur den Teil "X.YY".

Meine Frage ist es, was man wirklich Schlaues tun kann um das Ergebnis zu erhalten

z.B: Suche nach String ‚¬|v?(wildcard).?(wildcard)?(wildcard)

(natürlich kann ich das File einlesen und mich dann durchhangeln. Das ist aber ziemlich langsam - befürchte ich)

Danke schon mal im voraus

**alpines**

Dafür kannst du reguläre Ausdrücke verwenden, bspw. mit StringRegExp.

Du übergibst ein Muster wonach gesucht werden soll und es werden dir die entsprechenden Funde zurückgegeben.

Hier mal ein kleines Beispiel: https://regex101.com/r/zFIXiC/1/

Nichtsdestotrotz wird hier die gesamte Datei durchgescannt werden, in welchem Größenbereich bewegst du dich denn, dass du dir Sorgen darüber machst?

Wenn sich der Teil den du suchst immer am Ende befindet (das konnte ich aus deiner Beschreibung nicht ganz nachvollziehen), dann kannst du auch einfach die Datei mit FileOpen öffnen, mit FileSetPos an die entsprechende Position springen und dort einfach auslesen, das geht rasend schnell.

Sonderbaar

sind denn im String in den Werten X.YY zahlen oder Buchstaben? Oder beides?

ugt100

Hallo zusammen,

danke für die schnellen Antworten.

zu den Rückfragen:

Zeichen Position: ja das sind immer die letzten 13 Zeichen des Files

Grössenordnung des jeweiligen Log Files: die Files sing zw. 4 und 7 GB gross

Art der Zeichen: es sind immer Zahlen (X, YY)

Das mit mit 'FileSetPos an die entsprechende Position springen' klingt gut - das schaue ich mir dann mal genauer an

Gruss

ugt100

Sonderbaar

Somit kriegste schonmal deinen gewünschten Wert... vorausgesetzt X ist immer 1 stellig und YY 2 stellig

ürde man ein weiteres X vor dem . setzen, würde dieser Pattern trotzdem nur X.YY bringen. Hier gibt es echt spitzenmäßige Pattern-Bauer die es besser könnten...

Spoiler anzeigen

Code

#include <array.au3>
$string = "‚¬|vX.YY.ZZZZ"

$test = StringRegExp($string, "[a-zA-Z0-9]{1}.[a-zA-Z0-9]{2}", 2)
_ArrayDisplay($test)

**Musashi**

Zitat von alpines

in welchem Größenbereich bewegst du dich denn, dass du dir Sorgen darüber machst?

Zitat von Sonderbaar

sind denn im String in den Werten X.YY zahlen oder Buchstaben? Oder beides?

Hallo ugt100 !

Erstelle und poste doch bitte einfach ein Logfile. Vertrauliche Angaben (sofern vorhanden) kannst Du mit xxx übertippen - es geht nur um den Aufbau. Wie Du an den o.a. Fragen erkennst, ist es für Helfer unnötig mühsam und zeitaufwändig, wenn man erst mal 10 Beiträge lang herumraten, bzw. eine Testdatei selbst erstellen muss.

Edit : 4-7 GB . Dann mache einen Dummy bis max. 1 MB

Gruß Musashi

**Bitnugger**

Ich denke mal, so meint er das...

Code

#Include <Array.au3>

Local $sLogFile = _
    'BlablaBla' & @CRLF & _
    '----> "‚¬|vX.YY.ZZZZ" <-----' & @CRLF & _
    'BlablaBla' & @CRLF & _
    '----> "‚¬|vX1.Y1Y1.Z1Z1Z1Z1" <-----' & @CRLF & _
    'BlablaBla' & @CRLF & _
    '----> "‚¬|vX2.Y2Y2.Z2Z2Z2Z2" <-----' & @CRLF

Local $aRx = StringRegExp($sLogFile, '----> "‚¬\|v(.+\..+)\..+', 3)
_ArrayDisplay($aRx, '$aRx')

; Ergebnis:
; Row  |Col 0
; Row 0|X.YY
; Row 1|X1.Y1Y1
; Row 2|X2.Y2Y2

Alles anzeigen

**alpines**

Wenn es wirklich immer die letzten 13 Zeichen sind dann sollte man hier komplett auf StringRegExp verzichten, FileOpen + FileSetPos müsste hier einfach am schnellsten sein.

**Musashi**

Zitat von ugt100

Die letzten Zeichen des FIles liegen immer in der Form s.u. vor.

(Anmerkung: ‚¬|- diese Zeichenfolge kommt oft vor, sodass suchen nach dieser nicht das gewünschte Ergebnis bringt)

Diese Aussage ist für mich zumindest missverständlich.

"Immer nur (einmal) am Ende" ODER "Die Zeichenfolge kommt oft vor" ?

EDIT :

Zitat von ugt100

Zeichen Position: ja das sind immer die letzten 13 Zeichen des Files

Ok, das wäre gelöst !

Zu : StringRegExp($sLogFile ...

Liegt die max. Länge eines Strings nicht bei 2,147,483,647 ?

siehe : https://www.autoitscript.com/autoit3/docs/a…itsDefaults.htm

Gruß Musashi

**alpines**

Zitat von Musashi

Zu : StringRegExp($sLogFile ...

Liegt die max. Länge eines Strings nicht bei 2,147,483,647 ?

siehe : https://www.autoitscript.com/autoit3/docs/a…itsDefaults.htm

Das ist kein Problem, angenommen die Zeichenkette könnte mittendrin auftauchen, kann man das ganze so lösen.

Das ist jetzt kein wirklich guter Code, ich hab den so aus dem Kopf im Browser getippt aber die Idee kommt denke ich rüber.

Datei öffnen, max. Länge einlesen und parsen, wenn nichts gefunden wird und wir nicht am Ende sind, -13 Zeichen zurückspringen (falls es wir genau in der Mitte abgeschnitten haben) und neuen Teil parsen.

Code

Local $hFile = FileOpen("log.txt")

Do
    FileSetPos($hFile, -13, 1)

    $sCurrent = FileRead($hFile, 2^31 - 1)
    $iError = @error

    $aRegEx = StringRegExp($sCurrent, "pattern", 3)
Until UBound($aRegEx) or StringLen($sCurrent) = 13 or $iError = -1 ; -1 = EOF reached

If UBound($aRegEx) Then
    ;gefunden
Else
    ;nicht gefunden
EndIf

Alles anzeigen

**Bitnugger**

Zitat von Musashi

Liegt die max. Länge eines Strings nicht bei 2,147,483,647 ?

Ja, das Logfile dürfte also nicht größer als 1, 99 GB sein...

So, wie alpines es gezeigt hat, ist es quasi egal, wie groß das Logfile ist - wenn es aber nicht mehr als 16777216 Zeilen hat, geht es auch so:

Code

#Include <Debug.au3>

Local $sLogFileName = 'm:\Logfile.txt', $sLogFile = _
    'BlablaBla' & @CRLF & _
    '----> "‚¬|vX.YY.ZZZZ" <-----' & @CRLF & _
    'BlablaBla' & @CRLF & _
    '----> "‚¬|vX1.Y1Y1.Z1Z1Z1Z1" <-----' & @CRLF & _
    'BlablaBla' & @CRLF & _
    '----> "‚¬|vX2.Y2Y2.Z2Z2Z2Z2" <-----' & @CRLF

If Not FileExists($sLogFileName) Then FileWrite($sLogFileName, $sLogFile)

Local $aLogFile = FileReadToArray($sLogFileName)
Local $aMatch = _ArrayFindAll($aLogFile, '----> "‚¬\|v(.+\..+)\..+', 0, 0, 0, 3)
If UBound($aMatch) Then
    _ArrayColInsert($aMatch, 1)
    For $i = 0 To UBound($aMatch) -1 Step 1
        $aMatch[$i][1] = StringMid($aLogFile[$aMatch[$i][0]], 12 ,4)
    Next
    _DebugArrayDisplay($aMatch, '$aMatch', '', 0, Default, 'Zeilennummer|Match')
    ; Ergebnis:
    ; Row  |Zeilennummer|Match
    ; Row 0|1           |X.YY
    ; Row 1|3           |X1.Y
    ; Row 2|5           |X2.Y
EndIf

Alles anzeigen

**Musashi**

Hallo ugt100 !

Zitat von alpines

dann kannst du auch einfach die Datei mit FileOpen öffnen, mit FileSetPos an die entsprechende Position springen und dort einfach auslesen, das geht rasend schnell.

Zitat von ugt100

Das mit mit 'FileSetPos an die entsprechende Position springen' klingt gut - das schaue ich mir dann mal genauer an

Ich habe zum Testen eine große Textdatei generiert :

Dateigröße = 10,2 GB

Anzahl der Zeilen = 10.485.761 (jeweilige Länge 1000 Zeichen)

Dann wie alpines vorgeschlagen hat :

- die Datei mit FileOpen($hFileOpen) geöffnet

- die Position gesetzt ( -13 Zeichen vor dem Dateiende) mit : FileSetPos($hFileOpen, -13, $FILE_END)

- und mit FileRead($hFileOpen) die letzten 13 Zeichen gelesen und korrekt erhalten

Das geht wirklich rasend schnell (im Millisekunden-Bereich) !

Gruß Musashi

**Bitnugger**

Wenn nur die letzte Zeile ausgewertet werden soll, dann geht es auch so:

Code

Local $sLogFileName = 'Logfile.txt', $sLogFile = _
    'BlablaBla' & @CRLF & _
    '----> "‚¬|vX.YY.ZZZZ" <-----' & @CRLF
If Not FileExists($sLogFileName) Then FileWrite($sLogFileName, $sLogFile)

Local $sMatch = StringMid(FileReadLine($sLogFileName, -1), 12, 4)
ConsoleWrite('$sMatch = ' & $sMatch & @CRLF)

**Musashi**

Hi Bitnugger !

Zitat von Bitnugger

Wenn nur die letzte Zeile ausgewertet werden soll, dann geht es auch so:

Deine Variante dauert bei großen Dateien aber deutlich länger. Probiere mal meinen Testcode.

- Beim ersten Mal muss _GenerateBigFile() einkommentiert werden, damit das File angelegt wird.

- _ReadFile() ist die Variante mit FileSetPos.

- _ReadFile2() ist deine Variante mit FileReadLine

Edit :

Ach ja, StringMid habe ich weggelassen, aber das hat keinen Einfluss auf die Laufzeit. Es geht um FileReadLine. Die Auswertung einer bereits gefundenen einzelnen Zeile dauert ja nicht lange.

C

; TESTPROGRAMM : Große Textfiles für Test generieren :
; Stand : 05.12.2018
; ---------------------------------------------------------------------------------------------------------------------
#include <Constants.au3>
#include <StringConstants.au3>
#include <File.au3>
#include <FileConstants.au3>
#include <Date.au3>
#include <Timers.au3>  ; nur für Zeitmessung in der Testphase

Opt('MustDeclareVars', 1)

Global $sGenerateFilename  = @ScriptDir & "\Test-BigFile.txt"
Global $hTimer, $fTimerDiff, $iTimerHours = 0, $iTimerMins = 0, $iTimerSecs = 0, $iTimerMilliSecs = 0
Global $sString = "", $bBool

; Zeitmessung starten :
$hTimer = TimerInit()

; Wenn Testfile bereits generiert, dann auskommentieren
;$bBool = _GenerateBigFile($sGenerateFilename, 1)

_ReadFile($sGenerateFilename)
_ReadFile2($sGenerateFilename)

; Konsolenausgaben :
; Zeitdauer des Prozesses anzeigen :
$fTimerDiff = TimerDiff($hTimer)
$iTimerMilliSecs = Int(Mod($fTimerDiff, 1000))
_TicksToTime(Int($fTimerDiff), $iTimerHours, $iTimerMins, $iTimerSecs)
$sString = StringFormat("%02d:%02d:%02d.%03d (Std:Min:Sek.Millisek)", $iTimerHours, $iTimerMins, $iTimerSecs, $iTimerMilliSecs)
ConsoleWrite("Generierungszeit = " & $sString & @CRLF)
ConsoleWrite("Returnvalue      = " & $bBool & @CRLF)

; -------------------------------------------------------------------------------------------------------------------------------
; Funktion     : _GenerateBigFile
; Beschreibung : Generieren einer Textdatei
; Parameter    : $sFileToGenerate = Dateiname (voller Pfad), der generiert werden soll
;                [$iMode] : optionaler Parameter
;                  0 = mit Nullen beschreiben - blockweise (Default)
;                  1 = mit Zufallswerten beschreiben - blockweise
; Returns      : True, wenn erfolgreich
;                False bei beliebigem Fehler
; -------------------------------------------------------------------------------------------------------------------------------
Func _GenerateBigFile($sFileToGenerate, $iMode=0)
    Local $iBlockSize  = 1024          ; Größe des Zeichenblocks in Bytes
    Local $iNoOfBlocks = 1024 * 1024 * 10   ; Anzahl der zu schreibenden Zeichenblöcke
    Local $bReturnValue = False
    Local $hFileOpen
    Local $sGenerateBlock = ""
    Local $iBlocks = 1

    ; Block generieren :
    If ($iMode = 0) Then
        For $i = 1 To $iBlockSize
            $sGenerateBlock &= "0" ; Nullstring
        Next
    Else
        For $i = 1 To $iBlockSize
            $sGenerateBlock &= Chr(Random(65, 122, 1)) ; Integerwert zwischen 65 und 122 (für den ASCII Charakter)
        Next
    EndIf

    If FileExists($sFileToGenerate) Then FileDelete($sFileToGenerate)

    $hFileOpen = FileOpen($sFileToGenerate, $FO_OVERWRITE)
    If $hFileOpen = -1 Then
        MsgBox(48, "FileOpen", "Fehler beim Öffnen der Datei")
        $bReturnValue = False
        Return $bReturnValue
    EndIf


    ; - Blocksize * NoOfBlocks
    $iBlocks = 1
    While $iBlocks <= $iNoOfBlocks
        FileWrite($hFileOpen, $sGenerateBlock & @LF)
        $iBlocks += 1
    WEnd

    ; letzte Zeile schreiben :
    FileWrite($hFileOpen, 'Letzte Zeile X1234567890ABC')
    ; Flush Datei auf Disk :
    FileFlush($hFileOpen)

    ; Position gesetzt (13 Zeichen vom Dateiende :
    FileSetPos($hFileOpen, -13, $FILE_END)
    ; Inhalt vom Ende lesen
    ConsoleWrite("Position: " & FileGetPos($hFileOpen) & @CRLF & "Data: <" & FileRead($hFileOpen) & ">" & @CRLF)

    FileClose($hFileOpen)

    ConsoleWrite("Zeilen in WHILE = " & $iBlocks-1 & @CRLF)
    ConsoleWrite("FileGetsize     = " & FileGetSize(@ScriptDir & '\Test-BigFile.txt') & @CRLF)

    $bReturnValue = True
    Return $bReturnValue
EndFunc    ;==>_GenerateBigFile

; ----------------------------------------------------------------------------
Func _ReadFile($sFileToGenerate)
    Local $hFileOpen

    $hFileOpen = FileOpen($sFileToGenerate)
    If $hFileOpen = -1 Then
        MsgBox(48, "FileOpen", "Fehler beim Öffnen der Datei")
        Return False
    EndIf

    ; Position gesetzt (13 Zeichen vom Dateiende :
    FileSetPos($hFileOpen, -13, $FILE_END)
    ; Inhalt vom Ende lesen
    ConsoleWrite("Position: " & FileGetPos($hFileOpen) & @CRLF & "Data: <" & FileRead($hFileOpen) & ">" & @CRLF)

    FileClose($hFileOpen)
EndFunc    ;==>_ReadFile

; ----------------------------------------------------------------------------
Func _ReadFile2($sFileToGenerate)
    Local $hFileOpen
    Local $sString
    $hFileOpen = FileOpen($sFileToGenerate)
    If $hFileOpen = -1 Then
        MsgBox(48, "FileOpen", "Fehler beim Öffnen der Datei")
        Return False
    EndIf

    $sString = FileReadLine($hFileOpen, -1)
    ConsoleWrite('$sString = ' & $sString & @CRLF)

    FileClose($hFileOpen)
EndFunc    ;==>_ReadFile2

Alles anzeigen

(Der Code ist nur schnell zusammengestoppelt - also bitte keine Schönheitskritik )

Gruß Musashi

**Bitnugger**

Zitat von Musashi

Deine Variante dauert bei großen Dateien aber deutlich länger. Probiere mal meinen Testcode.

Ohhh...

Code

_ReadFile  = 00:00:00.003  Data         = "1234567890ABC"
_ReadFile2 = 00:02:01.476  Letzte Zeile = "X1234567890ABC"

ugt100

Guten morgen zusammen,

vor allen einen Dank für die Unterstützung.

Die Kuh ist vom Eis - mittels FileOpen + FileSetPos (Vorschlag von Alpines)

Der Grund ist die Tatsache, dass sich der gesuchte String immer am Ende des Files (letzten 13 Zeichen mit bekanntem Muster) zu suchen/finden ist.

Ein (für mich) zweiter Effekt ist das RegEx Pattern ("‚¬\|v(.+\..+)\..+', 3) - das kann ich als 'Schablone' für diverse Suchen einsetzen - Ein sehr willkommener Nebeneffekt !

Also allen nochmals vielen Dank für die kompetente, schnelle und verständliche Hilfe

Gruss

ugt100

ugt100

so nun auch auf erledigt gesetzt