foreach my $unique (@second_list_new)
{
    if ($unique ~~ @first_list_new))
    {
        print "already there $unique\n\n";
    }
    else
    {
        print "newly in this $unique\n\n";
    }
}
[download]

    if (grep (/^\Q$unique\E$/,@first_list_new))
[download]

     my @first_list_new = map { s/\s*$//m; lc $_ } <FIRST_LIST>;
[download]

The behaviour of smart match on arrays may well change in Perl 5.18 or 5.20.

This works quite nicely for me...

use strict;
use warnings;
use File::Slurp qw( slurp );
use Syntax::Keyword::Junction qw( any );

my @first  = map { lc($_) } slurp('file1.txt');
my @second = map { lc($_) } slurp('file2.txt');

chomp(@first, @second);

print "Machines extra in second list...\n";

for my $machine (@second)
{
    if ($machine eq any(@first)) {
        print "$machine is already there\n";
    }
    else {
        print "$machine is new\n";
    }
}
[download]

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

Wasn't familiar with Syntax::Keyword::Junction, so I appreciate seeing it used here. Also, File::Slurp's a good module to use...

Since the OP's comparing lists, List::Compare can help find unique entries in file2.txt:

use Modern::Perl;
use File::Slurp qw/read_file/;
use List::Compare;

my %hash;

my @file1 = map { chomp; lc } read_file 'file1.txt';
my @file2 = map { chomp; lc } read_file 'file2.txt';

my $lc = List::Compare->new( \@file1, \@file2 );

my @file2Only = $lc->get_Ronly;

say for @file2Only;
[download]

Output:

nt64osbld2
nt64osbld3
nt64oscitrix1
ntosbld4
ntosbld5
ntosbld6
vm-osw2k8x64-1
vm-osw2k8x64-2
[download]

Not in the OP's output formatting, but that wouldn't take much more...

I think (hope!) that smart match is mature enough at this point that you can rely on its behavior not changing for such a basic case.

Nevertheless, another way of solving the problem is always useful.




When's the last time you used duct tape on a duct? --Larry Wall

if (grep { $_ eq $unique } @first_list_new) {
   ...;
}
[download]

Hi tobyink, did you try this? i am getting syntax error if i replaced with what you gave. Thanks & Regards, Divakar

My suggested grep has been correct Perl syntax since Perl 5.0. (Perhaps before?)

Note there are no parentheses after the grep... not this:

grep({ ... } @list)
[download]

And note that there's no comma after the block... not this:

grep { ... }, @list
[download]

It just needs to be like this:

grep { ... } @list
[download]

If you really want parentheses, they can go on the outside:

(grep { ... } @list)
[download]

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

I believe the way you have it is a correct way to do it (see grep):

grep ( /^$unique$/, @first_list_new )
[download]

An alternate syntax is:

grep { /^$unique$/ } @first_list_new
[download]

This would be much quicker than using grep for what you seem to be doing.

I agree that, all else being equal, this would be the best design.

However, it ultimately depends on what the rest of the code does.




When's the last time you used duct tape on a duct? --Larry Wall

Not really. Even if the code uses both arrays then there is nothing preventing building a temporary hash through

my %hash = map { $_ => 1 } @first_list;
[download]

..and then discarding the hash after the check for new machines. More likely is that he is only interested in the second list, or just new machines, and they could be in an array just like before.
A Monk aims to give answers to those who have none, and to learn from those who know more.

EDIT: After incorporating tobyink's or ColonelPanic's suggestion, I get the same results, but it is now safe against regex metacharacters

use warnings;
use strict;

my @first_list;
my @second_list;
my %first_lc;
my @second_lc;

open FIRST_LIST, "< first_list.txt" or print $! "\n";
@first_list=<FIRST_LIST>;
close (FIRST_LIST);
chomp (@first_list);

open SECOND_LIST, "< second_list.txt" or print $! "\n";
@second_list=<SECOND_LIST>;
close (SECOND_LIST);
chomp (@second_list);

# create look up of machines in lower case
my %first_lc = map { lc => 1 } @first_list;
# not stricty necessary could use map in loop
my @second_lc = map { lc } @second_list;

print "Machines extra in second list\n\n";
foreach my $unique (@second_lc)
{
    if (exists $first_lc{$unique})
    {
        print "already there $unique\n\n";
    } else {
        print "newly in this $unique\n\n";
    }
}
[download]