智能代码补全助手

const express = require('express'); const app = express(); app.use(express.json());

app.use((req, res, next) => { res.header('Access-Control-Allow-Origin', '*'); res.header('Access-Control-Allow-Methods', 'GET,POST,PUT,PATCH,DELETE,OPTIONS'); res.header('Access-Control-Allow-Headers', 'Content-Type,Authorization'); if (req.method === 'OPTIONS') return res.sendStatus(204); next(); });

const items = [ { id: 1, name: 'Apple iPhone 15', tags: ['phone', 'apple', 'ios'] }, { id: 2, name: 'Samsung Galaxy S24', tags: ['phone', 'android', 'samsung'] }, { id: 3, name: 'Apple MacBook Pro', tags: ['laptop', 'apple', 'macos'] }, { id: 4, name: 'Dell XPS 13', tags: ['laptop', 'windows', 'dell'] }, { id: 5, name: 'Sony WH-1000XM5', tags: ['headphones', 'sony', 'audio'] }, { id: 6, name: 'Nintendo Switch', tags: ['gaming', 'console', 'nintendo'] }, { id: 7, name: 'Kindle Paperwhite', tags: ['ereader', 'amazon', 'reading'] }, { id: 8, name: 'Apple iPad Air', tags: ['tablet', 'apple', 'ios'] }, { id: 9, name: 'Google Pixel 9', tags: ['phone', 'android', 'google'] }, { id: 10, name: 'Logitech MX Master 3S', tags: ['mouse', 'logitech', 'accessory'] }, { id: 11, name: 'Razer Blade 15', tags: ['laptop', 'gaming', 'windows'] }, { id: 12, name: 'Bose QuietComfort Ultra', tags: ['headphones', 'bose', 'audio'] } ];

function paginate(array, page, size) { const total = array.length; const p = Math.max(1, Number.isInteger(page) ? page : 1); const s = Math.max(1, Number.isInteger(size) ? size : 10); const start = (p - 1) * s; if (start >= total) return []; return array.slice(start, Math.min(start + s, total)); }

const cache = new Map(); function getCache(key) { const entry = cache.get(key); if (!entry) return null; if (entry.exp < Date.now()) { cache.delete(key); return null; } return entry.value; } function setCache(key, value, ttlMs = 60000) { cache.set(key, { value, exp: Date.now() + ttlMs }); }

function httpError(status, code, message, details) { const err = new Error(message); err.status = status; err.code = code; if (details) err.details = details; return err; }

app.get('/api/items', (req, res, next) => { try { const { q = '', page = '1', size = '10' } = req.query; const pageNum = Number.parseInt(page, 10); const sizeNum = Number.parseInt(size, 10);

const details = {};
if (!Number.isFinite(pageNum) || pageNum < 1) details.page = 'page must be a positive integer';
if (!Number.isFinite(sizeNum) || sizeNum < 1 || sizeNum > 100) details.size = 'size must be an integer between 1 and 100';
if (typeof q !== 'string') details.q = 'q must be a string';
if (typeof q === 'string' && q.length > 100) details.q = 'q length must be <= 100';
if (Object.keys(details).length) throw httpError(400, 'INVALID_QUERY', 'Invalid query parameters', details);

const keyword = (q || '').trim().toLowerCase();
const cacheKey = `filtered:q=${keyword}`;
let filtered = getCache(cacheKey);
if (!filtered) {
  if (keyword.length === 0) {
    filtered = items.slice();
  } else {
    filtered = items.filter(it => {
      const inName = it.name.toLowerCase().includes(keyword);
      const inTags = Array.isArray(it.tags) && it.tags.some(t => String(t).toLowerCase().includes(keyword));
      return inName || inTags;
    });
  }
  setCache(cacheKey, filtered, 60000);
}

const data = paginate(filtered, pageNum, sizeNum);
res.json({
  data,
  meta: { page: pageNum, size: sizeNum, total: filtered.length }
});

} catch (err) { next(err); } });

app.use((err, req, res, next) => { const status = err.status || 500; const code = err.code || (status === 500 ? 'INTERNAL_ERROR' : 'ERROR'); const payload = { error: { code, message: err.message || 'Internal Server Error' } }; if (process.env.NODE_ENV !== 'production' && err.details) payload.error.details = err.details; res.status(status).json(payload); });

app.listen(3000, () => console.log('Server started on 3000'));

以下是补全并优化后的完整 Go 代码，支持并发抓取多个 URL、超时控制与重试、简单 LRU 缓存加速，并返回汇总 JSON。已添加必要注释。

package main

import ( "context" "encoding/json" "errors" "io" "log" "net/http" "sync" "time" )

// CacheEntry 表示缓存内容 type CacheEntry struct { URL string Body string FetchedAt time.Time }

// LRUCache 简化版 LRU 缓存（基于 map + slice 的顺序队列） type LRUCache struct { mu sync.Mutex data map[string]CacheEntry order []string // order[0] 为最近使用，末尾为最久未使用 limit int }

// NewLRUCache 初始化缓存 func NewLRUCache(limit int) *LRUCache { return &LRUCache{ data: make(map[string]CacheEntry, limit), order: make([]string, 0, limit), limit: limit, } }

// removeKey 从顺序队列移除指定 key func (c *LRUCache) removeKey(key string) { for i, k := range c.order { if k == key { c.order = append(c.order[:i], c.order[i+1:]...) return } } }

