Tài liệu GracePL

<gp>
echo "Hello, World!\n";

gracepl run hello.gp
# Hello, World!

<gp>
db_connect("mysql://user:pass@localhost/mydb");

http_handle("/api/users", function($req) {
    if ($req["method"] == "GET") {
        $users = db_query("SELECT id, name, email FROM users");
        http_json(["data" => $users, "count" => count($users)]);
    } elseif ($req["method"] == "POST") {
        $body = json_decode($req["body"]);
        db_exec("INSERT INTO users (name, email) VALUES (?, ?)",
                [$body["name"], $body["email"]]);
        http_json(["status" => "created"], 201);
    }
});

// Production middleware
http_request_id();
http_panic_recover();
http_cors_whitelist(["https://myapp.com"]);
metrics_enable("/metrics");
log_format("json");

http_serve(":8080");

<gp>
$results = chan_make(10);
$jobs    = [1, 2, 3, 4, 5];

// Chạy song song
foreach ($jobs as $n) {
    $num = $n;
    spawn {
        $results <- $num * $num;  // tính toán và gửi kết quả
    };
}

// Thu gom kết quả
$total = 0;
foreach ($jobs as $_) {
    $total += <-$results;
}

echo "Tổng bình phương: $total\n"; // 55

<gp>
// Comment một dòng
# Cũng là comment

/*
   Comment
   nhiều dòng
*/

echo "Code của bạn ở đây";

<gp>
$i = (int)"42";       // 42
$f = (float)"3.14";   // 3.14
$s = (string)100;     // "100"
$b = (bool)1;         // true
$a = (array)"hello";  // ["hello"]

// Kiểm tra kiểu
is_int($i);     // true
is_string($s);  // true
gettype($f);    // "double"

<gp>
// Gán biến
$name  = "Alice";
$age   = 30;
$items = [1, 2, 3];

// Null coalescing
$val = $maybeNull ?? "default";
$cfg["timeout"] ??= 30;

// Biến trong hàm
function demo() {
    $local = "chỉ trong hàm này";

    // Truy cập biến global
    global $name;
    echo $name;  // Alice
}

// Global declaration + init
global $counter = 0;

<gp>
$name = "Alice";

// Double-quoted — hỗ trợ interpolation
echo "Xin chào, $name!";            // Xin chào, Alice!
echo "Phần tử: {$arr[0]}";
echo "Method: {$obj->getName()}";

// Single-quoted — không interpolation
echo 'Đây là $name';                // Đây là $name

// Heredoc
$text = <<<EOT
Dòng 1
Biến: $name
EOT;

// Escape sequences
"\n"  "\t"  "\\"  "\""  "\$"

// Hàm phổ biến
strlen($s)
strtoupper($s) / strtolower($s)
substr($s, 0, 5)
str_replace("old", "new", $s)
strpos($s, "needle")           // false nếu không tìm thấy
trim($s) / ltrim() / rtrim()
explode(",", $s)               // split → array
implode(", ", $arr)            // join ← array
str_contains($s, "sub")
str_starts_with($s, "pre")
str_ends_with($s, "suf")
sprintf("%.2f", 3.14159)
preg_match('/\d+/', $s, $m)
preg_replace('/\s+/', ' ', $s)

<gp>
// if / elseif / else
if ($score >= 90) {
    echo "Xuất sắc";
} elseif ($score >= 70) {
    echo "Khá";
} else {
    echo "Trung bình";
}

// while
$i = 0;
while ($i < 5) { $i++; }

// for
for ($i = 0; $i < 10; $i++) {
    if ($i == 5) continue;
    if ($i == 9) break;
    echo $i;
}

// foreach
foreach ($items as $item) { echo $item; }
foreach ($map as $key => $val) { echo "$key=$val"; }

// switch
switch ($role) {
    case "admin":  echo "Quản trị"; break;
    case "editor": echo "Biên tập"; break;
    default:       echo "Khách";
}

// match (expression)
$label = match ($code) {
    200     => "OK",
    404     => "Not Found",
    500     => "Server Error",
    default => "Unknown",
};

<gp>
// Hàm thông thường
function greet(string $name, string $prefix = "Chào"): string {
    return "$prefix, $name!";
}

// Variadic
function sum(...$nums): int {
    return array_sum($nums);
}

// Closure — capture bằng use
$mult = 3;
$triple = function($x) use ($mult) { return $x * $mult; };

// Arrow function — auto-capture scope ngoài
$double = fn($x) => $x * 2;

// Higher-order
$numbers = [1, 2, 3, 4, 5];
$doubled  = array_map(fn($x) => $x * 2, $numbers);
$evens    = array_filter($numbers, fn($x) => $x % 2 == 0);
$total    = array_reduce($numbers, fn($c, $x) => $c + $x, 0);

