std.stdio

Стандартные функции ввода-вывода, расширяющие core.stdc.stdio. core.stdc.stdio импортируется неявно при импорте std.stdio.

Источник: std/stdio.d

Лицензия:: Лицензия Boost 1.0.

Авторы:: Уолтер Брайт, Андрей Александреску, Алекс Рённе Петерсен

alias KeepTerminator = std.typecons.Flag!"keepTerminator".Flag;

Если флаг KeepTerminator установлен в значение KeepTerminator.yes, тогда разделитель включается в строки, возвращаемые функцией.

struct File;

Оборачивает FILE*. В целом, D не пытается предоставить тонкие обертки над эквивалентными функциями в стандартной библиотеке C, но работа с значениями FILE* напрямую небезопасна и склонна к ошибкам во многих аспектах. Тип File гарантирует безопасную работу, автоматическое закрытие файла и удобство.

Базовый дескриптор FILE* хранится с подсчетом ссылок, таким образом, как только последняя переменная File связывается с данным FILE*, базовый FILE* автоматически закрывается.

Пример

// test.d
import std.stdio;

void main(string[] args)
{
    auto f = File("test.txt", "w"); // open for writing
    f.write("Hello");
    if (args.length > 1)
    {
        auto g = f; // now g and f write to the same file
                    // internal reference count is 2
        g.write(", ", args[1]);
        // g exits scope, reference count decreases to 1
    }
    f.writeln("!");
    // f exits scope, reference count falls to zero,
    // underlying `FILE*` is closed.
}

% rdmd test.d Jimmy
% cat test.txt
Hello, Jimmy!
% _

@safe this(string name, scope const(char)[] stdioOpenmode = "rb"); this(R1, R2)(R1 name) Constraints: if (isInputRange!R1 && isSomeChar!(ElementEncodingType!R1)); this(R1, R2)(R1 name, R2 mode) Constraints: if (isInputRange!R1 && isSomeChar!(ElementEncodingType!R1) && isInputRange!R2 && isSomeChar!(ElementEncodingType!R2));

Конструктор, принимающий имя файла для открытия и режим открытия.

Копирование одного объекта File в другой приводит к тому, что два объекта File ссылаются на один и тот же базовый файл.

Деструктор автоматически закрывает файл, как только ни один объект File больше не ссылается на него.

Параметры:

string `name`	диапазон или строка, представляющая имя файла
const(char)[] `stdioOpenmode`	диапазон или строка, представляющая режим открытия (с теми же семантиками, что и в функции C-библиотеки fopen)

Исключения:: ErrnoException если файл не удалось открыть.

ref @safe File opAssign(File rhs) return;

Присваивает файл другому. Цель присваивания отсоединяется от файла, к которому она была прикреплена, и присоединяется к новому файлу.

@trusted void open(string name, scope const(char)[] stdioOpenmode = "rb");

Отсоединяется от текущего файла (выбрасывая исключение при ошибке), а затем пытается открыть файл name в режиме stdioOpenmode. Режим имеет те же семантики, что и в функции C-библиотеки fopen.

Исключения:: ErrnoException в случае ошибки.

@trusted void reopen(string name, scope const(char)[] stdioOpenmode = "rb");

Использует объект File для открытия другого файла или изменения режима файла. Если name равно null, режим текущего открытого файла изменяется; в противном случае открывается новый файл, повторно используя C-функцию FILE*. Функция имеет те же семантики, что и в функции C-библиотеки freopen.

Примечание: Вызов reopen с null name не реализован во всех C-средах выполнения.

Исключения:: ErrnoException в случае ошибки.

@safe void popen(string command, scope const(char)[] stdioOpenmode = "r");

Отсоединяется от текущего файла (выбрасывая исключение при ошибке), а затем выполняет команду, вызывая функцию C-библиотеки popen.

Исключения:: ErrnoException в случае ошибки.

@safe void fdopen(int fd, scope const(char)[] stdioOpenmode = "rb");

Сначала вызывает detach (выбрасывая исключение при ошибке), а затем пытается связать данный дескриптор файла с File, и устанавливает имя файла в null.

Режим должен быть совместим с режимом дескриптора файла.

Исключения:: ErrnoException в случае ошибки.

Параметры:

int `fd`	Дескриптор файла для связи с этим `File`.
const(char)[] `stdioOpenmode`	Режим для связи с этим файлом. Режим имеет те же семантические значения, что и в функции C-библиотеки fdopen, и должен быть совместим с `fd`.

void windowsHandleOpen(HANDLE handle, scope const(char)[] stdioOpenmode);

Сначала вызывает detach (выбрасывая исключение при ошибке), а затем пытается связать данный дескриптор Windows HANDLE с File. Режим должен быть совместим с атрибутами доступа дескриптора. Только для Windows.

