Guia final para getters e setters em JavaScript
Getters e setters são funções ou métodos usados para pegue e conjunto os valores das variáveis. O conceito de getter-setter é comum em programação de computadores: quase todas as linguagens de programação de alto nível vêm com um conjunto de sintaxes para implementar getters e setters, incluindo JavaScipt.
Nesta postagem, veremos o que são getters setters e como crie e use-os em JavaScript.
Getters-setters e encapsulamento
A ideia de getters e setters é sempre mencionada em conjunto com o encapsulamento. O encapsulamento pode ser entendido de duas maneiras.
Em primeiro lugar, é a criação do Data-getters-setters trio para acessar e modificar esses dados. Esta definição é útil quando algumas operações, como a validação, têm que ser realizada nos dados antes de salvar ou visualizar os get-itters e setters fornecem a casa perfeita para isso.
Em segundo lugar, há uma definição mais estrita de acordo com a qual o encapsulamento é feito para esconder dados, para torná-lo inacessível a partir de outro código, exceto através dos getters e setters. Desta forma nós não acabamos sobrescrevendo acidentalmente dados importantes com algum outro código no programa.
Criar getters e setters
1. Com métodos
Como getters e setters são basicamente funciona que buscar / alterar um valor, existem mais de uma maneira para criá-los e usá-los. A primeira maneira é:
var obj = foo: 'este é o valor de foo', getFoo: function () return this.foo; , setFoo: function (val) this.foo = val; console.log (obj.getFoo ()); // "este é o valor de foo" obj.setFoo ('olá'); console.log (obj.getFoo ()); // "Olá" Isto é a maneira mais simples para criar getters e setters. Tem uma propriedade foo e existem dois métodos: getFoo e setFoo para retornar e atribuir um valor para essa propriedade.
2. Com palavras-chave
Mais “oficial” e maneira robusta de criar getters e setters é usando o pegue e conjunto palavras-chave.
Para criar um getter, Coloque o pegue palavra chave na frente de uma declaração de função que servirá como o método getter, e use o conjunto palavra chave da mesma maneira para criar um setter. A sintaxe é a seguinte:
var obj = fooVal: 'este é o valor de foo', get foo () return this.fooVal; , defina foo (val) this.fooVal = val; console.log (obj.foo); // "este é o valor de foo" obj.foo = 'olá'; console.log (obj.foo); // "Olá"
Note que os dados só podem ser armazenado sob um nome de propriedade (fooVal) isso é diferente a partir do nome dos métodos getter-setter (foo) porque uma propriedade segurando o getter-setter não pode segurar os dados também.
Qual o caminho é melhor?
Se você optar por criar getters e setters com palavras-chave, poderá usar o operador de atribuição para definir os dados e a operador de ponto para obter os dados, da mesma forma que você acessaria / definiria o valor de uma propriedade regular.
No entanto, se você escolher a primeira maneira de codificar getters e setters, será necessário chamar os métodos setter e getter. usando a sintaxe de chamada de função porque são funções típicas (nada de especial como aqueles criados usando o pegue e conjunto palavras-chave).
Além disso, há uma chance que você pode acabar acidentalmente atribuindo algum outro valor para as propriedades que mantinham esses métodos getter-setter e perdê-los completamente! Algo que você não precisa se preocupar no método posterior.
Então, você pode ver porque eu disse o segunda técnica é mais robusta.
Sobrescrever prevenção
Se, por algum motivo, você preferir a primeira técnica, faça as propriedades que contêm os métodos getter-setter somente leitura criando-os usando Object.defineProperties. Propriedades criadas via Object.defineProperties, Object.defineProperty e Reflect.defineProperty configurar automaticamente para gravável: falso que significa somente leitura:
/ * Sobrescrever prevenção * / var obj = foo: 'este é o valor de foo'; Object.defineProperties (obj, 'getFoo': valor: function () retornar this.foo;, 'setFoo': valor: função (val) this.foo = val;); obj.getFoo = 66; // getFoo não será sobrescrito! console.log (obj.getFoo ()); // "este é o valor de foo"
Operações dentro de getters e setters
Uma vez que você introduziu os getters e setters, você pode ir em frente e executar operações nos dados antes de mudar ou devolver.
No código abaixo, na função getter, os dados são concatenado com uma string antes de ser devolvido, e na função setter uma validação de se o valor é um número ou não é executado antes de atualizar n.
var obj = n: 67, get id () return 'O ID é:' + this.n; , set id (val) se (typeof val === 'number') this.n = val; console.log (obj.id); // "O ID é: 67" obj.id = 893; console.log (obj.id); // "O ID é: 893" obj.id = 'olá'; console.log (obj.id); // "O ID é: 893"
Proteger dados com getters e setters
Até agora, cobrimos o uso de getters e setters no primeiro contexto de encapsulamento. Vamos para o segundo, ou seja, como esconder dados de código externo com a ajuda de getters e setters.
Dados desprotegidos
A configuração de getters e setters não significa que os dados só possam ser acessados e alterados por esses métodos. No exemplo a seguir, é mudou diretamente sem tocar nos métodos getter e setter:
var obj = fooVal: 'este é o valor de foo', get foo () return this.fooVal; , defina foo (val) this.fooVal = val; obj.fooVal = 'olá'; console.log (obj.foo); // "Olá"
Nós não usamos o setter mas alterou diretamente os dados (fooVal). Os dados que inicialmente definimos dentro obj se foi agora! Para evitar que isso aconteça (acidentalmente), você precisa de alguma proteção para seus dados. Você pode adicionar isso limitando o escopo de onde seus dados estão disponíveis. Você pode fazer isso por qualquer escopo de bloco ou função escopo.
1. Bloco de escopo
Uma maneira é usar um escopo de bloco dentro do qual os dados serão definidos usando o deixei palavra-chave que limita seu escopo para aquele bloco.
UMA escopo de bloco pode ser criado colocando o seu código dentro de um par de chaves. Sempre que você criar um escopo de bloco, certifique-se de Deixe um comentário acima dele pedindo que o aparelho seja deixado sozinho, para que ninguém remove as chaves por engano pensando que eles são algumas chaves extras redundantes no código ou adicione um rótulo ao escopo do bloco.
/ * BLOCO ESCOPO, deixe o aparelho sozinho! * / let fooVal = 'este é o valor de foo'; var obj = get foo () return fooVal; , defina foo (val) fooVal = val fooVal = 'olá'; // não afetará o fooVal dentro do bloco console.log (obj.foo); // "este é o valor de foo"
Mudando / criando fooValfora do bloco não afetará a fooVal referido dentro dos getters setters.
2. Função escopo
A maneira mais comum de proteger os dados com o escopo é por mantendo os dados dentro de uma função e retornando um objeto com os getters e setters dessa função.
function myobj () var fooVal = 'este é o valor de foo'; return get foo () retornar fooVal; , defina foo (val) fooVal = val fooVal = 'olá'; // não afetará nosso fooVal original var obj = myobj (); console.log (obj.foo); // "este é o valor de foo"
O objeto (com o foo () getter-setter dentro dele) retornado pelo myobj () função é salvo em obj, e depois obj é usado para chame o getter e o setter.
3. Proteção de dados sem escopo
Há também outra maneira de proteger seus dados contra serem sobrescritos sem limitar seu escopo. A lógica por trás disso é assim: como você pode alterar um dado se não souber o que é chamado?
Se os dados tiverem um variável não tão facilmente reproduzível / nome da propriedade, É provável que ninguém (inclusive nós) acabe sobrescrevendo-o atribuindo algum valor a essa variável / nome de propriedade.
var obj = s89274934764: 'este é o valor de foo', get foo () return this.s89274934764; , defina foo (val) this.s89274934764 = val; console.log (obj.foo); // "este é o valor de foo"
Veja, essa é uma maneira de resolver as coisas. Embora o nome que eu escolhi não seja realmente bom, você também pode use valores aleatórios ou símbolos para criar nomes de propriedades, como é proposto por Derick Bailey nesta postagem do blog. O principal objetivo é mantenha os dados escondidos de outro código e deixe um par getter-setter para acessar / atualizar.
Quando você deve usar getters e setters?
Agora vem a grande questão: você começa a atribuir getters e setters para todos os seus dados agora?
Se vocês são escondendo dados, então tem nenhuma outra escolha.
Mas se os dados que estão sendo vistos por outro código estiverem corretos, você ainda precisará usar getters setters apenas para empacotá-lo com código que realiza algumas operações nele? eu diria sim. Código acrescenta muito em breve. Criando micro unidades de dados individuais com seu próprio getter-setter fornece-lhe uma certa independência para trabalhar nos dados mencionados sem afetar outras partes do código.
