retorno - variavel global javascript




Qual é o escopo das variáveis em JavaScript? (18)

JavaScript da velha escola

Tradicionalmente, o JavaScript realmente possui apenas dois tipos de escopo:

  1. Escopo global : Variáveis ​​são conhecidas em todo o aplicativo, desde o início do aplicativo (*)
  2. Escopo Funcional : Variáveis ​​são conhecidas dentro da função em que são declaradas, desde o início da função (*)

Não vou elaborar sobre isso, já que já existem muitas outras respostas explicando a diferença.

JavaScript moderno

As especificações mais recentes do JavaScript agora também permitem um terceiro escopo:

  1. Escopo do Bloco : Variáveis ​​são conhecidas dentro do bloco em que são declaradas, a partir do momento em que são declaradas (**)

Como faço para criar variáveis ​​de escopo de bloco?

Tradicionalmente, você cria suas variáveis ​​assim:

var myVariable = "Some text";

Variáveis ​​de escopo de bloco são criadas assim:

let myVariable = "Some text";

Então, qual é a diferença entre escopo funcional e escopo de bloco?

Para entender a diferença entre o escopo funcional e o escopo de bloco, considere o seguinte código:

// i IS NOT known here
// j IS NOT known here
// k IS known here, but undefined
// l IS NOT known here

