Input loop
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Read from a text stream either word-by-word or line-by-line until the stream runs out of data. The stream will have an unknown amount of data on it.
Ada
This example reads in a text stream from standard input line by line and writes the output to standard output. <lang ada>with Ada.Text_Io; use Ada.Text_Io;
procedure Read_Stream is
Line : String(1..10); Length : Natural;
begin
while not End_Of_File loop Get_Line(Line, Length); -- read up to 10 characters at a time Put(Line(1..Length)); -- The current line of input data may be longer than the string receiving the data. -- If so, the current input file column number will be greater than 0 -- and the extra data will be unread until the next iteration. -- If not, we have read past an end of line marker and col will be 1 if Col(Current_Input) = 1 then New_Line; end if; end loop;
end Read_Stream;</lang>
Aime
<lang aime>void read_stream(file f) {
text s;
while (f_line(f, s) != -1) { # the read line available as -s- }
}</lang>
ALGOL 68
For file consisting of just one page - a typical linux/unix file: <lang algol68>main:(
PROC raise logical file end = (REF FILE f) BOOL: ( except logical file end ); on logical file end(stand in, raise logical file end); DO print(read string); read(new line); print(new line) OD; except logical file end: SKIP
)</lang> For multi page files, each page is seekable with PROC set = (REF FILE file, INT page, line, char)VOID: ~. This allows rudimentary random access where each new page is effectively a new record. <lang algol68>main:(
PROC raise logical file end = (REF FILE f) BOOL: ( except logical file end ); on logical file end(stand in, raise logical file end); DO PROC raise page end = (REF FILE f) BOOL: ( except page end ); on page end(stand in, raise page end); DO print(read string); read(new line); print(new line) OD; except page end: read(new page); print(new page) OD; except logical file end: SKIP
)</lang> The boolean functions physical file ended(f), logical file ended(f), page ended(f) and line ended(f) are also available to indicate the end of a file, page and line.
AmigaE
<lang amigae>CONST BUFLEN=1024, EOF=-1
PROC consume_input(fh)
DEF buf[BUFLEN] : STRING, r REPEAT /* even if the line si longer than BUFLEN, ReadStr won't overflow; rather the line is "splitted" and the remaining part is read in the next ReadStr */ r := ReadStr(fh, buf) IF buf[] OR (r <> EOF) -> do something WriteF('\s\n',buf) ENDIF UNTIL r=EOF
ENDPROC
PROC main()
DEF fh
fh := Open('basicinputloop.e', OLDFILE) IF fh consume_input(fh) Close(fh) ENDIF
ENDPROC</lang>
AutoHotkey
This example reads the text of a source file line by line and writes the output to a destination file. <lang AutoHotkey>Loop, Read, Input.txt, Output.txt {
FileAppend, %A_LoopReadLine%`n
}</lang>
AWK
This just reads lines from stdin and prints them until EOF is read.
<lang awk>{ print $0 }</lang>
or, more idiomatic:
<lang awk>1</lang>
Batch File
<lang dos> for /f %%i in (file.txt) do if %%i@ neq @ echo %%i </lang>
BASIC
Applesoft BASIC
<lang ApplesoftBasic>100 INPUT "FILENAME:";F$ 110 D$ = CHR$(4) 120 PRINT D$"VERIFY"F$ 130 PRINT D$"OPEN"F$ 140 PRINT D$"READ"F$ 150 ONERR GOTO 190
160 GET C$ 170 PRINT CHR$(0)C$; 180 GOTO 160
190 POKE 216,0 200 IF PEEK(222) <> 5 THEN RESUME 210 PRINT D$"CLOSE"F$</lang>
BBC BASIC
This specifically relates to console input (stdin). <lang bbcbasic> STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE = -11 SYS "GetStdHandle", STD_INPUT_HANDLE TO @hfile%(1) SYS "GetStdHandle", STD_OUTPUT_HANDLE TO @hfile%(2) SYS "SetConsoleMode", @hfile%(1), 0 *INPUT 13 *OUTPUT 14 REPEAT INPUT A$ PRINT A$ UNTIL FALSE</lang>
Bracmat
This example first creates a test file with three lines. It then opens the file in read mode, sets the string of break characters and then reads the file token by token, where tokens are delimeted by break characters. Finally, the file position is set to an invalid value, which closes the file. <lang bracmat>( put$("This is a three line text","test.txt",NEW) & fil$("test.txt",r) & fil$(,STR," \t\r\n") & 0:?linenr & whl
' ( fil$:(?line.?breakchar) & put $ ( str $ ( "breakchar:" ( !breakchar:" "&SP | !breakchar:\t&"\\t" | !breakchar:\r&"\\r" | !breakchar:\n&"\\n" | !breakchar:&EOF ) ", word " (1+!linenr:?linenr) ":" !line \n ) ) )
& (fil$(,SET,-1)|out$"file closed") );</lang> Output:
breakchar:SP, word 1:This breakchar:\n, word 2:is breakchar:SP, word 3:a breakchar:SP, word 4:three breakchar:\n, word 5:line breakchar:EOF, word 6:text file closed
C
Reads arbitrarily long line each time and return a null-terminated string. Caller is responsible for freeing the string. <lang c>#include <stdlib.h>
- include <stdio.h>
char *get_line(FILE* fp) { int len = 0, got = 0, c; char *buf = 0;
while ((c = fgetc(fp)) != EOF) { if (got + 1 >= len) { len *= 2; if (len < 4) len = 4; buf = realloc(buf, len); } buf[got++] = c; if (c == '\n') break; } if (c == EOF && !got) return 0;
buf[got++] = '\0'; return buf; }
int main() { char *s; while ((s = get_line(stdin))) { printf("%s",s); free(s); } return 0; }</lang>
C++
The following functions send the words resp. lines to a generic output iterator <lang cpp>
- include <istream>
- include <string>
- include <vector>
- include <algorithm>
- include <iostream>
- include <iterator>
// word by word template<class OutIt> void read_words(std::istream& is, OutIt dest) {
std::string word; while (is >> word) { // send the word to the output iterator *dest = word; }
}
// line by line: template<class OutIt> void read_lines(std::istream& is, OutIt dest) {
std::string line; while (std::getline(is, line)) { // store the line to the output iterator *dest = line; }
}
int main() {
// 1) sending words from std. in std. out (end with Return) read_words(std::cin, std::ostream_iterator<std::string>(std::cout, " "));
// 2) appending lines from std. to vector (end with Ctrl+Z) std::vector<std::string> v; read_lines(std::cin, std::back_inserter(v)); return 0;
}
</lang>
An alternate way to read words or lines is to use istream iterators:
<lang cpp> template<class OutIt> void read_words(std::istream& is, OutIt dest) {
typedef std::istream_iterator<std::string> InIt; std::copy(InIt(is), InIt(), dest);
}
namespace detail {
struct ReadableLine : public std::string { friend std::istream & operator>>(std::istream & is, ReadableLine & line) { return std::getline(is, line); } };
}
template<class OutIt> void read_lines(std::istream& is, OutIt dest) {
typedef std::istream_iterator<detail::ReadableLine> InIt; std::copy(InIt(is), InIt(), dest);
} </lang>
C#
<lang csharp>using System; using System.IO;
class Program {
static void Main(string[] args) { StreamReader b = new StreamReader("file.txt"); //or any other Stream
string line = b.ReadLine();
while (line != null) { Console.WriteLine(line); line = b.ReadLine(); } }
}</lang>
Clojure
<lang lisp>(defn basic-input [fname]
(line-seq (java.io.BufferedReader. (java.io.FileReader. fname))))</lang>
COBOL
<lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. input-loop. ENVIRONMENT DIVISION. INPUT-OUTPUT SECTION. FILE-CONTROL. SELECT in-stream ASSIGN TO KEYBOARD *> or any other file/stream ORGANIZATION LINE SEQUENTIAL FILE STATUS in-stream-status. DATA DIVISION. FILE SECTION. FD in-stream. 01 stream-line PIC X(80). WORKING-STORAGE SECTION. 01 in-stream-status PIC 99. 88 end-of-stream VALUE 10. PROCEDURE DIVISION. OPEN INPUT in-stream PERFORM UNTIL EXIT READ in-stream AT END EXIT PERFORM END-READ DISPLAY stream-line END-PERFORM CLOSE in-stream . END PROGRAM input-loop.</lang>
Common Lisp
<lang lisp>(defun basic-input (filename)
(with-open-file (stream (make-pathname :name filename) :direction :input) (loop for line = (read-line stream nil nil) while line do (format t "~a~%" line))))</lang>
D
<lang d>void main() {
import std.stdio;
immutable fileName = "input_loop1.d";
foreach (const line; fileName.File.byLine) { pragma(msg, typeof(line)); // Prints: const(char[]) // line is a transient slice, so if you need to // retain it for later use, you have to .dup or .idup it. line.writeln; // Do something with each line. }
// Keeping the line terminators: foreach (const line; fileName.File.byLine(KeepTerminator.yes)) { // line is a transient slice. line.writeln; }
foreach (const string line; fileName.File.lines) { // line is a transient slice. line.writeln; }
}</lang>
<lang d>import tango.io.Console; import tango.text.stream.LineIterator;
void main (char[][] args) {
foreach (line; new LineIterator!(char)(Cin.input)) { // do something with each line }
}</lang>
<lang d>import tango.io.Console; import tango.text.stream.SimpleIterator;
void main (char[][] args) {
foreach (word; new SimpleIterator!(char)(" ", Cin.input)) { // do something with each word }
}</lang>
Note that foreach variables 'line' and 'word' are transient slices. If you need to retain them for later use, you should .dup them.
Delphi
<lang Delphi>program InputLoop;
{$APPTYPE CONSOLE}
uses SysUtils, Classes;
var
lReader: TStreamReader; // Introduced in Delphi XE
begin
lReader := TStreamReader.Create('input.txt', TEncoding.Default); try while lReader.Peek >= 0 do Writeln(lReader.ReadLine); finally lReader.Free; end;
end.</lang>
Déjà Vu
<lang dejavu>while /= :eof dup !read-line!stdin: !print( "Read a line: " !decode!utf-8 swap ) drop !print "End of file."</lang>
Eiffel
<lang Eiffel> note description : "{ There are several examples included, including input from a text file, simple console input and input from standard input explicitly. See notes in the code for details.
Examples were compile using Eiffel Studio 6.6 with only the default class libraries. }"
class APPLICATION
create make
feature
make do -- These examples show non-console input (a plain text file) -- with end-of-input handling. read_lines_from_file read_words_from_file
-- These examples use simplified input from 'io', that -- handles the details of whether it's stdin or not -- They terminate on a line (word) of "q" read_lines_from_console_with_termination read_words_from_console_with_termination
-- The next examples show reading stdin explicitly -- as if it were a text file. It expects and end of file -- termination and so will loop indefinitely unless reading -- from a pipe or your console can send an EOF. read_lines_from_stdin read_words_from_stdin
-- These examples use simplified input from 'io', that -- handles the details of whether it's stdin or not, -- but have no explicit termination read_lines_from_console_forever read_words_from_console_forever end
--|--------------------------------------------------------------
read_lines_from_file -- Read input from a text file -- Echo each line of the file to standard output. -- -- Some language examples omit file open/close operations -- but are included here for completeness. Additional error -- checking would be appropriate in production code. local tf: PLAIN_TEXT_FILE do print ("Reading lines from a file%N") create tf.make ("myfile") -- Create a file object tf.open_read -- Open the file in read mode
-- The actual input loop
from until tf.end_of_file loop tf.read_line print (tf.last_string + "%N") end
tf.close -- Close the file end
--|--------------------------------------------------------------
read_words_from_file -- Read input from a text file -- Echo each word of the file to standard output on a -- separate line. -- -- Some language examples omit file open/close operations -- but are included here for completeness. Additional error -- checking would be appropriate in production code. local tf: PLAIN_TEXT_FILE do print ("Reading words from a file%N") create tf.make ("myfile") -- Create a file object tf.open_read -- Open the file in read mode
-- The actual input loop
from until tf.end_of_file loop -- This instruction is the only difference between this -- example and the read_lines_from_file example tf.read_word print (tf.last_string + "%N") end
tf.close -- Close the file end
--|--------------------------------------------------------------
read_lines_from_console_with_termination -- Read lines from console and echo them back to output -- until the line contains only the termination key 'q' -- -- 'io' is acquired through inheritance from class ANY, -- the top of all inheritance hierarchies. local the_cows_come_home: BOOLEAN do print ("Reading lines from console%N") from until the_cows_come_home loop io.read_line if io.last_string ~ "q" then the_cows_come_home := True print ("Mooooo!%N") else print (io.last_string) io.new_line end end end
--|--------------------------------------------------------------
read_words_from_console_with_termination -- Read words from console and echo them back to output, one -- word per line, until the line contains only the -- termination key 'q' -- -- 'io' is acquired through inheritance from class ANY, -- the top of all inheritance hierarchies. local the_cows_come_home: BOOLEAN do print ("Reading words from console%N") from until the_cows_come_home loop io.read_word if io.last_string ~ "q" then the_cows_come_home := True print ("Mooooo!%N") else print (io.last_string) io.new_line end end end
--|--------------------------------------------------------------
read_lines_from_console_forever -- Read lines from console and echo them back to output -- until the program is terminated externally -- -- 'io' is acquired through inheritance from class ANY, -- the top of all inheritance hierarchies. do print ("Reading lines from console (no termination)%N") from until False loop io.read_line print (io.last_string + "%N") end end
--|--------------------------------------------------------------
read_words_from_console_forever -- Read words from console and echo them back to output, one -- word per line until the program is terminated externally -- -- 'io' is acquired through inheritance from class ANY, -- the top of all inheritance hierarchies. do print ("Reading words from console (no termination)%N") from until False loop io.read_word print (io.last_string + "%N") end end
--|--------------------------------------------------------------
read_lines_from_stdin -- Read input from a stream on standard input -- Echo each line of the file to standard output. -- Note that we treat standard input as if it were a plain -- text file local tf: PLAIN_TEXT_FILE do print ("Reading lines from stdin (EOF termination)%N") tf := io.input
from until tf.end_of_file loop tf.read_line print (tf.last_string + "%N") end end
--|--------------------------------------------------------------
read_words_from_stdin -- Read input from a stream on standard input -- Echo each word of the file to standard output on a new -- line -- Note that we treat standard input as if it were a plain -- text file local tf: PLAIN_TEXT_FILE do print ("Reading words from stdin (EOF termination)%N") tf := io.input
from until tf.end_of_file loop tf.read_line print (tf.last_string + "%N") end end
end
</lang>
Erlang
<lang erlang>% Implemented by Arjun Sunel -module(read_files). -export([main/0]).
main() -> Read = fun (Filename) -> {ok, Data} = file:read_file(Filename), Data end, Lines = string:tokens(binary_to_list(Read("read_files.erl")), "\n"), lists:foreach(fun (Y) -> io:format("~s~n", [Y]) end, lists:zipwith(fun(X,_)->X end, Lines, lists:seq(1, length(Lines)))). </lang>
Euphoria
Process text stream line-by-line: <lang Euphoria>procedure process_line_by_line(integer fn)
object line while 1 do line = gets(fn) if atom(line) then exit end if -- process the line end while
end procedure</lang>
F#
Using a sequence expression: <lang fsharp> let lines_of_file file =
seq { use stream = System.IO.File.OpenRead file use reader = new System.IO.StreamReader(stream) while not reader.EndOfStream do yield reader.ReadLine() }
</lang> The file is reopened every time the sequence is traversed and lines are read on-demand so this can handle arbitrarily-large files.
Factor
<lang factor>"file.txt" utf8 [ [ process-line ] each-line ] with-file-reader</lang>
Fantom
An input stream can be from a string or from a file. The method eachLine
will divide the stream by linebreaks. The method readStrToken
takes two arguments: a maximum size to read, and a function to decide when to stop reading - by default, it stops when it finds a white space.
<lang fantom> class Main {
public static Void main () { // example of reading by line str := "first\nsecond\nthird\nword" inputStream := str.in
inputStream.eachLine |Str line| { echo ("Line is: $line") }
// example of reading by word str = "first second third word" inputStream = str.in
word := inputStream.readStrToken // reads up to but excluding next space while (word != null) { echo ("Word: $word") inputStream.readChar // skip over the preceding space! word = inputStream.readStrToken } }
} </lang>
Forth
<lang forth>4096 constant max-line
- read-lines
begin stdin pad max-line read-line throw while pad swap \ addr len is the line of data, excluding newline 2drop repeat ;</lang>
Fortran
The code read line-by-line, but the maximum length of the line is limited (by a parameter)
<lang fortran>program BasicInputLoop
implicit none
integer, parameter :: in = 50, & linelen = 1000 integer :: ecode character(len=linelen) :: l
open(in, file="afile.txt", action="read", status="old", iostat=ecode) if ( ecode == 0 ) then do read(in, fmt="(A)", iostat=ecode) l if ( ecode /= 0 ) exit write(*,*) trim(l) end do close(in) end if
end program BasicInputLoop</lang>
gnuplot
The following gnuplot script echoes standard input to standard output line-by-line until the end of the stream. <lang gnuplot>!cat</lang> It makes use of the ability of gnuplot to spawn shell commands. In that sense it might be considered cheating. Nevertheless, this is a valid gnuplot script that does meet the requirements of the task description.
It seems impossible to complete this task with just standard gnuplot commands.
Go
The following reads a line at a time from stdin. The variable s is the line returned from stdin. <lang go>package main
import (
"bufio" "os"
)
func main() {
in := bufio.NewReader(os.Stdin) for { s, err := in.ReadString('\n') if err != nil { break } _ = s }
}</lang>
Groovy
Solution: <lang groovy>def lineMap = [:] System.in.eachLine { line, i ->
lineMap[i] = line
} lineMap.each { println it }</lang>
Test:
$ groovy -e 'def lineMap = [:] > System.in.eachLine { line, i -> > lineMap[i] = line > } > lineMap.each { println it }' <<EOF > > Whose woods these are I think I know > His house is in the village tho' > He will not see me stopping here > To watch his woods fill up with snow > EOF
Output:
1= 2=Whose woods these are I think I know 3=His house is in the village tho' 4=He will not see me stopping here 5=To watch his woods fill up with snow
Haskell
The whole contents of a file can be read lazily. The standard functions lines and words convert that lazily into the lists of lines resp. words. Usually, one wouldn't use extra routines for that, but just use readFile and then put 'lines' or words somewhere in the next processing step.
<lang haskell>import System.IO
readLines :: Handle -> IO [String] readLines h = do
s <- hGetContents h return $ lines s
readWords :: Handle -> IO [String] readWords h = do
s <- hGetContents h return $ words s</lang>
HicEst
<lang HicEst>CHARACTER name='myfile.txt', string*1000
OPEN(FIle=name, OLD, LENgth=bytes, IOStat=errorcode, ERror=9)
DO line = 1, bytes ! loop terminates with end-of-file error at the latest READ(FIle=name, IOStat=errorcode, ERror=9) string WRITE(StatusBar) string ENDDO
9 WRITE(Messagebox, Name) line, errorcode</lang>
Icon and Unicon
<lang Icon>link str2toks
- call either words or lines depending on what you want to do.
procedure main()
words()
end
procedure lines()
while write(read())
end
procedure words()
local line while line := read() do line ? every write(str2toks())
end</lang>
See str2toks
J
Script "read-input-until-eof.ijs": <lang J>#!/Applications/j602/bin/jconsole NB. read input until EOF ((1!:1) 3)(1!:2) 4 exit </lang> Example: <lang J>$ ./read-input-to-eof.ijs <<EOF > abc > def > ghi > now is the time for all good men ... > EOF abc def ghi now is the time for all good men ...</lang>
Java
Some people prefer Scanner or BufferedReader, so a way with each is presented. <lang java>import java.util.Scanner; ... Scanner in = new Scanner(System.in);//stdin //new Scanner(new FileInputStream(filename)) for a file //new Scanner(socket.getInputStream()) for a network stream while(in.hasNext()){ String input = in.next(); //in.nextLine() for line-by-line //process the input here }</lang> Or <lang java>import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; ... try{ BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));//stdin //new BufferedReader(new FileReader(filename)) for a file //new BufferedReader(new InputStreamReader(socket.getInputStream())) for a network stream while(inp.ready()){ String input = inp.readLine();//line-by-line only //in.read() for character-by-character //process the input here } } catch (IOException e) { //There was an input error }</lang>
JavaScript
These implementations of JavaScript define a readline()
function, so:
$ js -e 'while (line = readline()) { do_something_with(line); }' < inputfile
As above, this operates on standard input <lang javascript>var text_stream = WScript.StdIn; var i = 0;
while ( ! text_stream.AtEndOfStream ) {
var line = text_stream.ReadLine(); // do something with line WScript.echo(++i + ": " + line);
}</lang>
jq
The jq program for reading and writing is simply the one-character program:
.
For example, to echo each line of text in a file, one could invoke jq as follows:<lang jq>jq -r -R . FILENAME </lang>
If the input file consists of well-formed JSON entities (including scalars), then the following invocation could be used to "pretty-print" the input: <lang jq>jq . FILENAME</lang>
Other options, e.g. to emit JSON in compact form, also exist.
Julia
We create a text stream and read the lines from the stream one by one, printing them on screen. Note that the lines end by a newline, except the last one. The ending newlines are part of the strings returned by the function readline. Once the end of the stream is reached, readline returns an empty string. <lang Julia>stream = IOBuffer("1\n2\n3\n4\n\n6") ;
while((line = readline(stream)) != "")
print(line)
end</lang>
- Output:
1 2 3 4 6
Lang5
<lang lang5>: read-lines do read . "\n" . eof if break then loop ;
- ==>contents
'< swap open 'fh set fh fin read-lines fh close ;
'file.txt ==>contents</lang>
Lasso
<lang Lasso> local( myfile = file('//path/to/file.txt'), textresult = array )
- myfile -> foreachline => {
#textresult -> insert(#1) }
- textresult -> join('
')</lang>
Result: This is line one I am the second line Here is line 3
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 end </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>
LSL
LSL doesn't have a File System, but it does have Notecards that function as read-only text files, and can be use as configuration files or data sources.
To test it yourself; rez a box on the ground, add the following as a New Script, create a notecard named "Input_Loop_Data_Source.txt", and put what ever data you want in it (in this case I just put a copy of the source code.) <lang LSL>string sNOTECARD = "Input_Loop_Data_Source.txt"; default { integer iNotecardLine = 0; state_entry() { llOwnerSay("Reading '"+sNOTECARD+"'"); llGetNotecardLine(sNOTECARD, iNotecardLine); } dataserver(key kRequestId, string sData) { if(sData==EOF) { llOwnerSay("EOF"); } else { llOwnerSay((string)iNotecardLine+": "+sData); llGetNotecardLine(sNOTECARD, ++iNotecardLine); } } }</lang> Output:
Reading 'Input_Loop_Data_Source.txt' 0: string sNOTECARD = "Input_Loop_Data_Source.txt"; 1: default { 2: integer iNotecardLine = 0; 3: state_entry() { 4: llOwnerSay("Reading '"+sNOTECARD+"'"); 5: llGetNotecardLine(sNOTECARD, iNotecardLine); 6: } 7: dataserver(key kRequestId, string sData) { 8: if(sData==EOF) { 9: llOwnerSay("EOF"); 10: } else { 11: llOwnerSay((string)iNotecardLine+": "+sData); 12: llGetNotecardLine(sNOTECARD, ++iNotecardLine); 13: } 14: } 15: } EOF
Lua
<lang lua>lines = {} str = io.read() while str do
table.insert(lines,str) str = io.read()
end</lang>
Via generic for loop
Reads line-by-line via an iterator (from stdin). Substitute io.lines()
with io.open(filename, "r"):lines()
to read from a file.
<lang lua>lines = {}
for line in io.lines() do
table.insert(lines, line) -- add the line to the list of lines
end</lang>
Mathematica
<lang Mathematica>stream = OpenRead["file.txt"]; While[a != EndOfFile, Read[stream, Word]]; Close[stream]</lang>
MAXScript
this function will read a file line by line. <lang MAXScript>fn ReadAFile FileName = ( local in_file = openfile FileName while not eof in_file do ( --Do stuff in here-- print (readline in_file) ) close in_file )</lang>
Mercury
<lang>
- - module input_loop.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
main(!IO) :-
io.stdin_stream(Stdin, !IO), io.stdout_stream(Stdout, !IO), read_and_print_lines(Stdin, Stdout, !IO).
- - pred read_and_print_lines(io.text_input_stream::in,
io.text_output_stream::in, io::di, io::uo) is det.
read_and_print_lines(InFile, OutFile, !IO) :-
io.read_line_as_string(InFile, Result, !IO), ( Result = ok(Line), io.write_string(OutFile, Line, !IO), read_and_print_lines(InFile, OutFile, !IO) ; Result = eof ; Result = error(IOError), Msg = io.error_message(IOError), io.stderr_stream(Stderr, !IO), io.write_string(Stderr, Msg, !IO), io.set_exit_status(1, !IO) ).
</lang>
mIRC Scripting Language
<lang mirc>var %n = 1 while (%n <= $lines(input.txt)) {
write output.txt $read(input.txt,%n) inc %n
}</lang>
ML/I
The very nature of ML/I is that its default behaviour is to copy from input to output until it reaches end of file. <lang ML/I></lang>
Modula-2
<lang modula2>PROCEDURE ReadName (VAR str : ARRAY OF CHAR);
VAR n : CARDINAL;
ch, endch : CHAR;
BEGIN
REPEAT InOut.Read (ch); Exhausted := InOut.EOF (); IF Exhausted THEN RETURN END UNTIL ch > ' '; (* Eliminate whitespace *) IF ch = '[' THEN endch := ']' ELSE endch := ch END; n := 0; REPEAT InOut.Read (ch); Exhausted := InOut.EOF (); IF Exhausted THEN RETURN END; IF n <= HIGH (str) THEN str [n] := ch ELSE ch := endch END; INC (n) UNTIL ch = endch; IF n <= HIGH (str) THEN str [n-1] := 0C END; lastCh := ch
END ReadName;</lang>
Modula-3
<lang modula3>MODULE Output EXPORTS Main;
IMPORT Rd, Wr, Stdio;
VAR buf: TEXT;
<*FATAL ANY*>
BEGIN
WHILE NOT Rd.EOF(Stdio.stdin) DO buf := Rd.GetLine(Stdio.stdin); Wr.PutText(Stdio.stdout, buf); END;
END Output.</lang>
NetRexx
Using NetRexx ASK Special Variable
<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary
-- Read from default input stream (console) until end of data lines = lines[0] = 0 lineNo = 0
loop label ioloop forever
inLine = ask if inLine = null then leave ioloop -- stop on EOF lineNo = lineNo + 1 lines[0] = lineNo lines[lineNo] = inLine end ioloop
loop l_ = 1 to lines[0]
say l_.right(4)':' lines[l_] end l_
return </lang>
Using Java Scanner
<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary
-- Read from default input stream (console) until end of data lines = lines[0] = 0
inScanner = Scanner(System.in) loop l_ = 1 while inScanner.hasNext()
inLine = inScanner.nextLine() lines[0] = l_ lines[l_] = inLine end l_
inScanner.close()
loop l_ = 1 to lines[0]
say l_.right(4)':' lines[l_] end l_
return </lang>
Nimrod
<lang nimrod>var i = open("input.txt") for line in i.lines:
discard # process line
i.close()</lang>
Objeck
<lang objeck> use IO;
bundle Default {
class Test { function : Main(args : System.String[]) ~ Nil { f := FileReader->New("in.txt"); if(f->IsOpen()) { string := f->ReadString(); while(string->Size() > 0) { string->PrintLine(); string := f->ReadString(); }; f->Close(); }; } }
} </lang>
OCaml
<lang ocaml>let rec read_lines ic =
try let line = input_line ic in line :: read_lines ic with End_of_file -> []</lang>
The version above will work for small files, but it is not tail-recursive.
Below will be more scalable:
<lang ocaml>let read_line ic =
try Some (input_line ic) with End_of_file -> None
let read_lines ic =
let rec loop acc = match read_line ic with | Some line -> loop (line :: acc) | None -> List.rev acc in loop []
- </lang>
Or with a higher order function:
<lang ocaml>let read_lines f ic =
let rec loop () = try f(input_line ic); loop() with End_of_file -> () in loop()
read_lines print_endline (open_in Sys.argv.(1))</lang>
Oz
<lang oz>%% Returns a list of lines. %% Text: an instance of Open.text (a mixin class) fun {ReadAll Text}
case {Text getS($)} of false then nil [] Line then Line|{ReadAll Text} end
end</lang>
Pascal
<lang pascal>{ for stdio }
var
s : string ;
begin
repeat
readln(s); until s = "" ;
{ for a file }
var
f : text ; s : string ;
begin
assignfile(f,'foo'); reset(f); while not eof(f) do readln(f,s);
closefile(f);
end;</lang>
Perl
The angle brackets operator ( <...> ) reads one line at a time from a filehandle in scalar context: <lang perl>open FH, "< $filename" or die "can't open file: $!"; while (my $line = <FH>) {
chomp $line; # removes trailing newline # process $line
} close FH or die "can't close file: $!";</lang>
Or you can get a list of all lines when you use it in list context: <lang perl>@lines = <FH>;</lang>
Or a simpler program for lines of files entered as command line arguments or standard input: <lang perl>while (<>) {
# $_ contains a line
}</lang>
Invoking perl with the -p or -n option implies the above loop, executing its code once per input line, with the line stored in $_. -p will print $_ automatically at the end of each iteration, -n will not.
$ seq 5 | perl -pe '$_ = "Hello $_"' Hello 1 Hello 2 Hello 3 Hello 4 Hello 5 $ seq 5 | perl -ne 'print "Hello $_"' Hello 1 Hello 2 Hello 3 Hello 4 Hello 5
Perl 6
<lang perl6>my $handle = open "filename.txt"; # $handle could be $*IN to read from standard input
for $handle.lines -> $line { # iterates the lines of the $handle
# line endings are automatically stripped
for $line.words -> $word { # iterates the words of the line # are considered words groups of non-whitespace characters }
} </lang>
PHP
<lang php>$fh = fopen($filename, 'r'); if ($fh) {
while (!feof($fh)) { $line = rtrim(fgets($fh)); # removes trailing newline # process $line } fclose($fh);
}</lang>
Or you can get an array of all the lines in the file: <lang php>$lines = file($filename);</lang>
Or you can get the entire file as a string: <lang php>$contents = file_get_contents($filename);</lang>
PicoLisp
This reads all lines in a file, and returns them as a list of lists <lang PicoLisp>(in "file.txt"
(make (until (eof) (link (line)) ) ) )</lang>
PL/I
<lang pli>declare line character (200) varying;
open file (in) title ('/TEXT.DAT,type(text),recsize(200)' ); on endfile (in) stop;
do forever;
get file(in) edit (line) (L); put skip list (line);
end;</lang>
PowerShell
<lang Powershell>Get-Content c:\file.txt |
ForEach-Object { $_ }</lang>
or <lang Powershell>ForEach-Object -inputobject (get-content c:\file.txt) {$_}</lang>
PureBasic
File objects can be read bytewise, characterwise (ASCII or UNICODE), floatwise, doublewise, integerwise, linewise ... <lang PureBasic>If OpenConsole()
; file based line wise If ReadFile(0, "Text.txt") While Eof(0) = 0 Debug ReadString(0) ; each line until eof Wend CloseFile(0) EndIf ; file based byte wise If ReadFile(1, "Text.bin") While Eof(1) = 0 Debug ReadByte(1) ; each byte until eof Wend CloseFile(1) EndIf
EndIf</lang>
Python
Python file objects can be iterated like lists:
<lang python>my_file = open(filename, 'r') try:
for line in my_file: pass # process line, includes newline
finally:
my_file.close()</lang>
One can open a new stream for read and have it automatically close when done, with a new "with" statement: <lang python>from __future__ import with_statement
with open(filename, 'r') as f:
for line in f: pass # process line, includes newline</lang>
You can also get lines manually from a file: <lang python>line = my_file.readline() # returns a line from the file lines = my_file.readlines() # returns a list of the rest of the lines from the file</lang> This does not mix well with the iteration, however.
When (multiple) filenames are given on the command line:
<lang python>import fileinput
for line in fileinput.input():
pass # process line, includes newline</lang>
The fileinput module can also do inplace file editing, follow line counts, and the name of the current file being read etc.
R
Note that read.csv and read.table provide alternatives for files with 'dataset' style contents. <lang rsplus>lines <- readLines("file.txt")</lang>
Racket
The following prints input lines from standard input to standard output:
<lang racket>
- lang racket
(copy-port (current-input-port) (current-output-port)) </lang>
REBOL
<lang REBOL>REBOL [ Title: "Basic Input Loop" Author: oofoe Date: 2009-12-06 URL: http://rosettacode.org/wiki/Basic_input_loop ]
- Slurp the whole file in
x: read %file.txt
- Bring the file in by lines
x: read/lines %file.txt
- Read in first 10 lines
x: read/lines/part %file.txt 10
- Read data a line at a time
f: open/lines %file.txt while [not tail? f][ print f/1 f: next f ; Advance to next line. ] close f</lang>
REXX
version 1
Reading line by line from the standard input using linein and lines did not work. <lang rexx>do while stream(stdin, "State") <> "NOTREADY"
call charout ,charin(stdin)
end</lang>
version 2
<lang rexx>/* -- AREXX -- */ do until eof(stdin)
l = readln(stdin) say l
end</lang>
version 3
Note that if REXX is reading from the default (console) input stream, there is no well-
defined e-o-f (end of file), so to speak.
Therefore, the following two REXX programs use the presence of a null line to indicate e-o-f.
<lang rexx>/*REXX program to read from the (console) default input stream until nul*/
do until _== parse pull _ end /*until ...*/
exit /*stick a fork in it, we're done.*/</lang>
version 4
/*REXX program to read from the (console) default input stream until nul*/
do until _== _=linein() end /*until ...*/
exit /*stick a fork in it, we're done.*/
Ruby
Ruby input streams are IO objects. One can use IO#each or IO#each_line to iterate lines from a stream.
<lang ruby>stream = $stdin stream.each do |line|
# process line
end</lang>
IO objects are also Enumerable (like Array or Range), and have methods like Enumerable#map, which call IO#each to loop through lines from a stream.
<lang ruby># Create an array of lengths of every line. ary = stream.map {|line| line.chomp.length}</lang>
To open a new stream for reading, see Read a file line by line#Ruby.
Run BASIC
<lang runbasic>open "\testFile.txt" for input as #f while not(eof(#f)) line input #f, a$ print a$ wend close #f</lang>
Scala
<lang scala> scala.io.Source.fromFile("input.txt").getLines().foreach {
line => ... }</lang>
Slate
<lang slate>(File newNamed: 'README') reader sessionDo: [| :input | input lines do: [| :line | inform: line]].</lang>
sed
Sed by default loops over each line and executes its given script on it:
$ seq 5 | sed '' 1 2 3 4 5
The automatic printing can be suppressed with -n, and performed manually with p:
$ seq 5 | sed -n p 1 2 3 4 5
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var string: line is ""; begin while hasNext(IN) do readln(line); writeln("LINE: " <& line); end while; end func;</lang>
Sidef
To read from the standard input, you can use STDIN as your fh. <lang ruby>var file = File.new(__FILE__); file.open_r(\var fh, \var err)
|| "Can't open file `#{file}': #{err}\n".die;
fh.each { |line| # iterates the lines of the fh
line.each_word { |word| # iterates the words of the line say word; }
}</lang>
Smalltalk
<lang smalltalk>|f| f := FileStream open: 'afile.txt' mode: FileStream read. [ f atEnd ] whileFalse: [ (f nextLine) displayNl ] .</lang>
SNOBOL4
<lang snobol>loop output = input :s(loop) end</lang>
Tcl
<lang tcl>set fh [open $filename] while {[gets $fh line] != -1} {
# process $line
} close $fh</lang> For “small” files, it is often more common to do this: <lang tcl>set fh [open $filename] set data [read $fh] close $fh foreach line [split $data \n] {
# process line
}</lang>
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT file="a.txt" ERROR/STOP OPEN (file,READ,-std-) ACCESS source: READ/RECORDS/UTF8 $file s,text LOOP
READ/NEXT/EXIT source PRINT text
ENDLOOP ENDACCESS source </lang>
UnixPipes
the pipe 'yes XXX' produces a sequence
read by lines <lang bash>yes 'A B C D ' | while read x ; do echo -$x- ; done</lang> read by words <lang bash>yes 'A B C D ' | while read -d\ a ; do echo -$a- ; done</lang>
UNIX Shell
When there is something to do with the input, here is a loop: <lang bash>while read line ; do
# examine or do something to the text in the "line" variable echo "$line"
done</lang>
The following echoes standard input to standard output line-by-line until the end of the stream.
<lang bash>cat < /dev/stdin > /dev/stdout</lang>
Since cat
defaults to reading from standard input and writing to standard output, this can be further simplified to the following.
<lang bash>cat</lang>
Vala
<lang vala>int main() {
string? s; while((s = stdin.read_line()) != null) { stdout.printf("%s\n", s); } return 0;
}</lang>
Visual Basic .NET
This reads a stream line by line, outputing each line to the screen.
<lang vbnet>Sub Consume(ByVal stream As IO.StreamReader)
Dim line = stream.ReadLine Do Until line Is Nothing Console.WriteLine(line) line = stream.ReadLine Loop
End Sub</lang>
zkl
Many objects support "stream of" concepts such as lines, characters, chunks. Some are File, Data (bit bucket), List, Console. Word by word isn't explicitly supported. If an object is stream-able, it supports methods like foreach, pump, apply, reduce, etc. <lang zkl>foreach line in (File("foo.txt")){...} List(1,2,3).readln() // here, a "line" is a list element Utils.Helpers.zipWith(False, // enumerate a file
fcn(n,line){"%3d: %s".fmt(n,line).print()},[1..],File("cmp.zkl"))</lang>
- Programming Tasks
- Text processing
- Selection/Short Circuit/Console Program Basics
- Basic language learning
- Ada
- Aime
- ALGOL 68
- AmigaE
- AutoHotkey
- AWK
- Batch File
- BASIC
- Applesoft BASIC
- BBC BASIC
- Bracmat
- C
- C++
- C sharp
- Clojure
- COBOL
- Common Lisp
- D
- Tango
- Delphi
- Déjà Vu
- Eiffel
- Erlang
- Euphoria
- F Sharp
- Factor
- Fantom
- Forth
- Fortran
- Gnuplot
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- Icon Programming Library
- J
- Java
- JavaScript
- Jq
- Julia
- Lang5
- Lasso
- Liberty BASIC
- Logo
- LSL
- Lua
- Mathematica
- MAXScript
- Mercury
- MIRC Scripting Language
- ML/I
- Modula-2
- Modula-3
- NetRexx
- Nimrod
- Objeck
- OCaml
- Oz
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PowerShell
- PureBasic
- Python
- R
- Racket
- REBOL
- REXX
- Ruby
- Run BASIC
- Scala
- Scala Implementations
- Slate
- Sed
- Seed7
- Sidef
- Smalltalk
- SNOBOL4
- Tcl
- TUSCRIPT
- UnixPipes
- UNIX Shell
- Vala
- Visual Basic .NET
- Zkl
- PARI/GP/Omit
- TI-89 BASIC/Omit
- Streams