Unbestimmt tiefen HashinHash erzeugen (Allgemeines zu Perl)

[thread]13834[/thread]

Unbestimmt tiefen HashinHash erzeugen

Leser: 28

Articles: hide open all | hide show old branches

+15 replies

scriptor

2009-08-09 00:58

User since
2008-05-07
69 Artikel
BenutzerIn

Ich wäre noch mal für Eure Hilfe dankbar:

Aus "nur_ein_test_mit_zahl_123=456" soll diese Hashstruktur entstehen:

Code (perl): (dl )

$resulthash{'nur'}{'ein'}{'test'}{'mit'}{'zahl'}[123]=456

Die Idee war $iref wie einen Pointer dieser Struktur nachzuführen, etwa so:
$iref = $iref->{'nur'}; $iref = $iref->{'ein'}; $iref = $iref->{'test'}; $iref = $iref->{'mit'}; $iref = $iref->{'zahl'}; $iref = $iref->[123];

Das Beispiel ist auf das wesentliche reduziert und läuft natürlich so nicht. Die für mich fraglichen Stellen sind mit Fragezeichen versehen:

Code (perl): (dl )

#! /usr/bin/perl5.8.8
use strict;
use warnings;
use diagnostics;
use Data::Dumper;

sub QueryToHash
    {
    my $query       = shift ;           # der string mit der Query
    my %resulthash;
    my @parameter_arr = split /\&/, $query ;
    foreach my $parameter (@parameter_arr)
        {
        my $iref = \%resulthash;
        my ( $p_name, $p_value ) = split /=/, $parameter ;
        my @komponenten = split /_/, $p_name ;  # zerlege name in komponenten
        while( my $komponente = shift  @komponenten )
            {
            if( $komponente =~ /(\d{1,6})/  )   # komponente ist dezimal
                {
                $komponente = scalar $komponente;
                $iref = $iref->[ $komponente ]; # ???
                }
            else 
                {
                $iref = $iref->{ $komponente }; # ???
                }
            }
        $iref = $p_value;    # ???      
        }
    return \%resulthash;
    }
print Dumper( QueryToHash('test_hallo=nix&nur_ein_test_mit_zahl_123=456') );
1;

Edit: Unsinn in Zeile 22 und 26 entfernt!
Last edited: 2009-08-09 11:37:56 +0200 (CEST)

+5 replies
pq

2009-08-09 01:45

User since
2003-08-04
12208 Artikel
Admin1

ich hab mal sowas geschrieben, da ich es schon öfter gebraucht habe und es auch schon öfter gefragt wurde:
HashOfHashesAusArray
Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
lesen: Wie frage ich & perlintro brian's Leitfaden für jedes Perl-Problem
- +2 replies
- scriptor
  
  2009-08-09 01:58
  User since
  2008-05-07
  69 Artikel
  BenutzerIn
  Ja, aber kannst Du mir:
  
  Code (perl): (dl )
  
  $hash = $hash->{$el} ||= {};
  
  erklären?
  „Oder Gleich“ anonymer Hash?
  und wie weise ich letztlich dem Hashpointer einen Wert zu?
  - LanX-
    
    2009-08-09 11:13
    User since
    2008-07-15
    1000 Artikel
    BenutzerIn
    
    2009-08-08T23:58:30 scriptor
    
    Code (perl): (dl )
    
    $hash = $hash->{$el} ||= {};
    
    Code (perl): (dl )
    
    1 2
    
    $hash->{$el} = {} unless $hash->{$el}; $hash=$hash->{$el};
    
    Last edited: 2009-08-09 11:14:51 +0200 (CEST)
    me and my writeups
- +2 replies
- leo11
  
  2009-08-09 09:30
  User since
  2008-08-14
  250 Artikel
  BenutzerIn
  Du schreibst:
  "Sie bekommt die Arrayreferenz ubergeben.."
  
  Ich hätte gedacht, dass $ref je ein Wert aus der Liste ist. Erst a, dann b usw.
  
  Code (perl): (dl )
  
  @$ref
  
  Wieso dereferenzierst du das dann?
  
  Habs leider noch nicht zum laufen bekommen. Wär prima, wenn du das nochmal erklären würdest. Auch die Zeile nach der scriptor gefragt hat.
  - scriptor
    
    2009-08-09 11:00
    User since
    2008-05-07
    69 Artikel
    BenutzerIn
    
    So geht´s:
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7 8 9 10 11
    
    sub hash { my ($ref, $hash) = @_; for my $el (@$ref) { $hash = $hash->{$el} ||= {}; } } my $h = {}; my @array = qw/ a b c d e /; hash( \@array, $h); print Dumper( $h );
    
    Egebnis:
    
    Code: (dl )
    
    1 2 3 4 5 6 7 8 9 10 11
    
    $VAR1 = { 'a' => { 'b' => { 'c' => { 'd' => { 'e' => {} } } } } };