// Đệ quy
function fib($n) {
    if ($n <= 1) return $n;
    return fib($n-1) + fib($n-2);
}

<gp>
// Array
$arr = [1, 2, 3];
$arr[] = 4;            // thêm vào cuối
count($arr);           // 4

// Destructuring
[$a, $b, $c] = $arr;
[$first, , $third] = [10, 20, 30];

// Map
$user = [
    "name"  => "Alice",
    "age"   => 30,
    "roles" => ["admin", "user"]
];
echo $user["name"];        // Alice
$user["email"] = "a@b.c"; // thêm
unset($user["age"]);       // xóa

// Hàm array phổ biến
array_push($arr, $val);    // sửa $arr trực tiếp — KHÔNG gán lại!
array_pop($arr);
array_shift($arr);         // xóa đầu
array_unshift($arr, $val); // thêm đầu

in_array($needle, $arr);
array_search($needle, $arr);
array_keys($map);
array_values($arr);
array_merge($arr1, $arr2);
array_unique($arr);
array_reverse($arr);
array_chunk($arr, 3);

sort($arr);
usort($arr, fn($a, $b) => $a - $b);

array_sum($arr);
array_product($arr);

<gp>
class Person {
    public string $name;
    private int $age;
    static $count = 0;

    function __construct(string $name, int $age) {
        $this->name = $name;
        $this->age  = $age;
        self::$count++;
    }

    public function greet(): string {
        return "Chào, tôi là {$this->name}!";
    }

    static function getCount(): int { return self::$count; }

    // Magic methods
    function __toString(): string { return "Person({$this->name})"; }
    function __get($prop)        { return null; }
    function __set($prop, $val)  { }
    function __call($m, $args)   { }
}

// Kế thừa
class Employee extends Person {
    function __construct(string $name, int $age, public string $company) {
        parent::__construct($name, $age);
    }
}

$p = new Person("Alice", 30);
echo $p->greet();
echo Person::getCount();  // 1
echo $p instanceof Person;   // true

<gp>
interface Serializable {
    function serialize(): string;
    function unserialize(string $data): void;
}

abstract class Shape {
    abstract function area(): float;
    function describe(): string { return "Diện tích: " . $this->area(); }
}

trait Timestamps {
    public $createdAt;
    function setTimestamps() { $this->createdAt = time(); }
}

class Circle extends Shape implements Serializable {
    use Timestamps;

    function __construct(private float $r) { $this->setTimestamps(); }

    function area(): float { return M_PI * $this->r ** 2; }

    function serialize(): string { return json_encode(["r" => $this->r]); }
    function unserialize(string $d): void { $this->r = json_decode($d)["r"]; }
}

final class Singleton {
    static $inst = null;
    static function get(): self { return self::$inst ??= new self(); }
}

<gp>
// Integer enum (auto-increment từ 0)
enum Direction {
    NORTH,   // 0
    SOUTH,   // 1
    EAST,    // 2
    WEST     // 3
}

// Integer enum với giá trị tùy chỉnh
enum HttpStatus {
    OK     = 200,
    NOT_FOUND = 404,
    ERROR  = 500
}

// String enum
enum Color {
    RED   = "#FF0000",
    GREEN = "#00FF00",
    BLUE  = "#0000FF"
}

echo Direction::EAST;   // 2
echo HttpStatus::OK;    // 200
echo Color::RED;        // #FF0000

switch ($status) {
    case HttpStatus::OK:      echo "Thành công"; break;
    case HttpStatus::NOT_FOUND: echo "Không tìm thấy"; break;
}

<gp>
// Tham số + return type
function add(int $a, int $b): int {
    return $a + $b;
}

// Nullable
function findUser(?int $id): ?array {
    if ($id === null) return null;
    return db_query_row("SELECT * FROM users WHERE id = ?", [$id]);
}

// Union type
function process(int|string $value): string {
    return (string)$value;
}

// void return
function log(string $msg): void {
    file_put_contents("app.log", $msg . "\n", FILE_APPEND);
}

// Class type
function greet(Person $p): string {
    return "Chào {$p->name}";
}

<gp>
// Custom exception
class ValidationError extends Error {
    function __construct(string $msg, private string $field) {
        parent::__construct($msg);
    }
    function getField(): string { return $this->field; }
}

function validateEmail(string $email): void {
    if (!str_contains($email, "@")) {
        throw new ValidationError("Email không hợp lệ", "email");
    }
}

