我的技术分享

2026年4月实测：AI中转站怎么选？AIToke让Claude和GPT调用更丝滑

Thu, 23 Apr 2026 19:38:43 +0800

作为一名长期关注AI技术落地的开发者，2026年的模型生态让我既兴奋又头疼。兴奋的是，Claude Opus 4.7的复杂推理能力、GPT-5.4的多模态表现、Codex的代码生成效率，确实让开发效率翻倍；头疼的是，官方API的网络延迟、支付门槛、账号风控，依然是国内开发者绕不开的“三座大山”。

过去半年，我试过不下10个中转平台，有的延迟高得离谱，有的低价却暗藏模型降级风险。

直到上个月偶然发现AIToke https://www.aitoke.top/ ，才算真正找到了“稳定又省心”的解决方案。

为什么选AIToke？实测三个核心优势

模型全，覆盖主流旗舰：平台不仅接入了Claude全系（包括刚发布的Opus 4.7、Sonnet 4.6），还有GPT-5.4、Codex等OpenAI主力模型，甚至整合了部分国产模型。对于需要多模型对比测试的项目来说，一个平台就能搞定所有调用，不用再反复切换账号。

●

延迟低，国内直连无卡顿：我在阿里云上海服务器测试，调用Claude Opus 4.7的平均延迟仅1.3秒，GPT-5.4更是低至0.9秒，晚高峰峰值延迟也控制在2.8秒以内，比之前用的某平台快了近40%。关键是无需代理，直接国内访问，再也不用担心IP被封导致开发中断。

●

避坑指南：中转站别只看价格很多开发者容易被“超低价”吸引，但低价背后可能藏着模型降级、结果缓存、高并发限流等坑。AIToke的优势在于“稳定优先”——平台运营超过2年，提供7×24小时技术支持，实测请求成功率99.6%以上，即使连续调用也不会出现断流。另外，它完美兼容OpenAI标准协议，配置时只需替换Base URL和API Key，零二次开发就能接入现有项目，我花5分钟就完成了Claude Code的配置。

实际使用建议

●

编程场景：优先用Codex+AIToke，代码生成速度快，终端操作能力强，适合快速原型开发；

●

复杂需求拆解：切换Claude Opus 4.7，长上下文理解和结构化输出更稳，能像“架构师”一样把模糊需求转化为清晰计划；

●

多模型对比：直接用AIToke的聚合接口，一套代码调用多个模型，效率提升至少3倍。

2026年的AI开发，早不是“死磕一个模型”的时代了。与其被官方API的限制束缚，不如选个靠谱的中转站，让工具真正为效率服务。如果你也在为模型调用烦恼，不妨试试AIToke——至少对我来说，它解决了90%的使用痛点。

Go语言单元测试

Thu, 16 Apr 2026 16:50:24 +0800

Go语言单元测试

为什么要写单元测试

减少bug
提高代码质量
放心重构

#1 基本规则介绍

Go的单元测试比较容易实现，因为Go语言为我们提供了单元测试的框架。而对于单元测试的框架需要遵循下面的几条规定。

1.单元测试代码的go文件必须以_test.go结尾，Go语言测试工具只认符合这个规则的文件
2.单元测试的函数名必须以Test开头，是可导出公开的函数。备注：函数名最好是Test+要测试的方法函数名
3.测试函数的签名必须接收一个指向testing.T类型的指针作为参数，并且该测试函数不能返回任何值

#2 go test工具

go test命令是一个按照一定约定和组织的测试代码的驱动程序。在包目录内，所有以_test.go为后缀名的源代码文件都是go test测试的一部分，不会被go build编译到最终的可执行文件中。在*_test.go文件中有三种类型的函数，单元测试函数、基准测试函数和示例函数。go test命令会遍历所有的*_test.go文件中符合命名规则的函数，然后生成一个临时的main包用于调用相应的测试函数，然后构建并运行、报告测试结果，最后清理测试中生成的临时文件。

类型	格式	作用
测试函数	函数名前缀为Test	测试程序的一些逻辑行为是否正确
基准函数	函数名前缀为Benchmark	测试函数的性能
示例函数	函数名前缀为Example	为文档提供示例文档

#3 测试函数

#3.1 测试函数的格式

每个测试文件函数必须以_test.go结尾,并导入testing包，测试函数的基本格式（签名）如下：