+2 replies

scriptor

2009-08-09 13:24

User since
2008-05-07
69 Artikel
BenutzerIn

Hier nochmal das Beispiel nach den Hinweisen von pq und LanX korrigiert. Wenn die letzte Komponente erreicht ist, wird nun der Wert gesetzt. Funktioniert soweit.
Nicht funktioniert dagegen das Einbauen der Arrays ab Zeile 13. In der Regel wird der $iref auf einen Hash referenzieren, wie kann ich dann eine Liste zuweisen???

Code (perl): (dl )

sub QueryToHash
    {
    my $query       = shift ;           # der string mit der Query
    my %resulthash;
    my @parameter_arr = split /\&/, $query ;
    foreach my $parameter (@parameter_arr)
        {
        my $iref = \%resulthash;
        my ( $p_name, $p_value ) = split /=/, $parameter ;
        my @komponenten = split /_/, $p_name ;  # zerlege name in komponenten
        while( my $komponente = shift  @komponenten )
            {
          if( $komponente =~ /(\d{1,6})/  )   # komponente ist dezimal
               { # ???????????????????????????
                $komponente = scalar $komponente;
#               $iref->[ $komponente ] = [] unless $iref->[ $komponente ];
#                $iref = $iref->[ $komponente ]; 
               }
           else 
               {
                unless( $iref->{$komponente} )
                    {
                    unless( scalar @komponenten )
                        {
                        $iref->{$komponente} = $p_value ;
                        #next;
                        }
                    else
                        {
                        $iref->{$komponente} = {} ;
                        }
                    }
                $iref = $iref->{$komponente};
                }
            }
        }
    return \%resulthash;
    }
print Dumper( QueryToHash('nur_ein_test_mit_zahl_123=456&nur_ein_test_ohne_zahl=789') );

Und dazu die Ausgabe:

Code: (dl )

$iref = {
      'nur' => {
             'ein' => {
                'test' => {
                        'ohne' => {
                            'zahl' => '789'
                              },
                        'mit' => {
                               'zahl' => {
                                   '123' => '456'
              }}}}}};

Gewünscht wäre:

Code: (dl )

$iref = {
      'nur' => {
             'ein' => {
                'test' => {
                        'ohne' => {
                            'zahl' => '789'
                              },
                        'mit' => {
                               'zahl' => [123] = '456'
              }}}}}};

Last edited: 2009-08-09 14:01:34 +0200 (CEST)

MatthiasW

2009-08-09 15:14
User since
2008-01-27
367 Artikel
BenutzerIn
Wieso möchtest du denn da den Array haben? Werden die ersten 123 Einträge (dein Beispiel) überhaupt verwendet?
Du könntest doch auch die Zahl als Schlüssel eines Hash behandeln.

edit: Zudem nehme ich mal an, das dein Wunsch ein anderer ist, als du geschrieben hast?
Du meintest folgendes, oder?
Code: (dl )

1 2 3 4

