Introduzione all'incapsulamento in JavaScript
JavaScript è un robusto linguaggio di scripting orientato agli oggetti, in grado di creare applicazioni complesse sia sul client che il server. Tuttavia, maggiore è la complessità dell'attuazione, migliore è il codice gestibile e flessibile per affrontare la situazione. L'incapsulamento, uno dei principi della programmazione orientata agli oggetti è la chiave per raggiungere tali obiettivi.
Per definizione, l'incapsulamento in JavaScript è un processo di associazione dei dati con le funzioni che agiscono sui dati. L'incapsulamento ci consente di controllare e validare i dati. In JavaScript, le variabili assomigliano ai dati.
Incapsulamento significa nascondere le informazioni, cioè l'idea che le entità interne di un oggetto non debbano essere direttamente nude come entità pubbliche. Ciò contribuirà a limitare l'uso non autorizzato delle variabili. Invece, se i chiamanti vogliono ottenere un risultato definito, dovrebbero usare il metodo pubblico o le entità pubbliche all'interno dell'oggetto per accedere alle variabili private dell'oggetto.
Funzionamento dell'incapsulamento in JavaScript
Prendiamo un semplice problema in cui un oggetto "impiegato" contiene due attributi attributo "nome".
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
Tutto sembra a posto nell'esempio sopra. Abbiamo creato l'oggetto, stampato il suo valore di attributo e modificato. Ma il problema sembra sorgere quando un utente tenta di impostare un valore intero sull'attributo name.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
Per quanto riguarda JavaScript, questo è completamente legale, poiché in JavaScript una variabile può accettare qualsiasi tipo assegnato. Per correggere questo, dobbiamo impostare l'intervallo di caratteri validi che possono essere impostati sul nome dell'attributo dell'oggetto. Queste convalide non possono funzionare se il chiamante può accedere e modificare il valore di questi dati. La soluzione semplice per questo sarebbe
var employee = (
name : "Aditya Chaturvedi",
setName : function (value) (
var exp = new RegExp(/\d+/);
if( exp.test(value) ) (
alert("Invalid Name");
)
else (
this.name = value;
)
),
"getName" : function() (
return this.name;
)
);
alert( employee.getName() ); // Aditya Chaturvedi
employee.setName( "Rahul Khanna" );
alert( employee.getName() ); // Rahul Khanna
employee.setName( 42 ); // Invalid Name
alert( employee.getName() ); // Rahul Khanna
L'esempio precedente applica la convalida ma presenta ancora alcuni errori come se il chiamante accedesse direttamente al nome, può comunque modificarlo.
employee.setName( 42 ); // Invalid Name; Here name won't be changed.
employee.name = 42; // No validation happens and the name is changed
alert( employee.getName() ); // 42 is printed.
L'obiettivo finale qui è che il nome della variabile non dovrebbe essere disponibile a livello globale con l'oggetto "impiegato". L'incapsulamento aiuta. Ciò può essere risolto dai concetti Scope Function and Closures.
1. Ambito di applicazione
Qualsiasi variabile scritta all'interno del blocco di codice delle funzioni rimane nascosta dall'esterno.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Quindi se spostiamo la variabile "nome" all'interno della funzione "setName", i chiamanti non saranno in grado di accedervi direttamente. Ma non è facile inserire direttamente la variabile "nome" all'interno della funzione "setName" poiché la variabile all'interno di un blocco funzione non può essere utilizzata al di fuori del suo ambito, quindi il nome non sarebbe disponibile per il metodo "getName". Per questo la chiusura aiuterà.
2. Chiusure
Quando due funzioni sono raggruppate insieme a riferimenti al loro stato circostante o l'ambiente lessicale è noto come chiusura. In parole semplici, la chiusura dà accesso a una variabile locale di una funzione che può essere utilizzata da un'altra funzione all'interno di una funzione genitore. Qui abbiamo un nome variabile nascosto all'interno della funzione setName dal mondo esterno. Ma l'oggetto interno (myObj), può accedervi:
var employee = function () (
var name = "Aditya Chaturvedi";
var exp = new RegExp(/\d+/);
var myObj = (
setName : function (value) (
if( exp.test(value) ) (
alert("invalid name");
)
else (
name = value; // The object has access to "name"
)
),
getName : function () (
return name; // The object has access to "name"
)
); // End of the Object
);
employee.getName(); // doesn't work!
Ora abbiamo usato il concetto di chiusura, l'oggetto interno myObj è accessibile da entrambe le funzioni. Tuttavia, c'è un difetto nell'accesso all'oggetto interno. Sopra abbiamo visto employee.getName non può essere utilizzato, né employee.myObj.getName non può essere utilizzato poiché myObj è anche privato della funzione e le variabili private non sono accessibili all'esterno in questo modo. Quindi dobbiamo restituire l'oggetto interno ogni volta che viene chiamata la funzione anonima e assegnarlo a una variabile esterna.
var employee = function () (
var name = "Aditya Chaturvedi";
var exp = new RegExp(/\d+/);
return (
setName : function (value) (
if( exp.test(value) ) (
alert("Invalid Name");
)
else (
name = value;
)
),
getName : function () (
return name;
)
); // end of the return
)(); // Note this '()' means we're calling the function
// and assigning the returned value to the variable employee
alert(employee.getName()); // Aditya Chaturvedi
employee.setName( "Rahul Khanna" );
alert(employee.getName()); // Rahul Khanna
employee.setName( 42 ); // Invalid Name; the name does'nt changes.
employee.name = 42; // Doesn't affect the private fullName variable.
alert(employee.getName()); // Rahul Khanna is printed again.
Vantaggi dell'incapsulamento in JavaScript
Il vantaggio principale dell'utilizzo dell'incapsulamento in JavaScript è quello di fornire sicurezza ai dati. Altri vantaggi dell'incapsulamento includono:
- L'incapsulamento protegge un oggetto dall'accesso illegale.
- L'incapsulamento aiuta a raggiungere un livello senza rivelarne i dettagli complessi.
- Ciò ridurrà gli errori umani.
- Rendi l'applicazione più flessibile e gestibile.
- Semplifica l'applicazione.
Conclusione
L'incapsulamento è lo strumento in JavaScript che può essere utilizzato per rendere l'operazione complessa semplice e gestibile, rendendo l'applicazione complessiva sicura e facile da lavorare.
Articoli consigliati
Questa è una guida all'incapsulamento in JavaScript. Qui discutiamo del funzionamento dell'incapsulamento in JavaScript insieme a concetti e vantaggi. Puoi anche consultare i seguenti articoli per saperne di più-
- Funzionalità di JavaScript (commenti)
- Matrici in JavaScript: tipi e metodi
- Strumenti JavaScript
- Per Loop in JavaScript (flusso di lavoro)
- Variabili in JavaScript
- Tipi ed errori di gestione in JavaScript
- Funzioni Regex in Python (esempio)
- Esempi di commenti in PHP