what
1f25425762
borrow（池化）、ensure（实例）、borrowStatic（静态）各自写了一遍「取作用域 →
拼 extra → 建 Runtime → load」。borrowStatic 甚至把 newVM 逐行抄了一遍，只为把
noInstance 传成 true。
结果就是规则会漏：上一个 commit 修的「borrowStatic 没标 scoped」正是这么来的。
现在三条都走 newVM，作用域注入和 scoped 标记只有一份。
顺带删掉两处无意义的间接：
loadInto s.load(ctx, rt, ctorArgs, false) 的单行包装，只被 newVM 调一次
newRuntime 它的 scope 参数两个调用点都传 s.name，而注释描述的「会话 VM 用
会话 key」这条路径根本没实现（作用域 key 走的是 vmGlobals）。
参数名还跟同包的 type scope struct 撞名
**scope 是显式参数，不是从 ctx 嗅的**——这一点差点被我改坏：Instance 重建 VM
时要回到它**创建时**那个作用域，而不是当次调用 ctx 里的。对一个作用域实例调
Call(context.Background()) 不该把它的扩展弄丢。加了
TestScope_实例重建VM后仍在原作用域 守这条，用超时逼出 VM 重建（第一版用抛异常，
那不会丢 VM，两种写法都通过，等于没测）。
86 lines
3.4 KiB
Go
86 lines
3.4 KiB
Go
package jscriptx
|
||
|
||
import "context"
|
||
|
||
// CallStatic 调用脚本导出的 class 上的**静态方法**。
|
||
//
|
||
// export default class PkgImportController {
|
||
// static Startup() { store.Set("pkg.registry", "https://…") }
|
||
// Execute(g) { … }
|
||
// }
|
||
//
|
||
// _, err := script.CallStatic(ctx, "Startup")
|
||
//
|
||
// 它跟 Call 有两点不同，都是"静态"这个语义要求的：
|
||
//
|
||
// - **不构造实例**：constructor 不会跑。构造函数做的是"这一次调用的准备"，
|
||
// 跟脚本级的初始化无关，跑它只会白费一遍还可能有副作用。
|
||
// - **VM 用完就丢**，不回池。静态方法一般只在脚本生命周期里跑一两次，
|
||
// 为它留一个 VM 不划算；而且它做的事通常是往 Go 侧扩展里写东西，
|
||
// 那些副作用留在 Go 那边，VM 本身没有保留的价值。
|
||
//
|
||
// 脚本没写这个静态方法时返回的错误可以被 errors.Is(err, ErrFuncNotFound) 匹配上
|
||
// ——生命周期钩子多半是可选的，用它来区分"没写"和"写了但炸了"：
|
||
//
|
||
// if _, err := script.CallStatic(ctx, "Startup"); err != nil &&
|
||
// !errors.Is(err, ErrFuncNotFound) {
|
||
// return err // 真的出错了
|
||
// }
|
||
//
|
||
// 静态方法里能用 ctx 带进来的作用域扩展（WithScope），这正是它的用武之地：
|
||
// 把配置写进 store、往 Go 侧注册东西。但**它建的 JS 对象活不下来**——
|
||
// VM 一丢就没了，别指望后续调用能看到。
|
||
func (s *Script) CallStatic(ctx context.Context, fn string, args ...any) (any, error) {
|
||
if fn == DefaultFunc {
|
||
return nil, newError(KindNotFound, s.name, fn, ErrFuncNotFound,
|
||
"CallStatic 要给一个静态方法名")
|
||
}
|
||
return callAny(ctx, staticTarget{s}, fn, args)
|
||
}
|
||
|
||
// HasStatic 判断脚本导出的 class 上有没有这个静态方法。
|
||
//
|
||
// 它要建一个 VM 才能回答，所以别在热路径上反复调；只想"有就调"的话，
|
||
// 直接 CallStatic 然后判 ErrFuncNotFound 更省。
|
||
func (s *Script) HasStatic(fn string) bool {
|
||
if fn == DefaultFunc {
|
||
return false
|
||
}
|
||
vm, err := s.borrowStatic(context.Background())
|
||
if err != nil {
|
||
return false
|
||
}
|
||
// 建了 VM 就得记一笔丢弃，走跟 CallStatic 同一套记账。漏掉的话每调一次
|
||
// Stats().Created - Dropped 就永久 +1
|
||
defer staticTarget{s}.finish(vm, true)
|
||
|
||
// ctor != nil 排除 lookup 的全局兜底分支：静态方法必须挂在 class 上，
|
||
// 脚本导出的不是 class 时 lookup 可能在全局里找到同名函数
|
||
_, _, _, ok := vm.lookup(fn)
|
||
return ok && vm.ctor != nil
|
||
}
|
||
|
||
// staticTarget 让静态调用复用 invoke 那一整套（超时中断、panic 恢复、错误分类），
|
||
// 只是换一种取 VM 的方式：不构造实例，用完丢弃。
|
||
type staticTarget struct{ s *Script }
|
||
|
||
func (t staticTarget) owner() *Script { return t.s }
|
||
|
||
func (t staticTarget) acquire(ctx context.Context) (*vmHandle, error) {
|
||
return t.s.borrowStatic(ctx)
|
||
}
|
||
|
||
// finish 直接丢弃，不回池——见 CallStatic 的说明。
|
||
func (t staticTarget) finish(*vmHandle, bool) { t.s.dropped.Add(1) }
|
||
|
||
// borrowStatic 造一个只装了 class、没有实例的 VM。
|
||
func (s *Script) borrowStatic(ctx context.Context) (*vmHandle, error) {
|
||
if s.closed.Load() {
|
||
return nil, newError(KindClosed, s.name, "", ErrClosed, "脚本已关闭")
|
||
}
|
||
|
||
sc, _ := scopeOf(ctx)
|
||
// noInstance：静态方法挂在 class 上，不用白跑一遍 constructor
|
||
return s.newVM(ctx, sc, nil, true)
|
||
}
|