référence / alias de variable javascript

Est-il possible en javascript d'attribuer un alias / une référence à une variable locale?

Je veux dire quelque chose du genre C:

function foo() {
  var x = 1;
  var y = &x;
  y++;
  alert(x); // prints 2 
}

= MODIFIER =

Est-il possible d'aliaser arguments.callee dans ce code?:

function foo() {
  arguments.callee.myStaticVar = arguments.callee.myStaticVar || 0;
  arguments.callee.myStaticVar++;
  return arguments.callee.myStaticVar;
}

En JavaScript, les types primitifs tels que les entiers et les chaînes sont passés par valeur tandis que les objets sont passés par référence. Donc, pour y parvenir, vous devez utiliser un objet:

// declare an object with property x
var obj = { x: 1 };
var aliasToObj = obj;
aliasToObj.x ++;
alert( obj.x ); // displays 2

Dans une certaine mesure, cela est possible, vous pouvez créer un alias vers une variable à l'aide de fermetures:

Function.prototype.toString = function() {
    return this();
}

var x = 1;
var y = function() { return x }
x++;
alert(y); // prints 2, no need for () because of toString redefinition 

La possibilité de créer un alias dépend du type de données. Les objets, tableaux et fonctions seront gérés par référence et l'alias est possible. Les autres types sont essentiellement atomiques et la variable stocke la valeur plutôt qu'une référence à une valeur.

arguments.callee est une fonction, et vous pouvez donc y faire référence et modifier cet objet partagé.

function foo() {
  var self = arguments.callee;
  self.myStaticVar = self.myStaticVar || 0;
  self.myStaticVar++;
  return self.myStaticVar;
}

Notez que si dans le code ci-dessus vous deviez dire, self = function() {return 42;};alors selfferait référence à un objet différent de arguments.callee, qui reste une référence à foo. Lorsque vous avez un objet composé, l'opérateur d'affectation remplace la référence, il ne modifie pas l'objet référencé. Avec les valeurs atomiques, un cas comme y++est équivalent à y = y + 1, qui assigne un «nouvel» entier à la variable.

modifier à ma réponse précédente: si vous souhaitez compter les appels d'une fonction, vous pouvez essayer:

var countMe = ( function() {
  var c = 0;

  return function() {
    c++;
    return c;
  }
})();

alert(countMe()); // Alerts "1"
alert(countMe()); // Alerts "2"

Ici, c sert de compteur, et vous n'avez pas besoin d'utiliser arguments.callee.

En développant le message de user187291 , vous pouvez également utiliser des getters / setters pour éviter d'utiliser des fonctions.

var x = 1;
var ref = {
    get x()  { return x; },
    set x(v) { x = v; }
};
(ref.x)++;
console.log(x); // prints '2'
x--;
console.log(ref.x); // prints '1'

en 2019, j'ai besoin d'écrire des plugins jquery minifiés, donc j'en ai besoin aussi cet alias et donc en testant ces exemples et d'autres, à partir d'autres sources, j'ai trouvé un moyen sans copie dans la mémoire de l'objet entier, mais en ne créant qu'une référence. J'ai déjà testé cela avec Firefox et en regardant la mémoire des onglets du gestionnaire de tâches sur Firefox avant. Le code est:

var {p: d} ={p: document};
console.log(d.body);