Zig和C互操作实践

折腾了好几天终于搞定了，核心其实不难，但有几个坑容易踩。把要点列出来，省得大家再走弯路。

先搞清楚原理

Zig的底层原理涉及类型推导。用代码演示比画图更直观：

import asyncio
import time

async def fetch_data(url: str, delay: float = 0.5) -> dict:
    await asyncio.sleep(delay)
    return {'url': url, 'status': 200, 'data': f'Response from {url}'}

async def process_batch(urls: list) -> list:
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return [r for r in results if not isinstance(r, Exception)]

async def main():
    urls = [f'https://api.example.com/page/{j}' for j in range(10)]
    start = time.time()
    results = await process_batch(urls)
    elapsed = time.time() - start
    print(f'处理 {len(results)} 个请求，耗时 {elapsed:.2f}s')

asyncio.run(main())

实际怎么用

实际用的时候有几个注意点。首先是配置问题，不同环境参数可能不一样。其次是性能，数据量大的时候要注意类型推导。看这段实际运行的代码：

from functools import lru_cache
import time

@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

start = time.time()
result = fibonacci(35)
elapsed = time.time() - start
print(f'fib(35) = {result}, 耗时: {elapsed:.4f}s')
print(f'缓存信息: {fibonacci.cache_info()}')

# 装饰器模式
def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f'{func.__name__} 耗时: {elapsed:.4f}s')
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(0.1)
    return 'done'

slow_function()

进阶一点的用法

有些场景下Zig的常规写法不够用，需要做类型推导。这个改动涉及的地方不多，但要注意顺序：

容易踩的坑

说几个容易踩的坑。第一个是类型推导的问题，很多人在这上面栽过跟头。第二个是版本兼容性，不同版本行为可能不一样。第三个是边界情况，空值和异常输入要处理好。

写在最后

总结一下，Zig的关键在于并发调度机制。掌握了这个，其他用法都是在这个基础上扩展。建议多写几个小demo练手，光看不动手容易忘。