era uma vez, havia uma linguagem chamada C,1 e esta linguagem tinha uma coisa chamada struct, e você pode usá-lo para fazer heterogeneously agregada estruturas de dados que tinha membros. A principal coisa a se saber sobre C é que quando você tem uma estrutura chamada de currentUser, e um membro como o id, e você escreve algo como currentUser.id = 42, o compilador C converteu em extremamente rápido de instruções assembler. O mesmo para int id = currentUser.id.

Também de importância foi a de que você poderia ter ponteiros para funções em estruturas, para que você pudesse escrever coisas como currentUser->setId(42) se você preferiu fazer a definição de uma id uma função, e esta foi também traduzido em rápida do integrador.

E, finalmente, de programação C tem uma forte cultura de preferindo “extremamente rápido” para apenas “rápido”, e assim se você queria um programador de C atenção, você tinha para se certificar de que você nunca fazer algo que é apenas rápido, quando você poderia fazer algo que é extremamente rápido. Isto é uma generalização, claro. Tenho certeza que se perguntarmos por aí, eventualmente conheceremos ambos os programadores C que preferem abstrações elegantes ao Código extremamente rápido.

java e javascript

em Seguida, houve uma linguagem chamada de Java, e ele foi projetado para rodar em navegadores, e ser portátil em todos os tipos de hardware e sistemas operacionais, e um dos seus objetivos era conseguir programadores de C para escrever código Java no navegador, em vez de escrever C que viveu em um plugin. Ou melhor, essa era uma de suas estratégias, o objetivo era que a Sun Microsystems permanecesse relevante em um mundo que a Microsoft estava mercantilizando, mas esse é outro capítulo do livro de história.

assim, as pessoas simpáticas por trás de Java lhe deram sintaxe semelhante a C com os suspensórios e a dicotomia afirmação/expressão e a notação de ponto. Eles têm “objetos” em vez de estruturas, objetos e tem muito mais coisas acontecendo do que estruturas, mas o Java designers feita uma distinção entre currentUser.id = 42 e currentUser.setId(42), e a certeza de que um foi extremamente rápido e o outro era apenas rápido. Ou melhor, que um era rápido, e o outro era apenas ok em comparação com C, mas Programadores de C poderiam sentir que eles estavam fazendo um pensamento importante ao decidir se id deveria ser acessado diretamente para o desempenho ou indiretamente acessado para elegância e flexibilidade.

A história mostrou que esta era a maneira certa de vender uma nova língua. A história também mostrou que a distinção de desempenho real era irrelevante para quase todos. O desempenho é apenas por agora, a flexibilidade do código é para sempre.

Bem, descobriu-se que o Sol estava certo sobre a obtenção de programadores C usar Java (funcionou em mim, abandonei CodeWarrior e Lightspeed C), mas errado sobre o uso do Java em navegadores. Em vez disso, as pessoas começaram a usar outra linguagem chamada JavaScript para escrever código em navegadores, e usaram Java para escrever código em servidores.

irá surpreendê-lo saber que JavaScript também foi projetado para fazer com que os programadores C escrevam código? E que foi com a sintaxe de Tipo C com Chavetas, a dicotomia afirmação / expressão, e notação de ponto? E embora o JavaScript tem uma coisa que é meio-sorta como um objeto Java, meio-sorta como um Smalltalk dicionário, será que você se surpreenda ao saber que o JavaScript também tem uma distinção entre currentUser.id = 42 e currentUser.setId(42)? E que originalmente, um era lento, e o outro cão-lento, mas programadores poderiam fazer um pensamento importante sobre quando otimizar para o desempenho e quando dar uma piada sobre a sanidade programadora?

Não, Não vai surpreender você aprender que ele funciona mais ou menos como C, da mesma forma que Java tipo-sort funciona como C, e exatamente pela mesma razão. E a razão já não interessa.

the problem with direct access

muito logo após as pessoas começarem a trabalhar com Java em escala, eles aprenderam que acessar diretamente variáveis de instância era uma idéia terrível. Compiladores JIT estreitou a diferença de desempenho entre currentUser.id = 42 e currentUser.setId(42) quase nada de relevância para ninguém, e de código usando currentUser.id = 42 ou int id = currentUser.id foi extremamente inflexível.

