Read a file line by line: Difference between revisions

Content added Content deleted

Inline

Revision as of 12:02, 7 November 2011

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

Ada

Works with: Ada 2005

line_by_line.adb: <lang Ada>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;</lang>

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;

AutoHotkey

<lang 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</lang>

AWK

<lang AWK>awk '{ print $0 }' filename</lang>

BASIC

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

<lang basic> 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 </lang>

Brat

<lang brat>include :file

file.each_line "foobar.txt" { line |

 p line

}</lang>

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

<lang c>#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; }</lang>

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

<lang c>#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; }</lang>

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. <lang C>#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;

} </lang>

C++

<lang cpp>#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 ;

}</lang>

<lang cpp>#include <Core/Core.h>

using namespace Upp;

CONSOLE_APP_MAIN { FileIn in(CommandLine()[0]); while(in && !in.IsEof()) Cout().PutLine(in.GetLine()); }</lang>

C#

'File.ReadLines' reads the lines of a file which could easily be stepped through. <lang csharp>foreach (string readLine in File.ReadLines("FileName")

 DoSomething(readLine);</lang>

A full code may look like; <lang csharp>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());
   }
 }

}</lang>

Common Lisp

<lang lisp>(with-open-file (input "file.txt")

  (loop for line = (read-line input nil)
     while line do (format t "~a~%" line)))</lang>

D

<lang d>import std.stdio;

void main() {

   foreach (line; File("foobar.txt").byLine())
       write(line);

}</lang> 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.

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;

</lang> 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".

<lang Delphi> 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;

</lang>

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

Euphoria

<lang 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)</lang>

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)

Fantom

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

<lang fantom> class Main {

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

} </lang>

Forth

<lang 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 ;</lang>

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.) <lang frink> for line = lines["file:yourfile.txt"]

  println[line]

</lang>

GAP

<lang 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 amnesty.txt

ReadByLines("amnesty.txt");

384</lang>

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. <lang go>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))
   }

}</lang>

Haskell

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

<lang Haskell>main = do

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

</lang>

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.

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

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.

<lang j>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
 )</lang>

<lang j> example=: '/tmp/example.txt' conew 'linereader'

  next__example

this is line 1

  next__example

and this is line 2</lang>

Java

<lang 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) {}
               }
           }
       }
   }

}</lang>

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: <lang java5>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();
   }

}</lang> 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).

Liberty BASIC

<lang lb>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</lang> Mac <lang lb>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 </lang> Unix <lang lb>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 </lang>

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

<lang logo>while [not eof?] [print readline]</lang>

Lua

<lang lua>filename = "input.txt" fp = io.open( filename, "r" )

for line in fp:lines() do

   print( line )

end

fp:close() </lang>

Mathematica

<lang Mathematica> strm=OpenRead["input.txt"]; If[strm=!=$Failed,

 While[line=!=EndOfFile,
   line=Read[strm];
   (*Do something*)
 ]];

Close[strm]; </lang>

Objeck

<lang 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();
     };
   }
 }

} </lang>

Objective-C

To read an entire file into a string, you can: <lang objc>NSString *path = [NSString stringWithString:@"/usr/share/dict/words"]; NSError *error = nil; NSString *words = [[NSString alloc] initWithContentsOfFile:path

                                              encoding:NSUTF8StringEncoding error:&error];

</lang>

Use the UTF-8 encoder on ASCII.

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

<lang objc>NSArray* lines = [words componentsSeparatedByCharactersInSet:[NSCharacterSet newlineCharacterSet]];</lang>

OCaml

<lang 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</lang>

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: <lang C>FILE *f = fopen(name, "r"); if (!f) { pari_err(openfiler, "input", name); } while(fgets(line, MAX_LINELEN, f) != NULL) { // ... }</lang>

Pascal

See Delphi

Perl

For the simple case of iterating over the lines of a file you can do: <lang perl>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);</lang> 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: <lang perl>open(FOO, '<', 'foobar.txt') or die $!; while (my $line = <FOO>) {

   chomp($line);
   process($line);

} close(FOO);</lang>

The special use of the angle bracket operator with nothing inside, will read from all files whose names were specified on the command line: <lang perl>while (<>) {

   chomp;
   process($_);

}</lang>

Perl 6

<lang Perl 6>for open('test.txt').lines {

 .say

}</lang>

PicoLisp

<lang PicoLisp>(in "foobar.txt"

  (while (line)
     (process @) ) )</lang>

PHP

<lang 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

}</lang>

PureBasic

<lang PureBasic>FileName$ = OpenFileRequester("","foo.txt","*.txt",0)

If OpenFile(0, FileName$)

 While Not Eof(0)
   line$ = ReadString(0)
   DoSomethingWithTheLine(Line)
 Wend
 CloseFile(0)

EndIf</lang>

Python

For the simple case of iterating over the lines of a file you can do: <lang python>with open("foobar.txt") as f:

   for line in f:
       process(line)</lang>

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'. <lang python>import fileinput for line in fileinput.input():

   process(line)

</lang>

R

<lang R>conn <- file("notes.txt", "r") while(length(line <- readLines(conn, 1)) > 0) {

   cat(line, "\n")

}</lang>

Ruby

<lang ruby>IO.foreach "foobar.txt" do |line|

 # Do something with line.
 puts line

end</lang>

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

<lang ruby># IO.foreach and File.foreach can also read a subprocess. IO.foreach "| grep afs3 /etc/services" do |line|

 puts line

