referência / alias de variável javascript

É possível em javascript atribuir um alias / referência a um var local de alguma forma?

Quero dizer algo como C:

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

= EDITAR =

É possível criar um alias para argumentos.callee neste código ?:

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

Em JavaScript, os tipos primitivos, como inteiros e strings, são passados ​​por valor, enquanto os objetos são passados ​​por referência. Portanto, para conseguir isso, você precisa usar um objeto:

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

Até certo ponto, isso é possível, você pode criar um alias para uma variável usando fechamentos:

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 

Se você pode criar um alias para algo, depende do tipo de dados. Objetos, matrizes e funções serão tratados por referência e o aliasing é possível. Outros tipos são essencialmente atômicos e a variável armazena o valor em vez de uma referência a um valor.

argumentos.callee é uma função e, portanto, você pode ter uma referência a ela e modificar esse objeto compartilhado.

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

Observe que se no código acima você dissesse, self = function() {return 42;};então selfse referiria a um objeto diferente de arguments.callee, que permanece uma referência ao foo. Quando você tem um objeto composto, o operador de atribuição substitui a referência, ele não altera o objeto referido. Com valores atômicos, um caso como y++é equivalente a y = y + 1, que atribui um 'novo' inteiro à variável.

edite a minha resposta anterior: se quiser contar as invocações de uma função, você pode tentar:

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

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

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

Aqui, c serve como contador e você não precisa usar argumentos.callee.

Expandindo a postagem do user187291 , você também pode usar getters / setters para evitar o uso de funções.

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'

em 2019 preciso escrever plugins jquery minificados então preciso também desse alias e então testando esses exemplos e outros, de outras fontes, encontrei um jeito sem copiar na memória do objeto inteiro, mas criando apenas uma referência. Eu testei isso já com o firefox e observando a memória da guia do gerenciador de tarefas no firefox antes. O código é:

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