What is eof error

Время прочтения
6 мин

Просмотры 64K

Недавно я читал книгу «Компьютерные системы: архитектура и программирование. Взгляд программиста». Там, в главе про систему ввода-вывода Unix, авторы упомянули о том, что в конце файла нет особого символа EOF.

Если вы читали о системе ввода-вывода Unix/Linux, или экспериментировали с ней, если писали программы на C, которые читают данные из файлов, то это заявление вам, вероятно, покажется совершенно очевидным. Но давайте поближе присмотримся к следующим двум утверждениям, относящимся к тому, что я нашёл в книге:

1. EOF — это не символ.
2. В конце файлов нет некоего особого символа.

Что же такое EOF?

EOF — это не символ

Почему кто-то говорит или думает, что EOF — это символ? Полагаю, это может быть так из-за того, что в некоторых программах, написанных на C, можно найти код, в котором используется явная проверка на EOF с использованием функций getchar() и getc().

Это может выглядеть так:

    #include <stdio.h>
    ...
    while ((c = getchar()) != EOF)
      putchar(c);

Или так:

    FILE *fp;
    int c;
    ...
    while ((c = getc(fp)) != EOF)
      putc(c, stdout);

Если заглянуть в справку по getchar() или getc(), можно узнать, что обе функции считывают следующий символ из потока ввода. Вероятно — именно это является причиной возникновения заблуждения о природе EOF. Но это — лишь мои предположения. Вернёмся к мысли о том, что EOF — это не символ.

А что такое, вообще, символ? Символ — это самый маленький компонент текста. «A», «a», «B», «b» — всё это — разные символы. У символа есть числовой код, который в стандарте Unicode называют кодовой точкой. Например — латинская буква «A» имеет, в десятичном представлении, код 65. Это можно быстро проверить, воспользовавшись командной строкой интерпретатора Python:

$python
>>> ord('A')
65
>>> chr(65)
'A'

Или можно взглянуть на таблицу ASCII в Unix/Linux:

$ man ascii

Выясним, какой код соответствует EOF, написав небольшую программу на C. В ANSI C константа EOF определена в stdio.h, она является частью стандартной библиотеки. Обычно в эту константу записано -1. Можете сохранить следующий код в файле printeof.c, скомпилировать его и запустить:

#include <stdio.h>

int main(int argc, char *argv[])
{
  printf("EOF value on my system: %dn", EOF);
  return 0;
}

Скомпилируем и запустим программу:

$ gcc -o printeof printeof.c

$ ./printeof
EOF value on my system: -1

У меня эта программа, проверенная на Mac OS и на Ubuntu, сообщает о том, что EOF равняется -1. Есть ли какой-нибудь символ с таким кодом? Тут, опять же, можно проверить коды символов в таблице ASCII, можно взглянуть на таблицу Unicode и узнать о том, в каком диапазоне могут находиться коды символов. Мы же поступим иначе: запустим интерпретатор Python и воспользуемся стандартной функцией chr() для того, чтобы она дала бы нам символ, соответствующий коду -1:

$ python
>>> chr(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)

Как и ожидалось, символа с кодом -1 не существует. Значит, в итоге, EOF, и правда, символом не является. Переходим теперь ко второму рассматриваемому утверждению.

В конце файлов нет некоего особого символа

Может, EOF — это особенный символ, который можно обнаружить в конце файла? Полагаю, сейчас вы уже знаете ответ. Но давайте тщательно проверим наше предположение.

Возьмём простой текстовый файл, helloworld.txt, и выведем его содержимое в шестнадцатеричном представлении. Для этого можно воспользоваться командой xxd:

$ cat helloworld.txt
Hello world!

$ xxd helloworld.txt
00000000: 4865 6c6c 6f20 776f 726c 6421 0a         Hello world!.

Как видите, последний символ файла имеет код 0a. Из таблицы ASCII можно узнать о том, что этот код соответствует символу nl, то есть — символу новой строки. Это можно выяснить и воспользовавшись Python:

$ python
>>> chr(0x0a)
'n'

Так. EOF — это не символ, а в конце файлов нет некоего особого символа. Что же такое EOF?

Что такое EOF?

