File.readln

Read line from the file handle and write it to buf[], including terminating character.

This can be faster than line = File.readln() because you can reuse the buffer for each call. Note that reusing the buffer means that you must copy the previous contents if you wish to retain them.

  1. S readln(dchar terminator)
  2. size_t readln(C[] buf, dchar terminator)
  3. size_t readln(C[] buf, R terminator)
    struct File
    @safe
    size_t
    readln
    (
    C
    R
    )
    (
    ref C[] buf
    ,)
    if (
    is(Unqual!C == C)
    &&
    !is(C == enum)
    &&
    isBidirectionalRange!R
    &&
    is(typeof(terminator.front == dchar.init))
    )

Parameters

buf C[]

Buffer used to store the resulting line data. buf is enlarged if necessary, then set to the slice exactly containing the line.

terminator R

Line terminator (by default, '\n'). Use std.ascii.newline for portability (unless the file was opened in text mode).

Return Value

Type: size_t

0 for end of file, otherwise number of characters read. The return value will always be equal to buf.length.

Throws

StdioException on I/O error, or UnicodeException on Unicode conversion error.

Examples

// Read lines from `stdin` into a string
// Ignore lines starting with '#'
// Write the string to `stdout`
import std.stdio;

void main()
{
    string output;
    char[] buf;

    while (stdin.readln(buf))
    {
        if (buf[0] == '#')
            continue;

        output ~= buf;
    }

    write(output);
}

This method can be more efficient than the one in the previous example because stdin.readln(buf) reuses (if possible) memory allocated for buf, whereas line = stdin.readln() makes a new memory allocation for every line.

For even better performance you can help readln by passing in a large buffer to avoid memory reallocations. This can be done by reusing the largest buffer returned by readln:

// Read lines from `stdin` and count words
import std.array, std.stdio;

void main()
{
    char[] buf;
    size_t words = 0;

    while (!stdin.eof)
    {
        char[] line = buf;
        stdin.readln(line);
        if (line.length > buf.length)
            buf = line;

        words += line.split.length;
    }

    writeln(words);
}

This is actually what byLine does internally, so its usage is recommended if you want to process a complete file.

Meta