readline EXPR

Reads from the filehandle whose typeglob is contained in EXPR (or from *ARGV if EXPR is not provided). In scalar context, each call reads and returns the next line until end-of-file is reached, whereupon the subsequent call returns undef. In list context, reads until end-of-file is reached and returns a list of lines. Note that the notion of "line" used here is whatever you may have defined with $/ (or $INPUT_RECORD_SEPARATOR in English). See "$/" in perlvar.

�����違�㏍����� EXPR (EXPR �����ŝ����翫����� *ARGV) �����˨�障����⓾����� �����<�ゃ�˨����潟����˨�����茯㏍�粋昭��帥�障����� ��鴻�˨�í�潟�潟����㏍�鴻����с�壔����若�喝�冴��罸���˩��茵�茯㏍�粋昭�����ц�������障��; �����<�ゃ�˨� ���緇���障�ц˛��粋昭������������篁ュ����勐�若�喝�冴����с�� undef ���菴������障����� ��ŝ�鴻����潟�潟����㏍�鴻����с�壔�������<�ゃ�˨�勖��緇���障�ц˛��粋昭�����с��茵���勉�ŝ�鴻�����菴������障����� ��������с�勉��茵���������壔��$/ (��障���� English ��≪�吾�ャ�若�˨�с�� $INPUT_RECORD_SEPARATOR) �� 絎�臂í�����������������羈���������⓾�������������� "$/" in perlvar ��������с����⓾��������������

When $/ is set to undef, when readline is in scalar context (i.e., file slurp mode), and when an empty file is read, it returns '' the first time, followed by undef subsequently.

$/ ��� undef ���荐㊤����������翫����壔�� readline ��壔�鴻�˨�í�潟�潟����㏍�鴻�� (��ゃ�障�������<�ゃ����吾��莨若� ��≪�若��)�����ŝ�����腥冴�勉����<�ゃ�˨��茯㏍�粋昭��������翫����壔����������� '' ���菴������� ������篁ラ����� undef ���菴������障�����

This is the internal function implementing the <EXPR> operator, but you can use it directly. The <EXPR> operator is discussed in more detail in "I/O Operators" in perlop.

��������� <EXPR> 羲�膊�絖����絎�茖������⓾����������◒�∽�違�с�������� ��贋・篏帥�������������с����障����� <EXPR> 羲�膊�絖���˨�ゃ����⓾�勉�������ŝ��荅括完��˨�ゃ����⓾� "I/O Operators" in perlop ��ц⑯茫���������⓾����障�����

    my $line = <STDIN>;
    my $line = readline(STDIN);    # same thing

If readline encounters an operating system error, $! will be set with the corresponding error message. It can be helpful to check $! when you are reading from filehandles you don't trust, such as a tty or a socket. The following example uses the operator form of readline and dies if the result is not defined.

readline ��� OS ��勉�激�鴻����������í�若�˨�ŝ�������� $! ���絲上�������������í�若�<����祉�若�吾����祉�������������障����� tty �����純�宴�������������c�����篆♂�若�с����ŝ�������<�ゃ�˨����潟����˨�����茯㏍�粋昭��������˨� $! ��������с����壔�������勉����í����˨�ŝ����障����� 篁ヤ����勌����壩��膊�絖���勐就��� readline ���篏帥�c�⓾��������腟������� ��ɱ��臂í�勐�翫����� die �����障�����

    while ( ! eof($fh) ) {
        defined( $_ = readline $fh ) or die "readline failed: $!";

Note that you have can't handle readline errors that way with the ARGV filehandle. In that case, you have to open each element of @ARGV yourself since eof handles ARGV differently.

readline ��勉����í�若�� ARGV �����<�ゃ�˨����潟����˨�勖�号����с� ��宴����ŝ�����������羈���������⓾�������������� �����勐�翫�����eof ��� ARGV �����違�ŝ�c����号����ф�宴����勉�с�� @ARGV ��勉�������������勤��膣������ɱ����с�ŝ�若����潟�����綽�荀������������障�����

    foreach my $arg (@ARGV) {
        open(my $fh, $arg) or warn "Can't open $arg: $!";

        while ( ! eof($fh) ) {
            defined( $_ = readline $fh )
                or die "readline failed for $arg: $!";

Like the <EXPR> operator, if a readline expression is used as the condition of a while or for loop, then it will be implicitly assigned to $_. If either a readline expression or an explicit assignment of a readline expression to a scalar is used as a while/for condition, then the condition actually tests for definedness of the expression's value, not for its regular truth value.

<EXPR> 羲�膊�絖�������罕���� readline 綣���� while ��� for ��˨�若����勖�>散��������☖戎�����������翫����� ��������壩��藥���� $_ ��˩撮��ャ�������障����� readline 綣���障����� readline 綣���������鴻�˨�í�吾�勖��腓榊����ŭ撮��ャ�� while/for ��勖�>散�����������☖戎�����������翫����� ��>散��奝��絽吾�勛����勐�ゃ����í�������с�壔�ŝ�����綣���勐�ゃ��絎�臂í�������⓾����������í�������� �����鴻�������障�����