não havia nenhuma maneira de decorar tais operações com preocupações transversais como o registro ou validação. Não foi possível sobrepor o comportamento da configuração ou obter umid numa subclasse. (Programadores Java adoram subclasses!)

entretanto, programadores JavaScript também estavam escrevendo currentUser.id = 42, e eventualmente eles também descobriram que esta era uma idéia terrível. Um dos catalisadores para a mudança foi a chegada de frameworks para aplicações JavaScript lado cliente. Vamos dizer que temos um ridiculamente simples classe pessoa:

class Person { constructor (first, last) { this.first = first; this.last = last; } fullName () { return `${this.first} ${this.last}`; }};

, E um igualmente ridículo ver:

class PersonView { constructor (person) { this.model = person; } // ... redraw () { document .querySelector(`person-${person.id}`) .text(person.fullName()) }}

Toda vez que atualizar a classe pessoa, temos de nos lembrar para redesenhar o visualizar:

const currentUser = new Person('Reginald', 'Braithwaite');const currentUserView = new PersonView(currentUser);currentUserView.redraw();currentUser.first = 'Ragnvald';currentUserView.redraw();

Por que isso importa?

bem, se você não pode controlar onde certas responsabilidades são tratadas, você não pode realmente organizar o seu programa. Subclasses, métodos, mixinas e decoradores são técnicas: o que eles tornam possível é escolher qual o código responsável por qual funcionalidade.

E isso é a coisa toda sobre programação: organizar a funcionalidade. O acesso direto não permite que você organize a funcionalidade associada com a obtenção e configuração de propriedades, ele força o código fazendo a obtenção e configuração para também ser responsável por qualquer outra coisa associada com a obtenção e configuração.

get e set

não demorou muito para a biblioteca JavaScript autores para descobrir como fazer isso ir longe, usando um get e set método. Despojados do essencial para fins ilustrativos, podíamos escrever isto.:

class Model { constructor () { this.listeners = new Set(); } get (property) { this.notifyAll('get', property, this); return this; } set (property, value) { this.notifyAll('set', property, value); return this = value; } addListener (listener) { this.listeners.add(listener); } deleteListener (listener) { this.listeners.delete(listener); } notifyAll (message, ...args) { for (let listener of this.listeners) { listener.notify(this, message, ...args); } }}class Person extends Model { constructor (first, last) { super(); this.set('first', first); this.set('last', last); } fullName () { return `${this.get('first')} ${this.get('last')}`; }};class View { constructor (model) { this.model = model; model.addListener(this); }}class PersonView extends View { // ... notify(notifier, method, ...args) { if (notifier === this.model && method === 'set') this.redraw(); } redraw () { document .querySelector(`person-${this.model.id}`) .text(this.model.fullName()) }}

a Nossa nova Model superclasse manualmente permitindo que gerencia objetos para ouvir o get e set métodos em um modelo. Se forem chamados, os” ouvintes”são notificados através do método .notifyAll. Nós usamos e que para ter o PersonView ouvir o seu Person e chame seu próprio .redraw método quando uma propriedade é definida através de .set método.para que possamos escrever:

const currentUser = new Person('Reginald', 'Braithwaite');const currentUserView = new PersonView(currentUser);currentUser.set('first', 'Ragnvald');

E não precisamos chamar currentUserView.redraw(), porque a notificação foi construída em .set faz isso por nós.

Podemos fazer outras coisas com .gete.set, claro. Agora que são métodos, podemos decorá-los com registo ou validação se escolhermos. Os métodos tornam o nosso código flexível e aberto à Extensão. Por exemplo, podemos usar um E.mais tarde decorador para adicionar conselhos de registo a .set:

const after = (behaviour, ...methodNames) => (clazz) => { for (let methodName of methodNames) { const method = clazz.prototype; Object.defineProperty(clazz.prototype, methodName, { value: function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }, writable: true }); } return clazz; }function LogSetter (model, property, value) { console.log(`Setting ${property} of ${model.fullName()} to ${value}`);}@after(LogSetter, 'set')class Person extends Model { constructor (first, last) { super(); this.set('first', first); this.set('last', last); } fullName () { return `${this.get('first')} ${this.get('last')}`; }};

class Model { constructor () { this.listeners = new Set(); } addListener (listener) { this.listeners.add(listener); } deleteListener (listener) { this.listeners.delete(listener); } notifyAll (message, ...args) { for (let listener of this.listeners) { listener.notify(this, message, ...args); } }}const _first = Symbol('first'), _last = Symbol('last');class Person extends Model { constructor (first, last) { super(); this.first = first; this.last = last; } get first () { this.notifyAll('get', 'first', this); return this; } set first (value) { this.notifyAll('set', 'first', value); return this = value; } get last () { this.notifyAll('get', 'last', this); return this; } set last (value) { this.notifyAll('set', 'last', value); return this = value; } fullName () { return `${this.first} ${this.last}`; }};

const currentUser = new Person('Reginald', 'Braithwaite');const currentUserView = new PersonView(currentUser);currentUser.first = 'Ragnvald';

function getPropertyDescriptor (obj, property) { if (obj == null) return null; const descriptor = Object.getOwnPropertyDescriptor(obj, property); if (obj.hasOwnProperty(property)) return Object.getOwnPropertyDescriptor(obj, property); else return getPropertyDescriptor(Object.getPrototypeOf(obj), property);};const after = (behaviour, ...methodNames) => (clazz) => { for (let methodNameExpr of methodNames) { const = methodNameExpr.match(/^(?:(get|set) )(.+)$/); const descriptor = getPropertyDescriptor(clazz.prototype, methodName); if (accessor == null) { const method = clazz.prototype; descriptor.value = function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }; descriptor.writable = true; } else if (accessor === "get") { const method = descriptor.get; descriptor.get = function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }; descriptor.configurable = true; } else if (accessor === "set") { const method = descriptor.set; descriptor.set = function (...args) { const returnValue = method.apply(this, args); behaviour.apply(this, args); return returnValue; }; descriptor.configurable = true; } Object.defineProperty(clazz.prototype, methodName, descriptor); } return clazz; }