EOF (end-of-file) — это состояние, которое может быть обнаружено приложением в ситуации, когда операция чтения файла доходит до его конца.

Взглянем на то, как можно обнаруживать состояние EOF в разных языках программирования при чтении текстового файла с использованием высокоуровневых средств ввода-вывода, предоставляемых этими языками. Для этого напишем очень простую версию cat, которая будет называться mcat. Она побайтно (посимвольно) читает ASCII-текст и в явном виде выполняет проверку на EOF. Программу напишем на следующих языках:

• ANSI C
• Python 3
• Go
• JavaScript (Node.js)

Вот репозиторий с кодом примеров. Приступим к их разбору.

ANSI C

Начнём с почтенного C. Представленная здесь программа является модифицированной версией cat из книги «Язык программирования C».

/* mcat.c */
#include <stdio.h>

int main(int argc, char *argv[])
{
  FILE *fp;
  int c;

  if ((fp = fopen(*++argv, "r")) == NULL) {
    printf("mcat: can't open %sn", *argv);
    return 1;
  }

  while ((c = getc(fp)) != EOF)
    putc(c, stdout);

  fclose(fp);

  return 0;
}

Компиляция:

$ gcc -o mcat mcat.c

Запуск:

$ ./mcat helloworld.txt
Hello world!

Вот некоторые пояснения, касающиеся вышеприведённого кода:

• Программа открывает файл, переданный ей в виде аргумента командной строки.
• В цикле while осуществляется копирование данных из файла в стандартный поток вывода. Данные копируются побайтово, происходит это до тех пор, пока не будет достигнут конец файла.
• Когда программа доходит до EOF, она закрывает файл и завершает работу.

Python 3

В Python нет механизма явной проверки на EOF, похожего на тот, который имеется в ANSI C. Но если посимвольно читать файл, то можно выявить состояние EOF в том случае, если в переменной, хранящей очередной прочитанный символ, будет пусто:

# mcat.py
import sys

with open(sys.argv[1]) as fin:
    while True:
        c = fin.read(1) # читаем максимум 1 символ
        if c == '':     # EOF
            break
        print(c, end='')

Запустим программу и взглянём на возвращаемые ей результаты:

$ python mcat.py helloworld.txt
Hello world!

Вот более короткая версия этого же примера, написанная на Python 3.8+. Здесь используется оператор := (его называют «оператор walrus» или «моржовый оператор»):

# mcat38.py
import sys

with open(sys.argv[1]) as fin:
    while (c := fin.read(1)) != '':  # читаем максимум 1 символ до достижения EOF
        print(c, end='')

Запустим этот код:

$ python3.8 mcat38.py helloworld.txt
Hello world!

Go

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

// mcat.go
package main

import (
    "fmt"
    "os"
    "io"
)

func main() {
    file, err := os.Open(os.Args[1])
    if err != nil {
        fmt.Fprintf(os.Stderr, "mcat: %vn", err)
        os.Exit(1)
    }

    buffer := make([]byte, 1)  // 1-byte buffer
    for {
        bytesread, err := file.Read(buffer)
        if err == io.EOF {
            break
        }
        fmt.Print(string(buffer[:bytesread]))
    }
    file.Close()
}

Запустим программу:

$ go run mcat.go helloworld.txt
Hello world!

JavaScript (Node.js)

В среде Node.js нет механизма для явной проверки на EOF. Но, когда при достижении конца файла делается попытка ещё что-то прочитать, вызывается событие потока end.

/* mcat.js */
const fs = require('fs');
const process = require('process');

const fileName = process.argv[2];

var readable = fs.createReadStream(fileName, {
  encoding: 'utf8',
  fd: null,
});

readable.on('readable', function() {
  var chunk;
  while ((chunk = readable.read(1)) !== null) {
    process.stdout.write(chunk); /* chunk is one byte */
  }
});

readable.on('end', () => {
  console.log('nEOF: There will be no more data.');
});

Запустим программу:

$ node mcat.js helloworld.txt
Hello world!

EOF: There will be no more data.

Низкоуровневые системные механизмы

