Read a file line by line: Difference between revisions

=={{header|360 Assembly}}==

This program uses OS QSAM I/O macros (OPEN,CLOSE,GET,PUT,DCB).

READFILE CSECT

SAVE (14,12) save registers on entry

PG DS CL80 buffer

YREGS

=={{header|8th}}==

"path/to/file" f:open ( . cr ) f:eachline f:close

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program readfile64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|Action!}}==

Proc Main()

Return

=={{header|Ada}}==

{{works with|Ada 2005}}

line_by_line.adb:

procedure Line_By_Line is

Close (File);

end Line_By_Line;

{{Out}}

=={{header|Aime}}==

text s;

o_text(s);

o_byte('\n');

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.3.5 algol68g-2.3.5].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

FILE foobar;

printf(($g(0)": "$, count, line fmt, line))

OD;

{{out}}

<pre style="height:15ex;overflow:scroll">

=={{header|APL}}==

⍝⍝ GNU APL Version

∇listFile fname ;fileHandle;maxLineLen;line

This is the end of the text.

=={{header|Amazing Hopper}}==

#include <hopper.h>

println

exit(0)

{{out}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program readfile.s */

iMagicNumber: .int 0xCCCCCCCD

=={{header|Astro}}==

print line

=={{header|AutoHotkey}}==

FileSelectFile, File, 1, %A_ScriptDir%, Select the (text) file to read, Documents (*.txt) ; Could of course be set to support other filetypes

FileDelete, Output.txt ; Makes sure output is clear before writing

FileAppend, %Text%, Output.txt ; Writes the result to Output.txt

=={{header|AWK}}==

'''One-liner:'''

'''Shorter:'''<br>

so this is the shortest possible awk-program

(not counting the [[Empty program]]):

'''Longer:'''<br>

Reading several files, with some processing:

BEGIN { print "# Reading..." }

FNR==1 { f++; print "# File #" f, ":", FILENAME }

{ print } # same as "print $0"

END { print "# Done with", f, "file(s), with a total of", NR, "lines." }

Note:

* The variables c and f are initialized automatically to 0

==={{header|BaCon}}===

filename$ = "readlines.bac"

OPEN filename$ FOR READING AS fh

WEND

PRINT lines, " lines in ", filename$

{{out}}

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

110 OPEN #1:NAME$ ACCESS INPUT

120 COPY FROM #1 TO #0

==={{header|Locomotive Basic}}===

20 WHILE NOT EOF

30 LINE INPUT#9,i$

40 PRINT i$

==={{header|OxygenBasic}}===

The core function '''GetFile''' reads the whole file:

function getline(string s, int *i) as string

int sl=i, el=i

done:

print "Line count " c

==={{header|QBasic}}===

{{works with|QBasic}}

{{works with|QuickBasic}}

filename$ = "file.txt"

WEND

CLOSE #f

==={{header|uBasic/4tH}}===

uBasic/4tH only supports text files - and they can only be read line by line. '''READ()''' fills the line buffer. In order to pass (parts of) the line to a variable or function, the tokenizer function '''TOK()''' needs to be called with a specific delimiter. In order to parse the entire line in one go, the string terminator '''CHR(0)''' must be provided.

Do While Read (a)

Close a

==={{header|ZX Spectrum Basic}}===

The tape recorder interface does not support fragmented reads, because tape recorder start and stop is not atomic, (and a leadin is required for tape input).

In the following example, we read a file line by line from a file on microdrive 1.

20 OPEN #4;"m";1;"MYFILE": REM stream 4 is the first available for general purpose

30 INPUT #4; LINE a$: REM a$ will hold our line from the file

50 REM to gracefully exit when the file is read. (omitted from this example)

60 REM to prevent an error at end of file, place a handler here

=={{header|BASIC256}}==

filename$ = "file.txt"

end while

close f

=={{header|Batch File}}==

This takes account on the blank lines, because FOR ignores blank lines when reading a file.

rem delayed expansion must be disabled before the FOR command.

setlocal disabledelayedexpansion

echo(!var!

endlocal

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

{{works with|BBC BASIC for Windows}}

This method is appropriate if the lines are terminated by a single CR or LF:

IF file%=0 ERROR 100, "File could not be opened"

WHILE NOT EOF#file%

a$ = GET$#file%

ENDWHILE

This method is appropriate if the lines are terminated by a CRLF pair:

IF file%=0 ERROR 100, "File could not be opened"

WHILE NOT EOF#file%

IF ASCa$=10 a$ = MID$(a$,2)

ENDWHILE

=={{header|Bracmat}}==

<code>fil</code> is a relatively low level Bracmat function for manipulating files. Depending on the parameters it opens, closes, reads, writes a file or reads or sets the file position.

& fil$(,STR,\n) { first argument empty: same as before (i.e. "test.txt") }

{ if \n were replaced by e.g. "\n\t " we would read word-wise instead }

)

& (fil$(,SET,-1)|); { Setting file position before start closes file, and fails.

=={{header|Brat}}==

file.each_line "foobar.txt" { line |

p line

=={{header|C}}==

#include <conio.h>

return 0;

===with getline===

#include <stdio.h>

fclose(stream);

exit(EXIT_SUCCESS);

=== Using mmap() ===

Implementation using mmap syscall. Works on Linux 2.6.* and on *BSDs. Line reading routine takes a callback function, each line is passed into callback as begin and end pointer. Let OS handle your memory pages, we don't need no stinking mallocs.

#include <sys/types.h>

#include <sys/stat.h>

return read_lines("test.ps", print_line) ? 0 : 1;

}

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

'File.ReadLines' reads the lines of a file which could easily be stepped through.

A full code may look like;

using System.IO;

using System.Text;

}

}

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

