Différences de comportement des fonctions Javascript redéfinies en interne

Question

Pendant que je faisais de l'ingénierie inverse du code JavaScript, je suis tombé sur cette fonction :

function fun1() {
    const arr = ["a", "b", "c", "d", "e"];
    fun1 = function () {
        return arr;
    };
    return fun1();
}

Pour moi, cela semble redondant. Le code semble être :

1. Déclarez un tableau arr.
2. Redéfinissez la fonction à l'intérieur de la fonction pour qu'elle renvoie arr.
3. L'utilisation de return fun1() pour renvoyer le résultat de la fonction elle-même est maintenant redéfinie pour renvoyer return fun1() 返回函数本身的结果，现在被重新定义为返回 arr，所以似乎返回 arr, elle semble donc renvoyer
.

J'ai donc réécrit la fonction pour éliminer tout code redondant :

function fun2() {
    const arr = ["a", "b", "c", "d", "e"];
    return arr;
}

Cependant, J'ai été surpris de constater que ces deux fonctions se comportent complètement différemment

.

fun1() 似乎返回对 arr 的引用，而 fun2() 似乎返回 arrfun1() semble renvoyer une référence à

, tandis que fun2() semble renvoyer une copie de

.

Voici un exemple minimal reproductible qui illustre la différence :

// This function is redefined inside itself to return arr
function fun1() {
  const arr = ["a", "b", "c", "d", "e"];
  fun1 = function() {
    return arr;
  };
  return fun1();
}

// Why not return arr directly?
function fun2() {
  const arr = ["a", "b", "c", "d", "e"];
  return arr;
}

// But the result is different...
let test_fun_1 = fun1();

test_fun_1.pop();

test_fun_1 = fun1();

console.log("Logging test_fun_1");

console.log(test_fun_1); // ["a", "b", "c", "d"]

let test_fun_2 = fun2();

test_fun_2.pop();

test_fun_2 = fun2();

console.log("Logging test_fun_2");

console.log(test_fun_2); // ["a", "b", "c", "d", "e"]

// What is this magic?

On dirait que la magie s'est produite...

Quelle est la différence entre fun1() 和 fun2()

? 🎜🎜

Answer 1

Le tableau créé lorsque votre fun1()函数重新定义了（相对）全局的fun1符号。它将原始函数更改为局部内部函数，该函数封闭了数组。因此，只涉及一个数组，即第一次调用fun1() est appelé pour la première fois.

Votre fun2(), quant à lui, crée un tout nouveau tableau à chaque appel.

Si vous modifiez fun1() pour que la fonction interne soit affectée à une variable déclarée localement fun1, cela fonctionnera de la même manière que fun1()，以便将内部函数分配给一个在本地声明的fun1变量，它将与fun2() même.