Как высокоуровневые механизмы ввода-вывода, использованные в вышеприведённых примерах, определяют достижение конца файла? В Linux эти механизмы прямо или косвенно используют системный вызов read(), предоставляемый ядром. Функция (или макрос) getc() из C, например, использует системный вызов read() и возвращает EOF в том случае, если read() указывает на возникновение состояния достижения конца файла. В этом случае read() возвращает 0. Если изобразить всё это в виде схемы, то получится следующее:

Получается, что функция getc() основана на read().

Напишем версию cat, названную syscat, используя только системные вызовы Unix. Сделаем мы это не только из интереса, но и из-за того, что это вполне может принести нам какую-то пользу.

Вот эта программа, написанная на C:

/* syscat.c */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
  int fd;
  char c;

  fd = open(argv[1], O_RDONLY, 0);

  while (read(fd, &c, 1) != 0)
    write(STDOUT_FILENO, &c, 1);

  return 0;
}

Запустим её:

$ gcc -o syscat syscat.c

$ ./syscat helloworld.txt
Hello world!

В этом коде используется тот факт, что функция read(), указывая на достижение конца файла, возвращает 0.

Вот та же программа, написанная на Python 3:

# syscat.py
import sys
import os

fd = os.open(sys.argv[1], os.O_RDONLY)

while True:
    c = os.read(fd, 1)
    if not c:  # EOF
        break
    os.write(sys.stdout.fileno(), c)

Запустим её:

$ python syscat.py helloworld.txt
Hello world!

Вот — то же самое, написанное на Python 3.8+:

# syscat38.py
import sys
import os

fd = os.open(sys.argv[1], os.O_RDONLY)

while c := os.read(fd, 1):
    os.write(sys.stdout.fileno(), c)

Запустим и этот код:

$ python3.8 syscat38.py helloworld.txt
Hello world!

Итоги

• EOF — это не символ.
• В конце файлов нет некоего особого символа.
• EOF — это состояние, о котором сообщает ядро, и которое может быть обнаружено приложением в том случае, когда операция чтения данных доходит до конца файла.
• В ANSI C EOF — это, опять же, не символ. Это — константа, определённая в stdio.h, в которую обычно записано значение -1.
• «Символ» EOF нельзя найти в таблице ASCII или в Unicode.

Уважаемые читатели! А вы знаете о каких-нибудь более или менее широко распространённых заблуждениях из мира компьютеров?

Software errors are common. If you’re a regular user of the computer then you will be aware of a software error. There is no software that is free from the error.

But we can’t get rid of it. In other words, we can say that software error is present in every program.
Similar in Python EOF error occurs due to the wrong code. So, have you ever experienced the EOF error? Have you ever faced an EOF error while doing work on Python? If “yes”, this article will help you to find out the solution.

In this article, we will discuss the EOF error. Yet before that, we will learn about Python in a short description.

What is Python?

Well, Python is used for many things. It is used for high-level programming language and web development and so on. Besides, It aims to help programmers to write clear and logical code for small and large scale. It helps to run multiple programming paradigms and functional programming.

What is the EOF error in Python?

EOF stands for End Of File. Well, it is called an unexpected error by some technical developers of Python.

This error exists when the input ( ) procedure in both Python 2.7 and 3.6+ is disturbed when the input ( ) reaches the end of a file before reading all the codes.

This error comes out when you make a mistake in the structure or maybe in the syntax of your code.

What are the Reasons Behind EOF Error?

Well, like other errors reason. There’re some circumstances that cause an error. As it may be the cause of the wrong code. Now we discuss some unusual errors that appear in Python.

It is said that it is not an error, rather than the exception. And this exception is put up when one of the built-in functions, most commonly input ( ) reaches the end of the file without reading any data.

Sometimes all the program tries to perform and fetch something and modify it. Yet when it is unable to fetch, it means there will be an error that exist.

EOFerror is at the end of the file error. It occurs when a binary file in python has ended and cannot be able to read further. Sometimes it is because of the version problem. In Python 2 raw_input () function is used for getting input.

(For this check your version first)

Maybe your code is not supporting the input sequence. For fixing the error you just put code in the sequence.

Now we will discuss some common and usual EOF error. These situations are very common. We will clarify it with the help of an example.

As it is said before that this error happens when Python arrives at the end of the file before running every code. This happens because of:

•First the reason is when you don’t enclose a special statement like a loop or a function of code. And

•The second one is, you skip all the parenthesis in a line of code.

So we will discuss all two situations described above.

Wrapping a code in a special Statement:

In python, the function needs at least one line of code in the special statement for a loop. If you don’t add it then it will be the cause of EOF error. Have a look at the given example of a loop.

In the given above example, there is a variable called ingredients. That is a list of a store of a recipe.
If you run the code this will happen.

In the above case, we did not add any code in for loop. Therefore an EOF error occurs.
For a solution, we add some code to the loop. For this just add the Print ( ) statement.

After fixing the error

This shows that the error has fixed. In the case, if you do not make a special opinion then you can add “pass” as a placeholder.
Then this code will appear like this

The word “pass” is used by most developers when they build a program.

Enclosing Parenthesis

In Python an EOF error due to the missing parenthesis on a line of code. We use a string with a word like this .format ( ) to overcome the error.

When you have unlocked sets of parenthesis. Therefore this error comes to exist. This error can be fixed when you add (“)”) at the end of the print ( ) line of code.

If you don’t close line with the help of {} these brackets. Then this error will occur the Same thing will happen if you forget to close a line using [] these brackets.

Some Other Options to fixing the EOF error

You use try/except when reading your input string if an error exists you should check an empty string before printing it’s content, for example

1 try:
2. check = raw_input
(“would you like to continue? : “)
3 except EOFError:
4. print (“Error: EOF or
Empty input!”)
5. Check. = “ “
6 print check

Besides all, there is another trick if the raw_input function does not work properly then an error arises before reading all the data it will EOF error exception.

• Intake something before you send EOF (‘Ctrl+Z’+’Ctrl+D’)
• Try to find out the error if you want a technique for the solution.

As EOFerror is a simple syntax error. So there are some IDE add the same shutting parenthesis automatically. Well, there are some IDE who don’t do it.

Some tips to handle the EOF error

• You have to look at all the functions and their closing statements. Just make sure that all parameters and their syntaxes are correct.
• You have to check out the all parameters of every function before performing your program.
• You have to review all the corresponding incision. And try to be sure that everything is correct.

Final Words

The syntax error or unexpected End Of File error prevails when Python reaches at the end of the file without reading the code of line.
1. You can fix it. By checking out that allegation has loop and function has a proper code.
2. You have to check that all the parentheses are closed in the code.

Hopefully, you got the solution. If you have another technique to sort out the error then notify us with your precious idea.

• [Fixed]Netflix Error code tvq-st-103 |7 Easy Tricks|
• Fixed: Netflix This title is not available to watch instantly [ Simple Fixes ]

From Wikipedia, the free encyclopedia

In computing, end-of-file (EOF)^[1] is a condition in a computer operating system where no more data can be read from a data source. The data source is usually called a file or stream.

Details[edit]

In the C standard library, the character reading functions such as getchar return a value equal to the symbolic value (macro) EOF to indicate that an end-of-file condition has occurred. The actual value of EOF is implementation-dependent and must be negative (but is commonly −1, such as in glibc^[2]). Block-reading functions return the number of bytes read, and if this is fewer than asked for, then the end of file was reached or an error occurred (checking of errno or dedicated function, such as ferror is required to determine which).

EOF character[edit]

Input from a terminal never really «ends» (unless the device is disconnected), but it is useful to enter more than one «file» into a terminal, so a key sequence is reserved to indicate end of input. In UNIX the translation of the keystroke to EOF is performed by the terminal driver, so a program does not need to distinguish terminals from other input files. By default, the driver converts a Control-D character at the start of a line into an end-of-file indicator. To insert an actual Control-D (ASCII 04) character into the input stream, the user precedes it with a «quote» command character (usually Control-V). AmigaDOS is similar but uses Control- instead of Control-D.

In DOS and Windows (and in CP/M and many DEC operating systems such as the PDP-6 monitor,^[3] RT-11, VMS or TOPS-10^[4]), reading from the terminal will never produce an EOF. Instead, programs recognize that the source is a terminal (or other «character device») and interpret a given reserved character or sequence as an end-of-file indicator; most commonly this is an ASCII Control-Z, code 26. Some MS-DOS programs, including parts of the Microsoft MS-DOS shell (COMMAND.COM) and operating-system utility programs (such as EDLIN), treat a Control-Z in a text file as marking the end of meaningful data, and/or append a Control-Z to the end when writing a text file. This was done for two reasons:

• Backward compatibility with CP/M. The CP/M file system (and also the original 8-bit FAT implemented in Microsoft BASIC) only recorded the lengths of files in multiples of 128-byte «records», so by convention a Control-Z character was used to mark the end of meaningful data if it ended in the middle of a record. The FAT12 filesystem introduced with 86-DOS and MS-DOS has always recorded the exact byte-length of files, so this was never necessary on DOS.
• It allows programs to use the same code to read input from both a terminal and a text file.

In the ANSI X3.27-1969 magnetic tape standard, the end of file was indicated by a tape mark, which consisted of a gap of approximately 3.5 inches of tape followed by a single byte containing the character 13 (hex) for nine-track tapes and 17 (octal) for seven-track tapes.^[5] The end-of-tape, commonly abbreviated as EOT, was indicated by two tape marks. This was the standard used, for example, on IBM 360. The reflective strip that was used to announce impending physical end of tape was also called an EOT marker.

See also[edit]

• End-of-transmission character
• Substitute character
• End of message
• Here document
• -30-

References[edit]

EOF (англ. End-of-file) в компьютерной терминологии — индикатор операционной системы, означающий, что данные в источнике (файлы, потоки и т.д.) закончились.

Значение EOF

В языке СИ

В стандартной библиотеке языка Си функции ввода-вывода могут возвращать значение, равное макроопределению EOF для индикации достижения конеца файла или потока. Реальное значение EOF является отрицательным числом, которое зависит от системы (чаще всего −1), для гарантии несовпадение с кодом символа.
Значение EOF определено в stdio.h.

В UNIX подобных ОС

Терминал не вернет настоящий индикатор EOF, если устройство не выключено и исправно, но если требуется ввести более одного файла в терминал, то можно воспользоваться EOF. В UNIX сигнал о событии, что была нажата клавиша EOF обрабатывается драйвером, поэтому программам не нужно различать терминал от других входных файлов. По умолчанию, драйвер преобразует Control-D символ в начале строки в индикатор конца файла.
Чтобы вставить реальный Control-D (ASCII 04) символ во входной поток, пользователь предварительно отправляет командный символ (обычно Control-V). В AmigaDOS используется Control- вместо Control-D.

В ОС Windows/DOS

В таких операционных системах как Windows и MS-DOS, а также в ОС CP/M и множестве операционных систем DEC, терминал никогда не вернет значение EOF. Вместо этого программы различают, что источник данных является терминал или другое символьное устройство и интерпретируют зарезервированный символ или последовательность как символ конца файла индикатора. Чаще всего это ASCII Control-Z, код 26.
Для указания «EOF» в таких операционных системах как Windows и MS-DOS, а также в ОС CP/M и множестве операционных систем DEC,
следует воспользоваться комбинацией клавиш Ctrl+Z.

В стандарте ANSI X3.27-1969

В ANSI X3.27-1969 (стандарт магнитных лент), на конец файла указывает метка на ленте, которая представляет собой щель на ленте, за которой следует один байт со значением 0xD(hex) для ленты с девятью дорожками или со значением 17(oct) для ленты с семью дорожками.

Пример использования

  #include <iostream>
  using namespace std;
  void main()
  {    
     char ch = 0;
     while (ch = cin.get()) != EOF)
     {
         ch=cin.get();
         cout<<ch;
     }
  }

Источники

• http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdio.h.html
• https://www.gnu.org/software/libc/manual/html_mono/libc.html#EOF-and-Errors

Before starting how to fix EOF When Reading a Line using Python, it’s crucial to understand what causes it, or what even is it in the first place.

An EOF error occurs when you try to read from the end of a file. This can happen because there are no more lines left, or if your program expected some other value instead.

It might be due for example an encoding mistake made by accident while transferring data over Bluetooth connections etcetera!

EOFError(End Of File Error) is a type of exception handling error that Python raises because of either of the following reasons:

1. When the input() function is interrupted in both Python 2.7 and Python 3.6+
2. When the input() function reaches the end of the line unexpectedly in Python 2.7
3. You forgot to enclose your code within a special statement like a for loop or while loop
4. You did not close the parentheses properly i.e number of brackets is either more or less than it should be

The BaseException class is the base class of the Exception class which in turn inherits the EOFError class. Technically speaking, EOFError is not an error, but it is an exception.

When the built-in functions such as read() or input() return a string that is empty (unable to read any data), then the EOFError exception is raised.

Or in simple words, EOFError is raised when our program is trying to read or modify something but is unable to do so.

EXAMPLES OF EOFError

# You may also use like int(input())
# or alternative way
n = "10"
print(n * 10)

The code mentioned above will return an EOFError if no input is given to the online IDE, which means that there is no data for the program to work with.

Hence the error.

animals = ["cat", "dog", "mouse", "monkey"]
for i in animals:
    print(i)

In this code, we iterate through the “animals” list successfully but still, the IDE prompts an EOFError. This is because we haven’t put any code within our for-loop.

This is also the case with other statements, meaning that EOFError will be raised if we don’t specify any code within the while-loop, if-else statements, or a function.

To avoid this error we have to write some code, however small it is, within the loop. Or, if we don’t want to specify any code within the statement.

We can use the “pass” statement which is usually used as a placeholder for future code.

print("hello")

This code will also raise an EOFError since the number of parentheses opened and closed are not equal. To tackle this issue simply add a closing bracket at the end of the print statement.

We will be good to go. Another example of the same kind of problem is:

animals = ["cat", "dog", "mouse", "monkey"]

Since the closing square bracket is missing, the IDE will raise an EOFError.

animals = {'mammal':'cat', "fish":"shark"}
print(animals)

The same will be the case with dictionaries if the number of curly brackets is uneven.

Read more: How to Check if File Exists Using Python?

Read file

The most common reason for this is that you have reached the end of the file without reading all of the data.

To fix this, make sure that you read all of the data in the file before trying to access its contents. You can do this by using a loop to read through the file’s contents.

Alternatively, you can use a function like len() to find out how many bytes are in the file so that you can ensure that you read through all of them.

Fix EOFError: EOF When Reading a Line using Python

Conclusion

The statement “SyntaxError: unexpected EOF while parsing” is thrown by the IDE when the interpreter reaches the end of a program before every line of code has been executed.

To solve this error our first step should be to make sure that all statements such as for-loop, while-loop, if statements, etc contain some code. Next, we should make sure that all the parentheses have properly closed.

Read more: Ways To Use Python If Not

EOF — это не символ +34

1. EOF — это не символ.
2. В конце файлов нет некоего особого символа.

Что же такое EOF?

Почему кто-то говорит или думает, что EOF — это символ? Полагаю, это может быть так из-за того, что в некоторых программах, написанных на C, можно найти код, в котором используется явная проверка на EOF с использованием функций getchar() и getc().

Это может выглядеть так:

    #include <stdio.h>
    ...
    while ((c = getchar()) != EOF)
      putchar(c);

Или так:

    FILE *fp;
    int c;
    ...
    while ((c = getc(fp)) != EOF)
      putc(c, stdout);

Если заглянуть в справку по getchar() или getc(), можно узнать, что обе функции считывают следующий символ из потока ввода. Вероятно — именно это является причиной возникновения заблуждения о природе EOF. Но это — лишь мои предположения. Вернёмся к мысли о том, что EOF — это не символ.

А что такое, вообще, символ? Символ — это самый маленький компонент текста. «A», «a», «B», «b» — всё это — разные символы. У символа есть числовой код, который в стандарте Unicode называют кодовой точкой. Например — латинская буква «A» имеет, в десятичном представлении, код 65. Это можно быстро проверить, воспользовавшись командной строкой интерпретатора Python:

$python
>>> ord('A')
65
>>> chr(65)
'A'

Или можно взглянуть на таблицу ASCII в Unix/Linux:

$ man ascii

Выясним, какой код соответствует EOF, написав небольшую программу на C. В ANSI C константа EOF определена в stdio.h, она является частью стандартной библиотеки. Обычно в эту константу записано -1. Можете сохранить следующий код в файле printeof.c, скомпилировать его и запустить:

