Základní syntaxe jazyka Zig: proměnné a konstanty

V Zigu tvoří proměnné a konstanty páteř správy dat. Tento komplexní průvodce se ponoří do nuancí práce s proměnnými a konstantami, prozkoumá pokročilé koncepty a poskytne četné příklady, které ilustrují jejich použití.

Proměnné v Zigu

Proměnné v Zigu jsou měnitelná úložiště, která mohou obsahovat hodnoty specifických typů. Jsou klíčové pro ukládání a manipulaci s daty ve vašich programech.

Deklarace proměnných

V Zig deklarujete proměnné pomocí klíčového slova var. Základní syntaxe je:

var identifikátor: typ = počáteční_hodnota;

Pojďme to prozkoumat podrobněji:

var count: i32 = 0;                 (1)
var name: []const u8 = "Alice";     (2)
var is_active: bool = true;         (3)

1	Proměnná s identifikátorem `count`, typu 32bitový integer s počáteční hodnotou `0`.
2	Proměnná s identifikátorem `name`, typu pole 8bitových znaků s konstantní velikostí (slice) a počáteční hodnotou `Alice`.
3	Proměnná s identifikátorem `is_active`, typu `bool` s počáteční hodnotou `true` (pravda).

Deklarace více proměnných najednou

Zig umožňuje deklarovat více proměnných stejného typu na jednom řádku:

var x: i32 = 1, y: i32 = 2, z: i32 = 3;

Odvození typu proměnné

Zig podporuje odvození typu, což znamená, že často můžete vynechat explicitní deklaraci typu, pokud je zadána počáteční hodnota:

var age = 30;           // Zig si odvodí typ jako i32
var pi = 3.14159;       // Zig si odvodí typ jako f64
var message = "Hello";  // Zig si odvodí typ jako []const u8

Často se však považuje za osvědčený postup explicitně deklarovat typy pro jasnost a zabránit nezamýšleným převodům typů.

Vynucení typu a literálové přípony

Zig je na typy přísný a neprovádí implicitní typové vynucování. K určení přesného typu literálu můžete použít přípony literálu:

var a = 10;         // i32
var b = 10.0;       // f64
var c = 10.0f32;    // f32
var d = 10u64;      // u64

Proměnné deklarované s klíčovým slovem var jsou změnitelné, to znamená že jejich hodnota může být změněna.

var x = 5;
x = 10; // Toto je platné
x += 3; // Nyní je hodnota proměnné x 13

zig mutation

Po deklaraci však nemůžete změnit typ proměnné:

var y = 5;
y = 3.14; // Toto vyvolá chybu při kompilaci kódu.

Neinicializované proměnné

V Zigu můžete deklarovat proměnné bez jejich inicializace, ale musíte zadat typ:

var temperature: f32;

Před použitím však musíte proměnnou inicializovat, jinak se zobrazí chyba při kompilaci. Kompilátor Zigu zajišťuje, že všechny proměnné jsou před použitím inicializovány:

var temperature: f32;
// temperature += 5.0; // Toto vyvolá chybu při kompilaci kódu.
temperature = 20.0; // Odteď můžeme proměnnou používat

Zastínění

Zig umožňuje zastínění proměnných v rámci vnořených rozsahů:

const x = 10;
{
    var x = 20; // Tato proměná x zastíní vnější x
    assert(x == 20);
}
assert(x == 10); // Jsme zpátky u vnějšího x

Konstanty v Zigu

Konstanty v Zig jsou neměnné hodnoty, které jsou známé v době kompilace. Jsou deklarovány pomocí klíčového slova const.

Deklarace konstant

Syntaxe pro deklarování konstant je podobná jako u proměnných:

const identifikátor: typ = hodnota;

Například:

const PI: f64 = 3.14159;
const MAX_USERS: u32 = 100;
const APP_NAME: []const u8 = "MyZigApp";

Odvození typu u konstant

Stejně jako proměnné mohou konstanty používat odvození typu:

const GREETING = "Hello, World!";
const MAX_THREADS = 8;

Konstanty a výrazy v době kompilace

Jednou z bezvadných funkcí Zigu je, že všechny konstanty jsou vyhodnoceny v době kompilace. To znamená, že můžete používat složité výrazy nebo dokonce volání funkcí, pokud je lze vyřešit během kompilace:

const BUFFER_SIZE = 1024 * 1024; // 1 MB
const SQUARES = [_]i32{ 1, 2 * 2, 3 * 3, 4 * 4, 5 * 5 };

fn comptime_sqrt(x: f64) f64 {
    return @sqrt(x);
}

const SQRT_2 = comptime_sqrt(2.0);

Neměnnost

Konstanty jsou neměnné, což znamená, že jejich hodnotu nelze po deklaraci změnit:

const z = 20;
// z = 30; // Toto nepůjde, způsobí to chybu při kompilaci

zig immutability

Konstanty v kódu kompilace

Konstanty jsou zvláště užitečné v kódu v době kompilace a lze je použít k vytváření výkonných abstrakcí:

const std = @import("std");

fn Matrix(comptime rows: usize, comptime cols: usize) type {
    return [rows][cols]f32;
}

const Mat3x3 = Matrix(3, 3);

const identity = Mat3x3{
    .{ 1, 0, 0 },
    .{ 0, 1, 0 },
    .{ 0, 0, 1 },
};

Comptime proměnné

Zig zavádí jedinečný koncept nazvaný proměnné comptime, které se vyhodnocují v době kompilace, ale lze je použít způsoby, které u konstant být nemohou.

fn generateFibonacci(comptime n: usize) [n]u64 {
    @setEvalBranchQuota(10000);
    comptime var fibs: [n]u64 = undefined;
    comptime var i: usize = 0;
    inline while (i < n) : (i += 1) {
        fibs[i] = switch (i) {
            0, 1 => 1,
            else => fibs[i-1] + fibs[i-2],
        };
    }
    return fibs;
}

const fib10 = generateFibonacci(10);
// fib10 je nyní compile-time konstantní pole, které obsahuje prvních 10 Fibonacciho čísel

V tomto příkladu nám comptime var umožňuje používat proměnné proměnné během provádění v době kompilace, což umožňuje výkonné funkce metaprogramování.

Pokročilé věci

Zarovnání a vyplnění

Zig vám umožňuje určit zarovnání pro proměnné:

var x: i32 align(8) = 1234;

To může být užitečné pro optimalizaci přístupu k paměti nebo při propojení s hardwarem, který očekává specifické zarovnání.

Těkavé (volatile) proměnné

Pro proměnné, které se mohou měnit mimo kontrolu programu (např. I/O mapované v paměti), můžete použít klíčové slovo volatile:

var volatile memory_mapped_register: u32 = undefined;

Thread-Local Storage

Zig podporuje místní úložiště vláken s klíčovým slovem threadlocal:

threadlocal var thread_id: u32 = 0;

Nejlepší postupy

Ve výchozím nastavení použijte const a použijte var pouze v případě, že potřebujete proměnlivost.
Explicitně specifikujte typy pro parametry funkcí a veřejné API pro zlepšení přehlednosti.
Využijte vyhodnocení během kompilace u kódu kritického pro výkon a včas zachyťte chyby.
Ke zlepšení čitelnosti kódu používejte smysluplné názvy proměnných a konstant.
Využijte výkonné funkce kompilace Zig k vytvoření flexibilního, opakovaně použitelného kódu.
Mějte na paměti proměnlivý životní cyklus a inicializaci, zejména u komplexních řídicích toků.

Závěr

Pochopení proměnných a konstant v Zigu je klíčové pro psaní efektivních a správných programů. Přístup programovacího jazyka Zig k proměnným a konstantám s důrazem na vyhodnocení v době kompilace, explicitní proměnlivost a silné psaní pomáhá vytvářet předvídatelnější a výkonnější kód. Jak budete pokračovat ve zkoumání Zigu, zjistíte, že tyto základní koncepty hrají zásadní roli v pokročilejších funkcích jazyka, jako je comptime metaprogramování a nízkoúrovňová správa paměti.

Zvládnutím těchto konceptů budete dobře vybaveni, abyste mohli plně využít jedinečných schopností Zigu a psát robustní a efektivní kód.

Zdroje a odkazy

Zig Basic Syntax: Variables and Constants by Murat Genc