Vor kopieren warten bis Subroutine abgeschlossen (Allgemeines zu Perl) - Perl-Community.de

Start · Board · Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl

2024-05-11 15:40:40
Europe/Berlin
Einloggen (Registrieren)
- Einstellungen
- Statistics
Jemand zu Hause?
0 Benutzer online

[thread]14687[/thread]

submit to reddit

Vor kopieren warten bis Subroutine abgeschlossen

Leser: 28

Articles: hide open all | hide show old branches

+29 replies
Gast giordano

2010-02-17 14:50
Hallo,

Ich habe eine Subroutine extractXLS() geschrieben, das aus Excel-Files eine Text-Datei erstellt. Diese Text-Datei wird anschliessend kopiert in ein anderes Verzeichnis. Nun ist mir aufgefallen, dass die kopierte Version nicht alle Zeile enthält und ich vermute, dass der Kopiervorgang bereits begonnen hat, bevor die Subroutine abgeschlossen war. Wie kann ich den Kopiervorgang erst dann starten, wenn die Subroutine abgeschlossen ist?
Code: (dl )

1 2 3 4 5 6 7 8 9 10 11 12 13 14

use File::Copy; ... ... while ( my $excel = readdir(EXCELFILES) ) { if ( $excel =~ /xls/ ) { extractXLS(....); # produziert ein txt-File in $directory_txt } } my @filecopy = ("a.txt","b.txt","c.txt","d.txt"); foreach my $file (@filecopy ) { # erst starten, wenn extractXLS abgeschlossen ist copy($directory_txt.$file,$directory_txtcopy.$file) or die "File cannot copied"; }
Bin für jeden Tipp dankbar.

Gruss
giordano
- renee
  
  2010-02-17 14:56
  
  User since
  2003-08-04
  14371 Artikel
  ModeratorIn
  
  Ich würde eher darauf tippen, dass die Erstellung der .txt fehlerhaft ist wenn da Zeilen fehlen...
  
  Wenn Du nicht mit Threads oder ähnlichem arbeitest, werden die Kopien erst gemacht, wenn .txt's erstellt sind...
  Last edited: 2010-02-17 14:58:07 +0100 (CET)
  OTRS-Erweiterungen (http://feature-addons.de/)
  Frankfurt Perlmongers (http://frankfurt.pm/)
  --
  
  Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
  Perl-Entwicklung: http://perl-services.de/
- +8 replies
- Linuxer
  
  2010-02-17 14:57
  
  User since
  2006-01-27
  3875 Artikel
  HausmeisterIn
  
  Wenn Du in der Subroutine keine Aktionen in den Hintergrund legst (oder forkst), kann der Copy-Job eigentlich nicht starten bevor nicht die Subroutine ihren Teil erledigt hat.
  
  Ohne Kenntnis des Inhalts der Subroutine kann man nur Mutmaßungen äußern.
  meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
  Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
  - +6 replies
  - Gast giordano
    
    2010-02-17 15:33
    Hallo Renee und Linuxer,
    
    Besten Dank für die rasche Antwort. Ich habe die Dateien überprüft. Die zu kopierenden Dateien werden korrekt erstellt, bei der kopierten fehlen die letzten paar Zeilen. Ich weiss nicht, was ein fork und ein thread ist, aber ich denke, dass ich das nicht verwende. Hier noch der Code der Subroutine. Die Subroutine habe ich zuhinderst aufgestellt, die Ausführung findet jedoch vor copy statt.
    
    Code: (dl )
    
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
    
    use Spreadsheet::ParseExcel; sub extractXLS { # parameter my $exceldir = shift; my $excelfile = shift; my $OUTPUT = shift; my $wksh = shift; binmode( $OUTPUT,":utf8" ); # begin my $oBook = Spreadsheet::ParseExcel::Workbook->Parse($exceldir.$excelfile); my($iR, $iC, $oWkS, $oWkC); my $oWkS = $oBook->worksheet($wksh); #print "--------- SHEET:", $oWkS->{Name}, "\n"; for( my $iR = $oWkS->{MinRow} ; defined $oWkS->{MaxRow} && $iR <= $oWkS->{MaxRow} ; $iR++ ) { my $rec=''; for(my $iC = $oWkS->{MinCol} ; defined $oWkS->{MaxCol} && $iC <= $oWkS->{MaxCol} ; $iC++ ) { my $temp = ''; $oWkC = $oWkS->{Cells}[$iR][$iC]; $temp = $oWkC->Value if($oWkC); $rec = $rec.$temp.";"; } chop($rec); $rec = $rec,"\r"; print $OUTPUT $rec,"\n"; } }
    - +2 replies
    - Linuxer
      
      2010-02-17 16:38
      
      User since
      2006-01-27
      3875 Artikel
      HausmeisterIn
      
      Ein paar Anmerkungen zu Deinem Code.
      
      Code: (dl )
      
      1 2
      
      $rec = $rec,"\r"; print $OUTPUT $rec,"\n";
      
      Warum verwendest Du da den Komma-Operator bei der Zuweisung?
      Hast Du Warnungen aktiviert? Dann solltest Du eigentlich Warnungen bzgl. der Zeile $rec = $rec, "\r"; erhalten.
      
      Was spricht dagegen, die oben genannten 2 Zeilen so zu schreiben:
      
      Code: (dl )
      
      print $OUTPUT $rec, "\r\n";
      
      Btw:
      Strings kannst Du auch bequem mit .= verlängern:
      
      Code: (dl )
      
      1 2 3
      
      my $str = "Hallo "; $str .= "Welt"; print "$str\n";
      
      meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
      Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
      - Gast giordano
        
        2010-02-20 17:28
        
        Hallo Linuxer,
        Danke für die Bemerkungen. Ich habe warnings nicht eingeschaltet. Ich habe es nun eingeschaltet und tatsächlich ein paar Warungen erhalten, u.a. "unless use of a constant in void context at ...". Ich vermute, dass Du dieses meinst. Dein Vorschlag habe ich übernommen und es funktioniert. Ich habe auch print $OUPUT $rec,"\n" versucht und das klappt auch, d.h. es gibt mir dasselbe Resultat.
        Den Code mit \r hatte ich mal (mithilfe von kompetenten Leute) geschrieben, weil ich irgendwelche DOS-\r\n-Probleme hatte. Das war schon lange her und beim übernehmen des Codes habe ich vermutlich neue Anpassungen durchgeführt.
        Auf jedenfall, besten Dank
        giordano.
    - +3 replies
    - Gast wer
      
      2010-02-17 16:46
      
      Code: (dl )
      
      my($iR, $iC, $oWkS, $oWkC);
      
      Das ist Unnötig. "warnings" sollte sich melden.
      
      Code: (dl )
      
      $rec = $rec,"\r";
      
      Das macht keinen Sinn.
      
      Die ganzen Schleifen kann man auch besser schreiben:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12
      
      return unless(defined($oWkS->{MaxRow})); for my $iR ( $oWkS->{MinRow}..$oWkS->{MaxRow} ) { my @list=(); next unless(defined($oWkS->{MaxCol})); for my $iC ($oWkS->{MinCol}..$oWkS->{MaxCol}) { my $oWkC = $oWkS->{Cells}[$iR][$iC]; push(@list,$oWkC?$oWkC->Value:''); } print $OUTPUT join(';',@list)."\r\n"; }
      
      Warum öffnest/schließt du die Dateien außerhalb von "extractXLS"?
      Was ist "$wksh"?
      Benutzt du "strict" und "warnings"?
      - Gast giordano
        
        2010-02-20 17:45
        
        Hallo war,
        Besten Dank. Ich habe deinen Code gleich übernommen. $wksh ist die Nummer des Tabellenblatts.
        Zu: "Warum öffnest/schließt du die Dateien außerhalb von "extractXLS"?"
        Antwort kommt noch.
        
        Gruss
        giordano
      - Gast giordano
        
        2010-02-21 18:21
        
        Hallo wer,
        
        Zu: "Warum öffnest/schließt du die Dateien außerhalb von "extractXLS"?"
        
        Weil ich ein schlechter, resp. kein Programmierer bin. Du hast völlig recht. Wenn ich es rein tu, spare ich auch an Code. Werde es bei Gelegenheit anpassen.
        Besten Dank
        giordano
  - Gast giordano
    
    2010-02-17 15:58
    Hier noch weitere Infos, die vielleicht relevant sind:
    - WinXP
    ActivePerl
    
    Code: (dl )
    
    1 2 3 4
    
    use strict; use Spreadsheet::ParseExcel; use IO::File; use File::Copy;
- betterworld
  
  2010-02-17 16:07
  
  User since
  2003-08-21
  2613 Artikel
  ModeratorIn
  
  Um Deinen Verdacht zu überprüfen, kannst Du ja so etwas wie sleep(10); einbauen. Wenn Du dann feststellst, dass das Problem durch Warten tatsächlich behoben wird, kann man sich eine präzisere Lösung überlegen.
  Lieblingsmodule: IPC::System::Simple, Path::Class
- +16 replies
- bianca
  
  2010-02-17 16:08
  
  User since
  2009-09-13
  6979 Artikel
  BenutzerIn
  
  Hast Du mal mit $| = 1; den Ausgabepuffer ausgeschaltet.
  Vielleicht ist nach Deinem print $OUTPUT noch etwas im Puffer, da Du ja nirgendwo das Filehandle schließt.
  10 print "Hallo"
  20 goto 10
  - +5 replies
  - renee
    
    2010-02-17 16:29
    
    User since
    2003-08-04
    14371 Artikel
    ModeratorIn
    
    Lexikalische Filehandles werden geschlossen, sobald der Scope (hier: die Subroutine) verlassen wird.
    OTRS-Erweiterungen (http://feature-addons.de/)
    Frankfurt Perlmongers (http://frankfurt.pm/)
    --
    
    Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
    Perl-Entwicklung: http://perl-services.de/
    - +4 replies
    - Linuxer
      
      2010-02-17 16:32
      
      User since
      2006-01-27
      3875 Artikel
      HausmeisterIn
      
      Stimmt schon, aber wie groß ist der Scope für $OUTPUT?
      Der Handle wir - so wie ich den Code interpretiere - als Parameter an die Subroutine übergeben... stammt also von außerhalb der Routine...
      
      meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
      Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
      - +3 replies
      - bianca
        
        2010-02-17 16:36
        
        User since
        2009-09-13
        6979 Artikel
        BenutzerIn
        
        2010-02-17T15:32:16 Linuxer
        Der Handle wir - so wie ich den Code interpretiere - als Parameter an die Subroutine übergeben... stammt also von außerhalb der Routine...
        
        Eben, genau deshalb bleibt er m.E. ununterbrochen offen, bis er neu belegt wird. Und wenn da ein copy zwischenfunkt, schlägt es Funken. So zumindest fände ich es logisch.
        10 print "Hallo"
        20 goto 10
        
        +2 replies
        
        renee
        
        2010-02-17 16:46
        
        User since
        2003-08-04
        14371 Artikel
        ModeratorIn
        
        Ja, hast recht. Sorry. Ich habe übersehen, dass es zwar ein lexikalisches Filehandle ist, aber von außerhalb kommt.
        OTRS-Erweiterungen (http://feature-addons.de/)
        Frankfurt Perlmongers (http://frankfurt.pm/)
        --
        
        Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
        Perl-Entwicklung: http://perl-services.de/
        
        bianca
        
        2010-02-17 16:50
        
        User since
        2009-09-13
        6979 Artikel
        BenutzerIn
        
        2010-02-17T15:46:30 renee
        Ja, hast recht. Sorry.
        
        *rot werd*
        War nur ein Geistesblitz :)
        Normalerweise sage ich diese Worte :))
        10 print "Hallo"
        20 goto 10
  - +2 replies
  - Gast giordani
    
    2010-02-17 16:33
    
    Hallo bianca,
    Das wars. Die Filehandle (ich hatte mehrere) waren nicht geschlossen. Nachdem ich sie geschlossen habe, wurden komplette Kopien erstellt.
    Üblicherweise schliesse ich die Filehandles, aber das neue Filehandle-Paket hat mich überfordert.
    Besten Dank für Eure schnelle Hilfe.
    giordano
    - bianca
      
      2010-02-17 16:41
      
      User since
      2009-09-13
      6979 Artikel
      BenutzerIn
      
      Guest giordani
      Besten Dank für Eure schnelle Hilfe.
      giordano
      
      Bitte gerne.
      Funktioniert mein logisches Denken also noch. :)
      10 print "Hallo"
      20 goto 10
  - +8 replies
  - sid burn
    
    2010-02-20 18:08
    User since
    2006-03-29
    1520 Artikel
    BenutzerIn
    
    Code (perl): (dl )
    
    $| = 1
    
    schaltet den Ausgabepuffer nicht ab. Dieses lese ich immer wieder was aber falsch ist. Als erstes wird nur "AutoFlush" aktiviert, daher der Puffer existiert immer noch, nur wird dieser immer schnellstmöglicht geleert wie es geht.
    
    Ansonsten mag das zwar fast noch egal und kleinkarriert wirken. Viel wichtiger ist aber das das was "$| = 1" macht genau beschrieben ungefähr so lautet:
    
    Quote
    Auf dem derzeit aktiven Handle wird ein AutoFlush aktiviert.
    
    Was ist das derzeit aktive Filehandle? Standardmäßig ist das lediglich "STDOUT". Das heißt mit "$| = 1" schaltet man AutoFlush für STDOUT aktiv. Aber nicht global für alle Dateihandles. Daher wenn er ein "print $OUTPUT 'asd'" hat ist $OUTPUT nicht davon betroffen.
    
    Deswegen ist meine empfehlung auch das "$| = 1" gefrickel zu vergessen. Und stattdessen "use IO::Handle" einzubinden. Hat man das gemacht kann man auf jedem Dateihandle einfach eine Methode aufrufen um autoflush zu aktivieren.
    
    Code (perl): (dl )
    
    1 2 3 4 5 6
    
    use IO::Handle; STDOUT->autoflush(1); open my $fh, '>', 'asd.txt' or die $!; $fh->autoflush(1);
    
    Nicht mehr aktiv. Bei Kontakt: ICQ: 404181669 E-Mail: perl@david-raab.de
    - +2 replies
    - Gast giordano
      
      2010-02-21 18:28
      
      Hallo sid burn,
      
      Komme da nicht mehr mit, aber ich denke, das ist nun zu spezifisch. Nun läuft alles gut bei mir und es gibt auch keine warnings mehr. Das unschöne ist noch, dass ich meine filehändels draussen öffne. Bei Gelegenheit werde ich sie in der subroutine integrieren.
      Gruss
      giordano
      - sid burn
        
        2010-02-22 16:00
        
        User since
        2006-03-29
        1520 Artikel
        BenutzerIn
        
        Hi, ist nicht schlimm das du nicht mitkommst, wahrscheinlich war dein Problem davon sowieso nicht betroffen.
        
        Zur kurzen Erklärung. Wenn man in einer Programmiersprache I/O macht so gibt es aus Performance Gründen einige Puffer die im Spiel sind. Das bedeutet wenn du in Perl zum Beispiel etwas in einer Datei schreibst bedeutet es nicht das nach erfolgreichen ausführen des Perls befehls die Daten wirklich auf der Festplatte gelandet sind. Als Minimum gibt es folgende Puffer.
        
        * PerlIO Puffer
        * STDIO Puffer
        * Evtl. weitere OS Puffer (Dateisystem etc.)
        * Festplattencache Puffer
        
        Die letzten beiden sind eher Transparent. Daher selbst wenn es noch nicht Physikalisches geschrieben wurden, wenn du liest beachtet dein Betriebssystem diese Puffer und gibt dir den Inhalt zurück so als wäre es schon physikalisches geschrieben. Probleme hast du hier nur bei Stromausfall. Den dann sind die Daten wirklich weg wenn sie noch nicht geschrieben werden konnten.
        
        STDIO Puffer passiert auf C Ebene und ist eigentlich auch Fest mit dem OS verdrahtet. Zumindest bei Linux. Soweit ich in Erinnerung habe ist das aber nur ein Puffer der für die Performance da ist. Daher dieser wird immer schnellstmöglich geleert.
        
        Und direkt auf Perl Ebene haben wir den PerlIO Puffer. Dieser Leert aber nicht sofort sondern wenn du ausgaben auf einem Terminal machst wartet es immer solange bis es eine zeile zusammen hat und erst dann sendet es die fertige zeile zum OS, dass dann wiederrum die unterschiedlichen Puffer durchläuft. Bei Dateihandles etc. ist es Blockorientert sprich es kann z.B. sein das er immer nur 4 KiB Blöcken daten sendet (den genauen wert kenne ich nicht). Mit "autoflush" schaltest du diesen PerlIO Puffer aus, bzw du aktivierst autoflush. Der Puffer ist immer noch da, nur wird er immer so oft/schnell geleert wie es möglich ist. Wenn also nur ein Zeichen im Puffer ist wird dieser schon geleert, und wartet nicht solange bis du wirklich eine Zeile oder die 4KiB zusammen hast.
        
        Nur manchmal kann der PerlIO Puffer eben nachteilig sein. Wenn ich halt 300 zeichen in eine Datei schreibe aber kein Newline zeichen kommt, dann sind die 300 Zeichen auch noch nicht in der Datei gelandet. Und auch kein anderes Programm hat etwas davon mitbekommen, erst wenn der Puffer geleert wird, können andere Programme dort etwas mitbekommen. Am meisten tritt das aber eigentlich eher bei ausgaben auf der Shell auf. Wenn man beispielsweise eine Fortschrittanzeige macht und zum beispiel immer nur ein zeichen ausgeben möchte für einen Status etc.
        Nicht mehr aktiv. Bei Kontakt: ICQ: 404181669 E-Mail: perl@david-raab.de
    - Crian
      
      2010-02-22 10:59
      
      User since
      2003-08-04
      5866 Artikel
      ModeratorIn
      
      Danke für den Tipp, das sieht sehr viel netter aus!
      s--Pevna-;s.([a-z]).chr((ord($1)-84)%26+97).gee; s^([A-Z])^chr((ord($1)-52)%26+65)^gee;print;
      
      use strict; use warnings; Link zu meiner Perlseite
    - +2 replies
    - GwenDragon
      
      2010-02-22 11:17
      
      User since
      2005-01-17
      14578 Artikel
      Admin1
      
      Der Tipp ist sehr sinnreich.
      
      Es gibt auch eigentlich keinen Grund, $| noch zu nutzen, außer aus Tradition oder Schreibfaulheit.
      IO::Handle ist ja schon länger im Core (seit 5.3) und deswegen ohne Probleme einsetzbar.
      
      In jedem Fall ist das Verwenden von Methoden auf Dateihandles auch für Anfänger nachvollziehbarer als kryptische setzen globaler $-Variablen.
      die Drachin Gwendolyn
      - sid burn
        
        2010-02-22 15:24
        
        User since
        2006-03-29
        1520 Artikel
        BenutzerIn
        
        Quote
        In jedem Fall ist das Verwenden von Methoden auf Dateihandles auch für Anfänger nachvollziehbarer als kryptische setzen globaler $-Variablen.
        
        Vorallem, sehr viel aufwendiger wird es wenn man autoflush auf einem Handle aktivieren möchte das nicht STDOUT ist.
        
        Zum Beispiel um autoflush auf $fh zu aktivieren:
        
        Code (perl): (dl )
        
        1 2 3
        
        my $oldfh = select($fh); $| = 1; select($oldfh);
        
        Das ist nicht nur deutlich komplexer, sondern das muss man auch erstmal nachvollziehen was dort überhaupt passiert.
        
        Ansonsten ebenfalls sehr nett ist die "printflush" methode. Manchmal möchte man etwas ausgeben und den Puffer nicht beachten, aber deswegen muss man nicht gleich komplett im kompletten Programm den Puffer deaktivieren.
        
        Code (perl): (dl )
        
        1 2 3 4 5 6
        
        # STDOUT hat hier Puffer aktiviert for my ( @list ) { STDOUT->printflush('.'); sleep 1; } # STDOUT hat hier Puffer aktiviert
        
        Oder man kann es manuell mit mit "->flush()" flushen. So das man mehrere prints macht und nur zum schluß flusht, wenn es nötig ist.
        Nicht mehr aktiv. Bei Kontakt: ICQ: 404181669 E-Mail: perl@david-raab.de
    - +2 replies
    - bianca
      
      2010-02-22 14:54
      
      User since
      2009-09-13
      6979 Artikel
      BenutzerIn
      
      Danke für diese Darstellung, sid burn!
      Jetzt hab ich das endlich auch mal verinnerlicht.
      Da kann man mal sehen, was draus wird, wenn man mal irgendwann irgendwo etwas aufschnappt.
      
      Eine Frage noch dazu bitte: Wenn ich eine main.pl habe, die weitere *.pl's require'd, muss ich dann in jeder require'ten *.pl IO::Handle use'n und autoflush'en oder reicht das im Hauptprogramm einmalig?
      
      10 print "Hallo"
      20 goto 10
      - sid burn
        
        2010-02-22 15:11
        
        User since
        2006-03-29
        1520 Artikel
        BenutzerIn
        
        Quote
        Eine Frage noch dazu bitte: Wenn ich eine main.pl habe, die weitere *.pl's require'd, muss ich dann in jeder require'ten *.pl IO::Handle use'n und autoflush'en oder reicht das im Hauptprogramm einmalig?
        
        Grundsätzlich reicht es immer wenn du nur einmalig ein "use Modul" machst. Grundsätzlich würde ich dir aber immer empfehlen das wenn du es in einem Modul benötigst auch dort hereinzuschreibst. Sonst rennst du irgendwann in Fehler wenn du deine Sourcen Editierst. Und nachträglich hinzufügen ist aufwendiger/komplexer als es gleich von anfang an richtig zu machen.
        
        Ansonsten reicht es auch auf ein Handle einmalig autoflush zu aktivieren. STDOUT ist global wenn du es aktivierst, volkommen egal wo, ist es auch global aktiv. Aber auch hier gilt. Du solltest es immer explizit nochmal dort aktivieren wo du es benötigst und dich nicht drauf verlassen was ein anderes Modul etc. macht. Ändert sich nämlich etwas rennst du wieder in Problemen. Und der Zeitliche Aufwand solche Dinge zu debuggen kostet ein vielfaches als es gleich von anfang an explizit hinzuschreiben.
        Nicht mehr aktiv. Bei Kontakt: ICQ: 404181669 E-Mail: perl@david-raab.de
- +2 replies
- havi
  
  2010-02-17 16:59
  User since
  2003-08-04
  2036 Artikel
  BenutzerIn
  Guest giordano
  Hallo,
  
  Ich habe eine Subroutine extractXLS() geschrieben, das aus Excel-Files eine Text-Datei erstellt. Diese Text-Datei wird anschliessend kopiert in ein anderes Verzeichnis. Nun ist mir aufgefallen, dass die kopierte Version nicht alle Zeile enthält und ich vermute, dass der Kopiervorgang bereits begonnen hat, bevor die Subroutine abgeschlossen war. Wie kann ich den Kopiervorgang erst dann starten, wenn die Subroutine abgeschlossen ist?
  
  Code: (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14
  
  use File::Copy; ... ... while ( my $excel = readdir(EXCELFILES) ) { if ( $excel =~ /xls/ ) { extractXLS(....); # produziert ein txt-File in $directory_txt } } my @filecopy = ("a.txt","b.txt","c.txt","d.txt"); foreach my $file (@filecopy ) { # erst starten, wenn extractXLS abgeschlossen ist copy($directory_txt.$file,$directory_txtcopy.$file) or die "File cannot copied"; }
  
  Bin für jeden Tipp dankbar.
  
  Gruss
  giordano
  
  Du kannst das ganze auch mit vorhandenen CPAN-Modulen lösen...
  
  Code (perl): (dl )
  
  1 2 3 4 5
  
  use warnings; use strict; use Spreadsheet::Excel2Text qw( XlsSaveToText ); XlsSaveToText("C:\\Excel.xls", "C:\\Excel.txt");
  
  ... weiter in deinem Code:
  
  Code (perl): (dl )
  
  1 2
  
  my @filecopy = ("a.txt","b.txt","c.txt","d.txt"); foreach my $file (@filecopy ) {
  
  Gruß,
  Gernot
  Perl-Zeitung - http://perl-zeitung.at/
  Perl-Blog - http://usr-bin-perl.blogspot.com/
  - Gast giordano
    
    2010-02-21 18:12
    
    Hallo Gernot,
    Danke für Deine Hinweise. Schaue mir das bei anderer Gelegenheit genauer an. Jetzt läuft alles rund, ohne Fehlermeldungen und bin nun überglücklich.
    Gruss
    giordano

View all threads created 2010-02-17 14:50.