Исключения:: ErrnoException в случае ошибки.

const pure nothrow @property @safe bool isOpen();

Возвращает true если файл открыт.

const pure @property @trusted bool eof();

Возвращает true если файл находится в конце (см. feof).

Исключения:: Exception если файл не открыт.

const pure nothrow @property @safe string name();

Возвращает имя, которое в последний раз использовалось для инициализации этого File, если таковое имеется.

Некоторые функции, создающие или инициализирующие File устанавливают поле имени в null. Примеры включают tmpfile, wrapFile и fdopen. Смотрите документацию этих функций для получения подробностей.

Возвращает:: Имя, которое в последний раз использовалось для инициализации этого файла, или null в противном случае.

const pure nothrow @property @trusted bool error();

Если файл не открыт, возвращает true. В противном случае возвращает ferror для дескриптора файла.

@trusted void detach();

Отсоединяется от базового файла. Если единственный владелец, вызывает close.

Исключения:: ErrnoException при ошибке закрытия файла.

@trusted void close();

Если файл был не открыт, успешно завершается. В противном случае закрывает файл (вызывая fclose), выбрасывая исключение при ошибке. Даже если выбрасывается исключение, после этого объект File пустой. Это отличается от detach, так как всегда закрывает файл; следовательно, все остальные объекты File , ссылающиеся на тот же дескриптор, будут видеть закрытый файл в дальнейшем.

Исключения:: ErrnoException при ошибке.

pure nothrow @safe void clearerr();

Если файл не открыт, успешно завершается. В противном случае возвращает clearerr для дескриптора файла.

@trusted void flush();

Очищает буферы C FILE.

Вызывает fflush для дескриптора файла.

Исключения:: Exception если файл не открыт или если вызов fflush завершился ошибкой.

@trusted void sync();

Принудительно записывает в диск любые данные, буферизованные ОС. Вызовите flush перед вызовом этой функции, чтобы сначала очистить буферы C FILE.

Эта функция вызывает FlushFileBuffers на Windows и fsync на POSIX для дескриптора файла.

Исключения:: Exception если файл не открыт или если вызов ОС завершился ошибкой.

T[] rawRead(T)(T[] buffer);

Вызывает fread для дескриптора файла. Количество элементов для чтения и размер каждого элемента выводится из размера и типа входного массива соответственно.

Возвращает:: Срез buffer , содержащий данные, которые были фактически прочитаны. Этот срез будет короче, чем buffer , если EOF был достигнут до заполнения буфера.

Исключения:: Exception если buffer пустой. ErrnoException если файл не открыт или вызов fread завершился ошибкой. rawRead всегда читает в двоичном режиме на Windows.

Примеры:

static import std.file;

auto testFile = std.file.deleteme();
std.file.write(testFile, "\r\n\n\r\n");
scope(exit) std.file.remove(testFile);

auto f = File(testFile, "r");
auto buf = f.rawRead(new char[5]);
f.close();
writeln(buf); // "\r\n\n\r\n"

void rawWrite(T)(in T[] buffer);

Вызывает fwrite для дескриптора файла. Количество элементов для записи и размер каждого элемента выводится из размера и типа входного массива соответственно. Выбрасывается ошибка, если буфер не был записан полностью.

rawWrite всегда записывает в двоичном режиме на Windows.

Исключения:: ErrnoException если файл не открыт или если вызов fwrite завершился ошибкой.

Примеры:

static import std.file;

auto testFile = std.file.deleteme();
auto f = File(testFile, "w");
scope(exit) std.file.remove(testFile);

f.rawWrite("\r\n\n\r\n");
f.close();
writeln(std.file.read(testFile)); // "\r\n\n\r\n"

@trusted void seek(long offset, int origin = SEEK_SET);

Вызывает fseek для дескриптора файла, чтобы переместить его указатель позиции.

Параметры:

long `offset`	Двоичные файлы: количество байтов для смещения от начала. Текстовые файлы: либо ноль, либо значение, возвращенное `tell`.
int `origin`	Двоичные файлы: позиция, используемая в качестве ссылки для смещения, должна быть одной из SEEK_SET, SEEK_CUR или SEEK_END. Текстовые файлы: обязательно должна быть SEEK_SET.

Исключения:: Exception если файл не открыт. ErrnoException если вызов fseek завершился ошибкой.

const @property @trusted ulong tell();

Вызывает ftell для управляемой дескриптора файла.

Выбрасывает:: Exception если файл не открыт. ErrnoException если вызов ftell завершился ошибкой.

Примеры:

import std.conv : text;
static import std.file;

auto testFile = std.file.deleteme();
std.file.write(testFile, "abcdefghijklmnopqrstuvwqxyz");
scope(exit) { std.file.remove(testFile); }

auto f = File(testFile);
auto a = new ubyte[4];
f.rawRead(a);
writeln(f.tell); // 4

