Remove lines from a file: Difference between revisions

An appropriate message should appear if an attempt is made to remove lines beyond the end of the file.

<br><br>

 

=={{header|Ada}}==

use Ada.Text_IO;

 

"<filename>" & Temporary & " for temporary writing");

Put_Line(" requires first > 0, length >= 0");

 

=={{header|ALGOL 68}}==

# returns TRUE if successful, FALSE otherwise #

PROC remove lines = ( STRING file name, INT start line, INT number of lines )BOOL:

close( t );

print( ( "----", newline ) )

{{out}}

<pre>

----

</pre>

 

=={{header|AutoHotkey}}==

Loop, Read, %filename%

if ( A_Index < StartingLine )

 

SetWorkingDir, % A_ScriptDir

;Output:

with test.txt starting as

 

=={{header|AWK}}==

# syntax: GAWK -f REMOVE_LINES_FROM_A_FILE.AWK

# show files after lines are removed:

}

}

 

=={{header|BASIC}}==

 

Verbose and with a program loop to test the procedures.

' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '

' Remove File Lines V1.1 '

END FUNCTION

 

 

==={{header|IS-BASIC}}===

110 CALL REMOVELINES("fub.txt",5,3)

120 DEF REMOVELINES(NAME$,ST,N)

440 CLOSE #1

450 END HANDLER

 

=={{header|C}}==

#include <stdlib.h> /* for atoi() and malloc() */

#include <string.h> /* for memmove() */

fclose(fp);

return 0;

 

=={{header|C sharp}}==

{{works with|C sharp|6}}

using System.IO;

using System.Linq;

File.WriteAllLines(filename, File.ReadAllLines(filename)

.Where((line, index) => index < start - 1 || index >= start + count - 1));

 

=={{header|C++}}==

#include <iostream>

#include <string>

return ;

}

 

=={{header|Clojure}}==

Simple solution dealing with most of the lines in memory.

'[clojure.string :as str])

 

(with-open [wrt (jio/writer (str filepath ".tmp"))]

(.write wrt (str/join "\n" new-lines)))

 

More complex solution for big file, one line at a time.

'[clojure.string :as str])

 

(when (pos? n)

(println "WARN: You are trying to remove lines beyond EOF"))))))

 

=={{header|Common Lisp}}==

