Perl Input

Basic File and Standard Input Operations in Perl

Perl’s strength as a text‑processing language shows up early when you start reading data. Whether you want to read from a named file or from the standard input stream, Perl gives you two straightforward approaches. The first is the classic open routine, which hands you a filehandle that you can use like any other stream. The second lets you leave the file names up to the user: you supply them on the command line and Perl opens each one in turn. Both techniques can be combined with the special angle‑bracket syntax that reads a file line by line without explicit loops.

Let’s look at each method in a concrete setting. Imagine you have three small text files called a, b, and c, each containing a distinct word on a single line. You could write a script that opens one file and prints its contents. The script might look like this:

Running this script with perl script.pl a would display the word inside a. The same script would work with b or c simply by changing the argument. This approach gives you full control: you can manipulate the filehandle, close it when you’re done, and even seek to a particular position if needed.

The second style takes advantage of Perl’s handling of @ARGV, the array that holds all the command‑line arguments that aren’t options. You can let Perl iterate over that array for you, opening each file in turn, or you can tell it to read everything as if it were coming from the standard input. For example:

When you run this with perl script.pl a b c, the special <> operator opens each file in sequence and streams their lines to the loop. If you omit the filenames, Perl treats the loop as reading from STDIN. In that case you could pipe data into the script or type it directly at the prompt.

There are situations where you might want to take a specific action each time a file ends. Perl’s filehandle mechanism lets you detect that by using the eof function. Here’s a tweak that prints a separator after each file:

That prints the marker only once the entire file has been processed, just before the script moves on to the next name in @ARGV or to STDIN.

Sometimes you don’t care about the line order at all; you simply want all the input merged into one big string. Perl lets you do that with the local $/ = undef trick, which changes the input record separator to “undef”, making a read of the filehandle return the whole file at once:

This pattern is handy when you need to run a regular expression against the entire contents, or when you’re dealing with a compressed file that you’ve already unpacked into a string.

Perl’s angle‑bracket syntax is versatile. You can tell it to open files that match a pattern by using globbing characters directly in the loop:

In the example above, Perl expands a to every filename that begins with “a” in the current directory. That works the same way as shell globbing, so , ?, and character ranges can all be used. If you combine this with the eof check, you get a compact way to process all matching files and report when each ends.

Because the <> operator is so flexible, it is often the first tool that new Perl programmers use for file I/O. The simplicity of the syntax hides a lot of underlying magic - Perl handles the open, read, and close for you, and it knows how to treat standard input as a file when no arguments are supplied. By mastering these basic patterns you can write scripts that are short, readable, and that can adapt to a variety of input sources without extra code.

Handling Non‑blocking Input, Single‑Character Reads, and Wildcard File Opening

When scripts need to stay responsive while waiting for data, the default blocking behavior of standard input can become a bottleneck. Perl offers a low‑level interface to the system’s select call that lets a script probe a filehandle and see whether data is available. The trick is to set up a bitmask of the descriptors you want to monitor and then call select with that mask. Perl’s overloaded select accepts the same arguments as the system call, which can be confusing but is also powerful.

Below is a minimal example that watches both STDIN and a named file. The file a contains a single line, and the script waits for input from the user before it begins to read the file. The code shows the typical pattern: build a string that represents the bit vector, copy it to a temporary variable so that select can modify it, then test the result to see which filehandles are ready.

When you run this script, it will sit idle until you type something. Once you hit Enter, the script receives the input, prints it, and then begins to read from the file a. The select call returns 0 after the timeout if no descriptors are ready, so the loop terminates automatically. This pattern is useful when you want to multiplex several input streams or keep a server loop running while still accepting user commands.

Reading a single character is a slightly different story because most terminals operate in line‑buffered mode. To get raw characters you must turn off canonical input processing with a system call like stty before running your script. On macOS the command would look like this:

After the terminal is in raw mode, a simple read from STDIN will return immediately with the character the user typed. Perl can read that character with the read function or by reading a single byte from the filehandle. The same select technique described above can be used to avoid blocking while you wait for a key press.

Back to the angle‑bracket syntax: it is not limited to a single file name. You can use glob patterns directly inside the operator, which expands to all matching filenames. For example, if your directory contains a1, a2, b.txt, and c.log, the following loop will open every file that starts with a:

Because the operator handles the opening and closing automatically, you can write short scripts that scan a directory for specific file types and process them one after another. The glob syntax works with ranges too: file[1-3].txt expands to file1.txt, file2.txt, and file3.txt

Putting these pieces together, you can build a Perl program that reads from the command line, handles input as it arrives, processes files in bulk, and even responds to single‑character user commands. The language’s built‑in facilities keep the code compact, while still exposing the underlying system calls when you need more control. By mastering the <> operator, select, and globbing, you’ll find that Perl can handle almost any input scenario with just a few lines of code.