#include <stdio.h>

int main(int argc, char *argv[])
{
  printf("EOF value on my system: %dn", EOF);
  return 0;
}

Скомпилируем и запустим программу:

$ gcc -o printeof printeof.c

$ ./printeof
EOF value on my system: -1

У меня эта программа, проверенная на Mac OS и на Ubuntu, сообщает о том, что EOF равняется -1. Есть ли какой-нибудь символ с таким кодом? Тут, опять же, можно проверить коды символов в таблице ASCII, можно взглянуть на таблицу Unicode и узнать о том, в каком диапазоне могут находиться коды символов. Мы же поступим иначе: запустим интерпретатор Python и воспользуемся стандартной функцией chr() для того, чтобы она дала бы нам символ, соответствующий коду -1:

$ python
>>> chr(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)

Как и ожидалось, символа с кодом -1 не существует. Значит, в итоге, EOF, и правда, символом не является. Переходим теперь ко второму рассматриваемому утверждению.

В конце файлов нет некоего особого символа

Может, EOF — это особенный символ, который можно обнаружить в конце файла? Полагаю, сейчас вы уже знаете ответ. Но давайте тщательно проверим наше предположение.

Возьмём простой текстовый файл, helloworld.txt, и выведем его содержимое в шестнадцатеричном представлении. Для этого можно воспользоваться командой xxd:

$ cat helloworld.txt
Hello world!

$ xxd helloworld.txt
00000000: 4865 6c6c 6f20 776f 726c 6421 0a         Hello world!.

Как видите, последний символ файла имеет код 0a. Из таблицы ASCII можно узнать о том, что этот код соответствует символу nl, то есть — символу новой строки. Это можно выяснить и воспользовавшись Python:

$ python
>>> chr(0x0a)
'n'

Так. EOF — это не символ, а в конце файлов нет некоего особого символа. Что же такое EOF?

Что такое EOF?

EOF (end-of-file) — это состояние, которое может быть обнаружено приложением в ситуации, когда операция чтения файла доходит до его конца.

Взглянем на то, как можно обнаруживать состояние EOF в разных языках программирования при чтении текстового файла с использованием высокоуровневых средств ввода-вывода, предоставляемых этими языками. Для этого напишем очень простую версию cat, которая будет называться mcat. Она побайтно (посимвольно) читает ASCII-текст и в явном виде выполняет проверку на EOF. Программу напишем на следующих языках:

• ANSI C
• Python 3
• Go
• JavaScript (Node.js)

Вот репозиторий с кодом примеров. Приступим к их разбору.

ANSI C

Начнём с почтенного C. Представленная здесь программа является модифицированной версией cat из книги «Язык программирования C».

/* mcat.c */
#include <stdio.h>

int main(int argc, char *argv[])
{
  FILE *fp;
  int c;

  if ((fp = fopen(*++argv, "r")) == NULL) {
    printf("mcat: can't open %sn", *argv);
    return 1;
  }

  while ((c = getc(fp)) != EOF)
    putc(c, stdout);

  fclose(fp);

  return 0;
}

Компиляция:

$ gcc -o mcat mcat.c

Запуск:

$ ./mcat helloworld.txt
Hello world!

Вот некоторые пояснения, касающиеся вышеприведённого кода:

• Программа открывает файл, переданный ей в виде аргумента командной строки.
• В цикле while осуществляется копирование данных из файла в стандартный поток вывода. Данные копируются побайтово, происходит это до тех пор, пока не будет достигнут конец файла.
• Когда программа доходит до EOF, она закрывает файл и завершает работу.

Python 3

В Python нет механизма явной проверки на EOF, похожего на тот, который имеется в ANSI C. Но если посимвольно читать файл, то можно выявить состояние EOF в том случае, если в переменной, хранящей очередной прочитанный символ, будет пусто:

# mcat.py
import sys

with open(sys.argv[1]) as fin:
    while True:
        c = fin.read(1) # читаем максимум 1 символ
        if c == '':     # EOF
            break
        print(c, end='')

Запустим программу и взглянём на возвращаемые ей результаты:

$ python mcat.py helloworld.txt
Hello world!