@safe void rewind();

Вызывает rewind для дескриптора файла.

Выбрасывает:: Exception если файл не открыт.

@trusted void setvbuf(size_t size, int mode = _IOFBF);

Вызывает setvbuf для дескриптора файла.

Выбрасывает:: Exception если файл не открыт. ErrnoException если вызов setvbuf завершился ошибкой.

@trusted void setvbuf(void[] buf, int mode = _IOFBF);

Вызывает setvbuf для дескриптора файла.

Выбрасывает:: Exception если файл не открыт. ErrnoException если вызов setvbuf завершился ошибкой.

void lock(LockType lockType = LockType.readWrite, ulong start = 0, ulong length = 0);

Блокирует указанный сегмент файла. Если сегмент файла уже заблокирован другим процессом, ожидает, пока существующий замок не будет освобожден. Если оба start и length равны нулю, весь файл блокируется.

Замки, созданные с помощью lock и tryLock, имеют следующие свойства:

Все блокировки автоматически освобождаются при завершении процесса.
Замки не наследуются дочерними процессами.
Закрытие файла освободит все блокировки, связанные с файлом. В POSIX, даже блокировки, полученные через другой File также будут освобождены.
Не все реализации NFS правильно реализуют блокировку файлов.

bool tryLock(LockType lockType = LockType.readWrite, ulong start = 0, ulong length = 0);

Попытка заблокировать указанный сегмент файла. Если оба start и length равны нулю, весь файл блокируется.

Возвращает:: true если блокировка прошла успешно, и false если указанный сегмент файла уже заблокирован.

void unlock(ulong start = 0, ulong length = 0);

Удаляет блокировку по указанному сегменту файла.

void write(S...)(S args);

Записывает свои аргументы в текстовом формате в файл.

Выбрасывает:: Exception если файл не открыт. ErrnoException при ошибке записи в файл.

void writeln(S...)(S args);

Записывает свои аргументы в текстовом формате в файл, после чего переходит на новую строку.

Выбрасывает:: Exception если файл не открыт. ErrnoException при ошибке записи в файл.

void writef(alias fmt, A...)(A args)
Constraints: if (isSomeString!(typeof(fmt)));

void writef(Char, A...)(in Char[] fmt, A args);

Записывает свои аргументы в текстовом формате в файл в соответствии со строкой форматирования fmt.

Параметры:

Char[] `fmt`	Строка форматирования. При передаче в качестве аргумента времени компиляции, строка будет статически проверена на соответствие типам передаваемых аргументов.
A `args`	Элементы для записи.

Выбрасывает:: Exception если файл не открыт. ErrnoException при ошибке записи в файл.

void writefln(alias fmt, A...)(A args)
Constraints: if (isSomeString!(typeof(fmt)));

void writefln(Char, A...)(in Char[] fmt, A args);

Эквивалентно file.writef(fmt, args, '\n').

S readln(S = string)(dchar terminator = '\x0a')
Constraints: if (isSomeString!S);

Чтение строки из дескриптора файла и возвращение её как указанного типа.

Эта версия управляет собственным буфером чтения, что означает одно выделение памяти на вызов. Если вы не сохраняете ссылку на прочитанные данные, рассмотрите версию File.readln(buf), которая может обеспечить лучшую производительность, так как может повторно использовать свой буфер чтения.

Параметры:

S	Параметр шаблона; тип выделенного буфера и возвращаемого типа. По умолчанию `string`.
dchar `terminator`	Разделитель строки (по умолчанию `'\n'`).

Примечание: Разделители строк не поддерживаются из-за неоднозначности с readln(buf) ниже.

Возвращает:: Строку, которая была прочитана, включая символ конца строки.

Выбрасывает:: StdioException при ошибке ввода-вывода или UnicodeException при ошибке преобразования Юникода.

Пример

// Reads `stdin` and writes it to `stdout`.
import std.stdio;

void main()
{
    string line;
    while ((line = stdin.readln()) !is null)
        write(line);
}

size_t readln(C)(ref C[] buf, dchar terminator = '\x0a')
Constraints: if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum));

size_t readln(C, R)(ref C[] buf, R terminator)
Constraints: if (isSomeChar!C && is(Unqual!C == C) && !is(C == enum) && isBidirectionalRange!R && is(typeof(terminator.front == (dchar).init)));

Чтение строки из дескриптора файла и запись её в buf[], включая завершающий символ.

Это может быть быстрее, чем line = File.readln(), потому что вы можете повторно использовать буфер для каждого вызова. Обратите внимание, что повторное использование буфера означает, что вам нужно скопировать предыдущее содержимое, если вы хотите сохранить его.

Параметры:

C[] `buf`	Буфер для хранения полученных данных строки. buf увеличивается при необходимости, затем устанавливается в срез, точно содержащий строку.
dchar `terminator`	Разделитель строки (по умолчанию `'\n'`). Используйте `std.ascii.newline` для переносимости (если файл был открыт в текстовом режиме).

Возвращает:: 0 для конца файла, в противном случае количество прочитанных символов. Значение возврата всегда равно buf.length.

Выбрасывает:: StdioException при ошибке ввода-вывода или UnicodeException при ошибке преобразования Юникода.

Пример

// 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);
}

Этот метод может быть эффективнее, чем метод в предыдущем примере, потому что stdin.readln(buf) повторно использует (если возможно) память, выделенную для buf, в то время как line = stdin.readln() выделяет новую память для каждой строки. Для ещё лучшей производительности вы можете помочь readln, передав большой буфер, чтобы избежать перевыделения памяти. Это можно сделать, повторно используя самый большой буфер, возвращаемый 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);
}

Это фактически то, что делает byLine внутри, поэтому его использование рекомендуется, если вы хотите обработать весь файл.

uint readf(alias format, Data...)(auto ref Data data)
Constraints: if (isSomeString!(typeof(format)));

uint readf(Data...)(scope const(char)[] format, auto ref Data data);

Считывает отформатированные данные из файла, используя std.format.formattedRead.

Параметры:

const(char)[] `format`	Строка форматирования. При передаче в качестве аргумента времени компиляции, строка будет статически проверена на соответствие типам передаваемых аргументов.
Data `data`	Элементы, которые нужно прочитать.

Пример

// test.d
void main()
{
    import std.stdio;
    auto f = File("input");
    foreach (_; 0 .. 3)
    {
        int a;
        f.readf!" %d"(a);
        writeln(++a);
    }
}

% echo "1 2 3" > input
% rdmd test.d
2
3
4

Примеры:

static import std.file;

auto deleteme = std.file.deleteme();
std.file.write(deleteme, "hello\nworld\ntrue\nfalse\n");
scope(exit) std.file.remove(deleteme);
string s;
auto f = File(deleteme);
f.readf!"%s\n"(s);
writeln(s); // "hello"
f.readf("%s\n", s);
writeln(s); // "world"

bool b1, b2;
f.readf("%s\n%s\n", b1, b2);
assert(b1 == true && b2 == false);

static @safe File tmpfile();

Возвращает временный файл, вызывая tmpfile. Обратите внимание, что созданный файл не имеет name.

static @safe File wrapFile(FILE* f);

Функция без проверки типа, которая оборачивает существующий FILE*. Результирующий File никогда не инициирует закрытие файла. Обратите внимание, что созданный файл не имеет name.

pure @safe FILE* getFP();

Возвращает FILE* соответствующий этому объекту.

const @property @trusted int fileno();

Возвращает номер файла, соответствующий этому объекту.

@property HANDLE windowsHandle();

Возвращает базовую операционную систему HANDLE (только для Windows).

auto byLine(Terminator = char, Char = char)(KeepTerminator keepTerminator = No.keepTerminator, Terminator terminator = '\x0a')
Constraints: if (isScalarType!Terminator);

auto byLine(Terminator, Char = char)(KeepTerminator keepTerminator, Terminator terminator)
Constraints: if (is(immutable(ElementEncodingType!Terminator) == immutable(Char)));

Возвращает диапазон входных данных, настроенный для чтения из дескриптора файла по одной строке за раз.

Тип элементов диапазона будет Char[]. Примитивы диапазона могут выбросить StdioException при ошибке ввода-вывода.

Примечание: Каждый front не будет сохраняться после вызова popFront, поэтому вызывающий код должен скопировать его содержимое (например, вызвав to!string ), если сохранение необходимо. Если вызывающему коду нужно сохранить копию каждой строки, используйте функцию byLineCopy вместо этого.

Параметры:

Char	Тип символа для каждой строки, по умолчанию `char`.
KeepTerminator `keepTerminator`	Использовать `Yes.keepTerminator` для включения терминатора в конце каждой строки.
Terminator `terminator`	Разделитель строк (`'\n'` по умолчанию). Используйте `std.ascii.newline` для переносимости (если файл не был открыт в текстовом режиме).

Пример

import std.algorithm, std.stdio, std.string;
// Count words in a file using ranges.
void main()
{
    auto file = File("file.txt"); // Open for reading
    const wordCount = file.byLine()            // Read lines
                          .map!split           // Split into words
                          .map!(a => a.length) // Count words per line
                          .sum();              // Total word count
    writeln(wordCount);
}

Пример

import std.range, std.stdio;
// Read lines using foreach.
void main()
{
    auto file = File("file.txt"); // Open for reading
    auto range = file.byLine();
    // Print first three lines
    foreach (line; range.take(3))
        writeln(line);
    // Print remaining lines beginning with '#'
    foreach (line; range)
    {
        if (!line.empty && line[0] == '#')
            writeln(line);
    }
}

