Introdução ao encapsulamento em JavaScript
O JavaScript é uma robusta linguagem de script orientada a objetos, capaz de criar aplicativos complexos no cliente e no cliente. o servidor. No entanto, quanto maior a complexidade da implementação, melhor o código de manutenção e flexibilidade é necessário para lidar com a situação. Encapsulamento, um dos princípios da Programação Orientada a Objetos é a chave para alcançar esses objetivos.
Por definição, o encapsulamento em JavaScript é um processo de ligação de dados com as funções que atuam sobre os dados. O encapsulamento nos permite controlar e validar os dados. Em JavaScript, variáveis se assemelham a dados.
Encapsulamento significa ocultação de informações, ou seja, a ideia de que as entidades internas de um objeto não devem ser expostas diretamente como entidades públicas. Isso ajudará a restringir o uso não autorizado das variáveis. Em vez disso, se os chamadores quiserem obter um resultado definido, use o método público ou entidades públicas dentro do objeto para acessar as variáveis privadas do objeto.
Trabalho de encapsulamento em JavaScript
Vamos dar um problema simples, onde um objeto "employee" contém dois atributos "name".
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
Tudo parece bem no exemplo acima. Criamos o objeto, imprimimos seu valor de atributo e o modificamos. Mas o problema parece surgir quando algum usuário tenta definir um valor inteiro para o atributo name.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
No que diz respeito ao JavaScript, isso é completamente legal, pois no JavaScript uma variável pode aceitar qualquer tipo de dado. Para corrigir isso, precisamos definir o intervalo de caracteres válidos que podem ser configurados com o nome do atributo do objeto. Essas validações não funcionarão se o chamador puder acessar e modificar o valor desses dados. A solução simples para isso seria
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
O exemplo acima aplica a validação, mas ainda apresenta algumas falhas, pois, se o chamador acessar o nome diretamente, ele ainda poderá alterá-lo.
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.
O objetivo final aqui é que o nome da variável não esteja disponível globalmente com o objeto "employee". O encapsulamento ajuda. Isso pode ser resolvido pelos conceitos Escopo e fechamento de funções.
1. Escopo da Função
Qualquer variável escrita dentro do bloco de código das funções permanece oculta do lado de fora.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Portanto, se movermos a variável "name" dentro da função "setName", os chamadores não poderão acessá-la diretamente. Mas não é fácil colocar diretamente a variável "name" dentro da função "setName", pois a variável dentro de um bloco de função não pode ser usada fora de seu escopo; portanto, name não estaria disponível para o método "getName". Para este encerramento vai ajudar.
2. Encerramentos
Quando duas funções são agrupadas com referências ao estado circundante ou ao ambiente lexical é conhecido como fechamento. Em palavras simples, o fechamento fornece acesso a uma variável local de uma função a ser usada por outra função dentro de uma função pai. Aqui temos um nome de variável oculto dentro da função setName do mundo externo. Mas o objeto interno (myObj), pode acessá-lo:
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!
Agora que usamos o conceito de fechamento, o objeto interno myObj pode ser acessado por ambas as funções. Mas, ainda assim, há uma falha no acesso ao objeto interno. Acima, vimos employee.getName não pode ser usado, nem employee.myObj.getName pode ser usado, pois myObj também é privado para a função e variáveis privadas não podem ser acessadas fora dessa maneira. Portanto, precisamos retornar o objeto interno sempre que a função anônima for chamada e atribuí-lo a uma variável externa.
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.
Vantagens do encapsulamento em JavaScript
A principal vantagem de usar o encapsulamento em JavaScript é fornecer segurança aos dados. Outros benefícios do encapsulamento incluem:
- O encapsulamento protege um objeto contra acesso ilegal.
- O encapsulamento ajuda a atingir um nível sem revelar seus detalhes complexos.
- Isso reduzirá erros humanos.
- Torne o aplicativo mais flexível e gerenciável.
- Simplifica o aplicativo.
Conclusão
O encapsulamento é a ferramenta em JavaScript que pode ser usada para facilitar e gerenciar a operação complexa, tornando o aplicativo geral seguro e fácil de trabalhar.
Artigos recomendados
Este é um guia para Encapsulamento em JavaScript. Aqui discutimos o funcionamento do encapsulamento em javascript, juntamente com conceitos e vantagens. Você também pode consultar os seguintes artigos para saber mais:
- Recursos de JavaScript (Comentários)
- Matrizes em JavaScript - Tipos e métodos
- Ferramentas JavaScript
- Loop For em JavaScript (fluxo de trabalho)
- Variáveis em JavaScript
- Tipos e manipulação de erros em JavaScript
- Funções de Regex em Python (Exemplo)
- Exemplos de comentários em PHP