Read a file line by line

From Rosetta Code

Jump to: navigation, search

Read a file one line at a time, as opposed to reading the entire file at once.

[edit] Ada

Works with: Ada 2005

line_by_line.adb:

with Ada.Text_IO;
procedure Line_By_Line is
   Filename   : String := "line_by_line.adb";
   File       : Ada.Text_IO.File_Type;
   Line_Count : Natural := 0;
begin
   Ada.Text_IO.Open (File => File,
                     Mode => Ada.Text_IO.In_File,
                     Name => Filename);
   while not Ada.Text_IO.End_Of_File (File) loop
      declare
         Line : String := Ada.Text_IO.Get_Line (File);
      begin
         Line_Count := Line_Count + 1;
         Ada.Text_IO.Put_Line (Natural'Image (Line_Count) & ": " & Line);
      end;
   end loop;
   Ada.Text_IO.Close (File);
end Line_By_Line;

Output:

 1: with Ada.Text_IO;
 2: procedure Line_By_Line is
 3:    Filename   : String := "line_by_line.adb";
 4:    File       : Ada.Text_IO.File_Type;
 5:    Line_Count : Natural := 0;
 6: begin
 7:    Ada.Text_IO.Open (File => File,
 8:                      Mode => Ada.Text_IO.In_File,
 9:                      Name => Filename);
 10:    while not Ada.Text_IO.End_Of_File (File) loop
 11:       declare
 12:          Line : String := Ada.Text_IO.Get_Line (File);
 13:       begin
 14:          Line_Count := Line_Count + 1;
 15:          Ada.Text_IO.Put_Line (Natural'Image (Line_Count) & ": " & Line);
 16:       end;
 17:    end loop;
 18:    Ada.Text_IO.Close (File);
 19: end Line_By_Line;

[edit] Aime

file f;
text s;
 
f_affix(f, "src/aime.c");
 
while (f_line(f, s) != -1) {
    o_text(s);
    o_byte('\n');
}

[edit] ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extension to language used.

Works with: ALGOL 68G version Any - tested with release algol68g-2.3.5.

File: ./Read_a_file_line_by_line.a68

#!/usr/local/bin/a68g --script #
 
FILE foobar;
INT errno = open(foobar, "Read_a_file_line_by_line.a68", stand in channel);
 
STRING line;
FORMAT line fmt = $gl$;
 
PROC mount next tape = (REF FILE file)BOOL: (
  print("Please mount next tape or q to quit");
  IF read char = "q" THEN done ELSE TRUE FI
);
 
on physical file end(foobar, mount next tape);
on logical file end(foobar, (REF FILE skip)BOOL: done);
 
FOR count DO
  getf(foobar, (line fmt, line));
  printf(($g(0)": "$, count, line fmt, line))
OD;
done: SKIP

Output:

1: #!/usr/local/bin/a68g --script #
2: 
3: FILE foobar;
4: INT errno = open(foobar, "Read_a_file_line_by_line.a68", stand in channel);
5: 
6: STRING line;
7: FORMAT line fmt = $gl$;
8: 
9: PROC mount next tape = (REF FILE file)BOOL: (
10:   print("Please mount next tape or q to quit");
11:   IF read char = "q" THEN done ELSE TRUE FI
12: );
13: 
14: on physical file end(foobar, mount next tape);
15: on logical file end(foobar, (REF FILE skip)BOOL: done);
16: 
17: FOR count DO
18:   getf(foobar, (line fmt, line));
19:   printf(($g(0)": "$, count, line fmt, line))
20: OD;
21: done: SKIP

[edit] AutoHotkey

; --> Prompt the user to select the file being read
 
FileSelectFile, File, 1, %A_ScriptDir%, Select the (text) file to read, Documents (*.txt) ; Could of course be set to support other filetypes
If Errorlevel ; If no file selected
	ExitApp
 
; --> Main loop: Input (File), Output (Text)
 
Loop
{
FileReadLine, Line, %File%, %A_Index% ; Reads line N (where N is loop iteration)
if Errorlevel ; If line does not exist, break loop
	break
Text .= A_Index ". " Line . "`n" ; Appends the line to the variable "Text", adding line number before & new line after
}
 
; --> Delivers the output as a text file
 
FileDelete, Output.txt ; Makes sure output is clear before writing
FileAppend, %Text%, Output.txt ; Writes the result to Output.txt
Run Output.txt ; Shows the created file

[edit] AWK

awk '{ print $0 }' filename

[edit] BASIC

[edit] Locomotive Basic

10 OPENIN"foo.txt"
20 WHILE NOT EOF
30 LINE INPUT#9,i$
40 PRINT i$
50 WEND

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). However, the microdrive does support fragmented reads. In the following example, we read a file line by line from a file on microdrive 1.

10 REM open my file for input
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
40 REM because we do not know how many lines are in the file, we need an error trap
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
100 GOTO 30

[edit] Brat

include :file
 
file.each_line "foobar.txt" { line |
  p line
}

[edit] C

This is not easy to do, because the C library is so primitive. There is fgets(), but this function limits the length of a line. fgets() also loses characters if there is a NUL character '\0' in the middle of a line.

The next example uses fgetln() and err() from BSD, but will not work with most other systems.

Library: BSD libc

Works with: BSD version 4.4

#include <err.h>	/* err */
#include <stdio.h>	/* fopen, fgetln, fputs, fwrite */
 
/*
 * Read a file line by line.
 * http://rosettacode.org/wiki/Read_a_file_line_by_line
 */
int
main()
{
	FILE *f;
	size_t len;
	char *line;
 
	f = fopen("foobar.txt", "r");
	if (f == NULL)
		err(1, "foobar.txt");
 
	/*
	 * This loop reads each line.
	 * Remember that line is not a C string.
	 * There is no terminating '\0'.
	 */
	while (line = fgetln(f, &len)) {
		/*
		 * Do something with line.
		 */
		fputs("LINE: ", stdout);
		fwrite(line, len, 1, stdout);
	}
	if (!feof(f))
		err(1, "fgetln");
 
	return 0;
}

For other systems, you can code something like fgetln(). The next example refactors the code from Synchronous concurrency#C that reads lines.

#include <stdlib.h>	/* exit, malloc, realloc, free */
#include <stdio.h>	/* fopen, fgetc, fputs, fwrite */
 
struct line_reader {
	/* All members are private. */
	FILE	*f;
	char	*buf;
	size_t	 siz;
};
 
/*
 * Initializes a line reader _lr_ for the stream _f_.
 */
void
lr_init(struct line_reader *lr, FILE *f)
{
	lr->f = f;
	lr->buf = NULL;
	lr->siz = 0;
}
 
/*
 * Reads the next line. If successful, returns a pointer to the line,
 * and sets *len to the number of characters, at least 1. The result is
 * _not_ a C string; it has no terminating '\0'. The returned pointer
 * remains valid until the next call to next_line() or lr_free() with
 * the same _lr_.
 *
 * next_line() returns NULL at end of file, or if there is an error (on
 * the stream, or with memory allocation).
 */
char *
next_line(struct line_reader *lr, size_t *len)
{
	size_t newsiz;
	int c;
	char *newbuf;
 
	*len = 0;			/* Start with empty line. */
	for (;;) {
		c = fgetc(lr->f);	/* Read next character. */
		if (ferror(lr->f))
			return NULL;
 
		if (c == EOF) {
			/*
			 * End of file is also end of last line,
		`	 * unless this last line would be empty.
			 */
			if (*len == 0)
				return NULL;
			else
				return lr->buf;
		} else {
			/* Append c to the buffer. */
			if (*len == lr->siz) {
				/* Need a bigger buffer! */
				newsiz = lr->siz + 4096;
				newbuf = realloc(lr->buf, newsiz);
				if (newbuf == NULL)
					return NULL;
				lr->buf = newbuf;
				lr->siz = newsiz;
			}
			lr->buf[(*len)++] = c;
 
			/* '\n' is end of line. */
			if (c == '\n')
				return lr->buf;
		}
	}
}
 
/*
 * Frees internal memory used by _lr_.
 */
void
lr_free(struct line_reader *lr)
{
	free(lr->buf);
	lr->buf = NULL;
	lr->siz = 0;
}
 
/*
 * Read a file line by line.
 * http://rosettacode.org/wiki/Read_a_file_line_by_line
 */
int
main()
{
	struct line_reader lr;
	FILE *f;
	size_t len;
	char *line;
 
	f = fopen("foobar.txt", "r");
	if (f == NULL) {
		perror("foobar.txt");
		exit(1);
	}
 
	/*
	 * This loop reads each line.
	 * Remember that line is not a C string.
	 * There is no terminating '\0'.
	 */
	lr_init(&lr, f);
	while (line = next_line(&lr, &len)) {
		/*
		 * Do something with line.
		 */
		fputs("LINE: ", stdout);
		fwrite(line, len, 1, stdout);
	}
	if (!feof(f)) {
		perror("next_line");
		exit(1);
	}
	lr_free(&lr);
 
	return 0;
}

[edit] 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 <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#include <err.h>
 
int read_lines(char * fname, int (*call_back)(char*, char*))
{
        int fd = open(fname, O_RDONLY);
        struct stat fs;
        char *buf, *buf_end;
        char *begin, *end, c;
 
        if (fd == -1) {
                err(1, "open: %s", fname);
                return 0;
        }
 
        if (fstat(fd, &fs) == -1) {
                err(1, "stat: %s", fname);
                return 0;
        }
 
        /* fs.st_size could have been 0 actually */
        buf = mmap(0, fs.st_size, PROT_READ, MAP_SHARED, fd, 0);
        if (buf == (void*) -1) {
                err(1, "mmap: %s", fname);
                close(fd);
                return 0;
        }
 
        buf_end = buf + fs.st_size;
 
        begin = end = buf;
        while (1) {
                if (! (*end == '\r' || *end == '\n')) {
                        if (++end < buf_end) continue;
                } else if (1 + end < buf_end) {
                        /* see if we got "\r\n" or "\n\r" here */
                        c = *(1 + end);
                        if ( (c == '\r' || c == '\n') && c != *end)
                                ++end;
                }
 
                /* call the call back and check error indication. Announce
                   error here, because we didn't tell call_back the file name */
                if (! call_back(begin, end)) {
                        err(1, "[callback] %s", fname);
                        break;
                }
 
                if ((begin = ++end) >= buf_end)
                        break;
        }
 
        munmap(buf, fs.st_size);
        close(fd);
        return 1;
}
 
int print_line(char* begin, char* end)
{
        if (write(fileno(stdout), begin, end - begin + 1) == -1) {
                return 0;
        }
        return 1;
}
 
int main()
{
        return read_lines("test.ps", print_line) ? 0 : 1;
}

[edit] C++

#include <fstream>
#include <string>
#include <iostream>
 
int main( int argc , char** argv ) {
   int linecount = 0 ;
   std::string line ;
   std::ifstream infile( argv[ 1 ] ) ;
   if ( infile ) {
      while ( getline( infile , line ) ) {
	 std::cout << linecount << ": " << line << '\n' ;//supposing '\n' to be line end
	 linecount++ ;
      }
   }
   infile.close( ) ;
   return 0 ;
}

Library: U++

#include <Core/Core.h>
 
using namespace Upp;
 
CONSOLE_APP_MAIN
{
	FileIn in(CommandLine()[0]);
	while(in && !in.IsEof())
		Cout().PutLine(in.GetLine());
}

[edit] C#

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

foreach (string readLine in File.ReadLines("FileName")
  DoSomething(readLine);

A full code may look like;

using System;
using System.IO;
using System.Text;
 
namespace RosettaCode
{
  internal class Program
  {
    private static void Main()
    {
      var sb = new StringBuilder();
      string F = "File.txt";
 
      // Read a file, line by line.
      try
      {
        foreach (string readLine in File.ReadLines(F))
        {
          // Use the data in some way...
          sb.Append(readLine);
          sb.Append("\n");
        }
      }
      catch (Exception exception)
      {
        Console.WriteLine(exception.Message);
        Environment.Exit(1);
      }
 
      // Preset the results
      Console.WriteLine(sb.ToString());
    }
  }
}

[edit] Clojure

 
(with-open [r (clojure.java.io/reader "some-file.txt")]
   (doseq [l (line-seq r)]
     (println l)))

[edit] CoffeeScript

Works with: node.js

 
# This module shows two ways to read a file line-by-line in node.js.
fs = require 'fs'
 
# First, let's keep things simple, and do things synchronously.  This
# approach is well-suited for simple scripts.
do ->
  fn = "read_file.coffee"
  for line in fs.readFileSync(fn).toString().split '\n'
    console.log line
  console.log "DONE SYNC!"
 
# Now let's complicate things.
#
# Use the following code when files are large, and memory is
# constrained and/or where you want a large amount of concurrency.
#
# Protocol:
#   Call LineByLineReader, which calls back to you with a reader.
#   The reader has two methods.
#      next_line: call to this when you want a new line
#      close: call this when you are done using the file before
#         it has been read completely
#
#   When you call next_line, you must supply two callbacks:
#     line_cb: called back when there is a line of text
#     done_cb: called back when there is no more text in the file
LineByLineReader = (fn, cb) ->
  fs.open fn, 'r', (err, fd) ->
    bufsize = 256
    pos = 0
    text = ''
    eof = false
    closed = false
    reader =
      next_line: (line_cb, done_cb) ->
        if eof
          if text
            last_line = text
            text = ''
            line_cb last_line
          else
            done_cb()
          return
 
        new_line_index = text.indexOf '\n'
        if new_line_index >= 0
          line = text.substr 0, new_line_index
          text = text.substr new_line_index + 1, text.length - new_line_index - 1
          line_cb line
        else
          frag = new Buffer(bufsize)
          fs.read fd, frag, 0, bufsize, pos, (err, bytesRead) ->
            s = frag.toString('utf8', 0, bytesRead)
            text += s
            pos += bytesRead
            if (bytesRead)
              reader.next_line line_cb, done_cb
            else
              eof = true
              fs.closeSync(fd)
              closed = true
              reader.next_line line_cb, done_cb
        close: ->
          # The reader should call this if they abandon mid-file.
          fs.closeSync(fd) unless closed
 
    cb reader
 
# Test our interface here.
do ->
  console.log '---'
  fn = 'read_file.coffee'
  LineByLineReader fn, (reader) -> 
    callbacks =
      process_line: (line) ->
         console.log line
         reader.next_line callbacks.process_line, callbacks.all_done
      all_done: ->
        console.log "DONE ASYNC!"
    reader.next_line callbacks.process_line, callbacks.all_done

[edit] Common Lisp

(with-open-file (input "file.txt")
   (loop for line = (read-line input nil)
      while line do (format t "~a~%" line)))

[edit] D

import std.stdio;
 
void main() {
    foreach (line; File("unixdict.txt").byLine())
        writeln(line);
}

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.

[edit] Delphi

 
   procedure ReadFileByLine;
   var
      TextFile: text;
      TextLine: String;
   begin
      Assign(TextFile, 'c:\test.txt');
      Reset(TextFile);
      while not Eof(TextFile) do
         Readln(TextFile, TextLine);
      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 
      TextLines :  TStringList;
      i         :  Integer; 
   begin
      TextLines := TStringList.Create; 
      TextLines.LoadFromFile('c:\text.txt');
      for i := 0 to TextLines.count -1 do
      ShowMessage(TextLines[i]);
   end;

Above uses the powerful utility classs type TStringList from Classes Unit

See also GNU LGPL (Delphi replacement) Lazarus IDE FreePascal and specifically Lazarus FreePascal Equivalent for TStringList

[edit] Euphoria

constant cmd = command_line()
constant filename = cmd[2]
constant fn = open(filename,"r")
integer i
i = 1
object x
while 1 do
    x = gets(fn)
    if atom(x) then
        exit
    end if
    printf(1,"%2d: %s",{i,x})
    i += 1
end while
close(fn)

Output:

 1: constant cmd = command_line()
 2: constant filename = cmd[2]
 3: constant fn = open(filename,"r")
 4: integer i
 5: i = 1
 6: object x
 7: while 1 do
 8:     x = gets(fn)
 9:     if atom(x) then
10:         exit
11:     end if
12:     printf(1,"%2d: %s",{i,x})
13:     i += 1
14: end while
15: close(fn)

[edit] Fantom

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

 
class Main
{
  Void main ()
  {
    File (`data.txt`).eachLine |Str line|
    {
      echo ("Line: $line")
    }
  }
}

[edit] Forth

4096 constant max-line
 
: third ( A b c -- A b c A )
  >r over r> swap ;
 
: read-lines ( fileid -- )
  begin  pad max-line third read-line throw
  while  pad swap  ( fileid c-addr u )  \ string excludes the newline
         2drop
  repeat 2drop ;

[edit] Frink

The lines 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.)

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

[edit] GAP

ReadByLines := function(name)
	local file, line, count;
	file := InputTextFile(name);
	count := 0;
	while true do
		line := ReadLine(file);
		if line = fail then
			break;
		fi;
		count := count + 1;
	od;
	CloseStream(file);
	return count;
end;
 
# With [http://www.ibiblio.org/pub/docs/misc/amnesty.txt amnesty.txt]
ReadByLines("amnesty.txt"); 
# 384

[edit] Go

The standard library function shown here is bufio.ReadLine. This function allows files to be very rapidly scanned for desired data with no superfluous memory allocations or garbage being generated.

package main
 
import (
    "bufio"
    "fmt"
    "io"
    "os"
)
 
func main() {
    f, err := os.Open("file") // os.OpenFile has more options if you need them
    if err != nil {           // error checking is good practice
        fmt.Println(err)      // error *handling* is good practice
        return
    }
 
    // os.File has no special buffering, it makes straight operating system
    // requests.  bufio.Reader does buffering and has several useful methods.
    bf := bufio.NewReader(f)
 
    // there are a few possible loop termination
    // conditions, so just start with an infinite loop.
    for {
        // reader.ReadLine does a buffered read up to a line terminator,
        // handles either /n or /r/n, and returns just the line without
        // the /r or /r/n.
        line, isPrefix, err := bf.ReadLine()
 
        // loop termination condition 1:  EOF.
        // this is the normal loop termination condition.
        if err == io.EOF {
            break
        }
 
        // loop termination condition 2: some other error.
        // Errors happen, so check for them and do something with them.
        if err != nil {
            fmt.Println(err)
            return
        }
 
        // loop termination condition 3: line too long to fit in buffer
        // without multiple reads.  Bufio's default buffer size is 4K.
        // Chances are if you haven't seen a line terminator after 4k
        // you're either reading the wrong file or the file is corrupt.
        if isPrefix {
            fmt.Println("Error: Unexpected long line reading ", f.Name())
            return
        }
 
        // success.  The variable line is now a byte slice based on on
        // bufio's underlying buffer.  This is the minimal churn necessary
        // to let you look at it, but note! the data may be overwritten or
        // otherwise invalidated on the next read.  Look at it and decide
        // if you want to keep it.  If so, copy it or copy the portions
        // you want before iterating in this loop.  Also note, it is a byte
        // slice.  Often you will want to work on the data as a string,
        // and the string type conversion (shown here) allocates a copy of
        // the data.  It would be safe to send, store, reference, or otherwise
        // hold on to this string, then continue iterating in this loop.
        fmt.Println(string(line))
    }
}

[edit] Groovy

new File("Test.txt").eachLine { line, lineNumber ->
    println "processing line $lineNumber: $line"
}

[edit] Haskell

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

main = do
  file <- readFile "linebyline.hs"
  mapM_ putStrLn (lines file)

[edit] Icon and Unicon

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

procedure main()
f := open("input.txt","r") | stop("cannot open file ",fn)
while line := read(f) 
close(f)
end

[edit] J

J currently discourages this "read just one line" approach. In addition to the arbitrary character of lines, there are issues of problem size and scope (what happens when you have a billion characters between your newline delimiters?). Usually, it's easier to just read the entire file, or memory map the file, and when files are so large that that is not practical it's probably better to put the programmer in explicit control of issues like block sizes and exception handling.

This implementation looks for lines separated by ascii character 10. Lines returned here do not include the line separater character. Files with no line-separating character at the end are treated as well formed -- if the last character of the file is the line separator that means that you have an empty line at the end of the file.

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.

cocurrent 'linereader'
 
  NB. configuration parameter
  blocksize=: 400000
 
  NB. implementation
  offset=: 0
  position=: 0
  buffer=: ''
  lines=: ''
 
  create=: monad define
    name=: boxxopen y
    size=: 1!:4 name
    blocks=: 2 <@(-~/\)\ ~. size <. blocksize * i. 1 + >. size % blocksize
  )
 
  readblocks=: monad define
     if. 0=#blocks do. return. end.
     if. 1<#lines do. return. end.
     whilst. -.LF e.chars do.
       buffer=: buffer,chars=. 1!:11 name,{.blocks
       blocks=: }.blocks
       lines=: <;._2 buffer,LF
     end.
     buffer=: _1{::lines
  )
 
  next=: monad define
    if. (#blocks)*.2>#lines do. readblocks'' end.
    r=. 0{::lines
    lines=: }.lines
    r
  )

   example=: '/tmp/example.txt' conew 'linereader'
   next__example''