func TestName(t *testing.T){
    // 测试代码体}复制

func TestAdd(t *testing.T){ ... }func TestSum(t *testing.T){ ... }func TestLog(t *testing.T){ ... }复制

其中参数t用于报告测试失败和附加的日志信息。 testing.T的拥有的方法如下：

func (c *T) Error(args ...interface{})func (c *T) Errorf(format string, args ...interface{})func (c *T) Fail()func (c *T) FailNow()func (c *T) Failed() boolfunc (c *T) Fatal(args ...interface{})func (c *T) Fatalf(format string, args ...interface{})func (c *T) Log(args ...interface{})func (c *T) Logf(format string, args ...interface{})func (c *T) Name() stringfunc (t *T) Parallel()func (t *T) Run(name string, f func(t *T)) boolfunc (c *T) Skip(args ...interface{})func (c *T) SkipNow()func (c *T) Skipf(format string, args ...interface{})func (c *T) Skipped() bool复制

#3.2 测试函数示例一

package junitimport (
	"fmt"
	"testing")func sum(x,y int) int  {
	return x+y}func TestSum(t *testing.T) {
	sum := sum(10, 20)
	expected:=30
	if  sum!= expected {
		t.Errorf("期待的执行结果 %d, 但是获得的结果是 %d!", expected, sum)
	}
	fmt.Println(sum)}------------执行结果-----------=== RUN   TestSum30--- PASS: TestSum (0.00s)PASS复制

#3.3 测试函数示例二

package testimport (
	"fmt"
	"testing")// 加法func Add1(a, b int) int {
	return a + b}func Add2(a, b int) int {
	return a + b}func Add3(a, b int) int {
	return a + b}// 1. 单元测试初始化执行，可以理解为 initfunc TestMain(m *testing.M) {
	fmt.Println("在这里进行初始化操作 ...")
	m.Run()}// 2. 自定义单元测试的执行顺序func TestAll(t *testing.T) {
	t.Run("TestAdd2", testAdd2)
	t.Run("TestAdd1", testAdd1)
	t.Run("TestAdd3", testAdd3)}func testAdd1(t *testing.T) {
	i := Add1(5, 6)
	if i != 11 {
		t.Errorf("失败的单元测试 TestAdd1")
	}}func testAdd2(t *testing.T) {
	i := Add2(5, 6)
	if i != 11 {
		t.Errorf("失败的单元测试 TestAdd2")
	}}// 3. 利用 t.SkipNow() 跳过这个单元测试func testAdd3(t *testing.T) {
	t.SkipNow()
	i := Add3(5, 6)
	if i != 10 {
		t.Errorf("失败的单元测试 TestAdd3")
	}}复制

#4 基准测试

1、文件命名规则：
含有单元测试代码的go文件必须以_test.go结尾，Go语言测试工具只认符合这个规则的文件
单元测试文件名_test.go前面的部分最好是被测试的方法所在go文件的文件名。
2、函数声明规则：测试函数的签名必须接收一个指向testing.B类型的指针，并且函数没有返回值。
3、函数命名规则：
单元测试的函数名必须以Benchmark开头，是可导出公开的函数，最好是Benchmark+要测试的方法函数名。
4、函数体设计规则： b.N是基准测试框架提供，用于控制循环次数，循环调用测试代码评估性能。 b.ResetTimer()/b.StartTimer()/b.StopTimer()用于控制计时器，准确控制用于性能测试代码的耗时。

#4.1 基准测试函数格式

基准测试就是在一定的工作负载之下检测程序性能的一种方法。基准测试的基本格式如下：

func BenchmarkName(b *testing.B){
    // ...}复制

基准测试以Benchmark为前缀，需要一个*testing.B类型的参数b，基准测试必须要执行b.N次，这样的测试才有对照性，b.N的值是系统根据实际情况去调整的，从而保证测试的稳定性。 testing.B拥有的方法如下：

func (c *B) Error(args ...interface{})func (c *B) Errorf(format string, args ...interface{})func (c *B) Fail()func (c *B) FailNow()func (c *B) Failed() boolfunc (c *B) Fatal(args ...interface{})func (c *B) Fatalf(format string, args ...interface{})func (c *B) Log(args ...interface{})func (c *B) Logf(format string, args ...interface{})func (c *B) Name() stringfunc (b *B) ReportAllocs()func (b *B) ResetTimer()func (b *B) Run(name string, f func(b *B)) boolfunc (b *B) RunParallel(body func(*PB))func (b *B) SetBytes(n int64)func (b *B) SetParallelism(p int)func (c *B) Skip(args ...interface{})func (c *B) SkipNow()func (c *B) Skipf(format string, args ...interface{})func (c *B) Skipped() boolfunc (b *B) StartTimer()func (b *B) StopTimer()复制

#4.2 基准测试示例

基准测试并不会默认执行，需要增加-bench参数，所以我们通过执行go test -bench=Sum命令执行基准测试，每次操作对内存的申请使用go test -bench=Sum -benchmem

package junitimport (
	"testing")func sum(x,y int) int  {
	return x+y}func BenchmarkSum(b *testing.B) {
	for i := 0; i < b.N; i++ {
		 sum(i, i+2)
	}}-----------------输出结果----------------------goos: windows
goarch: amd64
pkg: projectDemo1/junit
BenchmarkSum-4   	1000000000	         0.606 ns/op
PASS//这里 1000000000 是指迭代次数，这是 Go 自己决定的，//而0.606ns/op 指的是每次执行 Sum 都需要 0.606 纳秒。复制

#4.3 性能比较函数

基准测试只能得到给定操作的绝对耗时，但是在很多性能问题是发生在两个不同操作之间的相对耗时，我们通常需要对两个不同算法的实现使用相同的输入来进行基准比较测试。性能比较函数通常是一个带有参数的函数，被多个不同的Benchmark函数传入不同的值来调用。举个例子如下：

func benchmark(b *testing.B, size int){/* ... */}func Benchmark10(b *testing.B){ benchmark(b, 10) }func Benchmark100(b *testing.B){ benchmark(b, 100) }func Benchmark1000(b *testing.B){ benchmark(b, 1000) }复制

#4.4 性能比较测试

package junitimport "testing"// Fib 是一个计算第n个斐波那契数的函数func Fib(n int) int {
	if n < 2 {
		return n	}
	return Fib(n-1) + Fib(n-2)}//benchmarkFib编写的性能比较函数func benchmarkFib(b *testing.B, n int) {
	for i := 0; i < b.N; i++ {
		Fib(n)
	}}func BenchmarkFib1(b *testing.B)  { benchmarkFib(b, 1) }func BenchmarkFib2(b *testing.B)  { benchmarkFib(b, 2) }func BenchmarkFib3(b *testing.B)  { benchmarkFib(b, 3) }func BenchmarkFib10(b *testing.B) { benchmarkFib(b, 10) }func BenchmarkFib20(b *testing.B) { benchmarkFib(b, 20) }func BenchmarkFib40(b *testing.B) { benchmarkFib(b, 40) }复制