// try / catch / finally
try {
    validateEmail("not-an-email");
    $result = doRiskyOp();
} catch (ValidationError $e) {
    echo "Validation: " . $e->getMessage() . " [" . $e->getField() . "]";
} catch (NetworkError|TimeoutError $e) {
    echo "Network: " . $e->getMessage();
} catch ($e) {
    echo "Lỗi chung: " . $e->getMessage();
} finally {
    cleanup();  // luôn chạy
}

// Error chaining
function fetchUser($id) {
    try {
        return db_query_row("SELECT * FROM users WHERE id = ?", [$id]);
    } catch ($e) {
        throw error_wrap($e, "fetchUser($id) failed");
    }
}

try {
    fetchUser(99999);
} catch ($e) {
    echo error_chain_message($e);
    // "fetchUser(99999) failed: no rows returned"
}

<gp>
// Chỉ export những gì cần thiết
export $PI = 3.14159265358979;

export function add($a, $b) {
    return $a + $b + _epsilon();  // có thể gọi private
}

export function circle_area($r) {
    return $PI * $r * $r;
}

export class Vector2D {
    function __construct(public $x, public $y) {}
    function magnitude() { return sqrt($this->x**2 + $this->y**2); }
}

// Private — không export
function _epsilon() { return 1e-10; }
$_config = ["precision" => 15];

<gp>
// import_as — isolated module
$math = import_as("lib/math.gp");

echo $math["add"](3, 4);         // 7.0000000001 (+ epsilon)
echo $math["PI"];                 // 3.14159265358979
echo $math["circle_area"](5);    // 78.539...

$v = new $math["Vector2D"](3, 4);
echo $v->magnitude();             // 5.0

// Private không accessible:
// $math["_epsilon"]  → null

// import thông thường — nạp vào scope
import "utils/helpers.gp";
helper_fn();  // accessible trực tiếp

<gp>
// ── Channel ────────────────────────────────────
$ch = chan_make();    // unbuffered
$ch = chan_make(10); // buffered size=10

$ch <- "hello";      // send (blocking nếu đầy)
$val = <-$ch;        // receive (blocking nếu trống)
chan_close($ch);

// Non-blocking
[$val, $ok] = chan_try_recv($ch);

// ── spawn (goroutine) ─────────────────────────
$results = chan_make(5);
for ($i = 0; $i < 5; $i++) {
    $n = $i;
    spawn {
        $results <- $n * $n;
    };
}

// ── WaitGroup ─────────────────────────────────
$wg = wg_make();
for ($i = 0; $i < 10; $i++) {
    wg_add($wg, 1);
    $idx = $i;
    spawn {
        processItem($idx);
        wg_done($wg);
    };
}
wg_wait($wg);

// ── select ────────────────────────────────────
select {
    case $data <- $ch1:
        echo "Nhận: $data";
    case $ch2 <- "pong":
        echo "Gửi pong";
    default:
        echo "Không ready";
}

<gp>
// Tạo context có thể cancel
$ctx = ctx_make();

spawn {
    ctx_wait_done($ctx);
    echo "Worker dừng\n";
    $done_ch <- true;
};

sleep_ms(2000);        // worker chạy 2 giây
ctx_cancel($ctx);      // báo dừng

// Context với timeout
$ctx = ctx_with_timeout(5000); // 5 giây
spawn {
    ctx_wait_done($ctx);
    if (ctx_cancelled($ctx)) {
        echo "Timeout hoặc cancel\n";
    }
};

// Truyền context qua hàm
function downloadFile($ctx, $url) {
    if (ctx_done($ctx)) return null;
    return http_get($url);
}

<gp>
global $counter = 0;
$mu = mutex_make();
$wg = wg_make();

// Race-free concurrent counter
for ($i = 0; $i < 100; $i++) {
    wg_add($wg, 1);
    spawn {
        mutex_lock($mu);
        global $counter;
        $counter++;
        mutex_unlock($mu);
        wg_done($wg);
    };
}

wg_wait($wg);
echo $counter; // đúng 100

// mutex_try_lock — non-blocking
if (mutex_try_lock($mu)) {
    // critical section
    mutex_unlock($mu);
} else {
    echo "lock busy";
}

<gp>
// JSON format cho ELK/Loki/Datadog
log_format("json");

log_info("request processed", ["user_id" => 42, "latency_ms" => 12]);
// → {"timestamp":"...","level":"INFO","message":"request processed","user_id":42,"latency_ms":12}

log_debug("cache hit", ["key" => "users:42"]);
log_warn("slow query", ["ms" => 1500]);
log_error("connection failed", ["host" => "db.example.com"]);

// Set log level
log_level("warn"); // chì warn + error

