std.io.getStdOut() / Writer

// -----------------------------------------------
// Getting a Writer for standard output
// -----------------------------------------------

const stdout = std.io.getStdOut().writer();
// std.io.getStdOut() : Returns a File struct representing standard output
// .writer()          : Obtains a Writer (std.fs.File.Writer type) from the File

try stdout.print("format string\n", .{});
// print() : Writes formatted output. Requires try because it can return an error

try stdout.writeAll("string\n");
// writeAll() : Writes a string as-is without any formatting

// -----------------------------------------------
// Getting a Reader for standard input
// -----------------------------------------------

const stdin = std.io.getStdIn().reader();
// std.io.getStdIn() : Returns a File struct representing standard input
// .reader()         : Obtains a Reader (std.fs.File.Reader type) from the File

var buf: [256]u8 = undefined;
// readUntilDelimiterOrEof() : Reads until the specified byte or EOF
// Returns ?[]u8; returns null at EOF
const line = try stdin.readUntilDelimiterOrEof(&buf, '\n');

// -----------------------------------------------
// Getting a Writer for standard error
// -----------------------------------------------

const stderr = std.io.getStdErr().writer();
// std.io.getStdErr() : Returns a File struct representing standard error
try stderr.print("error message\n", .{});

stdout_write.zig

// stdout_write.zig — sample for std.io.getStdOut() / getStdIn()
// Demonstrates how to use Writer/Reader for standard I/O
// using characters from Jujutsu Kaisen

// Import the standard library
const std = @import("std");

pub fn main() !void {
    // -----------------------------------------------
    // Get a Writer for standard output
    // -----------------------------------------------

    // Call getStdOut() to obtain the stdout File, then writer() to create a Writer.
    // All writes are performed through this Writer.
    const stdout = std.io.getStdOut().writer();

    // -----------------------------------------------
    // Formatted output with print()
    // -----------------------------------------------

    // print() takes a format string and a tuple of arguments.
    // try is required because the function can return an error.
    try stdout.print("=== Jujutsu Kaisen Sorcerer Roster ===\n", .{});
    try stdout.print("\n", .{});

    // Use {s} for strings and {d} for integers.
    const gojo_name = "Gojo Satoru";
    const gojo_grade = "Special Grade";
    const gojo_technique = "Limitless";
    try stdout.print("Name: {s}\n", .{gojo_name});
    try stdout.print("Grade: {s}\n", .{gojo_grade});
    try stdout.print("Technique: {s}\n", .{gojo_technique});
    try stdout.print("\n", .{});

    // -----------------------------------------------
    // Unformatted output with writeAll()
    // -----------------------------------------------

    // writeAll() writes a string directly without any format processing.
    // It is more efficient than print() when outputting a fixed string.
    try stdout.writeAll("--- Grade 1 Sorcerers ---\n");

    // -----------------------------------------------
    // List output using a struct and an array
    // -----------------------------------------------

    // Define a struct to hold sorcerer information.
    const Sorcerer = struct {
        name: []const u8,   // name
        grade: []const u8,  // grade
        cursed_energy: u32, // cursed energy level (placeholder value)
    };

    // Store Jujutsu Kaisen characters in an array.
    const sorcerers = [_]Sorcerer{
        .{ .name = "Gojo Satoru",   .grade = "Special Grade", .cursed_energy = 99999 },
        .{ .name = "Itadori Yuji",  .grade = "Grade 1",       .cursed_energy = 8800  },
        .{ .name = "Fushiguro Megumi", .grade = "Grade 1",    .cursed_energy = 7200  },
        .{ .name = "Kugisaki Nobara",  .grade = "Grade 1",    .cursed_energy = 6500  },
        .{ .name = "Nanami Kento",  .grade = "Grade 1",       .cursed_energy = 7800  },
    };

    // Iterate over the array with a for loop and print each sorcerer's info.
    for (sorcerers) |s| {
        try stdout.print("  {s} ({s}) Cursed Energy: {d}\n", .{ s.name, s.grade, s.cursed_energy });
    }
    try stdout.print("\n", .{});

    // -----------------------------------------------
    // Get and use a Writer for standard error
    // -----------------------------------------------

    // Call getStdErr() to obtain the stderr File.
    // Use it for error messages and debug information.
    const stderr = std.io.getStdErr().writer();
    try stderr.print("[debug] sorcerer count: {d}\n", .{sorcerers.len});

    // -----------------------------------------------
    // Get and use a Reader for standard input
    // -----------------------------------------------

    // Call getStdIn() to obtain the stdin File, then reader() to create a Reader.
    try stdout.writeAll("Enter a sorcerer name: ");

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

    // Prepare a buffer to hold the input.
    // Initializing with undefined avoids the cost of zero-initialization.
    var buf: [128]u8 = undefined;

    // readUntilDelimiterOrEof() reads until a newline ('\n').
    // The return type is ?[]u8; it is null at EOF.
    const maybe_input = try stdin.readUntilDelimiterOrEof(&buf, '\n');

    if (maybe_input) |raw| {
        // On Windows, a trailing '\r' may remain; trimRight() removes it.
        const input = std.mem.trimRight(u8, raw, "\r");
        try stdout.print("You entered: {s}\n", .{input});
    } else {
        try stdout.writeAll("(no input)\n");
    }

    try stdout.writeAll("\nDone.\n");
}

zig run stdout_write.zig
=== Jujutsu Kaisen Sorcerer Roster ===

Name: Gojo Satoru
Grade: Special Grade
Technique: Limitless

--- Grade 1 Sorcerers ---
  Gojo Satoru (Special Grade) Cursed Energy: 99999
  Itadori Yuji (Grade 1) Cursed Energy: 8800
  Fushiguro Megumi (Grade 1) Cursed Energy: 7200
  Kugisaki Nobara (Grade 1) Cursed Energy: 6500
  Nanami Kento (Grade 1) Cursed Energy: 7800

[debug] sorcerer count: 5
Enter a sorcerer name: Gojo Satoru
You entered: Gojo Satoru

Done.

std.io.getStdOut() returns a std.fs.File representing standard output. Calling .writer() on it gives you a Writer, which provides methods such as print() and writeAll() for writing to standard output. print() performs formatted output, accepting a format string and a tuple of arguments. Because it can return an error, try is required. For fixed strings that need no formatting, writeAll() is simpler. To read from standard input, obtain a Reader with std.io.getStdIn().reader() and use readUntilDelimiterOrEof() to read one line into a buffer. The return type is ?[]u8 (an optional), so you unwrap it with if (maybe_input) |raw|. A Writer for error output is obtained the same way with std.io.getStdErr().writer(). For details on format specifiers, see std.debug.print() (debug output). For string operations, see String Basics.