Обратите внимание, что ни один из примеров не обращается к данным строки, возвращаемым front после вызова соответствующего popFront (потому что содержимое может быть изменено).

auto byLineCopy(Terminator = char, Char = immutable(char))(KeepTerminator keepTerminator = No.keepTerminator, Terminator terminator = '\x0a')
Constraints: if (isScalarType!Terminator);

auto byLineCopy(Terminator, Char = immutable(char))(KeepTerminator keepTerminator, Terminator terminator)
Constraints: if (is(immutable(ElementEncodingType!Terminator) == immutable(Char)));

Возвращает диапазон входных данных, настроенный для чтения из дескриптора файла по одной строке за раз. Каждая строка будет выделена заново. front кэширует свое значение, чтобы позволить повторные вызовы без ненужных выделений.

Примечание: Благодаря кэшированию, byLineCopy может быть более эффективным с точки зрения памяти, чем File.byLine.map!idup.

Тип элементов диапазона будет Char[]. Примитивы диапазона могут выбросить StdioException при ошибке ввода-вывода.

Параметры:

Char	Тип символа для каждой строки, по умолчанию `immutable char`.
KeepTerminator `keepTerminator`	Использовать `Yes.keepTerminator` для включения терминатора в конце каждой строки.
Terminator `terminator`	Разделитель строк (`'\n'` по умолчанию). Используйте `std.ascii.newline` для переносимости (если файл не был открыт в текстовом режиме).

Пример

import std.algorithm, std.array, std.stdio;
// Print sorted lines of a file.
void main()
{
    auto sortedLines = File("file.txt")   // Open for reading
                       .byLineCopy()      // Read persistent lines
                       .array()           // into an array
                       .sort();           // then sort them
    foreach (line; sortedLines)
        writeln(line);
}

См. также:: std.file.readText

auto byRecord(Fields...)(string format);

Создает диапазон входных данных, настроенный для парсинга одной строки за раз из файла в кортеж.

Примитивы диапазона могут выбросить StdioException при ошибке ввода-вывода.

Параметры:

string format формат записи кортежа формат

Возвращает:: Диапазон входных данных, настроенный для парсинга одной строки за раз в кортеж записей.

См. также:: Аналогично byLine и использует формат внутри.

Примеры:

static import std.file;
import std.typecons : tuple;

// prepare test file
auto testFile = std.file.deleteme();
scope(failure) printf("Failed test at line %d\n", __LINE__);
std.file.write(testFile, "1 2\n4 1\n5 100");
scope(exit) std.file.remove(testFile);

File f = File(testFile);
scope(exit) f.close();

auto expected = [tuple(1, 2), tuple(4, 1), tuple(5, 100)];
uint i;
foreach (e; f.byRecord!(int, int)("%s %s"))
{
    writeln(e); // expected[i++]
}

auto byChunk(size_t chunkSize);

auto byChunk(ubyte[] buffer);

Возвращает диапазон входных данных, настроенный для чтения из дескриптора файла блоками.

Тип элементов диапазона будет ubyte[]. Примитивы диапазона могут выбросить StdioException при ошибке ввода-вывода.

Пример

void main()
{
    // Read standard input 4KB at a time
    foreach (ubyte[] buffer; stdin.byChunk(4096))
    {
        ... use buffer ...
    }
}

Параметр может быть числом (как показано в примере выше), определяющим размер каждого блока. В качестве альтернативы, byChunk принимает предоставленный пользователем буфер, который используется напрямую.

Пример

void main()
{
    // Read standard input 4KB at a time
    foreach (ubyte[] buffer; stdin.byChunk(new ubyte[4096]))
    {
        ... use buffer ...
    }
}

В любом случае содержимое буфера используется повторно при вызовах. Это означает, что front не сохраняется после вызова popFront, поэтому, если сохранение необходимо, вызывающий код должен скопировать его содержимое (например, вызвав buffer.dup). В примере выше buffer.length равно 4096 для всех итераций, за исключением последней, в которой случае buffer.length может быть меньше 4096 (но всегда больше нуля). С указанными ограничениями byChunk работает с любым алгоритмом, совместимым с входными диапазонами.

Пример

// Efficient file copy, 1MB at a time.
import std.algorithm, std.stdio;
void main()
{
    stdin.byChunk(1024 * 1024).copy(stdout.lockingTextWriter());
}

std.algorithm.iteration.joiner может использоваться для объединения блоков в один диапазон лениво.

Пример

import std.algorithm, std.stdio;
void main()
{
    //Range of ranges
    static assert(is(typeof(stdin.byChunk(4096).front) == ubyte[]));
    //Range of elements
    static assert(is(typeof(stdin.byChunk(4096).joiner.front) == ubyte));
}