function loop(arr) {
    // i IS known here, but undefined
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( var i = 0; i < arr.length; i++ ) {
        // i IS known here, and has a value
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( let j = 0; j < arr.length; j++ ) {
        // i IS known here, and has a value
        // j IS known here, and has a value
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here
}

loop([1,2,3,4]);

for( var k = 0; k < arr.length; k++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS NOT known here
};

for( let l = 0; l < arr.length; l++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS known here, and has a value
};

loop([1,2,3,4]);

// i IS NOT known here
// j IS NOT known here
// k IS known here, and has a value
// l IS NOT known here

Aqui, podemos ver que nossa variável j só é conhecida no primeiro loop for, mas não antes e depois. No entanto, nossa variável i é conhecida em toda a função.

Além disso, considere que as variáveis ​​do escopo de bloco não são conhecidas antes de serem declaradas, porque não são hasteadas. Você também não tem permissão para redeclarar a mesma variável no escopo de bloco dentro do mesmo bloco. Isso faz com que as variáveis ​​com escopo de bloco sejam menos propensas a erros do que as variáveis ​​com escopo global ou funcional, que são içadas e que não produzem erros no caso de várias declarações.

É seguro usar variáveis ​​de escopo de bloco hoje?

Se é ou não seguro usar hoje, depende do seu ambiente:

  • Se você estiver escrevendo código JavaScript do lado do servidor ( Node.js ), poderá usar com segurança a instrução let .

  • Se você estiver escrevendo código JavaScript do lado do cliente e usar um transpilador (como o Traceur ), poderá usar com segurança a instrução let , no entanto, seu código provavelmente não será o ideal em relação ao desempenho.

  • Se você está escrevendo código JavaScript do lado do cliente e não usa um transpilador, é necessário considerar o suporte ao navegador.

    Hoje, 23 de fevereiro de 2016, esses são alguns navegadores que não oferecem suporte ou apenas suporte parcial:

    • Internet Explorer 10 e abaixo (sem suporte)
    • Firefox 43 e abaixo (sem suporte)
    • Safari 9 e abaixo (sem suporte)
    • Opera Mini 8 e abaixo (sem suporte)
    • Navegador Android 4 e abaixo (sem suporte)
    • Opera 36 e abaixo (suporte parcial)
    • Chome 51 e abaixo (apoio parcial)

Como acompanhar o suporte ao navegador

Para uma visão geral atualizada de quais navegadores suportam a instrução let no momento da leitura desta resposta, veja esta página Can I Use ?

(*) Variáveis ​​com escopo global e funcional podem ser inicializadas e usadas antes de serem declaradas, porque variáveis ​​JavaScript são hoisted . Isso significa que as declarações estão sempre no topo do escopo.

(**) Variáveis ​​com escopo de bloco não são içadas

Qual é o escopo das variáveis ​​no javascript? Eles têm o mesmo escopo dentro do que uma função externa? Ou isso importa mesmo? Além disso, onde as variáveis ​​são armazenadas se forem definidas globalmente?


Js moderno, ES6 +, ' const ' e ' let '

Você deve usar o escopo de bloco para cada variável que você criar, assim como a maioria dos outros idiomas principais. var é obsoleto . Isso torna seu código mais seguro e mais fácil de manter.

const deve ser usado em 95% dos casos . Isso faz com que a referência da variável não possa mudar. Propriedades de matriz, objeto e nó DOM podem ser alteradas e provavelmente devem ser const .

let deve ser usado para qualquer variável que espera ser reatribuída. Isso inclui dentro de um loop for. Se você alterar o valor além da inicialização, use let .

Escopo de bloco significa que a variável só estará disponível dentro dos parênteses em que é declarada. Isso se estende a escopos internos, incluindo funções anônimas criadas dentro do seu escopo.


ES5 e mais cedo:

Variáveis ​​em Javascript foram inicialmente (pré ES6) lexicamente função escopo. O termo com escopo léxico significa que você pode ver o escopo das variáveis ​​"olhando" para o código.

Cada variável declarada com a varpalavra-chave é definida para a função. No entanto, se outras funções forem declaradas dentro dessa função, essas funções terão acesso às variáveis ​​das funções externas. Isso é chamado de cadeia de escopo . Funciona da seguinte maneira:

  1. Quando uma função procura resolver um valor de variável, ele primeiro observa seu próprio escopo. Este é o corpo da função, isto é, tudo entre chaves {} (exceto para variáveis ​​dentro de outras funções que estão neste escopo).
  2. Se não puder encontrar a variável dentro do corpo da função, ela subirá até a cadeia e examinará o escopo da variável na função em que a função foi definida . Isto é o que se entende com o escopo léxico, podemos ver no código onde esta função foi definida e, portanto, pode determinar a cadeia de escopo simplesmente olhando para o código.

Exemplo:

// global scope
var foo = 'global';
var bar = 'global';
var foobar = 'global';

function outerFunc () {
 // outerFunc scope
 var foo = 'outerFunc';
 var foobar = 'outerFunc';
 innerFunc();
 
 function innerFunc(){
 // innerFunc scope
  var foo = 'innerFunc';
  console.log(foo);
  console.log(bar);
  console.log(foobar);
  }
}

outerFunc();

O que acontece quando estamos tentando registrar as variáveis foo, bare foobarpara o console é o seguinte:

  1. Nós tentamos logar foo no console, foo pode ser encontrado dentro da innerFuncprópria função . Portanto, o valor de foo é resolvido para a string innerFunc.
  2. Nós tentamos logar a barra ao console, barra não pode ser encontrada dentro da innerFuncprópria função . Portanto, precisamos subir a cadeia de escopo . Primeiro olhamos para a função externa em que a função innerFuncfoi definida. Esta é a função outerFunc. No escopo outerFunc, podemos encontrar a barra de variáveis, que contém a string 'outerFunc'.
  3. foobar não pode ser encontrado em innerFunc. .Portanto, precisamos escalar a cadeia de escopo para o escopo innerFunc. Também não pode ser encontrado aqui, subimos outro nível para o escopo global (ou seja, o escopo mais externo). Encontramos a variável foobar aqui que contém a string 'global'. Se não tivesse encontrado a variável após subir a cadeia de escopo, o mecanismo JS lançaria um referenceError .

ES6 (ES 2015) e mais antigos:

Os mesmos conceitos de escopo lexical e scopechain ainda se aplicam ES6. No entanto, novas formas de declarar variáveis ​​foram introduzidas. Existem os seguintes:

  • let : cria uma variável com escopo de bloco
  • const : cria uma variável com escopo de bloco que precisa ser inicializada e não pode ser reatribuída

A maior diferença entre vare let/ consté que varé função escopo enquanto let/ constsão blocos de escopo. Aqui está um exemplo para ilustrar isso:

let letVar = 'global';
var varVar = 'global';

function foo () {
  
  if (true) {
    // this variable declared with let is scoped to the if block, block scoped
    let letVar = 5;
    // this variable declared with let is scoped to the function block, function scoped
    var varVar = 10;
  }
  
  console.log(letVar);
  console.log(varVar);
}


foo();

No exemplo acima, letVar registra o valor global porque as variáveis ​​declaradas com letsão de escopo de bloco. Eles deixam de existir fora do respectivo bloco, portanto, a variável não pode ser acessada fora do bloco if.


1) Existe um escopo global, um escopo de função e os escopos with e catch. Não há escopo de nível 'block' em geral para variáveis ​​- as instruções with e catch adicionam nomes a seus blocos.

2) Os escopos são aninhados por funções até o escopo global.

