Regex - Exakten String ersetzen (Allgemeines zu Perl)

[thread]21182[/thread]

Regex - Exakten String ersetzen

Tags: perl5 regex replace Similar Threads

Readers: 9

Articles: hide open all | hide show old branches

+7 replies
guest YAPD

2021-04-18 18:02
Hi Leute,

ich hoffe, es geht Euch gut in Corona Zeiten. :)

Ich habe mal eine kurze Frage zu Regex. Und zwar
möchte ich für meine Log - Verarbeitung das Package
aufsplitten.
Code: (dl )

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

my $LH_Module = ( caller( 1 ) )[ 3 ]; # Das ist der Aufruf my $LH_Package = $LH_Module; print "Package : $LH_Package" , "\n"; # Bestimmung des Caller - Aufrufs ( Sub - Routine ) my $LH_Caller = ( split( /::/ , ( caller( 1 ) )[ 3 ] ) )[ -1 ]; print "Caller : $LH_Caller" . "\n"; # Entfernung der Sub - Routine aus der Modul - Bezeichnung $LH_Module =~ s/\::$LH_Caller//; print "Module : $LH_Module" . "\n";
Beispiele :
Kernel::Extensions::IMCR
Kernel::Extensions::IMCR::Tester

Mein Problem ist dass, wenn ich z.B. den Log - Handler vom
Package Kernel::Extensions::IMCR lade, ist alles richtig :

> Package : Kernel::Extensions::IMCR::Loader
> Caller : Loader
> Module : Kernel::Extensions::IMCR

Lade ich den Log Handler aber über das Package Kernel::Extensions::IMCR::Tester in der Sub - Routine
Test( ), ersetzt er mir nicht nur die letzte Sub sondern
auch den Namen "Tester" davor :

> Package : Kernel::Extensions::IMCR::Tester::Test
> Caller : Test
> Module : Kernel::Extensions::IMCRer::Test -----> Hier müsste
"Kernel::Extensions::IMCR::Tester" stehen.

Ich weiss, dass ich Regex so ausführen muss, dass er den exakten
String ersetzt, also in dem Fall "::Test" und nicht "::Tester
davor ( hier bleibt ja das er übrig ).

