Habilidades modern-javascript-patterns
📦

modern-javascript-patterns

Seguro

Aplicar Padrões Modernos de JavaScript

Bases de código JavaScript legadas são difíceis de manter e otimizar. Esta habilidade fornece orientação abrangente sobre recursos ES6+, incluindo funções arrow, desestruturação, async/await, promises, padrões de programação funcional e recursos modernos de classes para escrever código JavaScript limpo, eficiente e sustentável.

Suporta: Claude Codex Code(CC)
📊 69 Adequado
1

Baixar o ZIP da skill

2

Upload no Claude

Vá em Configurações → Capacidades → Skills → Upload skill

3

Ative e comece a usar

Testar

A utilizar "modern-javascript-patterns". How do I destructure nested objects in JavaScript?

Resultado esperado:

Nested object destructuring allows you to extract values from deeply nested objects:

```javascript
const user = {
id: 1,
name: 'Alice',
address: {
city: 'Boston',
country: 'USA'
}
};

// Nested destructuring
const {
name,
address: { city, country }
} = user;

console.log(city); // 'Boston'
console.log(country); // 'USA'

// With default values
const {
address: {
city = 'Unknown',
zipCode = '00000'
} = {}
} = user;
```

A utilizar "modern-javascript-patterns". What's the difference between Promise.all and Promise.allSettled?

Resultado esperado:

Promise.all fails fast - if any promise rejects, the entire operation fails. Promise.allSettled waits for all promises to settle regardless of outcome:

```javascript
// Promise.all - fails on first rejection
const users = await Promise.all([
fetchUser(1),
fetchUser(2)
]); // Throws if either fails

// Promise.allSettled - waits for all
const results = await Promise.allSettled([
fetchUser(1),
fetchUser(2)
]);

results.forEach(result => {
if (result.status === 'fulfilled') {
console.log('Success:', result.value);
} else {
console.log('Failed:', result.reason);
}
});
```

Auditoria de Segurança

Seguro
v5 • 1/21/2026

This is a documentation skill containing educational content about JavaScript ES6+ patterns. All static analysis findings are false positives. The 'weak cryptographic algorithm' flags are triggered by JavaScript template literals and class private field syntax (#). The 'shell backtick execution' flags are false positives from JavaScript template literals in code examples. The 'dynamic import()' detections are legitimate ES6 module examples being documented. No malicious code patterns exist.

2
Arquivos analisados
1,897
Linhas analisadas
0
achados
5
Total de auditorias
Nenhum problema de segurança encontrado
Auditado por: claude Ver Histórico de Auditoria →

Pontuação de qualidade

38
Arquitetura
100
Manutenibilidade
87
Conteúdo
21
Comunidade
100
Segurança
83
Conformidade com especificações

O Que Você Pode Construir

Refatorar Bases de Código JavaScript Legadas

Migre código baseado em callbacks para padrões Promises e async/await. Substitua funções tradicionais por funções arrow para corrigir problemas de binding de 'this'. Aplique desestruturação e operadores spread para simplificar a manipulação de dados.

Aprender Programação Funcional em JavaScript

Entenda como usar map, filter e reduce para transformação de dados. Aprenda a criar funções puras que evitam efeitos colaterais. Aplique composição e piping de funções para pipelines de processamento de dados legíveis.

Escrever Código JavaScript Sustentável

Aplique padrões modernos de JavaScript para código mais limpo e expressivo. Use organização adequada de módulos e recursos de classes ES6. Implemente otimizações de performance como debouncing, throttling e avaliação preguiçosa.

Tente Estes Prompts

Pergunta Básica sobre ES6+
Como uso [recurso] em JavaScript moderno? Pode me mostrar exemplos de [caso de uso]?
Refatorando Código Legado
Tenho este código JavaScript legado: [trecho de código]. Como posso refatorá-lo para usar padrões ES6+ modernos? Quais recursos específicos devo aplicar?
Implementação de Padrões Assíncronos
Preciso implementar [tarefa assíncrona específica]. Devo usar Promises, async/await, ou uma combinação? Mostre-me o padrão de melhor prática para [cenário] com tratamento adequado de erros.
Desafio de Programação Funcional
Tenho um array de objetos: [estrutura de dados]. Como posso usar programação funcional para [transformar/agrupar/filtrar/agregar] esses dados? Mostre-me passo a passo como compor funções para esta tarefa.

Melhores Práticas

  • Use const por padrão e use let apenas quando a reatribuição for realmente necessária. Isso previne mutações acidentais e torna a intenção do código mais clara.
  • Prefira funções arrow para callbacks e métodos que precisam de binding lexical de 'this'. Use funções tradicionais apenas quando precisar de 'this' dinâmico.
  • Aplique desestruturação e operadores spread para manipulação mais limpa de dados. Evite acesso direto a propriedades e mutação quando possível.

Evitar

  • Evite envolver funções já assíncronas em novas Promises. Se uma função já retorna uma Promise, use-a diretamente com await.
  • Não mute dados de entrada em funções. Sempre retorne novos objetos ou arrays usando operadores spread para manter imutabilidade.
  • Evite pirâmides de callbacks e encadeamento excessivo de Promises. Use async/await para melhor legibilidade e tratamento de erros.

Perguntas Frequentes

Qual é a diferença entre funções arrow e funções tradicionais em JavaScript?
Funções arrow têm binding lexical de 'this' (herdam do escopo circundante) e não podem ser usadas como construtores. Funções tradicionais têm binding dinâmico de 'this' e podem ser chamadas com 'new'. Use funções arrow para callbacks e métodos onde 'this' não deve mudar.
Quando devo usar async/await vs Promises diretamente?
Use async/await para a maioria dos casos, pois produz código mais legível semelhante a código síncrono. Use Promises diretamente ao compor múltiplas operações assíncronas com Promise.all, Promise.race ou Promise.allSettled.
Como trato erros com async/await?
Envolva chamadas await em blocos try/catch. Para múltiplas operações assíncronas independentes, considere usar Promise.allSettled para tratar falhas de forma graciosa sem interromper toda a operação.
Quais são os benefícios da programação funcional em JavaScript?
Programação funcional torna o código mais previsível e fácil de testar. Funções puras sempre produzem a mesma saída para a mesma entrada e não têm efeitos colaterais. Métodos de array como map, filter e reduce criam transformações encadeáveis que são legíveis e sustentáveis.
Quando devo usar desestruturação vs acesso direto a propriedades?
Use desestruturação ao extrair múltiplas propriedades de um objeto ou array. Isso torna o código mais limpo e declara todas as variáveis de uma vez. Use acesso direto para acesso de propriedade única em casos simples.
Quais são as implicações de performance dos recursos modernos de JavaScript?
Recursos de JavaScript modernos são otimizados por engines modernos. Alguns padrões como operadores spread em grandes arrays podem criar overhead de performance. Use debouncing e throttling para event handlers. Para operações intensivas, considere geradores para avaliação preguiçosa.

Detalhes do Desenvolvedor

Estrutura de arquivos

📄 SKILL.md