代码高亮测试文档

用于测试各语言代码块的语法高亮效果。

Bash

#!/bin/bash

# 定义变量
NAME="World"
COUNT=5

# 循环输出
for i in $(seq 1 $COUNT); do
    echo "Hello, $NAME! 第 $i 次"
done

# 函数定义
greet() {
    local user=$1
    if [ -z "$user" ]; then
        echo "用法: greet <用户名>"
        return 1
    fi
    echo "你好, $user!"
}

greet "Claude"

# 文件操作
if [ -f "/etc/os-release" ]; then
    source /etc/os-release
    echo "当前系统: $NAME $VERSION_ID"
fi

CSS

/* 全局样式重置 */
:root {
    --primary-color: #3498db;
    --font-size-base: 16px;
}

body {
    margin: 0;
    padding: 0;
    font-family: 'Segoe UI', sans-serif;
    font-size: var(--font-size-base);
    background-color: #f5f5f5;
}

/* 卡片组件 */
.card {
    display: flex;
    flex-direction: column;
    align-items: center;
    width: 300px;
    padding: 1.5rem;
    border-radius: 8px;
    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
    transition: transform 0.3s ease;
}

.card:hover {
    transform: translateY(-4px);
}

@media (max-width: 768px) {
    .card {
        width: 100%;
    }
}

JavaScript

// 异步数据获取示例
const API_URL = "https://api.example.com";

// 封装 fetch 请求
async function fetchData(endpoint) {
    try {
        const response = await fetch(`${API_URL}/${endpoint}`);
        if (!response.ok) throw new Error(`HTTP 错误: ${response.status}`);
        return await response.json();
    } catch (err) {
        console.error("请求失败:", err.message);
        return null;
    }
}

// 使用 Promise 链
fetchData("users")
    .then(data => data?.map(user => ({ id: user.id, name: user.name })))
    .then(users => console.log("用户列表:", users))
    .catch(console.error);

// 防抖函数
function debounce(fn, delay = 300) {
    let timer;
    return (...args) => {
        clearTimeout(timer);
        timer = setTimeout(() => fn(...args), delay);
    };
}

const handleSearch = debounce(query => console.log("搜索:", query));

Java

import java.util.List;
import java.util.stream.Collectors;

// 泛型栈实现
public class Stack<T> {
    private final List<T> items = new java.util.ArrayList<>();

    public void push(T item) {
        items.add(item);
    }

    public T pop() {
        if (isEmpty()) throw new RuntimeException("栈为空");
        return items.remove(items.size() - 1);
    }

    public boolean isEmpty() {
        return items.isEmpty();
    }

    // Stream 操作示例
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie", "Dave");

        String result = names.stream()
            .filter(name -> name.length() > 3)
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));

        System.out.println("过滤结果: " + result);
    }
}

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 链表节点定义 */
typedef struct Node {
    int data;
    struct Node *next;
} Node;

/* 创建新节点 */
Node *create_node(int data) {
    Node *node = (Node *)malloc(sizeof(Node));
    if (!node) {
        fprintf(stderr, "内存分配失败\n");
        exit(EXIT_FAILURE);
    }
    node->data = data;
    node->next = NULL;
    return node;
}

/* 打印链表 */
void print_list(Node *head) {
    for (Node *cur = head; cur != NULL; cur = cur->next) {
        printf("%d -> ", cur->data);
    }
    printf("NULL\n");
}

int main() {
    Node *head = create_node(1);
    head->next = create_node(2);
    head->next->next = create_node(3);
    print_list(head);
    return 0;
}

C++

#include <iostream>
#include <vector>
#include <algorithm>

// 模板函数：快速排序
template <typename T>
void quick_sort(std::vector<T>& arr, int left, int right) {
    if (left >= right) return;
    T pivot = arr[(left + right) / 2];
    int i = left, j = right;

    while (i <= j) {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j) std::swap(arr[i++], arr[j--]);
    }

    quick_sort(arr, left, j);
    quick_sort(arr, i, right);
}

int main() {
    std::vector<int> nums = {5, 3, 8, 1, 9, 2, 7};
    quick_sort(nums, 0, nums.size() - 1);

    std::cout << "排序结果: ";
    for (const auto& n : nums) std::cout << n << " ";
    std::cout << std::endl;

    return 0;
}

PHP

<?php

// 数据库连接类（PDO 封装）
class Database {
    private PDO $pdo;

    public function __construct(string $dsn, string $user, string $pass) {
        $this->pdo = new PDO($dsn, $user, $pass, [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
        ]);
    }

    // 安全查询
    public function query(string $sql, array $params = []): array {
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute($params);
        return $stmt->fetchAll();
    }
}

// 路由分发示例
$routes = [
    'GET /users'    => fn() => ['status' => 'ok', 'data' => []],
    'POST /users'   => fn() => ['status' => 'created'],
];

$method = $_SERVER['REQUEST_METHOD'];
$path   = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$key    = "$method $path";

$response = isset($routes[$key]) ? $routes[$key]() : ['status' => 404];
echo json_encode($response);

Rust

use std::collections::HashMap;

// 枚举定义
#[derive(Debug)]
enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
    Triangle(f64, f64, f64),
}

impl Shape {
    // 计算面积
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(r)         => std::f64::consts::PI * r * r,
            Shape::Rectangle(w, h)   => w * h,
            Shape::Triangle(a, b, c) => {
                let s = (a + b + c) / 2.0;
                (s * (s - a) * (s - b) * (s - c)).sqrt()
            }
        }
    }
}

fn main() {
    let shapes: Vec<Shape> = vec![
        Shape::Circle(5.0),
        Shape::Rectangle(4.0, 6.0),
        Shape::Triangle(3.0, 4.0, 5.0),
    ];

    for shape in &shapes {
        println!("{:?} 面积: {:.2}", shape, shape.area());
    }

    // HashMap 统计词频
    let text = "hello world hello rust world hello";
    let mut freq: HashMap<&str, u32> = HashMap::new();
    for word in text.split_whitespace() {
        *freq.entry(word).or_insert(0) += 1;
    }
    println!("词频统计: {:?}", freq);
}

Python

from dataclasses import dataclass, field
from typing import Optional
import functools

# 数据类定义
@dataclass
class Student:
    name: str
    score: float
    grade: str = field(init=False)

    def __post_init__(self):
        self.grade = self._calc_grade()

    def _calc_grade(self) -> str:
        match self.score:
            case s if s >= 90: return "A"
            case s if s >= 75: return "B"
            case s if s >= 60: return "C"
            case _:            return "F"

# 装饰器：缓存计算结果
@functools.lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    """递归计算斐波那契数列（带缓存）"""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# 生成器：无限素数序列
def primes():
    sieve: dict[int, int] = {}
    n = 2
    while True:
        if n not in sieve:
            yield n
            sieve[n * n] = n
        else:
            p = sieve.pop(n)
            sieve[n + p] = p
        n += 1

if __name__ == "__main__":
    students = [Student("Alice", 92), Student("Bob", 78), Student("Carol", 55)]
    for s in sorted(students, key=lambda x: -x.score):
        print(f"{s.name}: {s.score} ({s.grade})")

    print("前10个素数:", [next(p := primes()) or p for p in [primes()]][0:1])
    gen = primes()
    print("前10个素数:", [next(gen) for _ in range(10)])

文档结束 — 共 9 种语言