Read a specific line from a file: Difference between revisions

{{task}}

Some languages have special semantics for obtaining a known line number from a file.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

declare

begin

if Line_7'Length = 0 then

end if;

end;

exception

when End_Error =>

when Storage_Error =>

 

=={{header|Aime}}==

read_line(text &line, text path, integer n)

{

file f;

 

 

 

}

 

main(void)

{

 

 

}

 

 

=={{header|AutoHotkey}}==

if ErrorLevel

 

=={{header|AWK}}==

#usage: readnthline.awk -v lineno=6 filename

FNR==lineno { storedline=$0; found++ }

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

requiredline% = 7

IF ASCtext$=10 text$ = MID$(text$,2)

 

=={{header|C}}==

Mmap file and search for offsets to certain line number. Since mapped file really is memory, there's no extra storage procedure once offsets are found.

#include <sys/types.h>

#include <sys/mman.h>

 

return ret;

 

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

#include <fstream>

#include <iostream>

return 1 ;

}

 

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

 

"Read the nth line from a text file. The first line has the number 1"

(assert (> n 0) (n))

if (and line (= line-number n))

do (return line))))

 

Example call:

"foo"

 

 

 

void main() {

writefln("the file only contains %d lines", countLines);

}

<pre>

line 7: foreach (char[] line; f.byLine()) {</pre>

 

=={{header|Erlang}}==

Using function into_list/1 from [[Read_a_file_line_by_line]].

There is no behaviour specified after printing an error message, so I throw an exception. An alternative would be to continue with a default value?

-module( read_a_specific_line ).

 

line_nr_error( function_clause ) -> too_few_lines_in_file;

line_nr_error( Error ) -> Error.

 

{{out}}

 

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

open System.IO

 

// if not not enough lines available

Console.WriteLine(line)

 

=={{header|Go}}==

 

import (

)

 

func main() {

}

 

 

=={{header|Groovy}}==

new File("lines.txt").eachLine { currentLine, lineNumber ->

if (lineNumber == 7) {

}

}

 

=={{header|Haskell}}==

 

main = do contents <- readFile filename

case drop 6 $ lines contents of

[] -> error "File has less than seven lines"

l:_ -> putStrLn l

 

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

While it is certainly possible to read at file at specific offsets without reading each line via ''seek'', with files using line feed terminated variable length records something has to read the data to determine the 7th record. This solution uses a combination of repeated alternation and generation limiting to achieve this. The counter is simply to discover if there are enough records.

 

write(readline("foo.bar.txt",7)|"failed")

end

procedure readline(f,n) # return n'th line of file f

f := open(\f,"r") | fail # open file

close(f)

if i = 0 then return line

 

=={{header|J}}==

(x-1) {:: <;.2 ] 1!:1 boxxopen y

 

Thus:

 

 

Note that this code assumes that the last character in the file is the line end character, and that the line end character is a part of the line to be retrieved.

 

'''Tacit alternative'''

This is not quite equivalent to the code above as it handles cross-platform line-endings and those line end character(s) are removed from the result.

 

<tt>example: java -cp . LineNbr7 LineNbr7.java</tt><br>

<tt>output : line 7: public static void main(String[] args) throws Exception {;</tt>

 

import java.io.*;

}

}

 

=={{header|Julia}}==

for i = 1:num-1

readline(stream)

result = readline(stream)

print(result != "" ? result : "No such line.")

{{Out}}

<pre>julia> open(line -> read_nth_lines(line, 7), "path/to/file")

"Hi, I am the content of the seventh line\n"</pre>

 

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

We read the whole file into memory, and use 'word$( string, number, delimiter)'. Line delimiter is assumed to be CRLF, and the file is assumed to exist at the path given.

requiredLine =7

 

if line7$ =chr$( 13) +chr$( 10) or line7$ ="" then notice "Empty line! ( or file has fewer lines)."

 

 

 

=={{header|MATLAB}} / {{header|Octave}}==

 

eln = 7; % extract line number 7

line = '';

end;

printf('line %i: %s\n',eln,line);

<nowiki>Insert non-formatted text here</nowiki>

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

method isFalse() public static returns boolean

return \(1 == 1)

 