Возвращает:: Вызов byChunk возвращает диапазон, инициализированный объектом File и соответствующим буфером.

Исключения:: Если заданный пользователем размер равен нулю или предоставленный пользователем буфер пуст, выбрасывается Exception. В случае ошибки ввода-вывода выбрасывается StdioException.

@safe auto lockingTextWriter();

Диапазон вывода, который блокирует файл при создании и разблокирует файл при выходе из области видимости.

Возвращает:: диапазон вывода, принимающий строковые типы, ubyte[], индивидуальные типы символов и отдельные ubyte.

Примечание: Запись массивов char или ubyte быстрее, чем запись каждого символа по отдельности из диапазона. Для больших объемов данных запись содержимого частями с использованием промежуточного массива может привести к увеличению скорости.

Исключения:: std.utf.UTFException если заданный данные представляют собой char диапазон и содержат некорректные данные UTF.

См. также:: byChunk для примера.

auto lockingBinaryWriter();

Возвращает диапазон вывода, который блокирует файл и позволяет быстро записывать в него.

Пример: Сгенерировать черно-белую картинку множества Мандельброта в двоичном формате Netpbm в стандартный вывод.

import std.algorithm, std.complex, std.range, std.stdio;

void main()
{
    enum size = 500;
    writef("P5\n%d %d %d\n", size, size, ubyte.max);

    iota(-1, 3, 2.0/size).map!(y =>
        iota(-1.5, 0.5, 2.0/size).map!(x =>
            cast(ubyte)(1+
                recurrence!((a, n) => x + y * complex(0, 1) + a[n-1]^^2)(complex(0))
                .take(ubyte.max)
                .countUntil!(z => z.re^^2 + z.im^^2 > 4))
        )
    )
    .copy(stdout.lockingBinaryWriter);
}

@property @safe ulong size();

Возвращает размер файла в байтах, ulong.max, если файл не может быть прочитан или выбрасывает исключение в случае ошибки.

Пример

import std.stdio, std.file;

void main()
{
    string deleteme = "delete.me";
    auto file_handle = File(deleteme, "w");
    file_handle.write("abc"); //create temporary file
    scope(exit) deleteme.remove; //remove temporary file at scope exit

    assert(file_handle.size() == 3); //check if file size is 3 bytes
}

enum LockType: int;

Используется для указания типа блокировки для File.lock и File.tryLock.

read: Указывает блокировку чтения (совмещенную). Блокировка чтения запрещает всем процессам запись в указанный участок файла, включая процесс, который первым заблокировал участок. Все процессы могут читать заблокированный участок. Разрешается несколько одновременных блокировок чтения, пока нет эксклюзивных блокировок.
readWrite: Указывает блокировку чтения/записи (эксклюзивную). Блокировка чтения/записи запрещает всем другим процессам доступ как для чтения, так и для записи в заблокированный участок файла. Если участок имеет эксклюзивную блокировку, он не может иметь никаких общих блокировок или других эксклюзивных блокировок.

enum auto isFileHandle(T);

Указывает, является ли T дескриптором файла, т.е. тип неявно преобразуется в File или указатель на core.stdc.stdio.FILE.

Возвращает:: true если T является дескриптором файла, false в противном случае.

Примеры:

static assert(isFileHandle!(FILE*));
static assert(isFileHandle!(File));

void write(T...)(T args)
Constraints: if (!is(T[0] : File));

Записывает свои аргументы в текстовом формате в стандартный вывод (без завершающей новой строки).

Параметры:

T args элементы для записи в stdout

Исключения:: В случае ошибки ввода-вывода выбрасывается StdioException.

Пример: Читает stdin и записывает его в stdout с подсчетом аргументов.

import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         write("Input ", count, ": ", line, "\n");
    }
}

void writeln(T...)(T args);

Эквивалентно write(args, '\n'). Вызов writeln без аргументов допустим и просто выводит новую строку в стандартный вывод.

Параметры:

T args элементы для записи в stdout

Исключения:: В случае ошибки ввода-вывода выбрасывается StdioException.

Пример: Читает stdin и записывает его в stdout с подсчетом аргументов.

import std.stdio;

void main()
{
    string line;

    for (size_t count = 0; (line = readln) !is null; count++)
    {
         writeln("Input ", count, ": ", line);
    }
}

void writef(alias fmt, A...)(A args)
Constraints: if (isSomeString!(typeof(fmt)));

void writef(Char, A...)(in Char[] fmt, A args);

Записывает отформатированные данные в стандартный вывод (без заключительной новой строки).

Параметры:

Char[] `fmt`	Строка формата. При передаче в качестве аргумента времени компиляции, строка будет статически проверена на соответствие типам передаваемых аргументов.
A `args`	Элементы для записи.