this is line 1
   next__example''
and this is line 2

[edit] Java

import java.io.BufferedReader;
import java.io.FileReader;
 
/**
 * Reads a file line by line, processing each line.
 *
 * @author  $Author$
 * @version $Revision$
 */
public class ReadFileByLines {
    private static void processLine(int lineNo, String line) {
        // ...
    }
 
    public static void main(String[] args) {
        for (String filename : args) {
            BufferedReader br = null;
            FileReader fr = null;
            try {
                fr = new FileReader(filename);
                br = new BufferedReader(fr);
                String line;
                int lineNo = 0;
                while ((line = br.readLine()) != null) {
                    processLine(++lineNo, line);
                }
            }
            catch (Exception x) {
                x.printStackTrace();
            }
            finally {
                if (fr != null) {
                    try {br.close();} catch (Exception ignoreMe) {}
                    try {fr.close();} catch (Exception ignoreMe) {}
                }
            }
        }
    }
}

Works with: Java version 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:

for (String filename : args) {
    try (FileReader fr = new FileReader(filename);BufferedReader br = new BufferedReader(fr)){
        String line;
        int lineNo = 0;
        while ((line = br.readLine()) != null) {
            processLine(++lineNo, line);
        }
    }
    catch (Exception x) {
        x.printStackTrace();
    }
}