=={{header|OCaml}}==

OCaml does not provide built-in facilities to obtain a particular line from a file. It only provides a function to read one line from a file from the current position in the input channel [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#VALinput_line input_line]. We can use this function to get the seventh line from a file, for example as follows:

 

try Some (input_line ic)

with End_of_file -> None

 

let () =

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

 

uses

Close(myfile);

writeln(line);

Output:

<pre>

 

=={{header|Perl}}==

# invoke as <scriptname> -n=7 [input]

while (<>) { $. == $n and print, exit }

 

 

 

=={{header|PicoLisp}}==

(do 6 (line))

=={{header|PL/I}}==

declare text character (1000) varying, line_no fixed;

 

put skip list (text);

next: ;

 

 

 

=={{header|PureBasic}}==

lineRead.i

line.s

MessageRequester("Error", "Couldn't open file " + filename + ".")

EndIf

 

=={{header|R}}==

Read 0 items

> seven <- scan('Incoming/quotes.txt', '', skip = 6, nlines = 1, sep = '\n')

Read 1 item

 

=={{header|Racket}}==

#lang racket

 

(define s1 (list-ref (file->lines "some-file") 6))

 

(define s2

(call-with-input-file "some-file"

(λ(i) (for/last ([line (in-lines i)] [n 7]) line))))

 

=={{header|REXX}}==

 

end

end

 

 

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

requiredLine = 7

open fileName$ for input as #f

close #f

print a$

 

=={{header|Scala}}==

The code will throw a <tt>NoSuchElementException</tt> if the file doesn't have 7 lines.

 

Solving the task to the letter, imperative version:

 

try {

lines = io.Source.fromFile("input.txt").getLines drop(6)

else seventhLine = lines next

}

case exc => Right(exc.getMessage)

}

val seventhLine = (for(f <- file.left;

line <- f.getLines.toStream.drop(6).headOption.toLeft("too few lines").left) yield

 

=={{header|sed}}==

=={{header|Seed7}}==

The function ''getLine'' skips lines with [http://seed7.sourceforge.net/libraries/file.htm#readln%28inout_file%29 readln]

and reads the requested line with [http://seed7.sourceforge.net/libraries/file.htm#getln%28inout_file%29 getln] afterwards:

 

const func string: getLine (inout file: aFile, in var integer: lineNum) is func

end if;

end if;

 

=={{header|Tcl}}==

This code can deal with very large files with very long lines (up to 1 billion characters in a line should work fine, provided enough memory is available) and will return an empty string when the ''n''th line is empty (as an empty line is still a valid line).

set f [open $filename]

while {[incr n -1] > 0} {

}

 

Where it is necessary to provide very fast access to lines of text, it becomes sensible to create an index file describing the locations of the starts of lines so that the reader code can <code>seek</code> directly to the right location. This is rarely needed, but can occasionally be helpful.

 

=={{header|TXR}}==

===From the top===

Variable "line" matches and takes eighth line of input:

 

===From the bottom===

Take the third line from the bottom of the file, if it exists.

@line

@(skip 1 2)

How this works is that the first <code>skip</code> will skip enough lines until the rest of the query successfully matches the input. The rest of the query matches a line, then skips two lines, and matches on EOF. So <code>@line</code> can only match at one location: three lines up from the end of the file. If the file doesn't have at least three lines, the query fails.

 

 

 

<pre>

</pre>

 

=={{header|Vedit macro language}}==

This example reads the 7th line (including newline character(s)) into text register 10.

 

Goto_Line(7)

if (Cur_Line < 7) {

Reg_Copy(10, 1)

}

 

If the file does not exist, the buffer will be empty and you get "File contains too few lines" error.

If the line is too long (more than about 230,000 characters), Vedit displays error message "Block too large for text registers, try clipboard").

This error could be avoided by reading the line to clipboard (which has larger size limit) or by copying the line to another edit buffer using a tmp file (in which case there is no size limit).

 

=={{header|XPL0}}==

Usage: readline <filename.ext

 

def MaxLen = 82; \maximum length of line that can be stored (incl CR+LF)

 

 

char LineN(MaxLen);

 

[[Category:File handling]]