Ambito degli oggetti ECMAScript

Lo scope si riferisce alla portata delle variabili.

Scope pubblico, privato e protetto

Concetto

Nel tradizionale design orientato agli oggetti, si presta molta attenzione agli scope pubblici e privati. Gli attributi degli oggetti nello scope pubblico possono essere acceduti dall'esterno dell'oggetto, ossia dopo che lo sviluppatore ha creato un'istanza dell'oggetto, può utilizzare i suoi attributi pubblici. Gli attributi nello scope privato possono essere acceduti solo all'interno dell'oggetto, ossia per il mondo esterno, questi attributi non esistono. Questo significa che se una classe definisce attributi e metodi privati, le sue sottoclassi non possono accedere a questi attributi e metodi.

Lo scope protetto è anche utilizzato per definire attributi e metodi privati, ma questi attributi e metodi possono essere acceduti anche dalle sottoclassi.

ECMAScript ha solo uno scope pubblico

Discutere di questi scope ECMAScript non ha quasi senso, perché ECMAScript ha solo uno scope - lo scope pubblico. Tutti gli attributi e i metodi di tutti gli oggetti ECMAScript sono pubblici. Pertanto, quando si definiscono classi e oggetti, è necessario essere particolarmente cauti. Ricorda, tutti gli attributi e i metodi sono pubblici di default!

Soluzione suggerita

Molti sviluppatori hanno proposto modelli validi di scope degli attributi online, risolvendo questo problema ECMAScript.

Poiché manca lo scope privato, gli sviluppatori hanno stabilito una convenzione per determinare quali attributi e metodi dovrebbero essere considerati privati. Questa convenzione prevede di aggiungere trattini agli attributi:

obj._color_ = "blue";

In questo codice, l'attributo color è privato. Attenzione, il trattino non cambia il fatto che l'attributo sia pubblico, ma avvisa altri sviluppatori di considerare l'attributo come privato.

Alcuni sviluppatori preferiscono anche utilizzare un trattino basso per indicare i membri privati, ad esempio: obj._color.

Ambito statico

Le proprietà e i metodi definiti dall'ambito statico possono essere acceduti da una posizione unica in qualsiasi momento. In Java, le classi possono avere proprietà e metodi senza dover istanziare l'oggetto della classe, ad esempio java.net.URLEncoder, il cui metodo encode() è un metodo statico.

ECMAScript non ha un ambito statico

In realtà, ECMAScript non ha un ambito statico. Tuttavia, può fornire proprietà e metodi ai costruttori. Ti ricordi? I costruttori sono solo funzioni. Le funzioni sono oggetti e gli oggetti possono avere proprietà e metodi. Ad esempio:

function sayHello() {
  alert("hello");
}
sayHello.alternate = function() {
  alert("hi");
}
sayHello();		// Output "hello"
sayHello.alternate();	// Output "hi"

TIY

Qui, il metodo alternate() è effettivamente il metodo di funzione sayHello. È possibile chiamare sayHello() come una funzione regolare per output "hello", o chiamare sayHello.alternate() per output "hi". Anche così, alternate() è un metodo dell'ambito pubblico di sayHello() e non un metodo statico.

Parola chiave this

Funzione di this

Uno dei concetti più importanti da comprendere in ECMAScript è l'uso della parola chiave this, che viene utilizzata nei metodi degli oggetti. La parola chiave this si riferisce sempre all'oggetto che chiama il metodo, ad esempio:

var oCar = new Object;
oCar.color = "red";
oCar.showColor = function() {
  alert(this.color);
};
oCar.showColor();		// Output "red"

TIY

Nel codice sopra, la parola chiave this viene utilizzata nel metodo showColor() dell'oggetto. In questo ambiente, this è uguale a oCar. Il seguente codice fa la stessa cosa del codice sopra:

var oCar = new Object;
oCar.color = "red";
oCar.showColor = function() {
  alert(oCar.color);
};
oCar.showColor();		// Output "red"

TIY

Ragioni per l'uso di this

Perché utilizzare this? Perché quando si istanzia un oggetto, non si può mai sapere quale nome di variabile utilizzerà lo sviluppatore. Utilizzando this, è possibile riutilizzare la stessa funzione in molti luoghi diversi. Pensa all'esempio seguente:

function showColor() {
  alert(this.color);
};
var oCar1 = new Object;
oCar1.color = "red";
oCar1.showColor = showColor;
var oCar2 = new Object;
oCar2.color = "blue";
oCar2.showColor = showColor;
oCar1.showColor();		// Output: "red"
oCar2.showColor();		// Output: "blue"

TIY

Nel codice sopra, prima si definisce la funzione showColor() utilizzando this, poi si creano due oggetti (oCar1 e oCar2), uno dei quali ha l'attributo color impostato su "red", e l'altro ha l'attributo color impostato su "blue". Entrambi gli oggetti hanno l'attributo showColor, che punta alla funzione showColor() originale (notare che non esiste un problema di nomi, poiché uno è una funzione globale e l'altro è un attributo dell'oggetto). Chiudendo showColor() per ciascun oggetto, l'output di oCar1 è "red", mentre quello di oCar2 è "blue". Questo perché quando si chiama oCar1.showColor(), la parola chiave this all'interno della funzione è uguale a oCar1. Quando si chiama oCar2.showColor(), la parola chiave this all'interno della funzione è uguale a oCar2.

Attenzione, quando si fa riferimento alle proprietà di un oggetto, è necessario utilizzare la parola chiave this. Ad esempio, se si utilizza il seguente codice, il metodo showColor() non può essere eseguito:

function showColor() {
  alert(color);
};

Se non si utilizza un oggetto o la parola chiave this per riferirsi a una variabile, ECMAScript lo considera una variabile locale o globale. Poi la funzione cercherà una variabile locale o globale chiamata color, ma non la troverà. Come conseguenza? La funzione mostrerà "null" nel messaggio di avviso.