$iref = { 'nur' => { 'ein' => { 'test' => { 'ohne' => { 'zahl' => '789' }, 'mit' => { 'zahl' => [ undef, ..., 456] } # 456 ist 124. Eintrag }}}}};
MfG
Last edited: 2009-08-09 15:20:53 +0200 (CEST)
perl -E'*==*",s;;%ENV=~m,..$,,$&+42;e,$==f;$"++for+ab..an;@"=qw,u t,,print+chr;sub f{split}say"@{=} me"'

+6 replies

topeg

2009-08-09 15:47

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Das funktioniert.
Ich hoffe es ist nicht zu kompliziert:

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

sub QueryToHash
{
  my $query = shift ;           # der string mit der Query
  my $resulthash={};
  my @parameter_arr = split /\&/, $query ;
  foreach my $parameter (@parameter_arr)
  {
    my ( $p_name, $p_value ) = split /=/, $parameter ;
    my $error=set_value($resulthash,[split('_',$p_name)],$p_value);
    die $error if($error);
  }
  return $resulthash;
}

sub set_value
{
  my $ref=shift;
  my $query=shift;
  my $val=shift;

  # understandable errormessage
  my @path;

  while(@$query)
  {
    my $key=shift(@$query);
    my $ref_type=ref_type($ref);
    my $key_type=key_type($key);
    if($ref_type eq $key_type)
    {
      my $nkey_type=key_type($query->[0]);
      if($nkey_type)
      {
        my $nref=($ref_type eq 'HASH')? $ref->{$key}: $ref->[$key];
        my $nref_type=ref_type($nref);

        if($nref_type)
        { $ref=$nref; }
        else
        {
          # no ref to hash or array
          # create ref
          if($ref_type eq 'HASH')
          {
            $ref->{$key}=($nkey_type eq 'HASH')?{}:[];
            $ref=$ref->{$key};
          }
          else
          {
            $ref->[$key]=($nkey_type eq 'HASH')?{}:[];
            $ref=$ref->[$key];
          }
        }
      }
      else
      {
        # @$query empty
        # set val;
        if($ref_type eq 'HASH')
        { $ref->{$key}=$val; }
        else
        { $ref->[$key]=$val; }
      }
    }
    else
    {
      # ERROR
      return "Type dismatch ref=$ref_type <=> key=$key_type in ".join('_',@path)." ($key)";
    }

    push(@path,$key);
  }

  return 0;
}

sub ref_type
{
  my $ref=shift;
  return undef if(!defined($ref));
  return 'HASH'  if(ref($ref) eq 'HASH');
  return 'ARRAY' if(ref($ref) eq 'ARRAY');
  return undef;
}

sub key_type
{
  my $key=shift;
  return undef if(!defined($key));
  return $key=~/^\d+$/?'ARRAY':'HASH';
}

print Dumper( QueryToHash('nur_ein_test_mit_zahl_123=456&nur_ein_test_ohne_zahl=789') );

Last edited: 2009-08-09 15:54:33 +0200 (CEST)

+5 replies

MatthiasW

2009-08-09 17:49

User since
2008-01-27
367 Artikel
BenutzerIn
[default_avatar]

Hm.. dein Code wirft einige Fragen auf:
* Hast du ein Beispiel für einen 'Type dismatch', ich verstehe nicht so recht, wie es dazu kommen kann.
* Wenn man an deinen Beispielstring ein '&nur_ein_test=10' anhängt, wird die Struktur zerstört. Hier ist der Fragesteller gefragt: Soll dies erlaubt sein?

Wenn es denn wirklich sein muss, würde ich es so machen:

Code (perl): (dl )

#!/usr/bin/perl

use strict;
use warnings;
use Data::Dumper;

my $q = 'ein_test_mit_zahl_123=456&ein_test_ohne_zahl=789';
# dies würde einen fehler erzeugen:
#$q .= '&ein_test=10';

print Dumper(resolve($q)), "\n";

sub resolve {
    my( $query ) = @_;

    my $res = my $tmp = undef;

    for ( split /\&/, $query ) {
        my( $path, $val ) = split /\=/;

        for ( split /\_/, $path ) {
            if ( /^\d+$/ ) {
                $$res = [] if ! defined $res;
                $tmp = $res if ! defined $tmp;
                $res = \$$res->[$_];
            } # if
            else {
                $$res = {} if ! defined $res;
                $tmp = $res if ! defined $tmp;
                $res = \$$res->{$_};
            } # else
        } # for
        
        if ( ref $$res ) {
            die "Incorrect query!\n'$path' points to a location that already holds data.\n";
        } # if
        else {
            $$res = $val;
        } # else
        
        $res = $tmp;
    } #for
    
    return $$res;
} # resolve

MfG

perl -E'*==*",s;;%ENV=~m,..$,,$&+42;e,$==f;$"++for+ab..an;@"=qw,u t,,print+chr;sub f{split}say"@{=} me"'

+4 replies

topeg

2009-08-09 22:10

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Quote
* Hast du ein Beispiel für einen 'Type dismatch', ich verstehe nicht so recht, wie es dazu kommen kann.

Wenn der Schlüssel (bei mir "$key", bei dir "$_") von einem anderen Typ ('HASH' oder 'ARRAY') ist als die Refenz (bei mir "$ref" bei dir "$$res").
Ich halte es für wichtig, das ab zu fangen ohne eine InterpreterWarnung zu provozieren.

Quote
* Wenn man an deinen Beispielstring ein '&nur_ein_test=10' anhängt, wird die Struktur zerstört.

Stimmt habe ich übersehen.
wenn man zwischen Zeile 63/64 folgenden Code einfügt wird das auch abgefangen:

Code (perl): (dl )

1
2

if(ref_type(($ref_type eq 'HASH')? $ref->{$key}: $ref->[$key]))
{ return "Can't replace Reference by Value in ".join('_',@path)." ($key)"; }

Dein Ansatz ist besser, habe nicht mehr daran gedacht, dass man auch Referenzen referenzieren kann. Damit umgeht man das Problem mit dem setzen des Wertes am Schluss.

Aber ich würde es noch ein wenig anders schreiben:

Code (perl): (dl )

sub QueryToHash
{
  my $query = shift ;           # der string mit der Query
  my $result;
  $result={};

  for my $parameter (split(/\&/, $query))
  {
    my ( $p_name, $p_value ) = split(/=/, $parameter,2);
    my $error=set_value($result,[split(/_/,$p_name)],$p_value);
    warn $error if($error);
  }

  return $result;
}

sub set_value
{
  my $ref=shift;
  my $res=\$ref;
  my $query=shift;
  my $val=shift;

  my @path;
  for my $key ( @$query )
  {
    push(@path,$key);
    if ( $key=~/^\d+$/ )
    {
      if(ref($$res) && ref($$res) ne 'ARRAY')
      { return "Incorrect query! last key of '".join('_',@path)."' not same type as in tree\n"; }
      $res = \$$res->[$key];
    }
    else
    {
      if(ref($$res) && ref($$res) ne 'HASH')
      { return "Incorrect query! last key of '".join('_',@path)."' not same type as in refernce\n"; }
      $res = \$$res->{$key};
    }
  }

  if ( ref $$res )
  { return "Incorrect query! '".join('_',@path)."' points to a location that already holds data.\n"; }
  else
  { $$res = $val; }

  return 0;
}

Das gibt ein paar mehr Fehlermeldungen aus und das Zerlegen des QueryStrings ist vom Setzen des Wertes getrennt.

+2 replies

scriptor

2009-08-09 23:24

User since
2008-05-07
69 Artikel
BenutzerIn

topeg und Matthias, sieht gut aus! Danke!
Weiterer Test mit doppeltem Array:

Code (perl): (dl )

print Dumper( QueryToHash('artikel_0_atog_mod_1_hour=14&artikel_0_atog_mod_1_min=20&artikel_0_atog_status_1=edit') );

Code (perl): (dl )

$VAR1 = {
      'artikel' => [
             {
               'atog' => {
                       'status' => [
                             undef,
                             'edit'
                           ],
                       'mod' => [
                          undef,
                          {
                            'hour' => '14',
                            'min' => '20'
                          }
                        ]
                     }
             }
               ]
    };

Wenn ich die Ausgabe richtig interpretiere, ist das Ergebnis richtig.
Jetzt muß ich nur noch das Script verstehen....

Edit: topeg auch am Satzanfang klein geschrieben. ;-)
Last edited: 2009-08-09 23:25:15 +0200 (CEST)

topeg

2009-08-10 01:16

User since
2006-07-10
2611 Artikel
BenutzerIn

user image

Der Code etwas dokumentiert:

Code (perl): (dl )

sub QueryToHash
{
  # der String mit der Querry
  my $query = shift ;
  # durch das sofortige setzen einer Hash-Referenz
  # erzwingen wir das alle Pfade mit einem Hash-Schlüssel beginnen müssen
  # sonst gibt es einen Fehler.
  my $result={};

  # splitten nach "&"
  for my $parameter (split(/\&/, $query))
  {
    # splitten nach dem ersten vorkommenden "="
    # das "2" sagt nur in zwei Teile splitten
    my ( $p_name, $p_value ) = split(/=/, $parameter,2);
    # Das setzen des wertes
    # splitten von Pfadname an "_"
    # und in eine Array Referenz packen.
    my $error=set_value($result,[split(/_/,$p_name)],$p_value);
    # wenn der Rückgabewert definiert und !=0
    # dann haben wir einen Fehler
    warn $error if($error);
  }

  return $result;
}

sub set_value
{
  my $ref=shift;
  
  # "zaubern" mit Zeigern:
  my $res=\$ref;
  # Hier wird der Zeiger auf den Speicherpunkt eines Zeigers,
  # der auf den Anonymen Hash in "$result" verweist, erzeugt
  # Das löst folgendes Problem:
  # Nehmen mir mal an wir haben ein Hash und übernehmen einen Wert daraus:
  # %hash
  # $val=$hash{test};
  # wollen wir den wert in %hash ändern müssen wir 
  # $hash{test}=$val;
  # nutzen, das macht aber bei Referenzen Probleme:
  # $ref=\%hash
  # $ref=$ref->{test};
  # hier können wir nicht schreiben:
  # $ref=$val;
  # und damit den wert in $ref->{test} (bzw. $hash{test}) ändern,
  # da wir den wert ausgelesen
  # und keine Referenz auf $ref->{test} erzeugt haben.
  #
  # wir brauchen also die Referenz auf $hash{test}
  # (beziehungsweise eine Referenz auf $ref->{test}):
  # $ref=\%hash;
  # $refref=\$ref->{test}; # (\$hash{test} ginge auch)
  # so haben wir die Referenz auf $ref->{test} ($hash{test})
  # und nicht mehr den Wert in $ref->{test}
  # Nun können wir mittels
  # $$refref=$val;
  # den wert in $hash{test} ändern.
  
  # anonymes Array
  my $query=shift;
  # Wert der gesetzt werden soll
  my $val=shift;

  # dient zur besseren Ausgabe von Fehlern
  # zeigt den "Ort" im "Baum" wo der Fehler aufgetreten ist.
  my @path;
  
  # Alle Schüssel abarbeiten
  for my $key ( @$query )
  {
    # den aktuellen Schlüssel zum Pfad
    push(@path,$key);
    
    # Wenn der Schlüssel eine Zahl ist,
    # dann muss es ein Array sein,
    # was gesucht wird.
    if ( $key=~/^\d+$/ )
    {
      # Wenn es eine Referenz ist (und nicht undef)
      # und wenn die Referenz kein Array ist
      # Dann haben wir einen Fehler
      if(ref($$res) && ref($$res) ne 'ARRAY')
      { return "Incorrect query! last key of '".join('_',@path)."' not same type as in tree\n"; }
      # merke wenn der Wert "undef" ist,
      # wird automatisch der gewünschte Variablentyp erzeugt
      # hier ein Array-Referenz
      $res = \$$res->[$key];
    }
    else
    {
      # wie oben wird geprüft, ob alles korrekt ist,
      # nur diesmal ob es eine Hash-Referenz ist
      if(ref($$res) && ref($$res) ne 'HASH')
      { return "Incorrect query! last key of '".join('_',@path)."' not same type as in refernce\n"; }
      # wieder schreiben
      # auch hier wird der gewünschte Typ automatisch erzeugt,
      # wenn er nicht vorhanden ist.
      # diesmal eine Hash-Referenz
      $res = \$$res->{$key};
    }
  }

  # wenn der hier eine Referenz enthalten ist,
  # dann stimmt irgend was nicht.
  # also Abbruch
  if ( ref $$res )
  { return "Incorrect query! '".join('_',@path)."' points to a location that already holds data.\n"; }
  else
  {
    # Wert setzen
    $$res = $val;
  }

  # alles gut gegangen
  return 0;
}

Das mit den Referenzen ist für einige nicht ganz einfach zu verstehen. Ich hoffe die Erklärung hat etwas geholfen.

MatthiasW

2009-08-10 11:07

User since
2008-01-27
367 Artikel
BenutzerIn

2009-08-09T20:10:37 topeg
Quote
* Hast du ein Beispiel für einen 'Type dismatch', ich verstehe nicht so recht, wie es dazu kommen kann.

Wenn der Schlüssel (bei mir "$key", bei dir "$_") von einem anderen Typ ('HASH' oder 'ARRAY') ist als die Refenz (bei mir "$ref" bei dir "$$res").
Ich halte es für wichtig, das ab zu fangen ohne eine InterpreterWarnung zu provozieren.

Da war ich gestern wohl etwas verwirrt ;) Danke nochmal für die Erläuterung^^

MfG
perl -E'*==*",s;;%ENV=~m,..$,,$&+42;e,$==f;$"++for+ab..an;@"=qw,u t,,print+chr;sub f{split}say"@{=} me"'

scriptor

2009-08-09 19:51

User since
2008-05-07
69 Artikel
BenutzerIn

Vielen Dank für die Unmenge Code! Ich werd da erst analysieren müssen.
Ich habe auch noch eine eigene Idee...

Die Frage war auch, was möglich sein soll. Ich wollte die Funktion universell halten, in der Praxis werden die Daten meist wohlstrukturiert und vollständig sein.

Typisch:
&artikel_atog_mod_1_hour=14 &artikel_atog_mod_1_min=20 &artikel_atog_status_1=edit

Erlaubt:
&noch_2_moeglich_100_hour=puah

Fehler:
$12_keine_liste_am_anfang=null

View all threads created 2009-08-09 00:58.