Вот более короткая версия этого же примера, написанная на Python 3.8+. Здесь используется оператор := (его называют «оператор walrus» или «моржовый оператор»):

# mcat38.py
import sys

with open(sys.argv[1]) as fin:
    while (c := fin.read(1)) != '':  # читаем максимум 1 символ до достижения EOF
        print(c, end='')

Запустим этот код:

$ python3.8 mcat38.py helloworld.txt
Hello world!

Go

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

// mcat.go
package main

import (
    "fmt"
    "os"
    "io"
)

func main() {
    file, err := os.Open(os.Args[1])
    if err != nil {
        fmt.Fprintf(os.Stderr, "mcat: %vn", err)
        os.Exit(1)
    }

    buffer := make([]byte, 1)  // 1-byte buffer
    for {
        bytesread, err := file.Read(buffer)
        if err == io.EOF {
            break
        }
        fmt.Print(string(buffer[:bytesread]))
    }
    file.Close()
}

Запустим программу:

$ go run mcat.go helloworld.txt
Hello world!

JavaScript (Node.js)

В среде Node.js нет механизма для явной проверки на EOF. Но, когда при достижении конца файла делается попытка ещё что-то прочитать, вызывается событие потока end.

/* mcat.js */
const fs = require('fs');
const process = require('process');

const fileName = process.argv[2];

var readable = fs.createReadStream(fileName, {
  encoding: 'utf8',
  fd: null,
});

readable.on('readable', function() {
  var chunk;
  while ((chunk = readable.read(1)) !== null) {
    process.stdout.write(chunk); /* chunk is one byte */
  }
});

readable.on('end', () => {
  console.log('nEOF: There will be no more data.');
});

Запустим программу:

$ node mcat.js helloworld.txt
Hello world!

EOF: There will be no more data.

Низкоуровневые системные механизмы

Как высокоуровневые механизмы ввода-вывода, использованные в вышеприведённых примерах, определяют достижение конца файла? В Linux эти механизмы прямо или косвенно используют системный вызов read(), предоставляемый ядром. Функция (или макрос) getc() из C, например, использует системный вызов read() и возвращает EOF в том случае, если read() указывает на возникновение состояния достижения конца файла. В этом случае read() возвращает 0. Если изобразить всё это в виде схемы, то получится следующее:

Получается, что функция getc() основана на read().

Напишем версию cat, названную syscat, используя только системные вызовы Unix. Сделаем мы это не только из интереса, но и из-за того, что это вполне может принести нам какую-то пользу.

Вот эта программа, написанная на C:

/* syscat.c */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
  int fd;
  char c;

  fd = open(argv[1], O_RDONLY, 0);

  while (read(fd, &c, 1) != 0)
    write(STDOUT_FILENO, &c, 1);

  return 0;
}

Запустим её:

$ gcc -o syscat syscat.c

$ ./syscat helloworld.txt
Hello world!

В этом коде используется тот факт, что функция read(), указывая на достижение конца файла, возвращает 0.

Вот та же программа, написанная на Python 3:

# syscat.py
import sys
import os

fd = os.open(sys.argv[1], os.O_RDONLY)

while True:
    c = os.read(fd, 1)
    if not c:  # EOF
        break
    os.write(sys.stdout.fileno(), c)

Запустим её:

$ python syscat.py helloworld.txt
Hello world!

Вот — то же самое, написанное на Python 3.8+:

# syscat38.py
import sys
import os

fd = os.open(sys.argv[1], os.O_RDONLY)

while c := os.read(fd, 1):
    os.write(sys.stdout.fileno(), c)

Запустим и этот код:

$ python3.8 syscat38.py helloworld.txt
Hello world!

Итоги

• EOF — это не символ.
• В конце файлов нет некоего особого символа.
• EOF — это состояние, о котором сообщает ядро, и которое может быть обнаружено приложением в том случае, когда операция чтения данных доходит до конца файла.
• В ANSI C EOF — это, опять же, не символ. Это — константа, определённая в stdio.h, в которую обычно записано значение -1.
• «Символ» EOF нельзя найти в таблице ASCII или в Unicode.

Уважаемые читатели! А вы знаете о каких-нибудь более или менее широко распространённых заблуждениях из мира компьютеров?