在当前文件下运行go test -bench=.进行基准测试，结果如下

goos: windows
goarch: amd64
pkg: projectDemo1/junit
BenchmarkFib1-4         267679506                3.99 ns/op
BenchmarkFib2-4         125047687                9.38 ns/op
BenchmarkFib3-4         52140361                20.8 ns/op
BenchmarkFib10-4         2096516               559 ns/op
BenchmarkFib20-4           14952             70338 ns/op
BenchmarkFib40-4               1        1076715400 ns/op
PASS
ok      projectDemo1/junit      10.189s复制

#4.5 重置时间

b.ResetTimer之前的处理不会放到执行时间里，也不会输出到报告中，所以可以在之前做一些不计划作为测试报告的操作。例如：

package junitimport (
	"testing"
	"time")func sum(x,y int) int  {
	return x+y}func BenchmarkSum(b *testing.B) {
	time.Sleep(5 * time.Second) // 假设需要做一些耗时的无关操作
	b.ResetTimer()              // 重置计时器
	for i := 0; i < b.N; i++ {
		sum(i,i+2)
	}}------------输出结果------------goos: windows
goarch: amd64
pkg: projectDemo1/junit
BenchmarkSum-4   	1000000000	         0.449 ns/op
PASS复制

#4.6 并行测试

以并行的方式执行给定的基准测试。RunParallel会创建出多个goroutine，并将b.N分配给这些goroutine执行，其中goroutine数量的默认值为GOMAXPROCS。用户如果想要增加非CPU受限（non-CPU-bound）基准测试的并行性，那么可以在RunParallel之前调用SetParallelism。 RunParallel通常会与-cpu标志一同使用

package junitimport (
	"testing")func sum(x,y int) int  {
	return x+y}func BenchmarkSumParallel(b *testing.B) {
	// b.SetParallelism(1) // 设置使用的CPU数
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sum(12,35)
		}
	})}-----------------------输出结果-------------------goos: windows
goarch: amd64
pkg: projectDemo1/junit
BenchmarkSumParallel-4   	1000000000	         1.04 ns/op
PASS复制

#5 示例函数

#5.1 示例函数的格式

被go test特殊对待的第三种函数就是示例函数，它们的函数名以Example为前缀。它们既没有参数也没有返回值。标准格式如下：

