2017-02-11 15 views

Odpowiedz

5

To kiedy deklarujesz identyfikator w zakresie, który ukrywa się jeden, który istnieje w zakresie zawierających:

var foo; // The outer one 
function example() { 
    var foo; // The inner one -- this "shadows" the outer one, making the 
      // outer one inaccessible within this function 
    // ... 
} 

Istnieje kilka sposobów można cień coś:

  1. O zmiennej deklaracji (var, let, const), jak wyżej

  2. Z deklaracji parametrów:

    var foo; // The outer one 
    function example(foo) { // This parameter shadows the outer `foo` 
        // ... 
    } 
    
  3. Z deklaracji funkcji:

    var foo; // The outer one 
    function example() { 
        function foo() { // This shadows the outer `foo` 
        } 
        // ... 
    } 
    

... i kilka innych. Wszystko, co deklaruje identyfikator w zakresie, który ukrywa (cienie) jeden w zakresie zawierającym, to deklaracja/definicja cieniowania.

+0

Nazwane instrukcje funkcyjne i bloki catch mogą również maskować zmienne zewnętrzne. – lonesomeday

2

Wikipedia definicja (https://en.wikipedia.org/wiki/Variable_shadowing):

W programowaniu komputerowym, przesłanianie występuje, gdy zmienna ogłoszony w pewnym zakresie (bloku decyzyjnego, metody lub wewnętrznej klasy ) ma taką samą nazwę jak zmienna zadeklarowane w zewnętrznym zakresie. Na poziomie poziom identyfikatorów (nazw, a nie zmiennych) jest znany jako jako maskowanie nazwy. Uważa się, że ta zewnętrzna zmienna jest zacieniona przez wewnętrzną zmienną , podczas gdy wewnętrzny identyfikator jest maskowany zewnętrznym identyfikatorem . Może to prowadzić do nieporozumień, ponieważ może być niejasne, które zmienne kolejne zastosowania nazwy zmiennej w tle odnoszą się do tego, która z nich zależy od reguł rozpoznawania nazw języka.

przykład Java:

public class Shadow { 
     private int myIntVar = 0; 

     public void shadowTheVar(){ 

      // since it has the same name as above object instance field, it shadows above 
      // field inside this method 
      int myIntVar = 5; 

      // If we simply refer to 'myIntVar' the one of this method is found 
      // (shadowing a seond one with the same name) 
      System.out.println(myIntVar); 

      // If we want to refer to the shadowed myIntVar from this class we need to 
      // refer to it like this: 
      System.out.println(this.myIntVar); 
     } 

     public static void main(String[] args){ 
      new Shadow().shadowTheVar(); 
     } 
    } 
0

za pytanie rozważyć ten kod

function foo(a) { 
var b = 2; 
// some code 
function bar() { 
// ... 
} 
// more code 
var c = 3; 
} 

W tym fragmencie, kiedy starają się wykonać od zasięgu globalnym.

bar(); // fails 
console.log(a, b, c); // all 3 fail 

Załóżmy na pasku function() {....} Jeśli masz inny kod jak

function foo(){ 
var b = 3; 
console.log(b); 
} 

wtedy oznacza to, że foo linside barze jest shadowing foo (a) w globalny zakres