Примечание: В более старых версиях Phobos, можно было написать:

writef(stderr, "%s", "message");

для вывода сообщения в stderr. Этот синтаксис больше не поддерживается и заменён на:

stderr.writef("%s", "message");

void writefln(alias fmt, A...)(A args)
Constraints: if (isSomeString!(typeof(fmt)));

void writefln(Char, A...)(in Char[] fmt, A args);

Эквивалентно writef(fmt, args, '\n').

uint readf(alias format, A...)(auto ref A args)
Constraints: if (isSomeString!(typeof(format)));

uint readf(A...)(scope const(char)[] format, auto ref A args);

Читает отформатированные данные из stdin с помощью std.format.formattedRead.

Параметры:

const(char)[] `format`	Строка формата. При передаче в качестве аргумента времени компиляции, строка будет статически проверена на соответствие типам передаваемых аргументов.
A `args`	Элементы для чтения.

Пример

// test.d
void main()
{
    import std.stdio;
    foreach (_; 0 .. 3)
    {
        int a;
        readf!" %d"(a);
        writeln(++a);
    }
}

% echo "1 2 3" | rdmd test.d
2
3
4

S readln(S = string)(dchar terminator = '\x0a')
Constraints: if (isSomeString!S);

Чтение строки из stdin.

Эта версия управляет собственным буфером чтения, что означает одно выделение памяти на вызов. Если вы не сохраняете ссылку на прочитанные данные, рассмотрите версию readln(buf), которая может обеспечить лучшую производительность, так как может повторно использовать свой буфер чтения.

Возвращает:: Прочитанную строку, включая символ завершения строки.

Параметры:

S	Параметр шаблона; тип выделенного буфера и возвращаемого типа. По умолчанию `string`.
dchar `terminator`	Разделитель строк (по умолчанию `'\n'`).

Примечание: Символы завершения строки не поддерживаются из-за неоднозначности с readln(buf) ниже.

Исключения:: StdioException при ошибке ввода-вывода или UnicodeException при ошибке преобразования в Юникод.

Пример: Читает stdin и записывает его в stdout.

import std.stdio;

void main()
{
    string line;
    while ((line = readln()) !is null)
        write(line);
}

Чтение строки из stdin и запись её в buf[], включая символ завершения.

Это может быть быстрее, чем line = readln(), потому что вы можете повторно использовать буфер для каждого вызова. Обратите внимание, что повторное использование буфера означает, что вам необходимо скопировать предыдущее содержимое, если вы хотите его сохранить.

Возвращает:: size_t 0 для конца файла, в противном случае количество прочитанных символов

Параметры:

C[] `buf`	Буфер, используемый для хранения прочитанной строки. buf изменяется при необходимости.
dchar `terminator`	Разделитель строк (по умолчанию `'\n'`). Используйте `std.ascii.newline` для переносимости (если файл был открыт в текстовом режиме).

Исключения:: StdioException при ошибке ввода-вывода или UnicodeException при ошибке преобразования в Юникод.

Пример: Читает stdin и записывает его в stdout.

import std.stdio;

void main()
{
    char[] buf;
    while (readln(buf))
        write(buf);
}

nothrow @nogc @trusted FILE* _popen(R1, R2)(R1 name, R2 mode = "r")
Constraints: if ((isInputRange!R1 && isSomeChar!(ElementEncodingType!R1) || isSomeString!R1) && (isInputRange!R2 && isSomeChar!(ElementEncodingType!R2) || isSomeString!R2));

Функция-обёртка, которая перенаправляет вызов core.sys.posix.stdio.popen с соответствующим образом сконструированными строками в стиле C.

struct lines;

Итерирует по строкам файла, используя foreach.

Пример

void main()
{
  foreach (string line; lines(stdin))
  {
    ... use line ...
  }
}

Разделитель строк ('\n' по умолчанию) входит в состав считанной строки (он может отсутствовать в последней строке файла). Несколько типов поддерживаются для line, и поведение lines меняется соответственно:

Если line имеет тип string, wstring, или dstring, новый строковый объект соответствующего типа выделяется при каждом чтении.
Если line имеет тип char[], wchar[], или dchar[], содержимое строки будет повторно использовано (перезаписано) при каждом чтении.
Если line имеет тип immutable(ubyte)[], поведение аналогично пункту (1), за исключением того, что проверка UTF на входных данных не выполняется.
Если line имеет тип ubyte[], поведение аналогично пункту (2), за исключением того, что проверка UTF на входных данных не выполняется.

Во всех случаях также принимается версия с двумя символами, в которой первый символ (целого типа, например, ulong или uint) отслеживает нулевой индекс текущей строки.

Пример

  foreach (ulong i, string line; lines(stdin))
  {
    ... use line ...
  }

В случае ошибки ввода-вывода выбрасывается StdioException .

