use experimental 'smartmatch';

Just be aware that smartmatch is pretty much consigned to history now. It's OK(ish) for little one-offs but I would not be basing any new code on it myself.

"It is clear that smartmatch is almost certainly either going to change or go away in the future. Relying on its current behavior is not recommended."

Just a small nit to pick with this line of code:

        ($ipentry,@domains)=split('\s{1,}|\t',$ligne);                
+                    # on "splitte" à un ou plusieurs espaces ou à une
+ tabulation
[download]

Your regular expression /\s{1,}|\t/, which can also be expressed as /[ \t\r\n\f]{1,}|\t/, says to match one or more whitespace characters (which includes the TAB character) or if that doesn't match then match a TAB character.

Your comment says that you want this regular expression: / {1,}|\t/ (or / +|\t/)

G'day soundlord,

Here's a few tips for this, and all your other Perl scripts, on your current O/S with your stated Perl version. Change

use strict;
use warnings;
[download]

to

use 5.026;
use warnings;
use autodie;
use utf8;
[download]

use 5.026; gives you all the features of your Perl version and use strict; automatically. There's many you can use here, and in other scripts; one that stands out in your posted code is, instead of adding "\n" to the end of your print statements, you can use say: 'say "XYZ";' is the same as 'print "XYZ\n";'.

use warnings; -- no change; use it always.

The autodie pragma will handle your I/O exceptions for you. '... or die "$targetfile not found :{";' is a poor error message: you're guessing at "not found" but it could be, for instance, a permission problem ($! is typically used to get the reason open() failed). Just code "open my $descripteur, '<:encoding(UTF-8)', $targetfile;" and leave the rest up to autodie.

One of my $work machines is openSUSE Leap 15.2 with Perl v5.26.1 -- I assume the same, or very close, to what you have. I too can get away with using UTF-8 characters (e.g. é) in my source code without "use utf8;"; someone else using your code may not. Play it safe and use the utf8 pragma.

If your first line is

#!/usr/bin/env perl
[download]

you can run your script as "./script.pl", instead of "perl script.pl". See perlrun for more about that.

foreach my $key (keys %hashEntries)
{
    my @temp=$hashEntries{$key};
    
    #print "Elements: ".@temp."\t";
    
    print "[After no dump] Test 2 $key ->\t";
    foreach my $element (@temp)
    {    
        if($element ~~ /ARRAY/)
        {
            print "Array détecté...\t";
            foreach my $autreelement (@$element)
            {
                    print "[@$autreelement]\n";
                    $lesdomaines.="@$autreelement";
                    $lesdomaines.="\t";
            }
        }
        else
        {
            print "[@$element]\n";
            $lesdomaines.="@$element";
            $lesdomaines.="\t";
        }
    }
    print $key."\t".$lesdomaines."\n"; 
    $lesdomaines="";
}
[download]

This is not a good solution. This is quite a poor solution. You shouldn't be checking if the value is an array reference. It should always be an array reference.

use List::Util    qw( uniq );
use Sort::Natural qw( natsort );

my %data;
while ( <$fh> ) {
   chomp;
   my ( $ip, @hosts ) = split;
   push @{ $data{ $ip } }, @hosts;
}

for my $ip ( natsort keys( %data ) ) {
   my @hosts = natsort uniq @{ $data{ $ip } };
   say join "\t", $ip, @hosts;
}
[download]

Actually, I'd use a hash of hashes since it will handle duplicates. The code would look something like this:

use Sort::Natural qw( natsort );

my %data;
while ( <$fh> ) {
   chomp;
   my ( $ip, @hosts ) = split;
   ++$data{ $ip }{ $_ } for @hosts;
}

for my $ip ( natsort keys( %data ) ) {
   my @hosts = natsort keys %{ $data{ $ip } };
   say join "\t", $ip, @hosts;
}
[download]

It needs to handle blank lines and comments, but you get the idea.

You don't need to use natsort, but it provides a better sort order than sort. In fact, you don't have to use any sorting at all, but it's nicer.

Hello!

I'm assuming that you call 'element' a value of $hash{$key} (because in a canonical way of speaking 'element' is a pair of key and value in a hash).

foreach my $element (values %hash) {
  if (ref $element eq ref []) {
  }
  # OR 
  if (ref $element eq 'ARRAY') {
  }
}
[download]

my $number_of_elements = scalar keys %hash;
[download]

There can be only one reference in a hash value. Did you mean "avoid pushing ARRAY into hash element, if it's already an ARRAY ref"?

my %hash;
foreach my $pair (qw/1_one 1_two 2_one 2_two/) {
  my ($key, $val) = split('_', $pair);
  if (not exists $hash{$key}) {
    $hash{$key} = [];
  }
  push @{ $hash{$key} }, $val;
}
[download]

My bad :{
I forgotten the "else part" of the "if" so... as a real beginner, the hashes are outputed :{
The part 3 is answered so...