fr and br 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 Files class (line numbers can be inferred from indices in the returned List):

import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.charset.Charset;
import java.io.IOException;
//...other class code
List<String> lines = null;
try{
    lines = Files.readAllLines(Paths.get(filename), Charset.defaultCharset());
}catch(IOException | SecurityException e){
    //problem with the file
}

[edit] Liberty BASIC

filedialog "Open","*.txt",file$
if file$="" then end
open file$ for input as #f
while not(eof(#f))
    line input #f, t$
    print t$
wend
close #f

Mac

filedialog "Open","*.txt",file$
if file$="" then end
open file$ for input as #f
while not(eof(#f))
    t$ = inputto$(#f, chr$(13))
    print t$
wend
close #f

Unix

filedialog "Open","*.txt",file$
if file$="" then end
open file$ for input as #f
while not(eof(#f))
    t$ = inputto$(#f, chr$(10))
    print t$
wend
close #f

[edit] Logo

There are several words which will return a line of input.

readline - returns a line as a list of words
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

while [not eof?] [print readline]

[edit] Lua

filename = "input.txt"
fp = io.open( filename, "r" )
 
for line in fp:lines() do
    print( line )
end
 
fp:close()

[edit] Mathematica

 
strm=OpenRead["input.txt"];
If[strm=!=$Failed,
  While[line=!=EndOfFile,
    line=Read[strm];
    (*Do something*)
  ]];
Close[strm];

[edit] MATLAB / Octave

The function fgetl() read lines from file:

 
  fid = fopen('foobar.txt','r');
  if (fid < 0) 
	printf('Error:could not open file\n')
  else
	while ~feof(fid),
		line = fgetl(fid);
                %% process line %% 
	end;
        fclose(fid)
  end;

[edit] NewLISP

 
(set 'in-file (open "filename" "read"))
(while (read-line in-file)
       (write-line))   
(close in-file)

[edit] Objeck

 
bundle Default {
  class ReadFile {
    function : Main(args : String[]) ~ Nil {
      f := IO.FileReader->New("in.txt");
      if(f->IsOpen()) {
        string := f->ReadString();
        while(f->IsEOF() = false) {
          string->PrintLine();
          string := f->ReadString();
        };
        f->Close();
      };
    }
  }
}

[edit] Objective-C

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

NSString *path = [NSString stringWithString:@"/usr/share/dict/words"];
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:

NSArray* lines = [words componentsSeparatedByCharactersInSet:[NSCharacterSet newlineCharacterSet]];

[edit] OCaml

let () =
  let ic = open_in "input.txt" in
  try
    while true do
      let line = input_line ic in
      print_endline line
    done
  with End_of_file ->
    close_in ic

[edit] PARI/GP

GP has an unfortunate limitations that prevents reading files line-by-line, but it's just as well since its file-handling capabilities are poor. The TODO file lists one desiderata as adding a t_FILE, which if added would presumably have support for this sort of operation.

Thus the usual way of interacting with files in more than the simple way allowed by read is done by PARI with the usual C commands:

FILE *f = fopen(name, "r");
if (!f) {
	pari_err(openfiler, "input", name);
}
while(fgets(line, MAX_LINELEN, f) != NULL) {
	// ...
}

[edit] Pascal

See Delphi

[edit] Perl

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

open(FOO, '<', 'foobar.txt') or die $!;
while (<FOO>) { # each line is stored in $_, with terminating newline
    chomp; # chomp, short for chomp($_), removes the terminating newline
    process($_);
}
close(FOO);

The angle bracket operator < > 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 $_, 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:

open(FOO, '<', 'foobar.txt') or die $!;
while (my $line = <FOO>) {
    chomp($line);
    process($line);
}
close(FOO);

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

while (<>) {
    chomp;
    process($_);
}

[edit] Perl 6

for open('test.txt').lines
{
  .say
}

[edit] PicoLisp

(in "foobar.txt"
   (while (line)
      (process @) ) )

[edit] PHP

<?php
$file = fopen(__FILE__, 'r'); // read current file
while ($line = fgets($file)) {
    $line = rtrim($line);      // removes linebreaks and spaces at end
    echo strrev($line) . "\n"; // reverse line and upload it
}

[edit] PL/I

 
read: procedure options (main);
   declare line character (500) varying;
 
   on endfile (sysin) stop;
 
   do forever;
      get edit (line)(L);
   end;
end read;

[edit] PureBasic

FileName$ = OpenFileRequester("","foo.txt","*.txt",0)
 
If OpenFile(0, FileName$)
  While Not Eof(0)
    line$ = ReadString(0)
    DoSomethingWithTheLine(Line)
  Wend
  CloseFile(0)
EndIf

[edit] Python

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

with open("foobar.txt") as f:
    for line in f:
        process(line)

The with statement ensures the correct closing of the file after it is processed, and iterating over the file object f, adjusts what is considered line separator character(s) so the code will work on multiple operating systems such as Windows, Mac, and Solaris without change.
Any exceptional conditions seen when processing the file will raise an exception. Leaving the while loop because of an exception will also cause the file to be correctly closed on the way.

Python also has the fileinput module. This can process multiple files parsed from the command line and can be set to modify files 'in-place'.

import fileinput
for line in fileinput.input():
    process(line)

[edit] R

conn <- file("notes.txt", "r")
while(length(line <- readLines(conn, 1)) > 0) {
    cat(line, "\n")
}

[edit] Racket

(define (read-next-line-iter file)
	   (let ((line (read-line file)))
	     (unless (eof-object? line)
	       (display line)
	       (newline)
	       (read-next-line-iter file))))
(call-with-input-file "foobar.txt" read-next-line-iter)

[edit] REXX

 
/*read a file one line at a time.*/
 
parse arg fileId
say 'displaying file:' fileId
 
  do recNo=1 while lines(fileId)>0       /*loop.   */
  yyy=linein(fileId)                     /*read.   */
       say                               /*blank.  */
       say 'record#='recNo               /*show #  */
       say yyy                           /*the line*/
  end
 
say
say 'file' fileId "has" j 'records.'     /*summary.*/

[edit] Ruby

IO.foreach "foobar.txt" do |line|
  # Do something with line.
  puts line
end

# File inherits from IO, so File.foreach also works.
File.foreach("foobar.txt") {|line| puts line}

# IO.foreach and File.foreach can also read a subprocess.
IO.foreach "| grep afs3 /etc/services" do |line|
  puts line
end

Caution! IO.foreach and File.foreach take a portname. To open an arbitrary filename (which might start with "|"), you must use File.open, then IO#each (or IO#each_line). The block form of File.open automatically closes the file after running the block.

filename = "|strange-name.txt"
File.open(filename) do |file|
  file.each {|line| puts line}
end

[edit] Scala

import scala.io._
Source.fromFile("foobar.txt").getLines.foreach(println)

[edit] Scheme

; Commented line below should be uncommented to use read-line with Guile
;(use-modules (ice-9 rdelim))
 
(define file (open-input-file "input.txt"))
(do ((line (read-line file) (read-line file))) ((eof-object? line))
        (display line)
        (newline))

[edit] Sed

Through a .sed file:

#!/bin/sed -f
p

or through a one-liner in bash:

 
sed p filename

[edit] Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
  local
    var file: aFile is STD_NULL;
    var string: line is "";
  begin
    aFile := open("input.txt", "r");
    while hasNext(aFile) do
      readln(aFile, line);
      writeln("LINE: " <& line);
    end while;
  end func;

The function hasNext returns TRUE when at least one character can be read successfully.

[edit] SNOBOL4

In SNOBOL4, file I/O is done by associating a file with a variable. Every subsequent access to the variable provides the next record of the file. Options to the input() function allow the file to be opened in line mode, fixed-blocksize (raw binary) mode, and with various sharing options. The input() operation generally fails (in most modern implementations) if the file requested is not found (in earlier implementations, that failure is reported the same way as end-of-file when the first actual read from the file is attempted). You can specify the file unit number to use (a vestigial remnant of the Fortran I/O package used by original Bell Labs SNOBOL4 implementations... in this case, I'll use file unit 20). Accessing the variable fails (does not succeed) when the end of file is reached.

        input(.infile,20,"readfrom.txt")      :f(end)
rdloop  output = infile                       :s(rdloop)
end

[edit] Tcl

set f [open "foobar.txt"]
while {[gets $f line] >= 0} {
    # This loops over every line
    puts ">>$line<<"
}
close $f

[edit] TUSCRIPT

 
$$ MODE TUSCRIPT
 
datei="rosetta.txt"
ERROR/STOP OPEN (datei,READ,-std-)
 
ACCESS q: READ/RECORDS/UTF8 $datei s,line
 LOOP
 READ/NEXT/EXIT q
 PRINT line
 ENDLOOP
ENDACCESS q

or:

 
LOOP line=datei
 PRINT line
ENDLOOP

[edit] UNIX Shell

Redirect standard input from a file, and then use IFS= read -r line to read each line.

mksh(1) manual says, "If read is run in a loop such as while read foo; do ...; done then leading whitespace will be removed (IFS) and backslashes processed. You might want to use while IFS= read -r foo; do ...; done for pristine I/O."

Works with: Almquist Shell

# This while loop repeats for each line of the file.
# This loop is inside a pipeline; many shells will
# run this loop inside a subshell.
cat input.txt |
while IFS= read -r line ; do
  printf '%s\n' "$line"
done