// Text mode (development)
log_format("text");
// → [INFO] 2026-03-05 14:30:00 request processed

<gp>
// Bật /metrics endpoint
metrics_enable("/metrics");

// Endpoint tųâ trả về Prometheus format:
// gracepl_requests_total 12345
// gracepl_request_errors_total 23
// gracepl_request_duration_ms_bucket{le="10ms"} 8000
// gracepl_request_duration_ms_bucket{le="50ms"} 10000
// gracepl_goroutines 42
// gracepl_memory_alloc_bytes 52428800
// gracepl_uptime_seconds 86400

// Xem active connections
$n = http_active_connections();

<gp>
// Tąâ circuit breaker: name, max failures, reset timeout (ms)
circuit_breaker("payment-api", 5, 30000);

// Gội function qua circuit breaker
$result = circuit_breaker_call("payment-api", function() {
    return http_post("https://payment.api/charge", ["amount" => 100]);
});

// Circuit mô khi open
if (isset($result["error"])) {
    log_warn("payment circuit open, fallback");
}

// State: "closed" → "open" → "half-open"
$state = circuit_breaker_state("payment-api");

// Reset manual
circuit_breaker_reset("payment-api");

<gp>
// Ðâng ký handler
event_on("user.created", function($data) {
    log_info("new user", ["email" => $data["email"]]);
    email_send(["to" => $data["email"], "subject" => "Welcome!"]);
});

// Emit event (trâ về số handlers Ðąâ gội)
$count = event_emit("user.created", ["email" => "alice@example.com"]);

// Hųy handlers
event_off("user.created");

<gp>
// Schedule vói @every syntax
$cleanup = cron("@every 5m", function() {
    db_exec("DELETE FROM sessions WHERE expired_at < NOW()");
});

$health = cron("@every 30s", function() {
    $res = http_get("https://api.example.com/health");
    if (!$res) { log_error("upstream down"); }
});

// Dùng job cų thể
cron_stop($cleanup);

// Dùng tất cẩ
cron_stop_all();

<gp>
// Chuyển session sang Redis (scale multi-instance)
session_redis("redis.cluster:6379", "password", "0");

// Sų̉ dų̣ng nhų bình thųồng
session_start();
session_set("user_id", 42);
$uid = session_get("user_id"); // 42
session_flash("message", "Đã lưu thành công");  // one-time message (sau redirect)
$msg = session_flash_get("message");            // đọc và xóa flash
session_destroy();

<gp>
db_connect("user:pass@tcp(host:3306)/mydb");
db_set_timeout(5000);

<gp>
redis_connect("redis.cluster:6379", "password", "0");
redis_set("key", "value");
$val = redis_get("key");

<gp>
// Ðâng ký callback khi config reload
config_on_reload(function() {
    global $config;
    $config = json_decode(file_get_contents("config.json"));
    log_info("config reloaded");
});

// Trigger reload
config_reload();

// Unix: kill -SIGHUP <pid> cùng trigger

<gp>
// File có tên *_test.gp được test runner phát hiện tự động
import "../lib/test.gp";

describe("Math", function() {
    it("cộng hai số", function() {
        assert_eq(1 + 1, 2);
        assert_eq(10 + 20, 30);
    });

    it("handles edge cases", function() {
        assert_eq(0 + 0, 0);
        assert_eq(-1 + 1, 0);
    });
});

describe("String", function() {
    it("converts to uppercase", function() {
        assert_eq(strtoupper("hello"), "HELLO");
    });

    it("contains substring", function() {
        assert_true(str_contains("gracepl", "grace"));
    });
});

describe("Exceptions", function() {
    it("catches thrown errors", function() {
        assert_throws(function() {
            throw new Error("test error");
        });
    });
});

gracepl test ./examples/
# [PASS] cộng hai số       (0.12ms)
# [PASS] string operations  (0.08ms)
# [PASS] exception được ném (0.05ms)
# [PASS] array operations   (0.09ms)
# ─────────────────────────────────────
# 4/4 passed in 0.34ms

gracepl pkg install gracepl/http-utils
gracepl pkg install gracepl/validator
gracepl pkg install gracepl/jwt
gracepl pkg list
# gracepl/http-utils   v1.2.0
# gracepl/validator    v2.0.1
# gracepl/jwt          v1.0.0

<gp>
// Package được cài trong vendor/
$validator = import_as("vendor/gracepl/validator/main.gp");

$errors = $validator["validate"]($data, [
    "email"    => "required|email",
    "password" => "required|min:8",
    "age"      => "integer|min:18"
]);

if (count($errors) > 0) {
    http_json($res, ["errors" => $errors], 422);
    return;
}