const notify = (name) => function (...args) { this.notifyAll(name, ...args); };@after(notify('set'), 'set first', 'set last')@after(notify('get'), 'get first', 'get last')class Person extends Model { constructor (first, last) { super(); this.first = first; this.last = last; } get first () { return this; } set first (value) { return this = value; } get last () { return this; } set last (value) { return this = value; } fullName () { return `${this.first} ${this.last}`; }};

const Notifier = mixin({ init () { this.listeners = new Set(); }, addListener (listener) { this.listeners.add(listener); }, deleteListener (listener) { this.listeners.delete(listener); }, notifyAll (message, ...args) { for (let listener of this.listeners) { listener.notify(this, message, ...args); } }}, { notify (name) { return function (...args) { this.notifyAll(name, ...args); } }});

@Notifier@after(Notifier.notify('set'), 'set first', 'set last')@after(Notifier.notify('get'), 'get first', 'get last')class Person { constructor (first, last) { this.init(); this.first = first; this.last = last; } get first () { return this; } set first (value) { return this = value; } get last () { return this; } set last (value) { return this = value; } fullName () { return `${this.first} ${this.last}`; }};

get first () { return this;}set first (value) { return this = value;}get last () { return this;}set last (value) { return this = value;}

function attrAccessor (...propertyNames) { return function (clazzOrObject) { const target = clazzOrObject.prototype || clazzOrObject; for (let propertyName of propertyNames) { Object.defineProperty(target, propertyName, { get: function () { if (this.attributes) return this.attributes; }, set: function (value) { if (this.attributes == undefined) this.attributes = new Map(); return this.attributes = value; }, configurable: true, enumerable: true }) } return clazzOrObject; }}

@Notifier@attrAccessor('first', 'last')@after(Notifier.notify('set'), 'set first', 'set last')@after(Notifier.notify('get'), 'get first', 'get last')class Person { constructor (first, last) { this.init(); this.first = first; this.last = last; } fullName () { return `${this.first} ${this.last}`; }};