3) As propriedades são resolvidas passando pela cadeia de protótipos. A instrução with traz nomes de propriedades de objetos para o escopo léxico definido pelo bloco with.

EDIT: ECMAAScript 6 (Harmony) é spec'ed para apoiar let, e eu sei que o cromo permite uma bandeira 'harmonia', então talvez ele suporta-lo ..

Let seria um suporte para o escopo do nível de bloco, mas você tem que usar a palavra-chave para fazer isso acontecer.

EDIT: Com base em Benjamin está apontando as declarações with e catch nos comentários, eu editei o post e adicionei mais. Tanto as instruções with como as catch introduzem variáveis ​​em seus respectivos blocos, e isso é um escopo de bloco. Essas variáveis ​​são alias às propriedades dos objetos passados ​​para elas.

 //chrome (v8)

 var a = { 'test1':'test1val' }
 test1   // error not defined
 with (a) { var test1 = 'replaced' }
 test1   // undefined
 a       // a.test1 = 'replaced'

EDIT: esclarecendo exemplo:

test1 é escopo para o bloco com, mas é aliado para a.test1. 'Var test1' cria uma nova variável test1 no contexto léxico superior (função ou global), a menos que seja uma propriedade de - que é.

Yikes! Tenha cuidado ao usar 'with' - assim como var é a noop se a variável já estiver definida na função, também é noop em relação aos nomes importados do objeto! Um pequeno alerta sobre o nome já definido tornaria isso muito mais seguro. Eu pessoalmente nunca vou usar com isso por causa disso.


A ideia de escopo em JavaScript quando originalmente projetado por Brendan Eich veio da linguagem de scripts HyperCard HyperTalk .

Nesta linguagem, as exibições foram feitas de forma semelhante a uma pilha de cartões de índice. Havia um cartão mestre chamado fundo. Era transparente e pode ser visto como o cartão inferior. Qualquer conteúdo deste cartão base foi compartilhado com cartões colocados em cima dele. Cada cartão colocado no topo tinha seu próprio conteúdo, que tinha precedência sobre o cartão anterior, mas ainda tinha acesso aos cartões anteriores, se desejado.

É exatamente assim que o sistema de escopo de JavaScript é projetado. Apenas tem nomes diferentes. Os cartões em JavaScript são conhecidos como Execution Contexts ECMA . Cada um desses contextos contém três partes principais. Um ambiente variável, um ambiente léxico e uma ligação. Voltando à referência das cartas, o ambiente léxico contém todo o conteúdo das cartas anteriores na parte inferior da pilha. O contexto atual está no topo da pilha e qualquer conteúdo declarado lá será armazenado no ambiente variável. O ambiente variável terá precedência no caso de colisões de nomenclatura.

Esta ligação apontará para o objeto contido. Às vezes, os escopos ou contextos de execução mudam sem a alteração do objeto contido, como em uma função declarada em que o objeto contido pode ser uma window ou uma função construtora.

Esses contextos de execução são criados a qualquer momento em que o controle é transferido. O controle é transferido quando o código começa a ser executado, e isso é feito principalmente a partir da execução da função.

Então essa é a explicação técnica. Na prática, é importante lembrar que em JavaScript

  • Os escopos são tecnicamente "contextos de execução"
  • Os contextos formam uma pilha de ambientes onde as variáveis ​​são armazenadas
  • O topo da pilha tem precedência (a parte inferior é o contexto global)
  • Cada função cria um contexto de execução (mas nem sempre uma nova ligação)