end</lang>

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.

<lang ruby>filename = "|strange-name.txt" File.open(filename) do |file|

 file.each {|line| puts line}

end</lang>

Scala

<lang scala>import scala.io._ Source.fromFile("foobar.txt").getLines.foreach(println)</lang>

Scheme

<lang 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))</lang>

Sed

Through a .sed file: <lang sed>#!/bin/sed -f p </lang>

or through a one-liner in bash: <lang bash> sed p filename </lang>

Seed7

<lang 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;</lang>

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

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.

<lang snobol4> input(.infile,20,"readfrom.txt") :f(end) rdloop output = infile :s(rdloop) end</lang>

Tcl

<lang tcl>set f [open "foobar.txt"] while {[gets $f line] >= 0} {

   # This loops over every line
   puts ">>$line<<"

} close $f</lang>

TUSCRIPT

<lang 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 </lang> or: <lang tuscript> LOOP line=datei

PRINT line

ENDLOOP </lang>

UNIX Shell

Works with: Bourne Shell

<lang bash>cat scratch.awk | while IFS= read -r line ; do

 # This loop repeats for each line of the file
 printf '%s\n' "$line"

done</lang>

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."

Visual Basic

<lang vb>' Read lines from a file ' ' (c) Copyright 1993 - 2011 Mark Hobley ' ' This code was ported from an application program written in Microsoft Quickbasic ' ' This code can be redistributed or modified under the terms of version 1.2 of ' the GNU Free Documentation Licence as published by the Free Software Foundation.

Sub readlinesfromafile()

 var.filename = "foobar.txt"
 var.filebuffersize = ini.inimaxlinelength
 Call openfileread
 If flg.error = "Y" Then
   flg.abort = "Y"
   Exit Sub
 End If
 If flg.exists <> "Y" Then
   flg.abort = "Y"
   Exit Sub
 End If

readfilelabela:

 Call readlinefromfile
 If flg.error = "Y" Then
   flg.abort = "Y"
   Call closestream
   flg.error = "Y"
   Exit Sub
 End If
 If flg.endoffile <> "Y" Then
   ' We have a line from the file
   Print message$
   GoTo readfilelabela
 End If
 ' End of file reached
 ' Close the file and exit
 Call closestream
 Exit Sub

End Sub

Sub openfileread()

 flg.streamopen = "N"
 Call checkfileexists
 If flg.error = "Y" Then Exit Sub
 If flg.exists <> "Y" Then Exit Sub
 Call getfreestream
 If flg.error = "Y" Then Exit Sub
 var.errorsection = "Opening File"
 var.errordevice = var.filename
 If ini.errortrap = "Y" Then
   On Local Error GoTo openfilereaderror
 End If
 flg.endoffile = "N"
 Open var.filename For Input As #var.stream Len = var.filebuffersize
 flg.streamopen = "Y"
 Exit Sub

openfilereaderror:

 var.errorcode = Err
 Call errorhandler
 resume '!!

End Sub

Public Sub checkfileexists()

 var.errorsection = "Checking File Exists"
 var.errordevice = var.filename
 If ini.errortrap = "Y" Then
   On Local Error GoTo checkfileexistserror
 End If
 flg.exists = "N"
 If Dir$(var.filename, 0) <> "" Then
   flg.exists = "Y"
 End If
 Exit Sub

checkfileexistserror:

 var.errorcode = Err
 Call errorhandler

End Sub

Public Sub getfreestream()

 var.errorsection = "Opening Free Data Stream"
 var.errordevice = ""
 If ini.errortrap = "Y" Then
   On Local Error GoTo getfreestreamerror
 End If
 var.stream = FreeFile
 Exit Sub

getfreestreamerror:

 var.errorcode = Err
 Call errorhandler
 resume '!!

End Sub

Sub closestream()

 If ini.errortrap = "Y" Then
   On Local Error GoTo closestreamerror
 End If
 var.errorsection = "Closing Stream"
 var.errordevice = ""
 flg.resumenext = "Y"
 Close #var.stream
 If flg.error = "Y" Then
   flg.error = "N"
   '!! Call unexpectederror
 End If
 flg.streamopen = "N"
 Exit Sub

closestreamerror:

 var.errorcode = Err
 Call errorhandler
 resume next

End Sub

Public Sub errorhandler()

 tmp$ = btrim$(var.errorsection)
 tmp2$ = btrim$(var.errordevice)
 If tmp2$ <> "" Then
   tmp$ = tmp$ + " (" + tmp2$ + ")"
 End If
 tmp$ = tmp$ + " : " + Str$(var.errorcode)
 tmp1% = MsgBox(tmp$, 0, "Error!")
 flg.error = "Y"
 If flg.resumenext = "Y" Then
   flg.resumenext = "N"

' Resume Next

 Else
   flg.error = "N"

' Resume

 End If

End Sub

Public Function btrim$(arg$)

 btrim$ = LTrim$(RTrim$(arg$))

End Function</lang>

Visual Basic .NET

<lang vbnet>Imports System.IO

 ' Loop through the lines of a file.
 ' Function assumes that the file exists.
 Private Sub ReadLines(ByVal FileName As String)

   Dim oReader As New StreamReader(FileName)
   Dim sLine As String = Nothing

   While Not oReader.EndOfStream
     sLine = oReader.ReadLine()
     ' Do something with the line.
   End While

   oReader.Close()

 End Sub</lang>