См. также:: byLine

this(File f, dchar terminator = '\x0a');

Конструктор.

Параметры:

File `f`	Файл для чтения строк.
dchar `terminator`	Разделитель строк (`'\n'` по умолчанию).

auto chunks(File f, size_t size);

Итерирует по файлу кусками по заданному размеру, используя foreach.

Пример

void main()
{
    foreach (ubyte[] buffer; chunks(stdin, 4096))
    {
        ... use buffer ...
    }
}

Содержимое buffer повторно используется при вызовах. В примере выше, buffer.length составляет 4096 для всех итераций, за исключением последней, где buffer.length может быть меньше 4096 (но всегда больше нуля). В случае ошибки ввода-вывода выбрасывается StdioException .

void toFile(T)(T data, string fileName)
Constraints: if (is(typeof(copy(data, stdout.lockingBinaryWriter))));

Записывает массив или диапазон в файл. Является сокращением для data.copy(File(fileName, "wb").lockingBinaryWriter). Аналогично std.file.write, строки записываются как есть, а не кодируются в соответствии с File.

class StdioException: object.Exception;

Выбрасывается при ошибках ввода-вывода.

uint errno;: Код ошибки операционной системы.
@trusted this(string message, uint e = core.stdc.errno.errno);: Инициализирует с сообщением и кодом ошибки.
static void opCall(string msg);

static void opCall();: Функции-обёртки, которые выбрасывают StdioException.

alias stdin = makeGlobal!"core.stdc.stdio.stdin".makeGlobal;

Поток стандартного ввода.

Возвращает:: stdin как File.

Примечание: Возвращённый File оборачивает core.stdc.stdio.stdin и поэтому является глобальным для потоков. Переназначение stdin на другой File должно выполняться в однопотоковом или заблокированном контексте, чтобы избежать гонок.

Всё чтение из stdin автоматически блокирует файл глобально, и все другие потоки, вызывающие read, будут ждать, пока блокировка не будет освобождена.

Примеры:

// Read stdin, sort lines, write to stdout
import std.algorithm.mutation : copy;
import std.algorithm.sorting : sort;
import std.array : array;
import std.typecons : Yes;

void main()
{
    stdin                       // read from stdin
    .byLineCopy(Yes.keepTerminator) // copying each line
    .array()                    // convert to array of lines
    .sort()                     // sort the lines
    .copy(                      // copy output of .sort to an OutputRange
        stdout.lockingTextWriter()); // the OutputRange
}

alias stdout = makeGlobal!"core.stdc.stdio.stdout".makeGlobal;

Поток стандартного вывода.

Возвращает:: stdout как File.

Примечание: Возвращённый File оборачивает core.stdc.stdio.stdout и поэтому является глобальным для потоков. Переназначение stdout на другой File должно выполняться в однопотоковом или заблокированном контексте, чтобы избежать гонок.

Все записи в stdout автоматически блокируют файл глобально, и все другие потоки, вызывающие write, будут ждать, пока блокировка не будет освобождена.

Примеры:

void main()
{
    stdout.writeln("Write a message to stdout.");
}

Примеры:

void main()
{
    import std.algorithm.iteration : filter, map, sum;
    import std.format : format;
    import std.range : iota, tee;

    int len;
    const r = 6.iota
              .filter!(a => a % 2) // 1 3 5
              .map!(a => a * 2) // 2 6 10
              .tee!(_ => stdout.writefln("len: %d", len++))
              .sum;

    writeln(r); // 18
}

Примеры:

void main()
{
    import std.algorithm.mutation : copy;
    import std.algorithm.iteration : map;
    import std.format : format;
    import std.range : iota;

    10.iota
    .map!(e => "N: %d".format(e))
    .copy(stdout.lockingTextWriter()); // the OutputRange
}

alias stderr = makeGlobal!"core.stdc.stdio.stderr".makeGlobal;

Стандартный поток ошибок.

Возвращает:: stderr в качестве File.

Примечание: Возвращаемый File оборачивает core.stdc.stdio.stderr, и поэтому является глобальным для потоков. Переназначение stderr на другой File должно выполняться в однопоточном или блокированном контексте, чтобы избежать гонок.

Все записи в stderr автоматически блокируют файл глобально, и это заставит все другие потоки, вызывающие write, ждать, пока блокировка не будет освобождена.

Примеры:

void main()
{
    stderr.writeln("Write a message to stderr.");
}

Файл openNetwork(строка хост, ushort порт);

Экспериментальный сетевой доступ через интерфейс Файла

Открывает TCP-соединение с заданным хостом и портом, а затем возвращает структуру Файла с чтением и записью через тот же интерфейс, что и любой другой файл (то есть, writef и диапазоны byLine работают!).

Авторы:: Adam D. Ruppe

Ошибки:: Работает только в Linux