Aplicando isto a um dos exemplos anteriores (5. "Encerramento") nesta página, é possível seguir a pilha de contextos de execução. Neste exemplo, existem três contextos na pilha. Eles são definidos pelo contexto externo, pelo contexto na função invocada imediatamente chamada var 6 e pelo contexto na função retornada dentro da função invocada imediatamente do var seis.

i ) O contexto externo. Tem um ambiente variável de a = 1
ii ) O contexto IIFE, ele tem um ambiente léxico de a = 1, mas um ambiente variável de a = 6 que tem precedência na pilha
iii ) O contexto da função retornada, possui um ambiente léxico de a = 6 e esse é o valor referenciado no alerta quando chamado.


Acho que o melhor que posso fazer é dar um monte de exemplos para estudar. Os programadores de JavaScript são praticamente classificados por quão bem eles entendem o escopo. Às vezes pode ser bastante contra-intuitivo.

  1. Uma variável com escopo global

    // global scope
    var a = 1;
    
    function one() {
      alert(a); // alerts '1'
    }
  2. Escopo local

    // global scope
    var a = 1;
    
    function two(a) { // passing (a) makes it local scope
      alert(a); // alerts the given argument, not the global value of '1'
    }
    
    // local scope again
    function three() {
      var a = 3;
      alert(a); // alerts '3'
    }
  3. Intermediário : não existe escopo de bloco em JavaScript (ES5; ES6 introduz let )

    uma.

    var a = 1;
    
    function four() {
      if (true) {
        var a = 4;
      }
    
      alert(a); // alerts '4', not the global value of '1'
    }

    b.

    var a = 1;
    
    function one() {
      if (true) {
        let a = 4;
      }
    
      alert(a); // alerts '1' because the 'let' keyword uses block scoping
    }
  4. Intermediário : propriedades do objeto

    var a = 1;
    
    function Five() {
      this.a = 5;
    }
    
    alert(new Five().a); // alerts '5'
  5. Avançado : fechamento

    var a = 1;
    
    var six = (function() {
      var a = 6;
    
      return function() {
        // JavaScript "closure" means I have access to 'a' in here,
        // because it is defined in the function in which I was defined.
        alert(a); // alerts '6'
      };
    })();
  6. Avançado : resolução de escopo baseada em protótipo

    var a = 1;
    
    function seven() {
      this.a = 7;
    }
    
    // [object].prototype.property loses to
    // [object].property in the lookup chain. For example...
    
    // Won't get reached, because 'a' is set in the constructor above.
    seven.prototype.a = -1;
    
    // Will get reached, even though 'b' is NOT set in the constructor.
    seven.prototype.b = 8;
    
    alert(new seven().a); // alerts '7'
    alert(new seven().b); // alerts '8'
  7. Global + Local : um caso extra-complexo

    var x = 5;
    
    (function () {
        console.log(x);
        var x = 10;
        console.log(x); 
    })();

    Isso imprimirá undefined e 10 vez de 5 e 10 já que o JavaScript sempre move as declarações de variáveis ​​(não as inicializações) para o topo do escopo, tornando o código equivalente a:

    var x = 5;
    
    (function () {
        var x;
        console.log(x);
        x = 10;
        console.log(x); 
    })();
  8. Variável com escopo da cláusula catch

    var e = 5;
    console.log(e);
    try {
        throw 6;
    } catch (e) {
        console.log(e);
    }
    console.log(e);

    Isto irá imprimir 5 , 6 , 5 . Dentro da cláusula catch e sombras variáveis ​​globais e locais. Mas esse escopo especial é apenas para a variável capturada. Se você escrever var f; dentro da cláusula catch, então é exatamente o mesmo que se você tivesse definido antes ou depois do bloco try-catch.


Aqui está um exemplo:

<script>

var globalVariable = 7; //==window.globalVariable

function aGlobal( param ) { //==window.aGlobal(); 
                            //param is only accessible in this function
  var scopedToFunction = {
    //can't be accessed outside of this function

    nested : 3 //accessible by: scopedToFunction.nested
  };

  anotherGlobal = {
    //global because there's no `var`
  }; 

}

</script>

Você vai querer investigar fechamentos e como usá-los para tornar membros privados .