gracepl debug myapp.gp
# Lắng nghe DAP trên stdin/stdout — VS Code kết nối tự động

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "gracepl",
      "request": "launch",
      "name": "Debug GracePL",
      "program": "${file}"
    }
  ]
}

<gp>
// ── HTTP Server ────────────────────────────────
http_handle("/", function($req) {
    http_json(["message" => "Hello from GracePL!"]);
});

// Route động: $req["params"]["id"] — lấy path segment
http_handle("/users/:id", function($req) {
    $id = $req["params"]["id"];
    $user = db_query_row("SELECT * FROM users WHERE id = ?", [$id]);
    if (!$user) { return http_json(["error" => "Not found"], 404); }
    http_json($user);
});

// Query string: $req["query"]["name"] — lấy ?name=Alice
http_handle("/search", function($req) {
    $q = isset($req["query"]["q"]) ? $req["query"]["q"] : "";
    http_json(["query" => $q]);
});

// Middleware stack — gọi trước http_serve()
http_request_id();                           // inject X-Request-Id header
http_panic_recover();                        // catch panic → 500 JSON
http_cors_whitelist(["https://myapp.com"]);  // CORS cho các origin được phép
http_rate_limit(100, 60);                    // 100 req/phút mỗi IP
http_security_headers();                     // X-Frame-Options, CSP, HSTS…
http_gzip();                                 // nén gzip tự động
metrics_enable("/metrics");                  // Prometheus /metrics endpoint
http_health("/health");                      // GET /health → {"status":"ok"}
log_format("json");                          // log dưới dạng JSON
http_static("public", "/static");            // serve file tĩnh
http_use(function($req) {                    // custom middleware
    return true; // false để chặn request
});

http_serve(":8080");

<gp>
// ── WebSocket ──────────────────────────────────
// Giới hạn dung lượng nhận tối đa mỗi tin nhắn/frame (vd: 10MB)
ws_set_read_limit(10485760);

listen("/chat") {
    on("connect", function($conn) {
        ws_room_join("general");
    });
    on("message", function($data) {
        // Broadcast string hoặc binary raw
        ws_room_broadcast("general", $data["text"]);
    });
}

// ── HTTP Client ────────────────────────────────
$res = http_get("https://api.example.com/data");
$post = http_post("https://api.example.com/users", [
    "headers" => ["Content-Type" => "application/json"],
    "body"    => json_encode(["name" => "Alice"])
]);

<!DOCTYPE html>
<html>
<head><title>{{title}} — MyApp</title></head>
<body>
    {{include "templates/header.html"}}
    <main>{{content}}</main>
    {{include "templates/footer.html"}}
</body>
</html>

<h1>{{page_title}}</h1>
{{if has_items}}
<ul>
    {{foreach items as item}}
    <li>{{item}}</li>
    {{end}}
</ul>
{{else}}
<p>Không có item nào.</p>
{{endif}}

<gp>
$posts = [
    ["title" => "Post 1", "date" => "2026-01-15"],
    ["title" => "Post 2", "date" => "2026-01-20"]
];

$cards = "";
foreach ($posts as $post) {
    $cards .= render("templates/card.html", $post);
}

$html = render("templates/list.html", [
    "page_title" => "Blog",
    "cards" => $cards
]);

# Cổng phải có dấu ":" ở đầu
APP_PORT=:3001
DB_HOST=localhost
DB_NAME=mydb
DB_USER=root
DB_PASS=secret
ALLOWED_ORIGIN=https://yourdomain.com

<gp>
// Nạp file .env (relative tới thư mục của script — không phải cwd)
env_load(".env");

// Đọc biến — tham số 2 là giá trị mặc định nếu key không tồn tại
$port   = env("APP_PORT", ":8000");
$dbHost = env("DB_HOST",  "localhost");
$debug  = env("DEBUG",    "false");

// Khởi động server
http_serve($port);

<gp>
// http_serve_tls(addr, cert_file, key_file)
// TLS 1.2+ với AES-GCM và ChaCha20-Poly1305

http_handle("/", function($req) {
    return http_json(["status" => "ok"]);
});

// Tự ký (development)
// openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

http_serve_tls(":443", "cert.pem", "key.pem");
// hoặc port khác:
// http_serve_tls(":8443", "certs/cert.pem", "certs/key.pem");

<gp>
// http_server_config(key, value)

http_server_config("read_timeout",  30);   // giây — mặc định 30s
http_server_config("write_timeout", 30);   // giây — mặc định 30s
http_server_config("idle_timeout",  120);  // giây — mặc định 120s
http_server_config("body_limit",    5242880); // bytes — mặc định 10MB (10<<20)
http_server_config("access_log",    false);   // tắt access log