// Get 获取缓存并提升至最近使用 func (c *LRUCache) Get(key string) (CacheEntry, bool) { c.mu.Lock() defer c.mu.Unlock() entry, ok := c.data[key] if !ok { return CacheEntry{}, false } // 提升到队列头部 c.removeKey(key) c.order = append([]string{key}, c.order...) return entry, true }

// Set 设置缓存，若超出限制则淘汰最久未使用项 func (c *LRUCache) Set(key string, entry CacheEntry) { c.mu.Lock() defer c.mu.Unlock() if _, ok := c.data[key]; ok { // 更新已有项并提升 c.data[key] = entry c.removeKey(key) c.order = append([]string{key}, c.order...) return } // 若容量已满，淘汰队列末尾（最久未使用） if len(c.order) >= c.limit { old := c.order[len(c.order)-1] delete(c.data, old) c.order = c.order[:len(c.order)-1] } c.data[key] = entry c.order = append([]string{key}, c.order...) }

// fetchURL 使用 context 控制超时/取消，并内置重试逻辑 func fetchURL(ctx context.Context, url string) (string, error) { client := &http.Client{} // 超时由 ctx 控制 const maxRetries = 3 baseBackoff := 100 * time.Millisecond

for attempt := 0; attempt < maxRetries; attempt++ {
    // 若已取消或超时，尽早退出
    if ctx.Err() != nil {
        return "", ctx.Err()
    }

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return "", err
    }
    req.Header.Set("Accept", "text/plain,*/*")

    resp, err := client.Do(req)
    if err != nil {
        // 网络错误或 ctx 取消
        if ctx.Err() != nil {
            return "", ctx.Err()
        }
        // 退避重试
        if attempt < maxRetries-1 {
            backoff := baseBackoff * time.Duration(1<<attempt) // 指数退避
            select {
            case <-time.After(backoff):
            case <-ctx.Done():
                return "", ctx.Err()
            }
            continue
        }
        return "", err
    }

    // 确保关闭 Body
    bodyBytes := []byte{}
    if resp.StatusCode >= 200 && resp.StatusCode < 300 {
        var readErr error
        bodyBytes, readErr = io.ReadAll(resp.Body)
        resp.Body.Close()
        if readErr != nil {
            // 读失败可重试
            if attempt < maxRetries-1 && ctx.Err() == nil {
                backoff := baseBackoff * time.Duration(1<<attempt)
                select {
                case <-time.After(backoff):
                case <-ctx.Done():
                    return "", ctx.Err()
                }
                continue
            }
            return "", readErr
        }
        return string(bodyBytes), nil
    } else {
        // 非 2xx 状态视为错误，尝试重试
        io.Copy(io.Discard, resp.Body)
        resp.Body.Close()
        if attempt < maxRetries-1 && ctx.Err() == nil {
            backoff := baseBackoff * time.Duration(1<<attempt)
            select {
            case <-time.After(backoff):
            case <-ctx.Done():
                return "", ctx.Err()
            }
            continue
        }
        return "", errors.New("non-2xx response")
    }
}
return "", errors.New("fetch failed after retries")

}

type CollectResult struct { URL string json:"url" Ok bool json:"ok" Length int json:"length" }

var cache *LRUCache

// handleCollect 并发抓取多个 URL，支持 LRU 缓存、超时与重试，返回结果 JSON func handleCollect(w http.ResponseWriter, r http.Request) { // 期望: /collect?url=https://a.com&url=https://b.com start := time.Now() ctx, cancel := context.WithTimeout(r.Context(), 3time.Second) defer cancel()

urls := r.URL.Query()["url"]
if len(urls) == 0 {
    http.Error(w, "missing url params", http.StatusBadRequest)
    return
}

// 预分配结果，保持与输入顺序一致
results := make([]CollectResult, len(urls))

// 将相同 URL 的索引聚合，避免重复抓取
urlIndices := make(map[string][]int, len(urls))
for i, u := range urls {
    urlIndices[u] = append(urlIndices[u], i)
}

// 先尝试缓存命中，命中的不再抓取
toFetch := make([]string, 0)
for u, idxs := range urlIndices {
    if entry, ok := cache.Get(u); ok {
        // 缓存命中：直接填充各索引结果
        for _, i := range idxs {
            results[i] = CollectResult{
                URL:    u,
                Ok:     true,
                Length: len(entry.Body),
            }
        }
        continue
    }
    toFetch = append(toFetch, u)
}

// 并发抓取未命中的 URL（一个 URL 一次抓取，结果映射到多个索引）
var wg sync.WaitGroup
for _, u := range toFetch {
    idxs := urlIndices[u]
    wg.Add(1)
    go func(u string, idxs []int) {
        defer wg.Done()
        body, err := fetchURL(ctx, u)
        if err != nil {
            for _, i := range idxs {
                results[i] = CollectResult{URL: u, Ok: false, Length: 0}
            }
            return
        }
        // 写入缓存
        cache.Set(u, CacheEntry{URL: u, Body: body, FetchedAt: time.Now()})
        for _, i := range idxs {
            results[i] = CollectResult{URL: u, Ok: true, Length: len(body)}
        }
    }(u, idxs)
}
wg.Wait()

tookMs := time.Since(start).Milliseconds()

// 输出 JSON
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{
    "results": results,
    "tookMs":  tookMs,
})

}

func main() { // 初始化 LRU 缓存，限制容量为 64 cache = NewLRUCache(64)

http.HandleFunc("/collect", handleCollect)
log.Println("Listening on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))

}