Leider krieg ich es einfach nicht hin. :(

Ich hoffe, ihr könnt mir hier helfen.

Vielen Dank & Viele Grüße
YAPD
Last edited: 2021-04-18 18:06:07 +0200 (CEST)
- barney
  
  2021-04-18 19:41
  User since
  2008-08-31
  236 articles
  BenutzerIn
  Haller,
  
  die Extraktion der letzten Sub aus den gesplitteten caller ist etwas verunglücket.
  
  Code: (dl )
  
  my $LH_Caller = ( split( /::/ , ( caller( 1 ) )[ 3 ] ) )[ -1 ];
  
  Der Ausdruck split( /::/ , ( caller( 1 ) )[ 3 ] liefert bereits einen einzelnen String. ( $String )[-1] liefert den letzten Wert der Liste zurück also $String. Das ()[-1] kann man sich also sparen.
  
  [ 3 ] liefert den vierten Wert einer Liste zurück. Gewünscht ist aber anscheinend der letzte Wert. Die richtige Lösung lautet also:
  
  Code: (dl )
  
  my $LH_Caller = (split( /::/ , ( caller( 1 ) )[ -1 ];
  
  Schöner ist vielleicht:
  
  Code: (dl )
  
  my ($LH_Caller) = reverse split /::/, caller(1);
- +5 replies
- Linuxer
  
  2021-04-18 20:18
  User since
  2006-01-27
  3894 articles
  HausmeisterIn
  Keine Ahnung, ob ich Dich hiermit richtig verstehe...
  
  Ich würde es nicht erst splitten und dann ein Substitute drüber jagen.
  Sondern entweder mit einem Regex-Match den letzten Teil vom Rest trennen;
  oder komplett am :: splitten und dann die gewünschten Teile verwenden.
  
  Variante 1:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
  
  #! /usr/bin/env perl use strict; use warnings; use 5.020; my $package = "Kernel::Extensions::IMCR::Loader"; my ( $module, $caller ) = $package =~ m{(\S+)::([^:]+)$}; say "Package: $package"; say "Module: $module"; say "Caller: $caller"; __END__;
  
  Variante 2:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  
  #! /usr/bin/env perl use strict; use warnings; use 5.020; my $package = "Kernel::Extensions::IMCR::Loader"; my @elements = split m/::/, $package; my $caller = pop @elements; my $module = join "::", @elements; say "Package: $package"; say "Module: $module"; say "Caller: $caller"; __END__;
  
  Last edited: 2021-04-19 09:51:55 +0200 (CEST)
  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!
  - +4 replies
  - guest YAPD
    
    2021-04-19 16:15
    Hi Linuxer,
    
    vielen Dank für deine Antwort :) Die von dir zur Verfügung gestellte
    Lösung funktioniert so, wie es sein sollte. Allerdings habe ich noch
    eine weitere Anschlussfrage.
    
    Zur Erklärung :
    
    Ich brauche das für meine Log - Verarbeitung meiner Anwendung, denn
    egal welches Modul aufgerufen wird, sollen diese 3 Informationen ( Package [ Alles] , Module und Caller ) zur Verfügung stehen. Ich prüfe hier anhand des Modul, ob es eine Software Extension ist, da die Log Verarbeitung es dann anders verarbeitet. Der Config Eintrag sieht so aus :
    
    Code: (dl )
    
    1 2 3 4
    
    $Self -> { Software_Extensions } = { 'IMCR' => { 'Bezeichnung' => 'IManage Config Reader' , 'Release' => '2.1.0' , 'Module' => 'Kernel::Extensions::IMCR' } };
    
    Mein Problem ist jetzt noch, dass ich immer das Standard Module brauche, also in diesem Fall 'Kernel::Extensions::IMCR'. Also sollte
    beim Package 'Kernel::Extensions::IMCR::Tester::Test' als Module nur 'Kernel::Extensions::IMCR' übrig bleiben.
    
    Ich hoffe, dass ich es einigermaßen gut erklärt habe.
    
    VG
    YAPD
    Last edited: 2021-04-20 17:47:44 +0200 (CEST)
    - +3 replies
    - Linuxer
      
      2021-04-19 20:03
      
      User since
      2006-01-27
      3894 articles
      HausmeisterIn
      
      Wenn das "Standard Module" immer fix ist, dann könnte man mit diesem Wissen die Variante 2 modifiziert verwenden.
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
      
      #! /usr/bin/env perl use strict; use warnings; use 5.020; my $package = "Kernel::Extensions::IMCR::Tester::Test"; # Annahme, es ist immer etwas mit Kernel::Extensions::IMCR::* my @elements = split m/::/, $package; my $module = join "::", splice(@elements,0,3); # immer die ersten drei Teile als Modul annehmen my $caller = join "::", @elements; # der Rest wird zum caller zusammengesetzt say "Package: $package"; say "Module: $module"; say "Caller: $caller"; __END__;
      
      Wenn die zu zerlegenden Namen variabel sind, lässt sich das nicht mehr so einfach machen.
      Dann muss mehr Wissen ins Programm integriert werden, um die korrekten Stellen zum Trennen zu finden.
      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!
      - +2 replies
      - YAPD
        
        2021-05-23 14:23
        
        User since
        2015-09-20
        146 articles
        BenutzerIn
        
        Hi Linuxer,
        
        erstmal vielen Dank für deinen letzten Beitrag und sorry, dass die
        Antwort so lange gedauert hat :)
        
        Zu meiner Problematik :
        
        Dein Vorschlag, die Split( ) Funktion zu nutzen, funktioniert zwar
        im Prinzip, es ist mir allerdings zu unsicher, da nicht sicher gestellt
        werden kann, dass immer die ersten 3 Module Standard sind.
        
        Ich verwende es für meine Log - Verarbeitung und möchte gerne
        festlegen, ob ein Modul eine Extensions ist. Des weiteren brauche
        ich den Namen des Moduls, da ich in diesem Fall den Namen des Moduls
        anhänge :
        
        Code: (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13
        
        my $LG_Package = "IMCR"; if( $LG_FH_Mode eq "Standard" ) { $LG_FH_Signifier = $LG_Signifier_Standard . "_" . "Standard"; $LG_FH_Directory = $LG_Directories_Standard; } if( $LG_FH_Mode eq "SE" ) { $LG_FH_Signifier = $LG_Signifier_Standard . "_" . $LG_Package; $LG_FH_Directory = $LG_Directories_Extensions; }
        
        Wie du siehst, ist hier das Paket 'LG_Package' noch fest definiert, doch
        hier brauche ich den Namen des Moduls, damit er die Datei richtig schreibt.
        
        Zur meiner Lösung :
        
        Ich lade ja als den Kernel des Objekt - Managers, der dann überall zur Verfügung steht :
        
        Code: (dl )
        
        local $Kernel::OM = Kernel::OM -> New( Debug_Mode => $Parameter{ Debug_Mode } );
        
        Ich lade das Modul über die jeweilige new( ) Methode des Moduls. Hier z. B. die
        Sub - Routine aus "Kernel::Extensions::IMCR' :
        
        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
        
        sub new { # Initialisierung des Konstruktors my ( $Class , %Parameter ) = @_; my $Self = { }; bless( $Self , $Class ); # ------------------------------------------------------------------------------------------ $Kernel::OM -> { SE } -> { 'Kernel::Extensions::IMCR' } -> { Name } = "IMCR"; $Self -> { Testumgebung } = 'ERFOLG'; my $LH = $Kernel::OM -> Load( 'Kernel::Logs' ); $LH -> Log( Prio => 'Error' , Code => 'T1000' , MSG => 'Testumgebung' ); return $Self; }
        
        Ich wollte erst einen Flag wie "Self -> { SE }" setzen und im Object - Loader abfragen, aber
        dann funktioniert die hier abgebildete Log - Verarbeitung in der new Methode nicht ( da er
        noch nicht weiß, dass es eine Extension ist ).
        
        Also habe ich das Package direkt im Objekt - Manager abgelegt, was den Vorteil hat, dass ich
        sowohl prüfen kann, ob es eine Extension ist und ich habe gleichzeitig den Namen für den
        Dateinamen der Logs.
        
        Code: (dl )
        
        $Kernel::OM -> { SE } -> { 'Kernel::Extensions::IMCR' } -> { Name } = "IMCR";
        
        Ich weiß nicht ob dies die beste Lösung ist, aber dein Vorschlag funktioniert leider aus dem Grund nicht
        dass es immer verschiedene Module mit einer verschiedenen Anzahl von "::" ist. Hier den Namen zu
        identifizieren, finde ich fast unmöglich.
        
        Ich hoffe, du kannst mir eine Ratschlag geben, ob dies so verwendbar ist, oder vielleicht hast du ja
        eine bessere Idee :)
        
        Vielen Dank im Voraus !
        
        VG
        YAPD
        Last edited: 2021-05-23 14:27:04 +0200 (CEST)
        Yet Another Perl Developer
        
        Linuxer
        
        2021-07-01 20:16
        
        User since
        2006-01-27
        3894 articles
        HausmeisterIn
        
        Hi YAPD,
        
        späte Antworten sind nicht schlimm.
        
        Aber ich muss gestehen, dass mir Deine Antwort vollkommen entgangen ist und ich sie jetzt erst durch Zufall entdeckt habe.
        
        Keine Ahnung, ob das noch irgendwie akut ist, oder ob Du das bereits irgendwie gelöst hast.
        
        Zum Beitrag:
        
        Ich muss allerdings vorab gestehen, dass ich den gesamten Aufbau des ganzen - trotz Deiner Versuche - nicht wirklich verstehe und durchblicke. Ganz ehrlich, mir kommt das alles vom Grundaufbau sehr seltsam vor.
        
        Quote
        Ich wollte erst einen Flag wie "Self -> { SE }" setzen und im Object - Loader abfragen, aber dann funktioniert die hier abgebildete Log - Verarbeitung in der new Methode nicht ( da er noch nicht weiß, dass es eine Extension ist ).
        
        Wenn Du ein "Self -> { SE }" setzen kannst, dann kannst Du diese Information doch auch setzen, bevor Du die Log-Verarbeitung in der gleichen new Methode aufrufst, und diese Information dann der Log-Methode mitgeben?
        
        Meine Gedanken (in Unverständnis über die gegebenen Strukturen) dazu wären:
        
        1. Wenn es Module und Extensions gibt, würde ich ein Kennzeichen einführen, woran das klar erkennbar wird.
        
        2. Entweder durch klar erkennbare Namensräume wie *::Module::* oder *::Extension::*
        
        3. Wenn es natürlich Extensions von Modulen gibt, wird das wiederum komplizierter, aber immer noch lösbar. Der Knackpunkt ist hier, eine Struktur festzulegen und sich anschließend daran halten und keinen Wildwuchs betreiben.
        
        4. Oder durch Kennzeichnung in jede(m|r) Modul/Erweiterung; z.B. durch einen Eintrag im $self, wie Du schon selber überlegt hattest.
        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!

View all threads created 2021-04-18 18:02.