http_serve(":8080");

<gp>
// Bước 1: Khởi tạo CSRF (trước khi serve)
csrf_init("secret-key-của-bạn"); // nếu bỏ qua → tự sinh random secret

// Bước 2: Sinh token cho form GET
http_handle("/form", function($req) {
    $token = csrf_token();
    return render("templates/form.html", ["csrf_token" => $token]);
});

// Bước 3: Kiểm tra token khi POST
http_handle("POST", "/submit", function($req) {
    $token = $req["body"]["_csrf"] ?? $req["headers"]["x-csrf-token"] ?? "";
    if (!csrf_verify($token)) {
        return http_status(403, "CSRF token không hợp lệ");
    }
    // xử lý form...
    return http_redirect("/success");
});

<form method="POST" action="/submit">
  <input type="hidden" name="_csrf" value="{{csrf_token | raw}}">
  <input type="text" name="name" placeholder="Tên">
  <button type="submit">Gửi</button>
</form>

<gp>
// Tương đương http_handle("GET", "/path", $fn)
http_route_get("/api/users", function($req) {
    return http_json(db_query("SELECT id, name FROM users"));
});

http_route_post("/api/users", function($req) {
    $data = json_decode($req["body"]);
    db_exec("INSERT INTO users (name) VALUES (?)", [$data["name"]]);
    return http_json(["status" => "created"], 201);
});

http_route_put("/api/users/:id", function($req) {
    $id = $req["params"]["id"];
    $data = json_decode($req["body"]);
    db_exec("UPDATE users SET name = ? WHERE id = ?", [$data["name"], $id]);
    return http_json(["updated" => true]);
});

http_route_delete("/api/users/:id", function($req) {
    $id = $req["params"]["id"];
    db_exec("DELETE FROM users WHERE id = ?", [$id]);
    return http_json(["deleted" => true]);
});

http_serve(":8080");

<gp>
// Đọc / ghi
$content = file_get_contents("data.txt");
file_put_contents("out.txt", $content);
file_put_contents("log.txt", "Line\n", FILE_APPEND);

// Dòng
$lines = file("data.txt");  // array các dòng
foreach ($lines as $line) { echo trim($line); }

// Kiểm tra
file_exists("path")
is_file("path")
is_dir("path")

// Thư mục
mkdir("new_dir", 0755, true);   // recursive
rmdir("dir");
scandir("dir");     // [".", "..", "file.txt", ...]

// Copy / Move / Delete
copy("src", "dst");
rename("old", "new");
unlink("file.txt");

// Đường dẫn
basename("/path/to/file.txt");   // "file.txt"
dirname("/path/to/file.txt");    // "/path/to"
realpath("../relative");
pathinfo("file.txt.gz");         // ["extension" => "gz", ...]

// File size / permissions
filesize("file.txt");
filemtime("file.txt");  // timestamp sửa đổi
chmod("file.txt", 0644);

<gp>
$data = ["name" => "Alice", "age" => 30, "tags" => ["go", "php"]];

// Encode
$json = json_encode($data);
// {"name":"Alice","age":30,"tags":["go","php"]}

$pretty = json_encode($data, JSON_PRETTY_PRINT);

// Decode → map/array
$map = json_decode($json);
echo $map["name"];   // Alice
echo $map["tags"][0]; // go


// Từ file
$config = json_decode(file_get_contents("config.json"));
file_put_contents("output.json", json_encode($result, JSON_PRETTY_PRINT));

<gp>
// GET request
$body = http_get("https://api.example.com/users");
$data = json_decode($body);
echo $data[0]["name"];

// POST với JSON body
$token = "secret";
$resp = http_post(
    "https://api.example.com/users",
    json_encode(["name" => "Alice", "email" => "alice@example.com"]),
    ["Content-Type" => "application/json", "Authorization" => "Bearer $token"]
);
$created = json_decode($resp);
echo "Created user #" . $created["id"];

// PUT — cập nhật resource
http_put("https://api.example.com/users/1",
    json_encode(["name" => "Alice Updated"]),
    ["Content-Type" => "application/json"]);

// DELETE
http_delete("https://api.example.com/users/1");

// Generic request
$resp = http_request("PATCH", "https://api.example.com/users/1",
    json_encode(["active" => true]),
    ["Content-Type" => "application/json"]);

// Download file về đĩa
http_download("https://example.com/report.pdf", "downloads/report.pdf");
echo "Tải xong!";

<gp>
// Kết nối
// Kết nối (MySQL, PostgreSQL, SQLite)
db_connect("user:pass@tcp(localhost:3306)/mydb");
// db_connect("postgres://user:pass@localhost/mydb");
// db_connect("sqlite://./data.db");

