Hello ppp,

Please see the entry “How do I change, delete, or insert a line in a file, or append to the beginning of a file?” in perlfaq5. Note the following:

The basic idea of inserting, changing, or deleting a line from a text file involves reading and printing the file to the point you want to make the change, making the change, then reading and printing the rest of the file. Perl doesn't provide random access to lines...

Once the new file has been written successfully, delete the original and rename the new file using either the builtin rename function or the move function from File::Copy.

Hope that helps,

Hii, Thanks for the answer. please see the EDIT part in my answer i tried it but it deltes all the text file.

while (my $line = <$fhi>) 
    {   
      //Here i write the code to get the time from text file in ech li
+ne and below i check in if condition if that exceed 34 hours then flu
+sh that line 
      
        if($Time >'34')
        { 
          $fhi->autoflush; 
        }
        print $fho;

    }
[download]

The autoflush function isn’t going to help you here. You need logic like this (untested):

while (my $line = <$fhi>)
{
    # get $time

    print $fho $line unless $time > 34;
}
[download]

That is: print to the output file only those lines which pass the test, and silently ignore those which don’t. And note that your statement: print $fho; needs to be changed to print $fho $line; in order to work correctly here.

Hope that helps,

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

I suggest you use module Tie::File. It allows you to treat the file just like an array, so adding, editing and removing lines is as easy as array operations.

use strict;
use warnings;
use Tie::File;

tie my @lines, 'Tie::File,  'ListOfIpAdress.txt' or die "$!";
# define sub F such that it returns 0 if Time > 34, 1 otherwise
@lines = grep { F($_) } @lines;
untie @lines;
[download]

Hii, Thanks , i tried thsi but doesnt change anything in my file.

my $file = 'C:\shekhar_Axestrack_Intern\WindowCreation\ListOfIpAdress.
+txt';
tie my @lines, 'Tie::File', $file  or die "can't update $file: $!";
# define sub Fun such that it returns 0 if Time > 34, 1 otherwise
@lines = grep { Fun($_) } @lines;
untie @lines;
sub Fun
{
        my($line) = @_; #I do manupulation on this line to get time fr
+om string
    
        # print $fho $line unless $div > 36;
        if( $time > 37)
        {return 0;}
        else{ return 1;}

}
[download]

You need to post a small self-contained program to demonstrate your problem. That way, we can reproduce your problem, verify that the output is wrong, and then offer ways to fix it. Unfortunately, your example code above refers to $time yet that variable is not defined in your posted code.

Oh, and make sure that all self-contained code samples you post start with:

use strict;
use warnings;
[download]

Update: See also SSCCE (Short, Self Contained, Correct (Compilable) Example).

I assume then that Fun() never returns 0.

sub Fun { $a = shift; return $a > 0 ? 1 : 0 }

@a = (1,2,-3,4,-5,99);
printf "%d, ",$_ for grep {Fun($_)} @a;
[download]

Output:

1, 2, 4, 99
[download]

Updated to add simple example

Dum Spiro Spero

I always recommend that you plan the program so that it can be re-run successfully if for any reason it does not succeed.   This means being “non-destructive” of the program’s inputs.   Instead of actually overwriting the input file to “remove” certain records, the program produces, as one of its several outputs, a new version of its input-file which “omits” certain records.   Then, if everything goes according to plan, that output-file becomes the input-file that will be used in the next run ... but the previous input-file also is still there.   (And maybe several of them, logrotate style.)

This is a very good strategy for a lot of good reasons:   for one thing, you can easily diff the two files (“before” and “after”) to be certain what it actually did.   You can objectively analyze the situation, and you can reliably do a re-run if necessary.

(If you really do need to update a file in-place, I suggest that you use a database-file format such as the ubiquitous SQLite ... but, even then, that you do not actually delete the successfully-processed records right away.   Instead, “soft-delete” them in some way, such as by writing a timestamp to a field that will be NULL for any records that are yet-to-be-processed.   Give yourself a source of history, as well as something that can be reversed should the need arise.   “Ka-ka occurs ...”)