Schrift
Wiki:Tipp zum Debugging: use Data::Dumper; local $Data::Dumper::Useqq = 1; print Dumper \@var;
Start · Board · Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl
[thread]11424[/thread]

Ganz simple Frage zum Operator !~



<< >> 9 Einträge, 1 Seite
Array
 2008-03-06 22:15
#106686 #106686
User since
2008-02-27
6 Artikel
BenutzerIn
[default_avatar]
Hallo Leute,

ich habe mich jetzt mal angemeldet, weil ich wahrscheinlich doch mal etwas öfters Hilfe brauchen werde.
An dieser Stelle nochmals Danke an alle die mir letzens bei meiner Frage zur for-Schleife geholfen haben.

Folgendes Problem habe ich heute:


Code (perl): (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

#!/usr/bin/perl -w

$muster ='(\d+\.\d+)';
$text = 4.12;
print "\$text: $text\n";


if (@zahlen = $text =~ m/$muster/)
        {print "(1) wahr: @zahlen\n";}
        else
        {print "(1) falsch: @zahlen\n";}
        
if (@zahlen = $text !~ m/$muster/)
        {print "(2) wahr: @zahlen\n";}
        else
        {print "(2) falsch: @zahlen\n";}
        
        
$text = 4.0;
print "\$text: $text\n";


if (@zahlen = $text =~ m/$muster/)
        {print "(3) wahr: @zahlen\n";}
        else
        {print "(3) falsch: @zahlen\n";}
        
if (@zahlen = $text !~ m/$muster/)
        {print "(4) wahr: @zahlen\n";}
        else
        {print "(4) falsch: @zahlen\n";}


Lese ich die Zahl 4.12 ein, gibt er mir (1) wahr: 4.12 aus. Ok, ist noch zu verstehen. Warum aber gibt er mir ebenso (2) wahr: (ohne Inhalt) aus??
Bei der zweiten if-Abfrage muss doch wegen des !~ Operators falsch ausgegeben werden, weil bei der ersten if-Abfrage wegen der Übereinstimmung die Abfrage true ist!

Die zweite Zahl ist 4.0. Hier bekomme ich (3) falsch: (ohne Inhalt). Verstehe ich auch, letzendlich wird nur 4 eingelesen und das Muster stimmt nicht mehr.
Ebenso bekomme ich (4) wahr: 1. Hier kann ich es nachvollziehen, 1 wird wahrscheinlich true bedeuten.

Normalerweise müsste das doch ganz simpel sein, oder beachte ich hier irgend eine Besonderheit nicht??


Vielen Dank für euere Bemühungen,

Array
KurtZ
 2008-03-06 22:39
#106687 #106687
User since
2007-12-13
411 Artikel
BenutzerIn
[default_avatar]
mal aus der Hüfte geschossen ...

Du überprüfst ob dem Array @zahlen etwas zugewiesen wird, lass mal weg und gib dafür $1 aus.
TMTOWTDYOG (there's more than one way to dig your own grave)
Linuxer
 2008-03-06 22:40
#106689 #106689
User since
2006-01-27
3890 Artikel
HausmeisterIn

user image
Du prüfst den Erfolg der Zuweisung, nicht den Erfolg des Matchings....

Quote
~ $ perl
if ( @aa = 4.12 !~ m/\d+\.\d+/ ) {
print "wahr", $/;
} else {
print "falsch", $/;
}


wahr
~ $ perl
if ( 4.12 !~ m/\d+\.\d+/ ) {
print "wahr", $/;
} else {
print "falsch", $/;
}


falsch
~ $
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!
KurtZ
 2008-03-06 22:55
#106690 #106690
User since
2007-12-13
411 Artikel
BenutzerIn
[default_avatar]
jup dachte ich mir !~ liefert dir ein leeres Array, das existiert und ist wahr, liefert beim Ausdruck nur Luft. Schau mal bei perlop was genau !~ liefern sollte (grübel ... )

Mit Data::Dumper schaust du in die Strukturen, und wenn du die Nachkomma in 4.0 behalten willst mach nen String draus

Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/perl -w
use Data::Dumper;
$\="\n";

$muster ='(\d+\.\d+)';
for $text ( qw( 4.12 4.0 ) ) {
        
        print "\n\n\$text: $text\n";


        if (@zahlen = ( $text =~ m/$muster/ ) )
                {print ++$count,". wahr: @zahlen\n",Dumper \@zahlen;}
        else
                {print ++$count,". falsch: @zahlen\n",Dumper \@zahlen;}
        
        if (@zahlen = ( $text !~ m/$muster/ ) )
                {print ++$count,". wahr: @zahlen\n",Dumper \@zahlen;}
        else
                {print ++$count,". falsch: @zahlen\n",Dumper \@zahlen;}
        
}
TMTOWTDYOG (there's more than one way to dig your own grave)
KurtZ
 2008-03-06 23:11
#106691 #106691
User since
2007-12-13
411 Artikel
BenutzerIn
[default_avatar]
KurtZ+2008-03-06 21:55:49--
jup dachte ich mir !~ liefert dir ein leeres Array, das existiert und ist wahr, liefert beim Ausdruck nur Luft. Schau mal bei perlop was genau !~ liefern sollte (grübel ... )


Also für mich siehts so aus als hätte !~ überhaupt keinen Listenkontext sondern nur den Wahrheitswert im scalaren Kontext. EDIT ein schönes Beispiel für eine fehlende Orthogonalität in Perl, die aber keiner vermisst

Dat ist bei Perl bei FALSE ein Leerstring der dann in dein array gepackt wird. Bei TRUE ist es hingegen 1 (die du auch in ein Array wickelst).

Mein Tip, wenn du wirklich ein Array aller Teilmatches haben willst dann nutze =~ und negiere die gesamte Aussage mit "unless" oder "if not"

Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/perl -w
use Data::Dumper;
$\="\n";

$muster ='(\d+)(\.)(\d+)';
for $text ( qw( 4.12 4 ) ) {
        
        print "\n\n\$text: $text\n";


        if (@zahlen = ( $text =~ m/$muster/ ) )
                {print ++$count,". wahr: @zahlen\n",Dumper \@zahlen;}
        else
                {print ++$count,". falsch: @zahlen\n",Dumper \@zahlen;}
        
        if (not @zahlen =  ($text =~ m/$muster/)  )
                {print ++$count,". wahr: @zahlen\n",Dumper \@zahlen;}
        else
                {print ++$count,". falsch: @zahlen\n",Dumper \@zahlen;}
        
}


[nop]$text: 4.12

1. wahr: 4 . 12
$VAR1 = [
'4',
'.',
'12'
];

2. falsch: 4 . 12
$VAR1 = [
'4',
'.',
'12'
];



$text: 4

3. falsch:
$VAR1 = [];

4. wahr:
$VAR1 = [];
[/nop]

Alles klar???
TMTOWTDYOG (there's more than one way to dig your own grave)
KurtZ
 2008-03-06 23:33
#106692 #106692
User since
2007-12-13
411 Artikel
BenutzerIn
[default_avatar]
KurtZ+2008-03-06 21:55:49--
jup dachte ich mir !~ liefert dir ein leeres Array, das existiert und ist wahr, liefert beim Ausdruck nur Luft.


na Super wieder Blödsinn erzählt! :)

Das Array ist WAHR weil es eben nicht leer ist, es hat genau ein Element nämlich den Leerstring der anzeigt das !~ FALSCH geliefert hat. Beim Ausdruck gibts dann trotzdem nur Luft.

Ein leeres Array hingegen hat immer den Wahrheitswert FALSCH. (siehe letztes Beispiel)
TMTOWTDYOG (there's more than one way to dig your own grave)
pq
 2008-03-07 15:54
#106806 #106806
User since
2003-08-04
12208 Artikel
Admin1
[Homepage]
user image
KurtZ+2008-03-06 22:11:49--
Also für mich siehts so aus als hätte !~ überhaupt keinen Listenkontext sondern nur den Wahrheitswert im scalaren Kontext. EDIT ein schönes Beispiel für eine fehlende Orthogonalität in Perl, die aber keiner vermisst

was sollte denn !~ bitteschön in einem array liefern? mit !~ fragt man nur, ob ein ausdruck *nicht*
matcht. warum will man das in einem listenkontext?
die gematchten teile bekommt man ja nur bei einer positiven abfrage.
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: Wiki:Wie frage ich & perlintro Wiki:brian's Leitfaden für jedes Perl-Problem
KurtZ
 2008-03-07 16:36
#106810 #106810
User since
2007-12-13
411 Artikel
BenutzerIn
[default_avatar]
pq+2008-03-07 14:54:50--
was sollte denn !~ bitteschön in einem array liefern? mit !~ fragt man nur, ob ein ausdruck *nicht*
matcht. warum will man das in einem listenkontext?
die gematchten teile bekommt man ja nur bei einer positiven abfrage.


!~ ist die negierung von =~ . Würde es sich Orthogonal verhalten , dann müsste es beim Match im Listenkontext etwas liefern, und im Skalaren FALSCH sein. Das Problem dieser Orthogonalität wäre nur das die Liste im Booleschen Kontext aber WAHR wäre, d.h.

if (@match = $string !~ /.../) verhielte sich konträr zu if ($string !~ /.../)

Wie gesagt eine Orthogonalität die keiner vermisst.
TMTOWTDYOG (there's more than one way to dig your own grave)
Array
 2008-03-08 15:19
#106830 #106830
User since
2008-02-27
6 Artikel
BenutzerIn
[default_avatar]
Vielen Dank an alle, v. a. KurtZ!!

Ich dachte eben, dass sich der Operator !~ absolut gleich (natürlich in negierter Art und Weise) verhält wie der Operator =~. Daher kam ja die Frage.
Aber da ich jetzt ja über die fehlende Orthogonalität aufgeklärt worden bin, leuchtet es mir ein.


Viele Grüße

Array
<< >> 9 Einträge, 1 Seite



View all threads created 2008-03-06 22:15.