Hi, please post an SSCCE. The code you have shown does not compile. It certainly looks as if your solution does not need to be this complicated, but it's hard to know since the code is incomplete.

Your problem description is also unclear. "I want to go into first directory/i/j/*" -- this path does not look like a directory.

If you haven't yet done so, take a look at the module I recommended in your previous thread, Path::Iterator::Rule. Or another module by the same author, Path::Tiny, which provides the handy visit() method. The following should do what you want:

use strict;
use warnings;
use feature 'say';
use Path::Tiny;
use List::Util 'any';

my $regexp = qr/(?:TbhODK|octuov|qas_uop)/;

my $found = path('/some/path')->visit(
    sub {
        my ($path, $results) = @_;
        return if $path->is_dir;
        $results->{$path}++ if any { /$regexp/ } $path->lines;
    },
    { recurse => 1 },
);

say for keys %{ $found };

__END__
[download]

Hope this helps!

Hi 1nickt ! I have updated the code, could you try and run once?

while I go through your code for now thank you !!

I really wish to know what's wrong in the code. :'(

I have review your code. seems like this two Path::Tiny; and List::Util 'any' are helpful module!

I wasn't allowed to install module in the laptop. but I will be sure to check out these soon for own knowledge!

#!/usr/bin/perl
use warnings;
use strict;
use File::Find;

$|++;

# defaults are case-insensitive, no recurse, open and search files (no
+t filename) 

if ($#ARGV < 0){die "Usage zgrep 'pattern' c(case sensitive optional) 
+r(recurse optional) n(search name only optional)
                   examples: zgrep 'debug me' r 
           will recursively search all files for 'debug me'\n";  
               }

my ($recurse, $name, $case) =(0,0,0);
if( grep{/\bn\b/} @ARGV ){@ARGV = grep { $_ ne 'n' } @ARGV; $name = 1 
+};
if( grep{/\br\b/} @ARGV ){@ARGV = grep { $_ ne 'r' } @ARGV; $recurse =
+ 1 };
if( grep{/\bc\b/} @ARGV ){@ARGV = grep { $_ ne 'c' } @ARGV; $case = 1 
+};

#print "$name $recurse $case @ARGV\n";

my $path = '.';

#only accept 1 search string, so quote phrases
my $search = $ARGV[0];

my $regex;  #defaults to case insensitive
if ($case){$regex =  qr/\Q$search\E/}
      else{$regex =  qr/\Q$search\E/i}
# use s modifier for multiline match

find (sub { 
       #skip directories which begin with 1
       if (-d && $_ =~ /^1.*$/) {
        $File::Find::prune = 1;
            return;
        }

     if( ! $recurse ){
      my $n = ($File::Find::name) =~ tr!/!!; #count slashes in file
      return $File::Find::prune = 1 if ($n > 1);
      }

     return if -d;
#     return unless (-f and -T ); # don't waste time on binaries

    if($name){
         if ($_ =~ /$regex/){print "$File::Find::name\n"};
     
     }else{
         return unless (-f and -T ); # don't waste time on binaries
         open (FH,"< $_");
         while(<FH>){
           print "$File::Find::name: $. :$_\n "  if /$regex/;
          }
         close FH;
      }
      
 }, $path);
    
exit;
[download]

thank you for the help !

I'll have a look ! that's very nice.

However, my priority now is to understand what is wrong with my code, which I still cant figure out till now.. :(

what is wrong with my code

My guess is you need to refresh @store_array within the @first_directory loop

foreach my $first (@first_directory){
  my @store_array = qw (1 2 3 4 5 6); # here
  while(my ($i,$j) = splice(@store_array,0,2)){
    my $second_directory = "$first/$i/$j";
  ..
[download]

try

#!/usr/bin/perl
use strict; use warnings;
use File::Glob 'bsd_glob';

my $store_location = '/path/to/file/store.txt';
open my $fh_log, '>', $store_location
   or die "Fail to open file '$store_location' $!";
  
my $Dir1 = "/somewhere";
my $Dir2 = "/somewhereelse";
my @first_directory = ( $Dir1, $Dir2 );

foreach my $first (@first_directory){
  my @store_array = qw (1 2 3 4 5 6 7 8);
  while (my ($i,$j) = splice(@store_array,0,2)){
    my $second_directory = "$first/$i/$j";
    if (-e $second_directory and -d $second_directory){      
       my @files = bsd_glob("$first/$i/$j/*");    
       foreach my $file (@files){
         my $lines = 0;
         my $match = 0;
         open(FILE, "<" , $file) or die "Can't open file '$file': $!";
+    
         while (<FILE>){
            if (/TbhODK|octuov|qas_uop/) {
              ++$match;
            }
            ++$lines;
         }
         print "$file : $lines lines read. $match matches found\n";
         close FILE;    
         print $fh_log "File $file has $match matches\n";
       }
    } else {                
       print $fh_log "Directory $first/$i/$j (fail to exist)\n"; 
    }
    
  }    
}
close $fh_log;
[download]

poj

The problem is your code contains no subroutines , yet contains four loops -- it should contain three subroutines minimum

This seems like a good place to add debugging statements using Data::Dumper (Basic debugging checklist). For example, if you show $second_directory, you'll see

$VAR1 = '/somewhere//1/2';
$VAR1 = '/somewhere//3/4';
$VAR1 = '/somewhere//5/6';
[download]

So first of all, you'll notice the double slashes, which is an issue that you can fix using e.g. File::Spec's catfile and catdir instead of building the strings yourself.

Second, you might notice that '/somewhereelse/' is missing. This is because splice is a destructive operation. As poj showed, one possible solution would be to move the declaration of @store_array right before the while loop that uses it. poj's code also shows how the if with three regexes can be more efficiently written as if ( /TbhODK|octuov|qas_uop/ ), and opening the $store_location once, at the start of the program, instead of re-opening it in append mode for each line of output.

In general, glob has several caveats, which might apply in your case, since you're using variables in the patterns. Switching to one of the other file-handling modules, such as Path::Class and/or File::Find::Rule, would help there.

Other than that, your code looks relatively ok to me; whether it works for you or not will depend on whether the directory structure matches what your code is doing, which we can't tell.