Problème de return avec l'OO

Bonjour à tous,

J'ai un petit souci avec l'orienté objet. ^^ Je débute.
J'ai un module Restriction.pm qui est appelé par une programme Restriction.pl.
Mon module pocède une fonction qui renvoie un résultat

Code:

return (1, $E1, $E2, @Tailles1, @Tailles2);

Que mon programme récupère

Code:

my ($Switch, $E1, $E2, @Tailles1, @Tailles2) = $Enz2->COMPARE($Enz4);

Le problème est que mes deux array (composées de chiffres) sont fusionnées lors de l'envoi.

Mes array dans le module juste avant le return ont pour valeurs
@Tailles1 donne 51, 966, 1968
@Tailles2 donne 698, 2356

Mes array dans le programme juste après leur récupération ont pour valeurs
@Tailles1 donne 51, 966, 1968, 698, 2356
@Tailles2 est vide

Est-ce normal? Pourriez-vous m'expliquer?

Merci,

Jasmine,

Code:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#!/usr/local/bin/perl
 
 
 
#----------------------------------------------- Restriction.pm --------------------------------------------#
#       Ce module prend en entrée des informations de cartes de restriction de plasmides
# (cf ComparaisonRestrictions.pl et Restriction.pl)
#       crée pour chaque enzyme un objet
#                               nom seq plasmide coupé par cette enzyme         $self->{SEQUENCE}
#                               taille seq plasmidique                          $self->{TAILLE}
#                               nom de l'enzyme en question                     $self->{ENZYME}
#                               son site de restriction                         $self->{SITE}
#                               la fréquence à laquelle elle coupe le plasmide  $self->{FREQUENCE}
#                               les positions de coupure                        $self->{POSITIONS}
#       et renvoie les enzymes coupant un nombre différent de fois mes deux plasmides
# ainsi que la taille des fragments obtenus                     return ($E1, $E2, @Tailles1, @Tailles2);
#----------------------------------------------- Restriction.pm --------------------------------------------#
 
 
=h
Dans le programme appelant ce module afin de créer un objet
my $Enz1 = Restriction->new ("Seq1", "5222", "Acc65I", "G'GTAC_C", 2, "1391, 3608");
=cut
 
 
 
use strict;
use warnings;
package Restriction;                                       # nom du package
 
 
sub new                                                 # fonction est définie
{
        my ($Classe, $Sequence, $Taille, $Enzyme, $Site, $Frequence, $Positions) = @_;
        my $self = {};                                  # référence anonyme vers une table de hachage vide
        bless ($self, $Classe);                         # indique que la référence est liée au package (à la classe)
        $self->{SEQUENCE} = $Sequence;
        $self->{TAILLE} = $Taille;
        $self->{ENZYME} = $Enzyme;
        $self->{SITE} = $Site;
        $self->{FREQUENCE} = $Frequence;
        $self->{POSITIONS} = $Positions;
        return $self;
}
1;                                                      # code de retour du module NE PAS OUBLIER
 
 
# fonction de comparaison qui renvoie les enzymes coupant un nombre différent de fois mes deux plasmides
# ainsi que la taille des fragments obtenus
 
sub COMPARE()
{
         my ($E1,$E2) = @_;
         # print $E1->{SEQUENCE}."\t".$E1->{ENZYME}."\t".$E1->{FREQUENCE}."\t". $E2->{SEQUENCE}."\t".$E2->{ENZYME}."\t".$E2->{FREQUENCE}."\n";
         if (($E1->{ENZYME} eq $E2->{ENZYME}) && ($E1->{FREQUENCE} != $E2->{FREQUENCE}))
        {
                # calcul des tailles des fragments de E1
                my @Localisations1 = split(/,/, $E1->{POSITIONS});
                my @Tailles1;
 
                my $i=0;
                foreach my $Loc1 (@Localisations1)
                {
                        $i++;
                        if(exists $Localisations1[$i])
                        {
                                my $taille = $Localisations1[$i] - $Localisations1[$i-1] + 1;
                                push (@Tailles1, $taille);
                                # print "i = ".$i."\t".$Localisations1[$i]."\t".$Localisations1[$i-1]." => $taille\n";
 
                        }
                }
 
                my $SommeT  = 0;
                foreach my $T (@Tailles1)
                {
                        $SommeT  = $SommeT + $T;
                }
                my $taille =  $E1->{TAILLE} - $SommeT;
                push (@Tailles1, $taille);
 
                # calcul des tailles des fragments de E2
                my @Localisations2 = split(/,/, $E2->{POSITIONS});
                my @Tailles2;
 
                my $i2=0;
                foreach my $Loc2 (@Localisations2)
                {
                        $i2++;
                        if(exists $Localisations2[$i2])
                        {
                                my $taille2 = $Localisations2[$i2] - $Localisations2[$i2-1] + 1;
                                push (@Tailles2, $taille2);
                                #print "\ni = ".$i."\t".$Localisations2[$i2]."\t".$Localisations2[$i2-1]." => $taille2\n";
                        }
                }
 
                my $SommeT2  = 0;
                foreach my $T (@Tailles2)
                {
                        $SommeT2  = $SommeT2 + $T;
                }
                my $taille2 =  $E2->{TAILLE} - $SommeT2;
                push (@Tailles2, $taille2);
 
                # renvoi du résultat
               return (1, $E1, $E2, @Tailles1, @Tailles2);
 
        }
        else
        {
                return (0, 0, 0, 0, 0);
        }
}

Code:

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
32
33
34
35
36
37
38
 
#------------- Restriction.pl ----------------#
 
use strict;
use warnings;
use Restriction;
use Data::Dumper;
 
 
 
my $Enz1 = Restriction->new ("Seq1", "5222", "Acc65I", "G'GTAC_C", 2, "1391, 3608");
my $Enz2 = Restriction->new ("Seq1", "5222", "AflIII", "A'CryG_T", 3, "6, 56, 1021");
my $Enz3 = Restriction->new ("Seq2", "5306", "Acc65I", "G'GTAC_C", 4, "63, 1200, 2563, 4038");
my $Enz4 = Restriction->new ("Seq2", "5306", "AflIII", "A'CryG_T", 2, "569, 2879");
 
 
 
my ($Switch, $E1, $E2, @Tailles1, @Tailles2) = $Enz2->COMPARE($Enz4);
 
if ($Switch == 1)
{
        print $E1->{ENZYME}." enzymes égales de fréquence différente\n";
        print "\nLe plasmide ".$E1->{SEQUENCE}." de taille ".$E1->{TAILLE}." est coupée".$E1->{FREQUENCE}." fois\n\t Fragments de tailles : ";
        foreach my $T1 (@Tailles1)
        {
                print "$T1\t";
        }
        print "\nLa plasmide ".$E2->{SEQUENCE}." de taille ".$E2->{TAILLE}." est coupée".$E2->{FREQUENCE}." fois\n\t Fragments de tailles : ";
        foreach my $T2 (@Tailles2)
        {
                print "$T2\t";
        }
}
 
 
 
 
close;