Casos de uso práticos de Proxy
Crie objetos para validação, logging e reatividade.
Casos de uso práticos de Proxy é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.
Proxies na prática
Agora você combinará proxies e Reflect para resolver problemas reais: validação, registro, valores padrão e muito mais. Cada padrão envolve um objeto simples sem alterá-lo.
Invólucro de validação
Aplique um esquema: rejeite qualquer escrita que viole uma rule. O target permanece limpo porque dados inválidos nunca são gravados.
function validated(obj, rules) {
return new Proxy(obj, {
set(target, prop, value, receiver) {
const rule = rules[prop];
if (rule && !rule(value)) {
throw new TypeError('invalid value for ' + prop);
}
return Reflect.set(target, prop, value, receiver);
}
});
}
const user = validated({}, { age: v => v >= 0 });
user.age = 25;
console.log(user.age);
try { user.age = -1; } catch (e) { console.log(e.message); }Invólucro de registro
Rastreie cada leitura e escrita para depuração, encaminhando a operação por meio de Reflect após o registro.
function logged(obj) {
return new Proxy(obj, {
get(t, p, r) { console.log('GET ' + p); return Reflect.get(t, p, r); },
set(t, p, v, r) { console.log('SET ' + p + '=' + v); return Reflect.set(t, p, v, r); }
});
}
const data = logged({ count: 0 });
data.count = 5;
console.log(data.count);Valores padrão
Retorne um fallback para qualquer propriedade ausente, para que as leituras nunca produzam undefined.
function withDefault(obj, fallback) {
return new Proxy(obj, {
get(t, p, r) {
return p in t ? Reflect.get(t, p, r) : fallback;
}
});
}
const scores = withDefault({ ada: 90 }, 0);
console.log(scores.ada);
console.log(scores.unknown);Índices negativos em vetores
Faça os vetores aceitarem índices negativos ao estilo do Python, traduzindo-os em um interceptador get.
function negIndex(arr) {
return new Proxy(arr, {
get(t, p, r) {
const i = Number(p);
if (Number.isInteger(i) && i < 0) {
return Reflect.get(t, t.length + i, r);
}
return Reflect.get(t, p, r);
}
});
}
const list = negIndex(['a', 'b', 'c']);
console.log(list[-1]);
console.log(list[0]);Visão somente leitura
Exponha um objeto que possa ser lido, mas nunca escrito, algo útil para proteger um config compartilhado.
function readonly(obj) {
return new Proxy(obj, {
set() { console.log('blocked write'); return false; },
deleteProperty() { console.log('blocked delete'); return false; }
});
}
const config = readonly({ apiUrl: '/api' });
config.apiUrl = '/hacked';
console.log(config.apiUrl);Contabilizando acessos
Acompanhe quantas vezes cada propriedade é lida, armazenando counts fora do target.
function counted(obj) {
const counts = {};
const proxy = new Proxy(obj, {
get(t, p, r) {
counts[p] = (counts[p] || 0) + 1;
return Reflect.get(t, p, r);
}
});
return { proxy, counts };
}
const { proxy, counts } = counted({ x: 1 });
proxy.x; proxy.x; proxy.x;
console.log(counts.x);Propriedades virtuais calculadas
Exponha valores derivados que não são armazenados, calculando-os novamente a cada leitura.
const rect = new Proxy({ width: 4, height: 3 }, {
get(t, p, r) {
if (p === 'area') return t.width * t.height;
return Reflect.get(t, p, r);
}
});
console.log(rect.area);
rect.width = 10;
console.log(rect.area);Lançando erros em leituras desconhecidas
Detecte erros de digitação antecipadamente lançando um erro quando o código ler uma propriedade inexistente.
function strict(obj) {
return new Proxy(obj, {
get(t, p, r) {
if (typeof p === 'string' && !(p in t)) {
throw new ReferenceError('unknown property: ' + p);
}
return Reflect.get(t, p, r);
}
});
}
const o = strict({ name: 'Ada' });
console.log(o.name);
try { console.log(o.naem); } catch (e) { console.log(e.message); }Combinando responsabilidades
Invólucros reais costumam combinar validação e registro em um único manipulador, com cada interceptador encaminhando a operação para Reflect.
const account = new Proxy({ balance: 0 }, {
set(t, p, v, r) {
if (p === 'balance' && v < 0) throw new RangeError('no overdraft');
console.log(p + ' set to ' + v);
return Reflect.set(t, p, v, r);
}
});
account.balance = 100;
console.log(account.balance);
try { account.balance = -50; } catch (e) { console.log(e.message); }Por que esses padrões são importantes
Os proxies adicionam comportamento transversal, validação, registro e valores padrão, além de controle de acesso, sem poluir o objeto original nem seus chamadores. É exatamente assim que estruturas reativas observam alterações no state. Use-os quando precisar de uma interceptação transparente.
const observed = new Proxy({ n: 0 }, {
set(t, p, v, r) {
const ok = Reflect.set(t, p, v, r);
console.log(p + ' is now ' + t[p]);
return ok;
}
});
observed.n = 1;
observed.n = 2;Verificação rápida
Qual interceptador de proxy você usaria para rejeitar valores inválidos antes que fossem armazenados?
Recapitulação: casos de uso práticos de proxies
Você aplicou proxies a problemas reais:
- Validação no interceptador set rejeita dados inválidos.
- Registro rastreia leituras e escritas por meio de
Reflect. - Valores padrão e propriedades virtuais ficam no interceptador get.
- Visões somente leitura, contagem de acessos e verificação rigorosa de erros de digitação envolvem objetos de forma transparente.
Perguntas Frequentes
A aula “Casos de uso práticos de Proxy” é grátis?
Sim — o texto completo de “Casos de uso práticos de Proxy” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.
O que vou aprender em “Casos de uso práticos de Proxy”?
Crie objetos para validação, logging e reatividade. Você pratica JavaScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar JavaScript Academy?
Nenhuma experiência prévia é necessária. JavaScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Casos de uso práticos de Proxy”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de JavaScript Academy?
Sim. Cada aula de JavaScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Criando um Proxy
- Armadilhas get e set
- A API Reflect
- Casos de uso práticos de Proxy