I metodi pubblici e privati di un'applicazione in jQuery andrebbero scelti con molta attenzione, onde evitare di trovarsi nella situazione di avere bisogno di un metodo e di non poterlo utilizzare in quanto privato. In JavaScript questa distinzione non ha nulla a che fare con il concetto di visibilità o di accesso ai dati, ma semplicemente di ambito di applicazione e contesto di esecuzione del codice (scope). Infatti JavaScript non ha dei modificatori di visibilità come PHP o Java, ma un contesto in cui un metodo può essere usato. Al di fuori di questo contesto il metodo, banalmente, non è accessibile dal codice esterno perchè il suo ciclo vitale si consuma all'interno del suo contesto. Vediamo degli esempi concreti.
Contesto è visibilità
Se per esempio definiamo il seguente namespace di applicazione:
var App = new function() {
}();
il contesto di esecuzione primario è App. Al suo interno possiamo definire proprietà private:
var App = new function() {
var target = $('#app');
}();
o pubbliche, usando this:
var App = new function() {
var target = $('#app');
this.version = 'Mobile';
}();
La differenza sta nel fatto che possiamo sempre accedere dall'esterno alla proprietà pubblica:
$(document).ready(function() {
console.log(App.version); // 'Mobile'
});
ma non possiamo accedere a quella privata, a meno che non definiamo un metodo pubblico che la restituisca, ossia un getter:
var App = new function() {
var target = $('#app');
this.version = 'Mobile';
this.getTarget = function() {
return target;
};
}();
Quindi avremo:
$(document).ready(function() {
console.log(App.getTarget()); // L'oggetto jQuery #app
});
Lo stesso vale per i metodi, che altro non sono che funzioni. I seguenti metodi ad esempio sono privati:
var App = new function() {
var target = $('#app');
this.version = 'Mobile';
this.getTarget = function() {
return target;
};
var method1 = function() {
// privato
};
function method2() {
// privato
}
}();
method1() e method2() vivono all'interno del contesto di App e non possono essere invocati dall'esterno. Invece, un metodo pubblico è il seguente (come getTarget()):
var App = new function() {
var target = $('#app');
this.version = 'Mobile';
this.getTarget = function() {
return target;
};
var method1 = function() {
// privato
};
function method2() {
// privato
}
this.stopAnimations = function() { // pubblico
$(':animated').stop(true, true).clearQueue();
};
}();
Possiamo usare questo metodo dall'esterno:
$(document).ready(function() {
App.stopAnimations();
});
Scegliere tra metodi pubblici e privati
Come norma di massima (anche se non si può parlare di regole ferree) dovreste definire un metodo come privato quando volete che questo metodo operi unicamente all'interno dell'applicazione sui dati di quest'ultima.
Al contrario, sceglierete un metodo pubblico quando volete che un'azione della vostra applicazione possa operare anche su dati esterni ad essa.
Se ad esempio avete un'animazione complessa, potete suddividere l'animazione in metodi privati che compiono dei calcoli sulle dimensioni degli elementi e sulla loro posizione.
Quindi se volete usare l'animazione anche all'esterno dell'applicazione e fare in modo che modifichi il suo comportamento in base al contesto, potete usare un metodo pubblico che utilizzi i metodi privati già citati:
var getOffsets = function(element) {
var pos = {};
pos.top = element.offset().top;
pos.left = element.offset().left;
return pos;
};
var getDimensions = function(element) {
var dims = {};
dims.width = element.width();
dims.height = element.height();
return dims;
};
this.createAnimation = function(element) {
var positions = getOffsets(element);
var dimensions = getDimensions(element);
var styles = $.extend(positions, dimensions);
// animazione
};
Il principio è quello del divide et impera: dividete le vostre macroroutine in routine più piccole valutando di volta in volta se i metodi da utilizzare debbano essere pubblici o privati.