s/// in map? - Arrayzuweisung kürzer schreiben (gelöst) (Allgemeines zu Perl)

[thread]16044[/thread]

s/// in map? - Arrayzuweisung kürzer schreiben [gelöst]

Leser: 23

Articles: hide open all | hide show old branches

+13 replies
Sven_123

2011-03-08 10:31
User since
2010-06-01
120 Artikel
BenutzerIn
Hallo,
ich rätsel seit einiger Zeit darüber, ob es möglich ist, folgende for-Schleife mit einem map zusammenzufassen:
Code (perl): (dl )

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

use strict; use Data::Dumper; my @bsp = ( "a b 3 4 eins.txt", "c d 7 2 zwei.txt", "e f 4 4 drei.txt"); for my $i (0..$#bsp){ my @vals = split (/\s+/,$bsp[$i]); $vals[4] =~ s/\.txt$//; $bsp[$i] = {$vals[4] => [$vals[2],$vals[3]]}; } print Dumper(\@bsp);
Müsste ich das ".txt" nicht abschneiden, könnte ich ja dieses schreiben:
Code (perl): (dl )

@bsp = map{{(split)[4] => [(split)[2,3]]}} @bsp;
In dem Beispiel könnte ich natürlich nach dem Punkt nochmal splitten und so zum gewünschten Ergebnis kommen:
Code (perl): (dl )

@bsp = map{{(split(/\./,(split)[4]))[0] => [(split)[2,3]]}} @bsp;
Aber ich ich wüsste gern, ob das mit einem s/// kombinierbar ist (oder wie ihr es möglichst kurz schreiben würdet).
In jedem Fall ist die Variante mit der for-Schleife aber vermutlich schneller, weil ich mir das getrennte splitten für key und values spar, oder? (Nicht dass man es hier merken würde.)

(Hoffe ich darf hier meine Fragen auch zu keinen Problemen bei denen ich nicht weiter käme, sondern nur zum Neugier stillen stellen... ;)
- +5 replies
- Taulmarill
  
  2011-03-08 10:48
  User since
  2004-02-19
  1750 Artikel
  BenutzerIn
  map solltest du nur verwenden, wenn das Ergebnis in einer anderen Variable gespeichert werden soll. Willst du die Werte in dem Array selbst verändern, ist eine for-Schleife genau richtig. Wenn du mit for über einen Array iterierst, dann wird der Wert aus dem Array nicht einfach in die Schleifenvariable kopiert sondern sie repräsentiert das Feld des Arrays, alles was du mit der Variable machst, wirkt sich auf das Array aus. Du kannst also so was machen:
  
  Code (perl): (dl )
  
  1 2 3 4 5
  
  for my $element ( @bsp ) { my @vals = split /\s+/, $element; $vals[4] =~ s/\.txt$//; $element = {$vals[4] => [$vals[2],$vals[3]]}; }
  
  edit: außerdem empfiehlt es sich oft, die Rückgabe von split in entsprechend benannte Variablen zu speichern, anstatt einfach alles in einen Array zu packen, so behält man leichter den Überblick. Nicht benötigte Werte braucht man dann an der Stelle auch gar nicht speichern:
  
  Code (perl): (dl )
  
  1 2 3 4 5
  
  for my $element ( @bsp ) { my( undef, undef, $Zahl, $andereZahl, $name ) = split /\s+/, $element; $name =~ s/\.txt$//; $element = {$name => [$Zahl, $andereZahl]}; }
  
  2nd edit: und hier noch eine Möglichkeit, die Werte direkt per RegEx zu extrahieren ohne split:
  
  Code (perl): (dl )
  
  1 2 3 4
  
  for my $element ( @bsp ) { my( $Zahl, $andereZahl, $name ) = $element =~ /(\d+)\s+(\d+)\s+(.+)\.txt$/; $element = {$name => [$Zahl, $andereZahl]}; }
  
  Last edited: 2011-03-08 10:57:06 +0100 (CET)
  $_=unpack"B*",~pack"H*",$_ and y&1|0& |#&&print"$_\n"for@.=qw BFA2F7C39139F45F78 0A28104594444504400 0A2F107D54447DE7800 0A2110453444450500 73CF1045138445F4800 0 F3EF2044E3D17DE 8A08A0451412411 F3CF207DF41C79E 820A20451412414 83E93C4513D17D2B
  - +4 replies
  - Sven_123
    
    2011-03-08 11:02
    User since
    2010-06-01
    120 Artikel
    BenutzerIn
    
    Dass man in der Schleife auf die tatsächlichen Array-Werte hatte ich mir nicht so vorgestellt, das ist gut zu wissen. map vermutlich deshalb nicht benutzen, weil es im Vergleich zur for-Schleife ineffizient ist (zumindest bei vergleichbarem), oder?
    Aber davon abgesehen, ist ein Konstrukt wie
    
    Code (perl): (dl )
    
    1 2
    
    #Funktioniert nicht, nur sinngemäß gemeint @bsp = map{{(split)[4]) =~ s/.txt$// => [(split)[2,3]]}} @bsp;
    
    überhaupt möglich, oder geht das gar nicht?
    - Taulmarill
      
      2011-03-08 11:08
      
      User since
      2004-02-19
      1750 Artikel
      BenutzerIn
      
      Gehen tut es schon, payx hat weiter unten gezeigt wie:
      
      2011-03-08T09:55:23 payx
      Hallo Sven_123,
      bei mir klappt es so:
      
      Code (perl): (dl )
      
      @bsp = map{{((split)[4]=~/(.+)\.txt/) => [(split)[2,3]]}} @bsp;
      
      Mir kommt es übrigens so vor, als ob ein Hash als Ergebnis hier geeigneter wäre als ein Array of Hashes.
      $_=unpack"B*",~pack"H*",$_ and y&1|0& |#&&print"$_\n"for@.=qw BFA2F7C39139F45F78 0A28104594444504400 0A2F107D54447DE7800 0A2110453444450500 73CF1045138445F4800 0 F3EF2044E3D17DE 8A08A0451412411 F3CF207DF41C79E 820A20451412414 83E93C4513D17D2B
    - +2 replies
    - payx
      
      2011-03-08 11:10
      
      User since
      2006-05-04
      564 Artikel
      BenutzerIn
      
      Hallo Sven 123,
      
      Mit s/// geht es nicht, weil dieses Konstrukt keine Treffer zurückliefert sondern die Anzahl der erfolgten Ersetzungen. (Ich glaube gelesen zu haben, dass das in Perl 6 erweitert wird.)
      
      Grüße
      payx
      - renee
        
        2011-03-08 12:51
        
        User since
        2003-08-04
        14371 Artikel
        ModeratorIn
        
        In Perl 5.14 wird es auch gehen - mit dem 'r'-Modifier:
        
        Code (perl): (dl )
        
        1 2
        
        my $file = 'test.txt'; my $png = $file =~ s/\.txt/.png/r;# $png -> test.png
        
        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/
- +7 replies
- payx
  
  2011-03-08 10:55
  User since
  2006-05-04
  564 Artikel
  BenutzerIn
  Hallo Sven_123,
  
  bei mir klappt es so:
  
  Code (perl): (dl )
  
  @bsp = map{{((split)[4]=~/(.+)\.txt/) => [(split)[2,3]]}} @bsp;
  
  Ich weiß aber nicht, ob das eine gute Lösung ist.
  
  Grüße
  payx
  
  PS:
  2011-03-08T09:31:13 Sven_123
  (Hoffe ich darf hier meine Fragen auch zu keinen Problemen bei denen ich nicht weiter käme, sondern nur zum Neugier stillen stellen... ;)
  
  Das ist ja wohl keine Frage!
  
  Editiert von payx: (code vereinfacht)
  Last edited: 2011-03-08 10:57:38 +0100 (CET)
  - Sven_123
    
    2011-03-08 11:18
    
    User since
    2010-06-01
    120 Artikel
    BenutzerIn
    
    Ah, ok, wieder was gelernt...ich dachte wenn ich sowas schreib, müsste ich ihm irgendwie das $1 mitgeben.
    
    Vielen Dank euch beiden :)
    
    Edit: Oh, und ja Taulmarill, ein Hash ist besser, als ein Array of Hashes - das ist irgendwie beim stufenweisen Zusammensetzen der Schritte so herausgekommen...*g
    Last edited: 2011-03-08 11:21:29 +0100 (CET)
  - +5 replies
  - Sven_123
    
    2011-03-08 12:02
    User since
    2010-06-01
    120 Artikel
    BenutzerIn
    
    Bei weiterem Rumspielen (ich schreib das ganze jetzt in einen Hash, da fällt map natürlich weg) wollt ich nochmal dein Konstrukt verwenden, allerdings funktioniert das nur bedingt. Kann mir wer folgendes Ergebnis erklären?
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7 8
    
    use strict; use warnings; use Data::Dumper; my $eins = {"indirekt.txt" =~ /(.+)\.txt/ => "value"}; my %zwei; $zwei{"direkt.txt" =~ /(.+)\.txt/} = "value"; print Dumper($eins,\%zwei);
    
    liefert
    
    Code: (dl )
    
    1 2 3 4 5 6
    
    $VAR1 = { 'indirekt' => 'value' }; $VAR2 = { '1' => 'value' };
    
    Bei der ersten Methode wird also $1 als key benutzt, bei der zweiten nur eine 1 als true. Gibt es da eine Logik dahinter, oder nicht?
    - +3 replies
    - clms
      
      2011-03-08 12:39
      
      User since
      2010-08-29
      373 Artikel
      BenutzerIn
      
      2011-03-08T11:02:57 Sven_123
      Kann mir wer folgendes Ergebnis erklären?
      
      Code (perl): (dl )
      
      1 2
      
      my $eins = {"indirekt.txt" =~ /(.+)\.txt/ => "value"}; my %zwei; $zwei{"direkt.txt" =~ /(.+)\.txt/} = "value";
      
      Bei der ersten Methode wird also $1 als key benutzt, bei der zweiten nur eine 1 als true. Gibt es da eine Logik dahinter, oder nicht?
      Ja. gibt es.
      
      Im ersten Fall wird "indirekt.txt" =~ /(.+)\.txt/ im List-Kontext ausgewertet. Da gibt es die Liste der gematchten Gruppen zurück (also ($1,$2...) oder values %+, genaues müsste ich jetzt auch nachschlagen). Hier ist es auf jeden Fall ("indirekt").
      
      Im zweiten Fall wird es im Scalar-Kontext ausgefühtr. Da gibt es die Anzahl der erfolgreichen Matches zurück. Die ist hier 1.
      
      Edit: Nachtrag
      Wenn man im zweiten Fall List-Kontext herstellt wird "direkt" als Key verwendet:
      
      Code (perl): (dl )
      
      $zwei{(),"direkt.txt" =~ /(.+)\.txt/} = ...
      
      BTW: Gibt es eigentlich eine elegantere Möglichkeit, den Match in List-Kontext zu setzen, als das (),?
      Last edited: 2011-03-08 12:51:45 +0100 (CET)
      - +2 replies
      - payx
        
        2011-03-08 12:46
        
        User since
        2006-05-04
        564 Artikel
        BenutzerIn
        
        Stimmt. Insofern war das vorherige Beispiel ein bisschen irreführend.
        
        So geht es:
        
        Code (perl): (dl )
        
        $zwei{("direkt.txt" =~ /(.+)\.txt/)[0]} = "value";
        
        Grüße
        payx
        
        Sven_123
        
        2011-03-08 12:54
        
        User since
        2010-06-01
        120 Artikel
        BenutzerIn
        
        Nochmals vielen Dank :)
    - Taulmarill
      
      2011-03-08 13:59
      
      User since
      2004-02-19
      1750 Artikel
      BenutzerIn
      
      2011-03-08T11:02:57 Sven_123
      (ich schreib das ganze jetzt in einen Hash, da fällt map natürlich weg)
      
      Nicht unbedingt, so finde ich das eigentlich recht ansprechend:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
      
      use strict; use warnings; use Data::Dumper; my @bsp = ( "a b 3 4 eins.txt", "c d 7 2 zwei.txt", "e f 4 4 drei.txt" ); my %hash = map { my( $Zahl, $andereZahl, $name ) = /(\d+)\s+(\d+)\s+(.+)\.txt$/; $name => [$Zahl, $andereZahl]; } @bsp; print Dumper(\%hash);
      
      $_=unpack"B*",~pack"H*",$_ and y&1|0& |#&&print"$_\n"for@.=qw BFA2F7C39139F45F78 0A28104594444504400 0A2F107D54447DE7800 0A2110453444450500 73CF1045138445F4800 0 F3EF2044E3D17DE 8A08A0451412411 F3CF207DF41C79E 820A20451412414 83E93C4513D17D2B

View all threads created 2011-03-08 10:31.