How to Receive and Store User Input in Zig

As you may know, I’ve been dabbling in Zig over the last couple of weeks, mainly via tackling the ziglings project, which I highly recommend if you’re looking to learn Zig via fixing broken tests.

When I’m learning a new language, I like to take the “Hello World” test one step further and attempt to take user input, store it as a variable, and then return it to the user.

Now, in other programming and command languages, this is fairly straight forward as I’m sure you’re aware:

echo "What is your name?"
read name
echo "Hello $name!"

The story is not quite as simple in Zig however:

const std = @import("std");

var buffer: [10]u8 = undefined;

pub fn main() !void {
    const stdin = std.io.getStdIn();
    const reader = stdin.reader();

    std.debug.print("What is your name?\n", .{});

    const read_input = try reader.readUntilDelimiterOrEof(&buffer, '\n');

    if (read_input) |user_input| {
        std.debug.print("Hello, {s}!\n", .{user_input});
    } else {
        std.debug.print("No input detected.\n", .{});
    }
}

I’m sure if you’re used to languages like Python, this can look quite overwhelming, so lets break it down.

The Breakdown

Lets take a look at the above example line by like so we can understand whats going on.

const std = @import("std");

First we import the Zig standard library and assign it to a constant with the same name.

var buffer: [10]u8 = undefined;

Next, we create a mutable buffer which is an array of 10 elements (in this example we just want to take someones first name, which is typically 10 or less characters) and set it to undefined which means that we aren’t assigning a value yet, but we will.

const stdin = std.io.getStdIn();
const reader = stdin.reader();

We then create some quality of life constants so that we can minimize the amount we need to write later one. std.io.getStdIn() returns a handle to stdin which is what allows us to capture input coming from the console and stdin.reader() expands on that by creating an object that will allow us to read data from stdin into a buffer.

std.debug.print("What is your name?\n", .{});

This one should be pretty straight forward if you’ve been exposed to any amount of Zig, we are simply printing a statement to the console.

const read_input = try reader.readUntilDelimiterOrEof(&buffer, '\n');

This is the main component of what we’re trying to achieve in this article so pay attention. Earlier in the snippet, we created reader, and here we will be calling readUntilDelimiterOrEof method which will read from the input stream until it either hits the defined delimiter (in this case \n i.e. when the user presses return) or it reaches the end of the file.

You may also see the previously created buffer being referenced with &buffer, this is where the input that is read with reader.readUntilDelimiterOrEof will be stored.

All of this is then wrapped up nicely within a constant called read_input which you can see at the start of the line.

    if (read_input) |user_input| {
        std.debug.print("Hello, {s}!\n", .{user_input});
    } else {
        std.debug.print("No input detected.\n", .{});
    }

We then wrap it up with some conditional logic that simple states if read_input contains anything, it will print what it contains, if not it’ll print that nothing was detected.

Give it a go!

Wrapping it up

It’s a lot, I get it, but understanding this will open a world of possibilities as not only can you now take user input but you can also store and then use that input in whatever way you see fit.

This is the guide that I wish I had earlier this week when I was trying to learn how to take user input in Zig, so if its helped you to understand, give me a follow and DM on X @grapplingdev, peace!