// Query — trả về array of maps
$rows = db_query("SELECT id, name FROM users WHERE active = ?", [1]);
foreach ($rows as $row) {
    echo "{$row['id']}: {$row['name']}\n";
}

// Single row
$user = db_query_row("SELECT * FROM users WHERE id = ?", [42]);

// Execute (INSERT, UPDATE, DELETE, DDL)
db_exec("INSERT INTO users (name, email) VALUES (?, ?)", ["Alice", "a@b.c"]);
db_exec("UPDATE users SET name = ? WHERE id = ?", ["Alice Updated", 42]);
db_exec("DELETE FROM users WHERE id = ?", [42]);

// Transaction
$tx = db_begin();
db_tx_exec($tx, "UPDATE accounts SET balance = balance - 100 WHERE id = ?", [1]);
db_tx_exec($tx, "UPDATE accounts SET balance = balance + 100 WHERE id = ?", [2]);
db_commit($tx);

// Prepared statements
$stmt = db_prepare("INSERT INTO logs (msg) VALUES (?)");
for ($i = 0; $i < 1000; $i++) {
    db_stmt_exec($stmt, ["log message $i"]);
}
db_stmt_close($stmt);

// Timeout + close
db_set_timeout(5000);
db_close();

<gp>
$key = "secret-key-của-bạn"; // tự SHA-256 thành 32 bytes nội bộ

// Mã hóa → base64(nonce[12] + ciphertext + tag[16])
$cipher = aes_encrypt("thông tin nhạy cảm", $key);
echo $cipher; // base64 string

// Giải mã
$plain = aes_decrypt($cipher, $key);
echo $plain; // "thông tin nhạy cảm"

// Dùng key 32-byte raw (không qua SHA-256 nội bộ)
$rawKey = bytes_from_hex("0123456789abcdef...");
$cipher2 = aes_encrypt_key("data", $rawKey);
$plain2  = aes_decrypt_key($cipher2, $rawKey);

<gp>
// Sinh cặp key RSA
$keys = rsa_generate(2048); // {"private": "-----BEGIN...", "public": "-----BEGIN..."}
$priv = $keys["private"];
$pub  = $keys["public"];

// Ký dữ liệu (SHA-256 hoặc SHA-512)
$sig = rsa_sign("payload data", $priv, "sha256");

// Xác minh chữ ký
$ok = rsa_verify("payload data", $sig, $pub, "sha256");

// Mã hóa bằng public key (RSA-OAEP)
$enc = rsa_encrypt("secret msg", $pub);
$dec = rsa_decrypt($enc, $priv);

<gp>
// proc_exec(cmd [, args, cwd, stdin]) → {stdout, exit_code}
// Blocking — chờ process kết thúc
$result = proc_exec("git", ["log", "--oneline", "-5"], "/app");
echo $result["stdout"];     // output của git
echo $result["exit_code"];  // 0 = thành công

// shell_exec(cmd) — chạy qua shell (sh -c / cmd /C), trả về output string
$files = shell_exec("ls -la /var/log");

// proc_exec_async — non-blocking, trả về resource handle
$handle = proc_exec_async("npm", ["run", "build"], "/app/frontend");
// ... làm việc khác trong lúc build chạy ...
$res = proc_wait($handle); // chờ kết thúc
echo "Build exit: " . $res["exit_code"];

// Với stdin (pipe input)
$out = proc_exec("grep", ["error"], "", "line1\nERROR: fail\nline3");
echo $out["stdout"]; // "ERROR: fail"

<gp>
// Kết nối TCP
$conn = tcp_connect("example.com", 80, 5000); // timeout 5000ms
if ($conn == false) { echo "Kết nối thất bại\n"; }

// Gửi / nhận
tcp_write($conn, "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n");
$resp = tcp_read($conn, 4096);
echo $resp;

echo tcp_remote_addr($conn); // "93.184.216.34:80"
echo tcp_local_addr($conn);  // "192.168.1.5:54321"
tcp_set_deadline($conn, 3000); // timeout 3s cho lần đọc/ghi tiếp
tcp_close($conn);

<gp>
// Cách 1: tcp_serve (blocking, xử lý từng conn trong goroutine)
tcp_serve(9000, function($conn) {
    $data = tcp_read($conn, 1024);
    tcp_write($conn, "Echo: " . $data);
    tcp_close($conn);
});

// Cách 2: Manual accept loop
$server = tcp_listen(9000);
echo "Listening: " . tcp_server_addr($server) . "\n";
while (true) {
    $conn = tcp_accept($server);
    spawn {
        $msg = tcp_read($conn, 1024);
        tcp_write($conn, strtoupper($msg));
        tcp_close($conn);
    }
}
tcp_server_close($server);