{{works with|C++03 to C++17 }}

#include <string>

#include <iostream>

infile.close( ) ;

return 0 ;

====using std::getline====

</pre>

#include <fstream>

#include <iostream>

}

std::cout << "finished" << std::endl;

{{out}}

{{libheader|U++}}

using namespace Upp;

while(in && !in.IsEof())

Cout().PutLine(in.GetLine());

=={{header|Clojure}}==

(with-open [r (clojure.java.io/reader "some-file.txt")]

(doseq [l (line-seq r)]

(println l)))

=={{header|CLU}}==

po: stream := stream$primary_output()

stream$close(fstream)

end

=={{header|COBOL}}==

PROGRAM-ID. read-file-line-by-line.

GOBACK

=={{header|CoffeeScript}}==

{{works_with|node.js}}

# This module shows two ways to read a file line-by-line in node.js.

fs = require 'fs'

console.log "DONE ASYNC!"

reader.next_line callbacks.process_line, callbacks.all_done

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

(loop for line = (read-line input nil)

=={{header|D}}==

import std.stdio;

foreach (line; "read_a_file_line_by_line.d".File.byLine)

line.writeln;

The File is managed by reference count, and it gets closed when it gets out of scope or it changes. The 'line' is a char[] (with newline), so if you need a string you have to idup it.

=={{header|DBL}}==

; Read a file line by line for DBL version 4

;

GOTO CLOS

=={{header|DCL}}==

$ loop:

$ read /end_of_file = done input line

$ goto loop

$ done:

=={{header|Delphi}}==

procedure ReadFileByLine;

var

CloseFile(TextFile);

end;

The example file (above) '''"c:\test.txt"''' is assigned to the text file variable '''"TextFile"''' is opened and any line is read in a loop into the string variable '''"TextLine"'''.

procedure ReadFileByLine;

var

ShowMessage(TextLines[i]);

end;

Above uses the powerful utility classs type [http://www.delphibasics.co.uk/RTL.asp?Name=TStringList TStringList] from Classes Unit

=={{header|Draco}}==

proc nonrec main() void:

/* first we need to declare a file buffer and an input channel */

/* finally, close the file */

close(in_ch)

=={{header|Elena}}==

ELENA 4.x :

import extensions;

import extensions'routines;

{

File.assign:"file.txt".forEachLine(printingLn)

=={{header|Elixir}}==

Two Slightly different solutions in the FileReader namespace

defmodule FileReader do

# Create a File.Stream and inspect each line

end

end

=={{header|Erlang}}==

read_a_file_line_by_line:into_list/1 is used by [[Read_a_specific_line_from_a_file]]. If this task is updated keep backwards compatibility, or change [[Read_a_specific_line_from_a_file]], too.

-module( read_a_file_line_by_line ).

into_list( {error, _Error}, _IO, Acc ) -> lists:reverse( Acc );

into_list( Line, IO, Acc ) -> into_list( io:get_line(IO, ''), IO, [Line | Acc] ).

{{out}}

=={{header|ERRE}}==

PROGRAM LETTURA

CLOSE(1) ! chiude il file

END PROGRAM

From ERRE manual: use an EXCEPTION to trap a "file not found" error. If you change INPUT(LINE statement with a GET you can read the file one character at time.

=={{header|Euphoria}}==

constant filename = cmd[2]

constant fn = open(filename,"r")

i += 1

end while

{{out}}

(1) name the euphoria script file <B>readfile.ex</B> or whatever name you want to give it. Change this line "constant filename = cmd[2]" to "constant filename = cmd[<B>3</B>]" like the following code.

constant filename = cmd[3]

constant fn = open(filename,"r")

i += 1

end while

From the command line run:

eui readfile.ex "File.txt"

{{out}}

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

Using DotNet's [http://msdn.microsoft.com/en-us/library/dd383503.aspx System.IO.File.ReadLines] iterator:

[<EntryPoint>]

let main argv =

File.ReadLines(argv.[0]) |> Seq.iter (printfn "%s")

=={{header|Factor}}==

=={{header|Fantom}}==

Reads each line from the file "data.txt".

class Main

{

}

}

=={{header|Forth}}==

: third ( A b c -- A b c A )

while pad swap ( fileid c-addr u ) \ string excludes the newline

2drop

=={{header|Fortran}}==

In the absence of such error reception, ugly messages are presented as the prog. is cancelled, and the most common such error is to name a missing file. So, an INQUIRE statement to check first. This too should have an ERR and IOSTAT blather (the file name might be malformed) but enough is enough. The assignment direction for such codes as EXIST and IOSTAT is ''left'' to right rather than the usual right to left (as in FILE = FNAME), but rather than remember this, it is easiest to take advantage of Fortran's (complete) absence of reserved words and define a logical variable EXIST so that the statement is EXIST = EXIST, and the compiler and the programmer can go their own ways.

INTEGER ENUFF !A value has to be specified beforehand,.

PARAMETER (ENUFF = 2468) !Provide some provenance.

20 CLOSE (IN) !All done.

END !That's all.

With F90 and later it is possible to use an ALLOCATE statement to prepare a variable of a size determined at run time, so that one could for each record use the <code>Q</code> format code (or a new feature of the READ statement) to ascertain the size of the record about to be read, free the storage for the old ALINE and allocate a new sized ALINE, then read that record into ALINE. This avoids worrying about the record overflowing (or underflowing) ALINE, at the cost of hammering at the memory allocation process.

=={{header|FreeBASIC}}==

Open "input.txt" For Input As #1

Print

Print "Press any key to quit"

=={{header|Frink}}==

The <CODE>lines</CODE> function can also take an optional second string argument indicating the encoding of the file, and can read from any supported URL type (HTTP, FTP, etc.) or a <CODE>java.io.InputStream</CODE>.

for line = lines["file:yourfile.txt"]

println[line]

=={{header|Gambas}}==

Dim hFile As File

Dim sLine As String

Wend

=={{header|GAP}}==

local file, line, count;

file := InputTextFile(name);

# With [http://www.ibiblio.org/pub/docs/misc/amnesty.txt amnesty.txt]

ReadByLines("amnesty.txt");

=={{header|Genie}}==

/*

Read file line by line, in Genie

lines++

stdout.printf("%04d %s\n", lines, line)

{{out}}

Scanning stops unrecoverably at EOF, the first I/O error, or a token too large to fit in the buffer. When a scan stops, the reader may have advanced arbitrarily far past the last token. Programs that need more control over error handling or large tokens, or must run sequential scans on a reader, should use bufio.Reader instead.

import (

}

}

;ReadLine

This function allows files to be rapidly scanned for desired data while minimizing memory allocations. It also handles /r/n line endings and allows unreasonably long lines to be handled as error conditions.

import (

fmt.Println(string(line))

}

;ReadString

In comparison, ReadString is a little quick and dirty, but is often good enough.

import (

}

}

=={{header|Groovy}}==

println "processing line $lineNumber: $line"

Thanks to laziness, there's no difference between reading the file all at once and reading it line by line.

file <- readFile "linebyline.hs"

mapM_ putStrLn (lines file)

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

Line oriented I/O is basic. This program reads lines from "input.txt" into the variable line, but does nothing with it.

f := open("input.txt","r") | stop("cannot open file ",fn)

while line := read(f)

close(f)

=={{header|J}}==

This implementation does nothing special when dealing with multi-gigabyte lines. If you encounter an excessively large line and if do not have enough physical memory, your system will experience heavy memory pressure. If you also do not have enough virtual memory to hold a line you will get an out of memory exception.

NB. configuration parameter

lines=: }.lines

r

next__example''

this is line 1

next__example''

=={{header|Java}}==

import java.io.FileReader;

}

}

{{works with|Java|7+}}

In Java 7, the try with resources block handles multiple readers and writers without nested try blocks. The loop in the main method would look like this:

try (FileReader fr = new FileReader(filename);BufferedReader br = new BufferedReader(fr)){

String line;

x.printStackTrace();

}

<code>fr</code> and <code>br</code> are automatically closed when the program exits the try block (it also checks for nulls before closing and throws closing exceptions out of the block).

A more under-the-hood method in Java 7 would be to use the <code>Files</code> class (line numbers can be inferred from indices in the returned <code>List</code>):

import java.nio.file.Paths;

import java.nio.charset.Charset;

}catch(IOException | SecurityException e){

//problem with the file

=={{header|JavaScript}}==

var readFile = function(path) {

};

=={{header|jq}}==

When invoked with the -R option, jq will read each line as a JSON string. For example:

0

0.8414709848078965

0.1411200080598672

-0.7568024953079282

To perform any kind of reduction operation while reading the lines one-by-one, one would normally use

`input` or `inputs`. For example, to compute the maximum of the above sin values:

=={{header|Jsish}}==

var f = new Channel('read-by-line.jsi');

var line;

while (line = f.gets()) puts(line);

{{out}}

<pre>prompt$ jsish read-by-line.jsi

=={{header|Julia}}==

for line in eachline(f)

println("read line: ", line)

end

=={{header|Kotlin}}==

import java.io.File

fun main(args: Array<String>) {

File("input.txt").forEachLine { println(it) }

=={{header|Lasso}}==

handle => {#f->close}

#f->forEachLine => {^

#1

'<br>' // note this simply inserts an HTML line break between each line.

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

if file$="" then end

open file$ for input as #f

print t$

wend

Mac

if file$="" then end

open file$ for input as #f

print t$

wend

Unix

if file$="" then end

open file$ for input as #f

print t$

wend

=={{header|Lingo}}==

The following code works fine for text files using 'CRLF' or 'CR only' as line end characters, but unfortunately not for the *nix default 'LF only' (note: Lingo's implementation Director does not run on Linux. It was originally created for ancient Mac OS systems, and later also ported to Windows):

fp.openFile(_movie.path & "input.txt", 1)

fileSize = fp.getLength()

if fp.getPosition()>=fileSize then exit repeat

end repeat

=={{header|LiveCode}}==

local tFile, tLines, startRead

put "/usr/share/dict/words" into tFile

close file tFile

put tLines

=={{header|Logo}}==

* readword - returns a line as a single word, or an empty list if it reached the end of file

* readrawline - returns a line as a single word, with no characters escaped

=={{header|Lua}}==

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

fp:close()

===Simpler version===

The following achieves the same result as the example above, including implicitly closing the file at the end of the loop.

for line in io.lines("input.txt") do

print(line)

end

=={{header|M2000 Interpreter}}==

Documents have Load.Doc statement to load text file. Here we see how we make indexes, and then reopen for input, and move to index, and then load a line.

Module checkit {

\\ prepare a file

}

checkit

=={{header|Maple}}==

while (true) do

input := readline(path):

if input = 0 then break; end if:

#The line is stored in input

=={{header|Mathematica}}/{{header|Wolfram Language}}==

If[strm=!=$Failed,

While[line=!=EndOfFile,

(*Do something*)

]];

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

The function fgetl() read lines from file:

fid = fopen('foobar.txt','r');

if (fid < 0)

end;

fclose(fid)

=={{header|Maxima}}==

readfile(name) := block(

close(f),

v

=={{header|Mercury}}==

Basic version.

:- interface.

ReadLineResult = error(Error),

error(io.error_message(Error))

Version using a stream fold.

:- interface.

process_line(line(Line), !LineCount, !IO) :-

!:LineCount = !.LineCount + 1,

=={{header|Neko}}==

Need to define a growing buffer to handle streaming unknown sizes, 2 to the 29 max, for this one.

Read a file line by line, in Neko

<doc><pre>Tectonics:

} catch a break;

}

{{out}}

=={{header|NetRexx}}==

=== Using Java <tt>Scanner</tt> ===

options replace format comments java crossref symbols nobinary

return fileLines

=== Using Java <tt>Reader</tt> ===

options replace format comments java crossref symbols nobinary

return fileLines

=={{header|NewLISP}}==

(set 'in-file (open "filename" "read"))

(while (read-line in-file)

(write-line))

=={{header|Nim}}==

=={{header|Objeck}}==

bundle Default {

class ReadFile {

}

}

=={{header|Objective-C}}==

To read an entire file into a string, you can:

NSError *error = nil;

NSString *words = [[NSString alloc] initWithContentsOfFile:path

encoding:NSUTF8StringEncoding error:&error];

Use the UTF-8 encoder on ASCII.

Now to get the individual lines, break down the string:

=={{header|OCaml}}==

let ic = open_in "input.txt" in

try

done

with End_of_file ->

But if we want to write a functional loading function we should remember that the <code>try/with</code> couple breaks the [[tail recursion]]. So we should externalise it outside of the loop in another function:

try Some (input_line ic)

with End_of_file -> None

let lines = read_lines ic in

close_in ic;

we use it like this:

let lines = lines_of_file "unixdict.txt" in

=={{header|Oforth}}==

=={{header|PARI/GP}}==

Thus the usual way of interacting with files in more than the simple way allowed by <code>read</code> is done by PARI with the usual [[#C|C]] commands:

if (!f) {

pari_err(openfiler, "input", name);

while(fgets(line, MAX_LINELEN, f) != NULL) {

// ...

=={{header|Pascal}}==

{{Works with|Free Pascal}}

Works for text files. "testin.txt" must exist in directory of program and you must have read/write access. No IO-Checks.

program ReadFileByLine;

var

Close(InputFile);

Close(OutputFile)

=={{header|Perl}}==

For the simple case of iterating over the lines of a file you can do:

|| die "Could not open file: $!";

while (<$fh>)

process($_);

}

File encoding can be specified like:

The angle bracket operator <code>< ></code> reads a filehandle line by line. (The angle bracket operator can also be used to open and read from files that match a specific pattern, by putting the pattern in the brackets.)

Without specifying the variable that each line should be put into, it automatically puts it into <code>$_</code>, which is also conveniently the default argument for many Perl functions. If you wanted to use your own variable, you can do something like this:

|| die "Could not open file: $!";

while (my $line = <$fh>)

process($line);

}

The special use of the angle bracket operator with nothing inside, will read from all files whose names were specified on the command line:

chomp;

process($_);

As noted in <code>perlop.pod</code> under "I/O Operators", <code>&lt;&gt;</code> opens with the 2-arg <code>open()</code> and so can read from a piped command. This can be convenient but is also very much insecure--a user could supply a file with the name like

or any other arbitrary command, which will be executed when perl attempts to open a pipe for it. As such, this feature is best reserved for one-liners and is bad practice to use in production code. The same is true for the open(FILEHANDLE, EXPR) form of open as opposed to open(FILEHANDLE, MODE, EXPR). (See <code>perlfunc.pod</code> on the <code>open()</code> function.)

The readline function can be used instead of < >:

while (readline $fh)

{ ... }

while (my $line = readline $fh)

{ ... }

The readline function is the internal function used to implement < >, but can be used directly and is useful for conveying programmer intent in certain situations.

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">constant</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">command_line</span><span style="color: #0000FF;">()[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"r"</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">lno</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>

<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

argument 1 get "r" fopen var f

while

f fgets number? if drop f fclose false else print true endif

=={{header|PHP}}==

$file = fopen(__FILE__, 'r'); // read current file

while ($line = fgets($file)) {