func ExampleName() {
    // ...}复制

#5.2 示例函数示例

func ExampleSum() {
	fmt.Println(sum(10,31))
	fmt.Println(sum(123,233))
	// Output:
	// [41]
	// [356]}复制

#5.3 示例代码用处

示例函数能够作为文档直接使用，例如基于web的godoc中能把示例函数与对应的函数或包相关联。
示例函数只要包含了// Output:也是可以通过go test运行的可执行测试。
示例函数提供了可以直接运行的示例代码，可以直接在golang.org的godoc文档服务器上使用Go Playground运行示例代码。下图为strings.ToUpper函数在Playground的示例函数效果。

#6 更多参考

Go常用方法总结

Thu, 16 Apr 2026 16:49:56 +0800

1 判断类型是否一样

reflect.TypeOf(a).Kind() == reflect.TypeOf(b).Kind()

#2 判断两个interface{}是否相等

reflect.DeepEqual(a, b interface{})

#3 将一个interface{}赋值给另一个interface{}

reflect.ValueOf(a).Elem().Set(reflect.ValueOf(b))

#4 strconv包简介

在Go语言中，我们往往需要对一些常用的数据类型进行转换，如string，int，int64 ,float等数据类型之间的转换，基于此Go语言为我们提供了一个名为strconv的包来为我们提供这些类型的转换方法。

#4.1 string转化成int类型

Atoi() 将字符串类型的整数转换为int类型。

func Atoi(s string) (i int, err error)复制

如果传入的字符串参数无法转换为int类型，就会返回错误。

s1 := "100"i1, err := strconv.Atoi(s1)if err != nil {
    fmt.Println("can't convert to int")} else {
    fmt.Printf("type:%T value:%#v\n", i1, i1) //type:int value:100}复制

#4.2 int类型转化成字符串string

Itoa() 将int类型数据转换为对应的字符串表示。

func Itoa(i int) string复制

i2 := 200s2 := strconv.Itoa(i2)fmt.Printf("type:%T value:%#v\n", s2, s2) //type:string value:"200"复制

#4.3 Parse系列函数

Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

ParseFloat()

func ParseBool(str string) (value bool, err error)

返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误

ParseInt()

func ParseInt(s string, base int, bitSize int) (i int64, err error)

返回字符串表示的整数值，接受正负号。 base指定进制（2到36），如果base为0，则会从字符串前置判断，”0x”是16进制，”0”是8进制，否则是10进制； bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；返回的err是*NumErr类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围err.Error = ErrRange。

ParseFloat()

func ParseFloat(s string, bitSize int) (f float64, err error)

解析一个表示浮点数的字符串并返回其值。如果s合乎语法规则，函数会返回最为接近s表示值的一个浮点数（使用IEEE754规范舍入）。 bitSize指定了期望的接收类型，32是float32（返回值可以不改变精确值的赋值给float32），64是float64；返回值err是*NumErr类型的，语法有误的，err.Error=ErrSyntax；结果超出表示范围的，返回值f为±Inf，err.Error= ErrRange。

b, err := strconv.ParseBool("true")f, err := strconv.ParseFloat("3.1415", 64)i, err := strconv.ParseInt("-2", 10, 64)u, err := strconv.ParseUint("2", 10, 64)复制

#4.4 Format系列函数

Format系列函数实现了将给定类型数据格式化为string类型数据的功能

FormatBool() 根据b的值返回”true”或”false”。

func FormatBool(b bool) string

FormatInt() 返回i的base进制的字符串表示。base 必须在2到36之间，结果中会使用小写字母’a’到’z’表示大于10的数字。

func FormatInt(i int64, base int) string

FormatUint() 是FormatInt的无符号整数版本

func FormatUint(i uint64, base int) string

FormatFloat() 函数将浮点数表示为字符串并返回。

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

更多Go语言标准库API请参考studygolang

基于 new-api 二次开发的增强版 AI 中转系统

Thu, 16 Apr 2026 16:46:03 +0800

项目说明

注释

本仓库为基于的二次开发开源版本，保留上游项目标识、核心架构与主要文档结构new-api
适合作为二开功能整理、部署实践与后续持续迭代的公开代码仓库
如需查看原版能力、更新记录与完整官方文档，请优先参考上游项目与文档new-api

[!提示]

如果你准备直接部署此仓库，建议先阅读下方的快速开始与部署说明
如果你准备继续二次开发，建议定期与上游保持对比，减少后续合并成本new-api
当前二开仓库地址：https://github.com/xiaoer0215/Newapi-2.git
下方保留的官方仓库、镜像与文档链接主要用于上游说明与兼容参考;如果你希望完全通过当前仓库分发，还需要同步维护你自己的Releases、镜像与文档页

重要

本项目仅供个人学习使用，不保证稳定性，且不提供任何技术支持
使用者必须在遵循 OpenAI 的使用条款以及法律法规的情况下使用，不得用于非法用途
根据《生成式人工智能服务管理暂行办法》的要求，请勿对中国地区公众提供一切未经备案的生成式人工智能服务

🧩 支线注释

部署此分支

如果你想直接部署这个二级开发仓库，而不是从上游仓库开始，请使用：

git clone https://github.com/xiaoer0215/Newapi-2.gitcd Newapi-2

注释：
官方仓库、映像和文档链接保存在下方，供上游参考和兼容性说明使用
如果你想通过这个分支完全分发，还应维护自己的发布、映像注册表、变更日志和文档主页

当前该仓库中整理的自定义添加

监控增强：增加了组监控和模型监控功能，提升了对状态、成功率和失败次数的可视化
用户和管理员界面调整：自定义登录/注册、模型市场、代币页面及相关交互
模型市场归因：模型市场页面由One-Hub模拟
用户端AI图像生成：包括由现场工作流程和平衡计费支持的基本AI图像生成条目
可自定义数据仪表盘：仪表盘模块可根据需要安排，并可额外为QQ组、支持联系人或类似用例设置两个二维码槽
个人速率限制：支持按分钟、小时和天数为每个用户设置请求限制
钱包和订阅管理：增加了可视化钱包折扣和奖金积分，以及按用户订阅详情管理订阅实例
兑换码与自动配送：兑换码可与关联用户一起搜索，自动配送支持商品列表以及卡片秘密导入和销售
日志和主页覆盖：支持请求日志、错误日志和使用/计费日志，修复自定义HTML主页覆盖无法完全覆盖导航栏和页脚的问题; 版权仍需保留new-api
账单查询改进：支持通过用户名或付款编号搜索支付记录，并取消了原始的订单编号显示逻辑

🧩 二开版本补充说明

当前仓库部署入口

如果你希望直接使用当前二开仓库，而不是从上游仓库开始，请优先使用下面的仓库地址：

git clone https://github.com/xiaoer0215/Newapi-2.gitcd Newapi-2

说明：
当前文档中保留的官方链接用于保留上游引用与能力说明
如果要做到“全部通过你自己的仓库部署”，还建议你补齐自己的二进制发布、Docker 镜像仓库、更新日志和文档首页

当前仓库已整理的二开与定制能力

监控与展示增强：补充了分组监控与相关监控展示能力，支持不同时间窗口查看状态、失败次数、成功率等信息
数据看板定制：首页 / 数据看板支持按需要配置展示版块，并可额外放置最多两个联系二维码面板，可用于 QQ 群、客服微信等场景
前台与管理端 UI 调整：登录注册、模型广场、令牌管理、钱包管理等页面做了二开风格的界面与交互调整
用户端 AI 生图：新增独立 AI 生图入口，可按后台绘图分组自动识别模型，为用户自动创建生图专用令牌，并直接走站内余额结算
邀请奖励与审核风控：支持首次邀请奖励、首充达标奖励、后台人工审核、驳回理由、邀请余额发放，以及同 IP / 设备指纹 / 支付账户排查
签到与请求控制：在原有签到基础上增加 Turnstile、人机校验、同 IP 每日限制，以及 VPN / 代理 / 机房 / 住宅代理 IP 检测;同时支持用户个人限速，按分钟 / 小时 / 天设置请求上限
钱包、支付与账单：钱包管理界面支持折扣、赠送额度、到账额度等可视化展示，并支持钱包 / 订阅扣费偏好切换；充值账单侧支持按用户名或支付号检索记录
订阅与运营能力：补充订阅套餐、用户订阅实例管理、补时 / 赠送 / 作废等操作；兑换码支持后台搜索管理；自动发货支持商品上架、卡密导入与售卖
日志与首页覆盖能力：支持启用额度消费日志、请求错误日志等记录;首页与页脚支持 HTML / Markdown / iframe 方式自定义覆盖，适合完整替换首页展示，但仍需保留项目版权信息

🤝 我们信任的合作伙伴

排名不分先后

🙏 特别鸣谢

感谢 JetBrains 为本项目提供免费的开源开发许可证

🚀 快速开始

使用 Docker Compose（推荐）

# 克隆项目git clone https://github.com/QuantumNous/new-api.gitcd new-api# 编辑 docker-compose.yml 配置nano docker-compose.yml# 启动服务docker-compose up -d

使用 Docker 命令

# 拉取最新镜像docker pull calciumion/new-api:latest# 使用 SQLite（默认）docker run --name new-api -d --restart always \
  -p 3000:3000 \
  -e TZ=Asia/Shanghai \
  -v ./data:/data \
  calciumion/new-api:latest# 使用 MySQLdocker run --name new-api -d --restart always \
  -p 3000:3000 \
  -e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi" \
  -e TZ=Asia/Shanghai \
  -v ./data:/data \
  calciumion/new-api:latest

💡 提示：会将数据保存在当前目录的文件夹中，你也可以改为绝对路径如-v ./data:/datadata-v /your/custom/path:/data

🎉 部署完成后，访问即可使用！http://localhost:3000

📖 更多部署方式请参考部署指南

📚 文档

📖 官方文档 |

快速导航：

分类	链接
🚀 部署指南	安装文档
⚙️ 环境配置	环境变量
📡 接口文档	API 文档
❓ 常见问题	常见问题
💬 社区交流	交流渠道

✨ 主要特性

详细特性请参考特性说明

🎨 核心功能

特性	说明
🎨 全新用户界面	现代化的用户界面设计
🌍 多语言	支持中文、英文、法语、日语
🔄 数据兼容	完全兼容原版 One API 数据库
📈 数据看板	可视化控制台与统计分析
🔒 权限管理	令牌分组、模型限制、用户管理

💰 支付与计费

✅ 在线充值（易支付、Stripe）
✅ 模型按次数收费
✅ 缓存计费支持（OpenAI、Azure、DeepSeek、Claude、Qwen等所有支持的模型）
✅ 灵活的计费策略配置

🔐 授权与安全

😈 Discord 授权登录
🤖 LinuxDO 授权登录
📱 Telegram 授权登录
🔑 OIDC 统一认证
🔍 Key 查询使用额度（配合 neko-api-key-tool）

🚀 高级功能

API 格式支持：

⚡ OpenAI的回应
⚡ OpenAI Realtime API（含 Azure）
⚡ 克劳德·梅斯
⚡ 谷歌Gemini
🔄 Rerank 模型（Cohere、Jina）

智能路由：

⚖️ 渠道加权随机
🔄 失败自动重试
🚦 用户级别模型限流

格式转换：

🔄 OpenAI 兼容 ⇄ Claude 消息
🔄 OpenAI 兼容 → Google Gemini
🔄 Google Gemini → OpenAI 兼容 - 仅支持文本，暂不支持函数调用
🚧 OpenAI 兼容 ⇄ OpenAI Responses - 开发中
🔄 思考转内容功能

推理努力支持：

查看详细配置

OpenAI 系列模型：

o3-mini-high- 高推理努力
o3-mini-medium- 中等推理努力
o3-mini-low- 推理努力低
gpt-5-high- 高推理努力
gpt-5-medium- 中等推理努力
gpt-5-low- 推理努力低

Claude 思考模型：

claude-3-7-sonnet-20250219-thinking- 启用思考模式

谷歌 Gemini 系列模型：

gemini-2.5-flash-thinking- 启用思考模式
gemini-2.5-flash-nothinking- 禁用思考模式
gemini-2.5-pro-thinking- 启用思考模式
gemini-2.5-pro-thinking-128- 启用思考模式，并设置思考预算为128tokens
也可以直接在 Gemini 模型名称后追加 / / 来控制思考力度（无需再设置思考预算后缀）-low-medium-high

🤖 模型支持

详情请参考接口文档 - 中继接口

模型类型	说明	文档
🤖 OpenAI 兼容	OpenAI 兼容模型	文档
🤖 OpenAI的回应	OpenAI Responses 格式	文档
🎨 中途-代理	Midjourney-Proxy（Plus）	文档
🎵 Suno-API	Suno API	文档
🔄 晋升	Cohere、Jina	文档
💬 克洛德	消息格式	文档
🌐 双子座	Google Gemini 格式	文档
🔧 Dify	ChatFlow 模式	-
🎯 自定义	支持完整调用地址	-

📡 支持的接口

查看完整接口列表

🚢 部署

提示

最新版 Docker 镜像： calciumion/new-api:latest

📋 部署要求

组件	要求
本地数据库	SQLite（Docker 需挂载目录）`/data`
远程数据库	MySQL ≥ 5.7.8 或 PostgreSQL ≥ 9.6
容器引擎	Docker / Docker 组合

⚙️ 环境变量配置

常用环境变量配置

变量名	说明	默认值
`SESSION_SECRET`	会话密钥（多机部署必须）	-
`CRYPTO_SECRET`	加密密钥（Redis 必须）	-
`SQL_DSN`	数据库连接字符串	-
`REDIS_CONN_STRING`	Redis 连接字符串	-
`STREAMING_TIMEOUT`	流式超时时间（秒）	`300`
`STREAM_SCANNER_MAX_BUFFER_MB`	流式扫描器单行最大缓冲（MB），图像生成等超大片段（如 4K 图片 base64）需适当调大`data:`	`64`
`MAX_REQUEST_BODY_MB`	请求体最大大小（MB，解压后计;防止超大请求/zip bomb 导致内存暴涨），超过将返回`413`	`32`
`AZURE_DEFAULT_API_VERSION`	Azure API 版本	`2025-04-01-preview`
`ERROR_LOG_ENABLED`	错误日志开关	`false`
`PYROSCOPE_URL`	Pyroscope 服务地址	-
`PYROSCOPE_APP_NAME`	Pyroscope 应用名	`new-api`
`PYROSCOPE_BASIC_AUTH_USER`	Pyroscope Basic Auth 用户名	-
`PYROSCOPE_BASIC_AUTH_PASSWORD`	Pyroscope Basic Auth 密码	-
`PYROSCOPE_MUTEX_RATE`	Pyroscope mutex 采样率	`5`
`PYROSCOPE_BLOCK_RATE`	Pyroscope 块采样率	`5`
`HOSTNAME`	Pyroscope 标签里的主机名	`new-api`

📖 完整配置：环境变量文档

🔧 部署方式

方式 1：Docker Compose（推荐）

# 克隆项目git clone https://github.com/QuantumNous/new-api.gitcd new-api# 编辑配置nano docker-compose.yml# 启动服务docker-compose up -d

方式 2：Docker 命令

使用 SQLite：

docker run --name new-api -d --restart always \
  -p 3000:3000 \
  -e TZ=Asia/Shanghai \
  -v ./data:/data \
  calciumion/new-api:latest

使用 MySQL：

docker run --name new-api -d --restart always \
  -p 3000:3000 \
  -e SQL_DSN="root:123456@tcp(localhost:3306)/oneapi" \
  -e TZ=Asia/Shanghai \
  -v ./data:/data \
  calciumion/new-api:latest

💡 路径说明：
./data:/data- 相对路径，数据保存在当前目录的 data 文件夹
也可使用绝对路径，如：/your/custom/path:/data

方式 3：宝塔面板

安装宝塔面板（≥ 9.2.0 版本）
在应用商店搜索 New-API
一键安装

📖 图文教程

⚠️多机部署注意事项

警告

必须设置 - 否则登录状态不一致SESSION_SECRET
公用 Redis 必须设置 - 否则数据无法解密CRYPTO_SECRET

🔄 渠道重试与缓存

重试配置： 设置 → 运营设置 → 通用设置 → 失败重试次数

缓存配置：

REDIS_CONN_STRING：Redis 缓存（推荐）
MEMORY_CACHE_ENABLED：内存缓存

🔗 相关项目

上游项目

项目	说明
一个API	原版项目基础
中途-代理	Midjourney 接口支持

配套工具

项目	说明
neko-api-key-tool	Key 额度查询工具
新API-地平线	新API 高性能优化版

💬 帮助支持

📖 文档资源

资源	链接
📘 常见问题	常见问题
💬 社区交流	交流渠道
🐛 反馈问题	问题反馈
📚 完整文档	官方文档

🤝 贡献指南

欢迎各种形式的贡献！

🐛 报告 Bug
💡 提出新功能
📝 改进文档
🔧 提交代码

📜 许可证

本项目采用 GNU Affero 通用公共许可证 v3.0 （AGPLv3）授权。

本项目为开源项目，在 One API（MIT 许可证）的基础上进行二次开发。

如果您所在的组织政策不允许使用 AGPLv3 许可的软件，或您希望规避 AGPLv3 的开源义务，请发送邮件至：support@quantumnous.com

从零搭建Go语言开发环境

Thu, 26 Mar 2026 10:49:06 +0800

下载

Go官网下载地址：https://golang.org/dl/

Go官方镜像站（推荐）：https://golang.google.cn/dl/

#2 安装

#2.1 双击下载好的文件go1.13.4.windows-amd64.msi

#2.2 一直点击下一步即可安装成功

#2.3 建议把go语言安装在每个盘的根目录下：如 E:/go

#3 验证是否安装成功

#3.1 打开命令提示符输入go version回车

#4 配置环境变量GOPATH和GOROOT

#GOROOT:go安装的根目录，如E:/go

#GOPATH:项目开发文件夹目录，如D:/go_project

#5 Go开发编辑器Goland安装

#5.1 下载地址 https://www.jetbrains.com/go/

#5.2 一直点击下一步即可安装成功

#5.3 激活Goland 2019.2

激活教程：https://www.cnblogs.com/ltt2017/p/11356351.html

#6 Go开发GOPATH目录结构说明

在进行Go语言开发的时候，我们的代码总是会保存在$GOPATH/src目录下。在工程经过go build、go install或go get等指令后，会将下载的第三方包源代码文件放在$GOPATH/src目录下，产生的二进制可执行文件放在 $GOPATH/bin目录下，生成的中间缓存文件会被保存在 $GOPATH/pkg 下。

如果我们使用版本管理工具（Version Control System，VCS。常用如Git）来管理我们的项目代码时，我们只需要添加$GOPATH/src目录的源代码即可。bin 和 pkg 目录的内容无需版本控制。

#7 Go项目结构

#7.1 适合个人开发者

我们知道源代码都是存放在GOPATH的src目录下，那我们可以按照下图来组织我们的代码。

#7.2 目前流行的项目结构

Go语言中也是通过包来组织代码文件，我们可以引用别人的包也可以发布自己的包，但是为了防止不同包的项目名冲突，我们通常使用顶级域名来作为包名的前缀，这样就不担心项目名冲突的问题了。

因为不是每个个人开发者都拥有自己的顶级域名，所以目前流行的方式是使用个人的github用户名来区分不同的包。

#7.3 适合企业开发者

未找到相关的 Issues 进行评论

请联系 @ourlang 初始化创建

我的技术分享

Mon, 16 Mar 2026 16:48:23 +0800

我的技术分享

千里之行,始于足下

Go语言

Wed, 16 Apr 2025 16:48:50 +0800

Go语言

#1 什么是Go语言？

Go语言也称 Golang，兼具效率、性能、安全、健壮等特性。Go语言从底层原生支持并发，无须第三方库、开发者的编程技巧和开发经验就可以轻松搞定写代码更加高效；优化了多处理器系统的应用程序，使其可以媲美C或者C++代码程序的速度。另外，他更加安全的支持并行进程；

Go语言不仅提供了高性能语言，同时让开发更加迅速；

Go语言是一门编译型的系统编程语言，具有静态编译语言的高性能和动态语言的高效开发双重特点。

#2 Go语言特性

#2.1 自动垃圾回收

在Go语言中，系统会自动判断何时需要释放之前分配的内存空间，并在CPU相对空闲时对不使用的内存进行收集。

#2.2 丰富的内置类型

在Go语言中，内置类型包含：整型，浮点型，数组，字符串，字典map，切片slice。因为语言的内置特性，开发者不用添加依赖的包，让代码更简洁。

#2.3 函数多返回值

Go语言是静态开发语言中率先提供多返回值功能的语言。如果开发者只关心函数中的某几个返回值，可以直接使用下划线作为占位符忽略其他不关心的返回值。

#2.4 异常处理

异常处理涉及3个关键字：error、panic和recover。其中error报告程序中的普通错误，panic报告程序中的致命性错误，而recover可以让程序从panic状态中恢复。

#2.5 匿名函数与闭包

匿名函数就是没有定义函数名的一种函数。而在Go语言中，闭包就是匿名函数，它可以通过匿名函数“捕获”和它在同一作用域的其它常量和变量。

#2.6 结构体

结构体是一系列具有相同或不同类型的数据构成的数据集合。例如，可以利用结构体定义一个学生的学号/姓名/性别/年龄等属性。

#2.7 接口

接口是具体描述一系列方法的集合。例如，可以利用接口将一个人的说、唱这些行为集中到一起。

#2.8 并发编程

并发编程，就是在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。如图所示。

Golang从语言级别上对并发提供了支持，goroutine是Go并发设计的核心，而goroutine就是Go语言实现的协程。在Go程序里，只需要在函数调⽤语句前添加关键字“go”，就可创建并发执行单元。

#3 Go语言适合做什么

其实Go语言主要用作服务器端开发，其定位是用来开发“大型软件”的，适合于需要很多程序员一起开发，并且开发周期较长的大型软件和支持云计算的网络服务。

Go语言融合了传统编译型语言的高效性和脚本语言的易用性和富于表达性，不仅提高了项目的开发速度，而且后期维护起来也非常轻松。

鉴于Go语言的特点和设计的初衷，从以下几个方面来分析Go语言擅长的领域：在服务器编程方面，Go语言适合处理日志、数据打包、虚拟机处理、文件系统、分布式系统、数据库代理等；网络编程方面，Go语言广泛应用于 Web 应用、API 应用、下载应用等；此外，Go语言还可用于内存数据库和云平台领域，目前国外很多云平台都是采用 Go 开发。

除了上面介绍到的，Go语言还可以用来开发底层，例如以太坊、超级账本等都是基于Go语言开发的。

而且对于现在比较流行的区块链技术方面，Go语言也是非常受欢迎的，很多基于区块链的 DApps（去中心化应用）和工具都是用的Go语言来实现的。

下面列举了一些基于Go语言开发的优秀开源项目：

云计算基础设施领域,代表项目:docker、kubernetes、etcd、consul、cloudflare CDN、七牛云存储等。
基础软件，代表项目：tidb、influxdb、cockroachdb 等。
微服务，代表项目：go-kit、micro、monzo bank 的 typhon、bilibili 等。
互联网基础设施，代表项目：以太坊、hyperledger 等。

总之，Go语言的优势还是比较多的，比如Go语言的性能非常出色，最关键的是在性能强劲的同时还能像解释型语言一样高效地进行开发。

#4 Go语言和其它编程语言的对比

在软件行业做过一段时间的人都知道，没有万能的编程语言，也没有万能开发框架，更没有万能的解决方案。任何新技术的产生都应该归功于一部分人对老旧技术的强烈不满。Go语言也不例外。比如，C语言的依赖管理、C++ 的垃圾回收、Java 笨重的类型系统和厚重的 Java EE 规范，以及脚本语言（如 PHP、Python 和 Ruby）的性能，这些都是很多开发者社区经常争论和抱怨的问题。 Go语言的优势 Go语言是集多编程范式之大成者，体现了优秀的软件工程思想和原则，其特性可以使开发者快速地开发、测试和部署程序，大大提高了生产效率。下面我们来看看与其他主流语言相比，Go语言具有的优势。

相对于 C/C++ 来讲，Go语言拥有清晰的依赖管理和全自动的垃圾回收机制，因此其代码量大大降低，开发效率大大提高。
相对于 Java 来讲，Go语言拥有简明的类型系统、函数式编程范式和先进的并发编程模型。因此其代码块更小更简洁、可重用性更高，并可在多核计算环境下更快地运行。
对于 PHP 来讲，Go语言更具通用性和规范性。这使得其更适合构建大型的软件，并能够更好地将各个模块组织在一起。在性能方面，PHP 不可与 Go 同日而语。
对于 Python/Ruby 来讲，Go 的优势在于其简洁的语法、非侵入式和扁平化的类型系统和浑然天成的多范式编程模型。与 PHP 一样，Python 和 Ruby 也是动态类型的解释型语言，这就意味着它们的运行速度会比静态类型的编译型语言慢很多。

总而言之，Go语言对于当前大多数主流语言来讲，最大的优势在于具有较高的生产效率、先进的依赖管理和类型系统，以及原生的并发计算支持。因此，Go语言自发布以来就受到了各个领域开发者的关注和青睐。 Go语言的劣势下面，我们来客观地看一下目前Go语言需要加强或改进的地方（虽然有些 Gopher 并不这么认为）。

从分布式计算的角度来看，Go语言的成熟度不及 Erlang（现在已经出现了一些这方面的Go语言代码包，我们已经可以看到光明的未来了）。
从程序运行速度的角度来看，Go语言虽然已与 Java 不相上下，但还不及 C（差距正在不断地缩小）。
从第三方库的角度来看，Go语言的库数量还远远不及其他几门主流语言（比如 Java、Python、Ruby 等）。不过与Go语言的年纪相比，用它实现的第三方库已经相当多了，并且它们的数量在持续地飞速增长中。

另外，在更深的层面，Go语言标准库中也有些不尽如人意的的地方。具体如下。

从语言语法角度来看，Go语言语法里的语法糖并不多，这让许多 Python、Ruby 爱好者们对它不屑一顾。另外，变量赋值方式多得有点儿累赘了。最让人遗憾的也是我比较在意的一个地方是，Go语言不支持自定义的泛型类型。
从并发编程角度来看，Go语言提供的并发模型很强大，但也有一些编写规则需要了解。否则，很容易踩进“坑”里。其实不提倡把这叫作“坑”。因为这些所谓的“坑”，大都是我们由于对原理不熟悉而自己挖出来的。
从垃圾回收角度看，Go语言的垃圾回收采用的是并发的标记清除算法（Concurrent Mark and Sweep，CMS）。虽然是并发的操作，时间比串行操作短很多，但是还是会在垃圾回收期间停止所有用户程序的操作。这一点多少会影响到对实时性要求比较高的应用。不过，在Go语言 1.3 之后的版本中，这方面的问题已经得到了极大的改善。

虽然Go语言还有一些瑕疵，但从整体来看，它已经是一门非常优秀的通用编程语言了。并且，Go语言在今后的发展上会关注性能、可靠性、可移植性和一些功能增强，所以上述缺憾会随着版本的推进而逐渐减弱和消失。