<gp>
// UDP gửi (fire-and-forget)
udp_send("logger.internal", 5140, "log message");

// UDP server
$sock = udp_listen(8125);
while (true) {
    [$data, $addr] = udp_recv($sock, 512);
    echo "From $addr: $data\n";
    udp_reply($sock, "ACK", $addr); // phản hồi về địa chỉ gốc
}
udp_server_close($sock);

<gp>
$ips = dns_lookup("github.com");
// ["140.82.121.4", "140.82.121.3"]

$mxs = dns_lookup_mx("gmail.com");
// [{"host": "gmail-smtp-in.l.google.com.", "pref": 5}, ...]
foreach ($mxs as $mx) {
    echo $mx["host"] . " (priority: " . $mx["pref"] . ")\n";
}

<gp>
// Theo dõi 1 file
$w = file_watch("config.json", function($event) {
    echo "File thay đổi: " . $event["path"] . " op: " . $event["op"] . "\n";
    // op: "create" | "write" | "remove" | "rename" | "chmod"
});

// Theo dõi thư mục đệ quy
$w2 = file_watch("templates/", function($event) {
    if ($event["op"] == "write") {
        echo "Template " . $event["path"] . " đã cập nhật\n";
    }
}, ["recursive" => true]);

// Thêm/bỏ path từ watcher đang chạy
file_watch_add($w2, "static/");
file_watch_remove($w2, "templates/old/");

// Dừng theo dõi
sleep(60);
file_watch_stop($w);
file_watch_stop($w2);

<gp>
// Lưu với TTL 60 giây
cache_set("user:42", ["name" => "Alice", "role" => "admin"], 60);

// Lấy — null nếu hết hạn hoặc không có
$user = cache_get("user:42");
if ($user != null) {
    echo "Cache hit: " . $user["name"];
} else {
    // load từ DB và cache lại
    $user = db_query_row("SELECT * FROM users WHERE id = 42");
    cache_set("user:42", $user, 300); // cache 5 phút
}

// Xóa key
cache_delete("user:42");

// Xóa toàn bộ cache
cache_flush();

<gp>
prof_start(); // bật profiler

// ... chạy code cần đo ...
$data = db_query("SELECT * FROM products");
foreach ($data as $item) {
    process_item($item);
}

prof_stop(); // tắt profiler

// In báo cáo: function name, call count, total time
echo prof_report();

<gp>
// Tạo lỗi gốc
$dbErr = error_create("Kết nối DB thất bại", 500);

// Bọc lỗi với context
$svcErr = error_wrap($dbErr, "Không thể nạp dữ liệu người dùng", 503);
$apiErr = error_wrap($svcErr, "Request thất bại");

// Kiểm tra lỗi
if (is_error($apiErr)) {
    // Lấy toàn bộ chuỗi thông báo
    echo error_chain_message($apiErr);
    // → "Request thất bại: caused by: Không thể nạp dữ liệu người dùng: caused by: Kết nối DB thất bại"

    // Lấy nguyên nhân gốc
    $root = error_cause(error_cause($apiErr));
    echo $root["message"]; // "Kết nối DB thất bại"
    echo $root["code"];    // 500
}

<gp>
// Tạo bytes
$b = bytes_from_string("Hello");   // string → KBytes
$b2 = bytes_from_hex("deadbeef");  // hex string → KBytes

// Thao tác
echo bytes_length($b);         // 5
echo bytes_get($b, 0);         // 72 (ASCII 'H')
bytes_set($b, 0, 104);         // sửa byte đầu thành 'h'
$slice = bytes_slice($b, 1, 3); // bytes[1..3)
$joined = bytes_concat($b, $b2);

// Chuyển đổi
echo bytes_to_string($b);      // "hello"
echo bytes_to_hex($b);         // "68656c6c6f"

// File binary
$img = file_read_bytes("photo.jpg");
echo bytes_length($img);       // kích thước file
file_write_bytes("copy.jpg", $img);

<gp>
// pack(format, ...values) → binary string
// Format codes: N=uint32 big-endian, n=uint16 big-endian, C=uint8, A=string
$header = pack("NnC", 1000, 42, 7);

// unpack — positional
$vals = unpack("NnC", $header);
echo $vals[0]; // 1000 (uint32)
echo $vals[1]; // 42   (uint16)
echo $vals[2]; // 7    (uint8)

// unpack — named (PHP style: "N1len/n1flags")
$data = unpack("N1length/n1flags/C1version", $header);
echo $data["length"]; // 1000
echo $data["flags"];  // 42