Cada pedaço do código JavaScript (código global ou funções) tem uma cadeia de escopo associada a ele. Essa cadeia de escopo é uma lista ou cadeia de objetos que define as variáveis ​​que estão “no escopo” para esse código. Quando o JavaScript precisa procurar o valor de uma variável x (um processo chamado resolução de variável ), ele começa examinando o primeiro objeto na cadeia. Se esse objeto tiver uma propriedade chamada x , o valor dessa propriedade será usado. Se o primeiro objeto não tiver uma propriedade chamada x , o JavaScript continuará a pesquisa com o próximo objeto na cadeia. Se o segundo objeto não tiver uma propriedade chamada x , a pesquisa será movida para o próximo objeto e assim por diante. Se x não for uma propriedade de qualquer um dos objetos na cadeia de escopo, então x não estará no escopo desse código e ocorrerá um ReferenceError.No código JavaScript de nível superior (isto é, código não contido em qualquer definição de função), a cadeia do escopo consiste em um único objeto, o objeto global. Em uma função não aninhada, a cadeia de escopo consiste em dois objetos. O primeiro é o objeto que define os parâmetros e as variáveis ​​locais da função, e o segundo é o objeto global. Em uma função aninhada, a cadeia de escopo tem três ou mais objetos. É importante entender como essa cadeia de objetos é criada. Quando uma função é DEFINIDA , ela armazena a cadeia de escopo então em vigor. Quando essa função é INVOKED, ele cria um novo objeto para armazenar suas variáveis ​​locais e adiciona esse novo objeto à cadeia de escopo armazenada para criar uma nova cadeia mais longa que representa o escopo para essa chamada de função. Isso se torna mais interessante para funções aninhadas, porque cada vez que a função externa é chamada, a função interna é definida novamente. Como a cadeia de escopo difere em cada invocação da função externa, a função interna será sutilmente diferente a cada vez que é definida - o código da função interna será idêntico em cada invocação da função externa, mas a cadeia de escopos associada a essa função externa código será diferente . Essa noção de uma cadeia de escopo é crucial para entender os encerramentos.


Em "Javascript 1.7" (extensão do Mozilla para Javascript) também é possível declarar variáveis ​​de escopo de bloco com a instrução let :

 var a = 4;
 let (a = 3) {
   alert(a); // 3
 }
 alert(a);   // 4

Existem apenas escopos de função no JS. Não bloqueie escopos! Você pode ver o que está sendo içado também.

var global_variable = "global_variable";
var hoisting_variable = "global_hoist";

// Global variables printed
console.log("global_scope: - global_variable: " + global_variable);
console.log("global_scope: - hoisting_variable: " + hoisting_variable);

if (true) {
    // The variable block will be global, on true condition.
    var block = "block";
}
console.log("global_scope: - block: " + block);

function local_function() {
    var local_variable = "local_variable";
    console.log("local_scope: - local_variable: " + local_variable);
    console.log("local_scope: - global_variable: " + global_variable);
    console.log("local_scope: - block: " + block);
    // The hoisting_variable is undefined at the moment.
    console.log("local_scope: - hoisting_variable: " + hoisting_variable);

    var hoisting_variable = "local_hoist";
    // The hoisting_variable is now set as a local one.
    console.log("local_scope: - hoisting_variable: " + hoisting_variable);
}

local_function();

// No variable in a separate function is visible into the global scope.
console.log("global_scope: - local_variable: " + local_variable);

JavaScript tem apenas dois tipos de escopo:

  1. Escopo global : global é nada, mas um escopo de nível de janela. Aqui, variável presente em todo o aplicativo.
  2. Escopo Funcional : Variável declarada dentro de uma função com var palavra-chave tem escopo funcional.

Sempre que uma função é chamada, um objeto de escopo de variável é criado (e incluído na cadeia de escopo), que é seguido por variáveis ​​em JavaScript.

        a = "global";
         function outer(){ 
              b = "local";
              console.log(a+b); //"globallocal"
         }
outer();

Cadeia de escopo ->

  1. Nível de janela - a e função outer estão no nível superior na cadeia de escopo.
  2. quando a função externa chamou um novo variable scope object (e incluído na cadeia de escopo) adicionado com a variável b dentro dele.

