如何在JavaScript中模拟指针？

Question

我正在创建一种可编译为 Swift、Rust 和 JavaScript 的语言（或者至少在尝试）。 Rust 和 Swift 都使用指针/引用/解除引用等，而 JavaScript 则不使用。因此，在类似 Rust 的语言中，您可能会这样做：

fn update(x) {
  *x++
}

fn main() {
  let i = 0
  update(&i)
  log(i) #=> 1
}

在类似 JavaScript 的语言中，如果您这样做，那么它将失败：

function update(x) {
  x++
}

function main() {
  let i = 0
  update(i)
  log(i) #=> 0
}

因为值在传入时被克隆（正如我们显然知道的那样）。

所以我首先考虑的是这样做：

function update(scopeWithI) {
  scopeWithI.i++
}

function main() {
  let i = 0
  let scopeWithI = { i }
  update(scopeWithI)
  i = scopeWithI.i
  log(i) #=> 1
}

但这需要进行大量额外的处理，而且似乎没有必要。相反，我可能会尝试编译为：

function update(scopeWithI) {
  scopeWithI.i++
}

function main() {
  let scope = {}
  scope.i = 0
  update(scope)
  log(scope.i) #=> 1
}

这意味着您创建的每个嵌套作用域，您都必须开始手动创建/管理作用域链。实际上这是行不通的，因为 update 被硬编码为 i。因此，您可能必须传入您想要的变量名称。

function update(scope, ...names) {
  scope[names[0]]++
}

但接下来的情况就像是：

function update(scope, ...names) {
  scope[names[0]]++
}

function main() {
  let scope = {}
  scope.i = 0
  if random() > 0.5
    let childScope = { scope }
    childScope.x = 0
    update(childScope, ['i'])
    update(childScope, ['x'])
    update(childScope, ['x'])
    log(childScope.x) #=> 2
  else
    update(childScope, ['i'])

  log(scope.i) #=> 1
}

看来这可能会让我们到达某个地方。

所以，通用的解决方案是将作用域作为函数的第一个参数。

function add(scope, name1, name2) {
  return scope[name1] + scope[name2]
}

解除引用意味着直接从作用域读取值，而传递引用（如 Rust 或 C 中的 &name）则意味着传递作用域和名称。

这样的事情会起作用吗？或者更准确地说，需要更改或添加什么？它需要变得比这更复杂吗？

我想尝试找到一种方法将面向指针的代码转换为JavaScript（转译），而不是首先尝试找出看起来不那么直接的复杂得多的方法，并通过重新定义a来避免JavaScript中的指针模拟很多方法。似乎避免在 JavaScript 中使用任何指针会更难弄清楚，所以我试图看看是否可以在 JavaScript 中模拟指针类型的系统。

为了避免指针模拟，您必须重新定义方法。

update(x) {
  *x++
}

必须在各处更改该函数的外部用法。所以这样：

main() {
  let i = 0
  update(&i)
}

会变成：

main() {
  let i = 0
  i++ // inline the thing
}

对于这个简单的情况，这很好，但对于更复杂的函数，它开始看起来像宏，并且可能会变得复杂。

因此，我们没有改变外部用法，而是让您必须传递范围。

另一种方法可能是让每个变量都是一个具有值的对象，所以它更像是：

update(x) {
  x.value++
}

main() {
  let i = { value: 0 }
  update(i)
}

那么我自己在想，如何处理对引用的引用呢？

update2(x) {
  update(&x)
}

update(x) {
  *x++
}

main() {
  let i = 0
  update2(&i)
}

在我描述的系统中，这将是这样的：

update2(x) {
  // then what?
  let y = { value: x }
  update(y)
}

update(x) {
  // like this?
  x.value.value++
}

main() {
  let i = { value: 0 }
  update2(i)
}

所以看来这实际上行不通。

Answer 1

不用说，JavaScript 确实不有通过引用传递参数的通用机制。

“引用”一词可能会产生一些混淆，因为在 JavaScript 中，人们可以将对象传递给函数——它们是引用——但这是一种按值调用机制。引用调用实际上意味着参数变量是调用者变量的别名，因此为该别名赋值相当于为调用者变量赋值。除了一些非常特殊的情况（例如 <非严格模式下的 code>arguments 奇异对象，或 export 机制，或带有 var 链接window 对象，这些都不能以最佳实践方式帮助您解决您的情况），JavaScript 中没有这样的变量别名机制。

下面是一个关于如何在非严格模式下在浏览器上下文中“利用”var 效果的示例：

function modify(ref) {
    // Using the fact that global `var` variables are aliases
    //  for properties on the global object
    // (This is not considered good practice)
    globalThis[ref] = globalThis[ref] + 1;
}

var a = 1;
modify("a"); // We pass a reference to `a`
console.log(a);

简而言之，除了旧 JavaScript 语言中的一些糟糕设计（草率模式）之外，这在一般 JavaScript 中是不可能的。所有有效的尝试都是通过设置给定对象的属性之一来对给定对象执行突变。您不能希望有一个函数可以将参数变量分配给参数变量，从而修改调用者的变量。这是不可能的——按照设计。请注意赋值和变异之间的重要区别。

如果调用者的变量（不是属性）需要分配一个新值（不仅仅是突变，而是真正的赋值），那么该赋值必须 > 发生在那个变量上——函数无法为调用者做的事情。

因此，在 JavaScript 中执行此类赋值的方法是让函数返回调用者需要重新赋值的任何内容，并且执行该赋值仍然是调用者的责任：

function modify(value) {
    return 3;
}

let value = 1;
value = modify(value);
console.log(value);

当涉及多个变量时，让函数返回一个“打包”对象，调用者可以将其解构回自己的变量：

function modify(a, b) {
    return [a + 1, b * 2];
}

let a = 1, b = 2;
[a, b] = modify(a, b);
console.log(a, b);

Answer 2

JavaScript 对象是“通过引用”传递的：

const obj = {
  hello: "world"
};

console.log(obj.hello); // "world"
f(obj);
console.log(obj.hello); // "bob"

function f(s) {
  s.hello = "bob";
}

因此，如果您想要像 C、Rust 或 Swift 这样的“引用”，请将所有内容放入对象中。考虑一下

fn update(x) {
  x++
}

fn main() {
  let i = 0
  update(&i)
  log(i) #=> 1
}

在 JavaScript 中它会是：

function update(obj) {
  obj.x++
}

const i = { x: 0 };
update(i);
console.log(i.x); // 1

Answer 3

这有效还是我误解了？

update2(x) {
  update(x)
}

update(x) {
  x.value++
}

main() {
  let i = { value: 0 }
  update2(i)
}