(let ((tmp-filename (concatenate 'string filename ".tmp"))

(lines-omitted 0))

;; Warn if line removal went past the end of the file

(when (< lines-omitted num)

 

=={{header|D}}==

 

void main() {

f.writeln(line);

}

 

=={{header|ECL}}==

Implemented for HPCC logical files, not single physical files, since all datasets in HPCC are distributed.

IMPORT STD;

RemoveLines(logicalfile, startline, numlines) := FUNCTIONMACRO

IF(RecCnt < EndLine,STD.System.Log.addWorkunitWarning('Attempted removal past end of file-removal ignored')));

ENDMACRO;

And a simple test case to run:

MyFile := DATASET(100,TRANSFORM({UNSIGNED1 RecID},SELF.RecID := COUNTER));

RemoveLines(MyFile,3,10);

 

=={{header|Elixir}}==

def remove_lines(filename, start, number) do

File.open!(filename, [:read], fn file ->

IO.puts File.read!(filename)

IO.puts "after:"

 

{{out}}

 

=={{header|Erlang}}==

-module( remove_lines ).

 

{Keeps, Removes} = lists:split( Start, Lines ),

{"ok", Keeps ++ lists:nthtail( How_many, Removes )}.

{{out}}

With "foobar.txt" that looks like this:

 

=={{header|F_Sharp|F#}}==

open System.IO

 

if tooShort then Console.Error.WriteLine "Not enough lines"

File.WriteAllLines(argv.[0], sliced)

Output

 

D:\Projects\Rosetta>Remove_lines_from_a_file.exe foo 1 2

5

 

 

=={{header|Fortran}}==

As always, there is a problem with the length of a piece of string. The allowance here is 66666 characters. Some filesystems know the length of records, and may make the maximum record length available to enquiry, but others don't know and use instead a marker which might be CR, CRLF, LF or LFCR and even a mixture in the same file. The Fortran programme does not see this with FORMATTED input, just the content of the record, character style. Output, on a windows/DOS system, will always terminate records with CRLF. A null record would be after the first CRLF in the sequence CRLFCRLF, and so on. With UNFORMATTED, the programme must make its own decisions.

 

SUBROUTINE CROAK(GASP) !Something bad has happened.

CHARACTER*(*) GASP !As noted.

CALL FILEHACK("foobar.txt",1,2)

END

 

When run on file foobar.txt containing

 

Formulating error messages is tedious, in the absence of a function such as IFMT(n) to be used in <code>CALL CROAK("First record must be positive, not "//IFMT(IST))</code> A more accomplished programme would worry about running out of disc space (signalled by the taking of the END=''label'' option in a WRITE statement) and I/O errors along the way using the ERR=''label'' option, but it is difficult to devise recovery schemes for unexpected errors. Similarly, the OPEN statements are at risk of confronting a file that is available for READ, but not for WRITE. It would help in organising all this if OPEN(...) was a function, but instead one can refer to the recondite IOSTAT error codes, possibly with assistance as with

CHARACTER*42 FUNCTION ERRORWORDS(IT) !Look for an explanation. One day, the system may offer coherent messages.

Curious collection of encountered codes. Will they differ on other systems?

END IF !But on all systems?

END FUNCTION ERRORWORDS !Hopefully, helpful.

 

Finally, there is a chance the operating system can be asked to do this, by fragmenting the file in-place into odd-sized pieces. The first piece would be all the records up to the chop, and the second would be all records after resumption. The advantage here is that the rest of the file need no longer be read and written, and files can be large...

 

=={{header|FreeBASIC}}==

 

Sub removeLines(fileName As String, startLine As UInteger, numLines As UInteger)

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Frink}}==

{

modified = lines.removeLen[start-1, len]

if modified != len

w.println[line]

w.close[]

 

=={{header|Gambas}}==

 

Public Sub Main()

Return sNewFile 'Return the details

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

}

return b, true

 

=={{header|Groovy}}==

 

def sourceFile = new File(filename).getAbsoluteFile()

def outputFile = File.createTempFile("remove", ".tmp", sourceFile.getParentFile())

}

 

 

=={{header|Haskell}}==

 

main = getArgs >>= (\[a, b, c] ->

c1 = read c :: Int

putStr $ unlines $ concat [take (b1 - 1) contents, drop c1 $ drop b1 contents]

 

=={{header|Icon}} and {{header|Unicon}}==

removelines("foo.bar",3,2) | stop("Failed to remove lines.")

end

close(f)

return # done

 

=={{header|J}}==

'count start'=. x

file=. boxxopen y

lines=. <;.2 fread file

(;lines {~ <<< (start-1)+i.count) fwrite file

 

Thus:

$ cat cal.txt

July 2011

17 18 19 20 21 22 23

24 25 26 27 28 29 30

 

 

1 2

3 4 5 6 7 8 9

17 18 19 20 21 22 23

24 25 26 27 28 29 30

 

Note that this code defines the last character in the file as the line end character.

 

=={{header|Java}}==

import java.io.BufferedReader;

import java.io.File;

}

 

 

=={{header|jq}}==

then to copy lines from a file named INFILE except for NUMBER lines starting with START,

invoke jq as follows:

 

For example:

 

jq -s -R -r --arg start 1 --arg number 2 -f remove.jq input.txt

# attempt to remove "number" lines from line number "start" onwards:

def remove_lines(start; number):

| (if $count < $max then "WARNING: there are only \($count) lines" else empty end), .;

 

 

{{works with|jq|1.5}}

 

The command invocation looks like this:

 

# number "start" onwards:

def remove_lines_streaming(start; number):

end) ;

 

 

=={{header|Julia}}==

 

const prgm = basename(Base.source_path())

f = open(file, "w")

write(f, join(lines))

 

Usage:

 

=={{header|Kotlin}}==

 

import java.io.File

removeLines("input.txt", 2, 3)

printFile("input.txt", "after removal of 3 lines starting from the second")

 

{{out}}

 

=={{header|Lasso}}==

 

local(

#file -> dowithclose => {

#file -> writestring(#content -> join(''))

Input:

<pre>1 Here is a row

</pre>

Call:

Output:

<pre>1 Here is a row

=={{header|Liberty BASIC}}==

It's always a bit dangerous to experiment with code that alters files. Un-rem the 'kill' to remove the temp file and the next line so the file is renamed to the original!

call removeLines "foobar.txt", 1, 2

end

'name filename$ + ".tmp" as filename$

end sub

 

=={{header|Lua}}==

local fp = io.open( filename, "r" )

if fp == nil then return nil end

 

fp:close()

 

p = Import[doc, "List"];

If[start + n - 1 <= Length@p,

Print["Too few lines in document. Operation aborted."]

]

 

=={{header|NewLISP}}==

 

(context 'ABC)

 

(ABC:remove-lines-from-a-file "foobar.txt" 8 3)

(exit)

 

=={{header|OCaml}}==

 

try Some (input_line ic)

with End_of_file -> None

if Array.length Sys.argv < 4 then usage ();

delete_lines

 

<pre>$ cal > cal.txt

=={{header|Oforth}}==

 

| line b endLine |

ListBuffer new ->b

drop numLines 0 == ifFalse: [ "Error : Removing lines beyond end of file" println return ]

 

 

=={{header|Pascal}}==

{{works with|Free Pascal|2.6.2}}

 

 

{$mode objfpc}{$H+}

ReadLn;

End.

 

{{out}}

 

=={{header|Perl}}==

If you want a backup file (maybe because deleting lines from a file in place is a pretty silly idea), change the <code>-i</code> in the first line to <code>-i.bak</code>, for example.

use strict ;

use Tie::File ;

}

 

 

=={{header|Phix}}==

 

=={{header|Phixmonti}}==

100 var startLine

10 var lineCount

else

"WRONG! error in file operation" print

 

=={{header|PicoLisp}}==

(let L (in File (make (until (eof) (link (line)))))

(if (> (+ (dec 'Start) Cnt) (length L))

(out File

(mapc prinl (cut Start 'L))

 

=={{header|PowerBASIC}}==

{{works with|PowerBASIC Console Compiler}}

 

 

FUNCTION PBMAIN () AS LONG

filespec = DIR$

WEND

 

Sample output:

=={{header|PowerShell}}==

{{works with|PowerShell|4.0}}

function del-line($file, $start, $end) {

$i = 0

}

del-line "foobar.txt" 1 2

 

=={{header|PureBasic}}==

; Contents of file 'input.txt' before deletion of lines :

;

CloseConsole()

EndIf

 

{{out|Output ('input.txt' after removal of lines}}

=={{header|Python}}==

Uses the [http://docs.python.org/library/fileinput.html fileinput] standard module.

 

import fileinput, sys

pass

else:

 

{{out}}

 

=={{header|Racket}}==

#lang racket

(define (remove-lines file from num)

(define-values [pfx rest] (split-at lines (sub1 from)))

(display-lines-to-file (append pfx (drop rest num)) file #:exists 'replace))

 

=={{header|Raku}}==

(formerly Perl 6)

my @lines = split /^^/, slurp $filename;

unlink $filename; # or rename

splice(@lines,$beg,$len) == $len or warn "Too few lines";

spurt $filename, @lines;

{{out}}

<pre>$ cal >foo

::* &nbsp; the output file non─existence

::* &nbsp; authority to read from (and write to) the file (folder)

parse arg iFID ',' N "," many . /*input FID, start of delete, how many.*/

if iFID='' then call er "no input fileID specified." /*oops.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

er: say; say '***error***'; say; say arg(1); say; exit 13

'''output''' when using the input of: &nbsp; <tt> foobar.txt,2,4 </tt>

<pre>

 

=={{header|Ring}}==

cStr = read("C:\Ring\bin\filename.txt")

aList = str2list(cStr)

see cStr + nl

write("C:\Ring\bin\filename.txt",cStr)

Input:

<pre>

 

=={{header|Ruby}}==

 

def remove_lines(filename, start, num)

remove_lines(filename, start, remove)

teardown(filename)

 

{{out}}

 

=={{header|Run BASIC}}==

startLine = 100

lineCount = 10

wend

close #in

 

=={{header|Rust}}==

extern crate docopt;

 

}

}

 

=={{header|Scala}}==

args match {

case Array(filename, start, num) =>

println("Usage: RemoveLinesFromAFile <filename> <startLine> <numLines>")

}

 

=={{header|Seed7}}==

include "osfiles.s7i";

 

removeLines(argv(PROGRAM)[1], integer parse (argv(PROGRAM)[2]), integer parse (argv(PROGRAM)[3]));

end if;

 

=={{header|Sidef}}==

lines.splice(beg, len).len == len || warn "Too few lines";

}

 

 

=={{header|Snobol4}}==

Developed using the Snobol4 dialect Spitbol for Linux, version 4.0

 

 

* Function to remove a chunk of lines from a file, will go backward, too, if numlines < 0

end

 

{{in}}

<pre>1

The usual way to solve this task in Stata consists in removing lines from the currently loaded dataset. This is done with the '''[http://www.stata.com/help.cgi?drop drop]''' command, or alternately with '''keep'''.

 

drop in 20/30

 

* keep lines 20 to 30, and remove everything else

 

=={{header|Tcl}}==

# Work out range to remove

set from [expr {$startLine - 1}]

puts -nonewline $f [join [lreplace $lines $from $to] "\n"]

close $f

 

=={{header|TUSCRIPT}}==

$$! input=testfile,begnr=3,endnr=4

$$ MODE TUSCRIPT

ENDACCESS/PRINT q

ENDACCESS/PRINT z

Output:

<pre style='height:30ex;overflow:scroll'>

 

=={{header|UNIX Shell}}==

error() {

echo >&2 "$0: $*"

 

sed "$start,${end}d" "$file" >/tmp/$$ && mv /tmp/$$ "$file"

 

If you have a modern sed on the system, you can use it to do an in-place edit. GNU sed:

 

sed -i "$start,${end}d" "$file"

 

BSD/MacOS sed:

 

sed -i "" "$start,${end}d" "$file"

 

=={{header|VBA}}==

First way : read the text file line by line

 

Sub Main()

End If

End Sub

 

{{in}}

 

Second Way : Read the text file at once and work with Arrays

 

Sub Main()

Close #Nb

End If

 

{{in}}

 

=={{header|VBScript}}==

Sub remove_lines(filepath,start,number)

Set objFSO = CreateObject("Scripting.FileSystemObject")

 

Call remove_lines("C:\Test.txt",3,4)

 

{{in}}

{{trans|Kotlin}}

More or less.

import "io" for File

 

}

 

 

{{out}}

Line 8

</pre>

 

=={{header|zkl}}==

Two solutions, one in memory and the other read the file line by line and hope the OS buffers. Write to stdout to avoid "what to use as dst" questions.

blob:=File(fname).read(); // file to memory

n:=blob.seek(Void,start-1); // seek to line and remember it

File.stdout.write(blob);

}

{{out}}

<pre>

</pre>

Line by line:

if (start < 1) throw(Exception.ValueError);

f:=File(fname);

f.pump(File.stdout.write);

}

{{out}}

<pre>