Agora, quando uma variável a exigida, ela primeiro procura pelo escopo da variável mais próxima e se a variável não está lá, ela se move para o próximo objeto da cadeia do escopo da variável. O que, nesse caso, é o nível da janela.


Javascript usa cadeias de escopo para estabelecer o escopo de uma determinada função. Normalmente, há um escopo global e cada função definida possui seu próprio escopo aninhado. Qualquer função definida dentro de outra função possui um escopo local que está vinculado à função externa. É sempre a posição na fonte que define o escopo.

Um elemento na cadeia de escopo é basicamente um mapa com um ponteiro para seu escopo pai.

Ao resolver uma variável, o javascript começa no escopo mais interno e pesquisa para fora.


execute o código. espero que isso dê uma ideia sobre o escopo

Name = 'global data';
document.Name = 'current document data';
(function(window,document){
var Name = 'local data';
var myObj = {
    Name: 'object data',
    f: function(){
        alert(this.Name);
    }
};

myObj.newFun = function(){
    alert(this.Name);
}

function testFun(){
    alert("Window Scope : " + window.Name + 
          "\nLocal Scope : " + Name + 
          "\nObject Scope : " + this.Name + 
          "\nCurrent document Scope : " + document.Name
         );
}


testFun.call(myObj);
})(window,document);

Existem dois tipos de escopos em JavaScript.

  1. Escopo global : a variável que é anunciada no escopo global pode ser usada em qualquer lugar do programa sem problemas. Por exemplo:

    var carName = " BMW";
    
    // code here can use carName
    
    function myFunction() {
         // code here can use carName 
    }
  2. Escopo funcional ou escopo local : a variável declarada neste escopo pode ser usada apenas em sua própria função. Por exemplo:

    // code here can not use carName
    function myFunction() {
       var carName = "BMW";
       // code here can use carName
    }

No JavaScript existem dois tipos de escopo:

  • Escopo local
  • Âmbito global

A função Abaixo possui uma variável de escopo local carName. E essa variável não é acessível de fora da função.

function myFunction() {
    var carName = "Volvo";
    alert(carName);
    // code here can use carName
}

A classe abaixo tem uma variável de escopo global carName. E essa variável é acessível em qualquer lugar da classe.

class {

    var carName = " Volvo";

    // code here can use carName

    function myFunction() {
        alert(carName);
        // code here can use carName 
    }
}

Meu entendimento é que existem 3 escopos: escopo global, disponível globalmente; escopo local, disponível para uma função inteira, independentemente dos blocos; e escopo de bloco, disponível apenas para o bloco, declaração ou expressão em que foi usado. Escopo global e local são indicados com a palavra-chave 'var', dentro de uma função ou fora, e o escopo de bloco é indicado com a palavra-chave 'let'.

Para aqueles que acreditam que existe apenas escopo global e local, explique por que a Mozilla teria uma página inteira descrevendo as nuances do escopo de bloco no JS.

let


O ECMAScript 6 introduziu as palavras-chave let e const. Essas palavras-chave podem ser usadas no lugar da palavra-chave var. Ao contrário da palavra-chave var, as palavras-chave let e const suportam a declaração de escopo local dentro de instruções de bloco.

var x = 10
let y = 10
const z = 10
{
  x = 20
  let y = 20
  const z = 20
  {
    x = 30
    // x is in the global scope because of the 'var' keyword
    let y = 30
    // y is in the local scope because of the 'let' keyword
    const z = 30
    // z is in the local scope because of the 'const' keyword
    console.log(x) // 30
    console.log(y) // 30
    console.log(z) // 30
  }
  console.log(x) // 30
  console.log(y) // 20
  console.log(z) // 20
}

console.log(x) // 30
console.log(y) // 10
console.log(z) // 10

Tente este exemplo curioso. No exemplo abaixo, se a fosse um numérico inicializado em 0, você veria 0 e, em seguida, 1. Exceto se um é um objeto e javascript passará f1 um ponteiro de um em vez de uma cópia dele. O resultado é que você recebe o mesmo alerta nas duas vezes.

var a = new Date();
function f1(b)
{
    b.setDate(b.getDate()+1);
    alert(b.getDate());
}
f1(a);
alert(a.getDate());




var