En Perl, quelle est la signification de if (s/^ \ + //)?

Question

Dans un code Perl/Tk Je trouve une déclaration conditionnelle comme ci-dessous

if (s/^\+//) 
{ 
    #do something 
} 
elsif (/^-/) 
{ 
    #do another thing 
} 

On dirait que certains pattern matching a été fait. Mais je ne peux pas le comprendre. Quelqu'un peut-il m'aider à comprendre ce modèle de correspondance?

Answer 1

Ce sont les deux expressions régulières. Vous pouvez lire sur eux au perlre et perlretut. Vous pouvez jouer avec eux sur http://www.rubular.com.

Ils font tous deux implicitement quelque chose avec $_. Il y a probablement un while ou foreach autour de vos lignes de code sans une variable de boucle. Dans ce cas, $_ devient cette variable de boucle. Il peut par exemple contenir la ligne en cours d'un fichier en cours de lecture.

1. Si la valeur actuelle de $_ contient un signe + (plus) comme premier caractère au début de la chaîne, #do somehting.
2. Sinon, s'il contient un signe - (minus), #do another thing.

Dans le cas 1., il remplace également le signe + par rien (c'est-à-dire qu'il le supprime). Il ne supprime pas le - dans 2. cependant.

---

Regardons une explication avec YAPE::Regex::Explain.

use YAPE::Regex::Explain; 
print YAPE::Regex::Explain->new(qr/^\+/)->explain(); 

La voici. Pas vraiment utile dans notre cas, mais un bel outil quand même. Notez que les parties (?-imsx et ) sont les éléments par défaut que Perl suggère. Ils sont toujours là sauf si vous les changez.

The regular expression: 

(?-imsx:^\+) 

matches as follows: 

NODE      EXPLANATION 
---------------------------------------------------------------------- 
(?-imsx:     group, but do not capture (case-sensitive) 
         (with^and $ matching normally) (with . not 
         matching \n) (matching whitespace and # 
         normally): 
---------------------------------------------------------------------- 
^      the beginning of the string 
---------------------------------------------------------------------- 
    \+      '+' 
---------------------------------------------------------------------- 
)      end of grouping 
---------------------------------------------------------------------- 

---

Mise à jour: Comme Mikko L dans les commentaires ont souligné, vous devriez peut-être factoriser/changer ce morceau de code. Bien qu'il fasse probablement ce qu'il est censé faire, je crois que ce serait une bonne idée de le rendre plus lisible. Celui qui l'a écrit ne se souciait évidemment pas de vous en tant que mainteneur tardif. Je vous suggère de faire. Vous pouvez le modifier en:

# look at the content of $_ (current line?) 
if (s/^\+//) 
{ 
    # the line starts with a + sign, 
    # which we remove! 

    #do something 
} 
elsif (m/^-/) 
{ 
    # the line starts witha - sign 
    # we do NOT remove the - sign! 

    #do another thing 
} 

Answer 2

Ce sont des expressions régulières, utilisées pour la correspondance de formes et la substitution.

Vous devriez lire sur le concept, mais comme pour votre question:

s/^\+// 

Si la chaîne a commencé avec un plus, supprimer ce plus (le "s" signifie "substitut"), et return true .

/^-/ 

Vrai si la chaîne commence par un signe moins.

Answer 3

Ce code est équivalent à

if ($_ =~ s/^\+//) { # s/// modifies $_ by default 
    #do something 
} 
elsif ($_ =~ m/^-/) { # m// searches $_ by default 
    #do another thing 
} 

s/// et m// sont les opérateurs de apostrophe regexp. Vous pouvez lire à leur sujet dans perlop.

Answer 4

Les autres réponses ont donné un résumé du fonctionnement du code, mais pas beaucoup de pourquoi. Voici un exemple simple de la raison pour laquelle on pourrait utiliser une telle logique.

#!/usr/bin/env perl 

use strict; 
use warnings; 

my $args = {}; 

for (@ARGV) { 
    if (s/^no//) { 
    $args->{$_} = 0; 
    } else { 
    $args->{$_} = 1; 
    } 
} 

use Data::Dumper; 
print Dumper $args; 

Lorsque vous appelez le script comme

./test.pl hi nobye 

vous obtenez

$VAR1 = { 
      'hi' => 1, 
      'bye' => 0 
     }; 

La clé est la chaîne, si elle est précédée par no puis retirez-le (pour obtenir la clé en question) et placez plutôt la valeur à 0.

L'exemple de l'OP est un peu plus impliqué, mais suit la même logique.

• si le début clé avec un +, retirez-le et faire quelque chose
• si le début clé avec un -, ne suppriment pas et faire quelque chose d'autre