Escribir TypeScript sin patrones conduce a errores en tiempo de ejecución y mantenimiento difícil. Esta habilidad proporciona patrones para desarrollo orientado a tipos que captura errores en tiempo de compilación, hace que los estados inválidos sean irrepresentables y agrega validación en tiempo de ejecución.
下载技能 ZIP
在 Claude 中上传
前往 设置 → 功能 → 技能 → 上传技能
开启并开始使用
测试它
正在使用“typescript-best-practices”。 Refactor this state to use discriminated unions: ```ts type LoadingState = { loading: boolean; data?: Data; error?: Error };```
预期结果:
```ts
type LoadingState<T> =
| { status: 'idle' }
| { status: 'loading' }
| { status: 'success'; data: T }
| { status: 'error'; error: Error };
// Compiler now enforces exhaustive handling
function processState<T>(state: LoadingState<T>): Result {
switch (state.status) {
case 'idle': return defaultResult();
case 'loading': return pendingResult();
case 'success': return successResult(state.data);
case 'error': return errorResult(state.error);
default: const _exhaustive: never = state;
throw new Error(`unhandled state: ${_exhaustive}`);
}
}
```
正在使用“typescript-best-practices”。 Add Zod validation with type inference: ```ts interface User { id: string; email: string; name: string; } async function createUser(data: unknown): Promise<User> { // TODO: validate data return data as User; } ```
预期结果:
```ts
import { z } from 'zod';
const UserSchema = z.object({
id: z.string().uuid(),
email: z.string().email(),
name: z.string().min(1),
});
type User = z.infer<typeof UserSchema>;
async function createUser(raw: unknown): Promise<User> {
const result = UserSchema.safeParse(raw);
if (!result.success) {
throw new Error(`Invalid user: ${result.error.message}`);
}
return result.data;
}
```
安全审计
安全Static analysis detected 117 patterns but all are false positives. JavaScript template literals flagged as shell backticks, crypto.randomUUID() flagged as weak crypto, example config patterns flagged as credential access. This is legitimate TypeScript documentation with no actual security risks.
质量评分
你能构建什么
Corrección de Código Propenso a Errores
Refactorizar código que usa banderas opcionales en uniones discriminadas, haciendo imposible representar estados inválidos en tiempo de compilación.
Agregar Validación en Tiempo de Ejecución
Agregar esquemas Zod con inferencia de tipos para validar datos externos en límites de confianza, previniendo desajustes de tipos en tiempo de ejecución.
Aplicar Garantías en Tiempo de Compilación
Agregar declaraciones switch exhaustivas con verificaciones never que fallan en compilación cuando se agregan nuevas variantes.
试试这些提示
Apply TypeScript best practices to this code. Make illegal states unrepresentable using discriminated unions where boolean flags represent mutually exclusive states.
Add runtime validation using Zod. Define a schema as the single source of truth and infer TypeScript types from it. Use safeParse for input validation and strict parse at trust boundaries.
Add exhaustive switch handling with never checks to this code. Every code path must return a value or throw. Unhandled cases should become compile errors.
Create a typed configuration module using Zod validation. Load config from environment variables at startup, validate with Zod, and export a typed config object. Avoid accessing process.env directly in application code.
最佳实践
- Definir tipos antes de la implementación. Dejar que el sistema de tipos guíe qué estructuras de datos y firmas de funciones son necesarias.
- Usar uniones discriminadas en lugar de propiedades opcionales para hacer que los estados inválidos sean irrepresentables en tiempo de compilación.
- Agregar verificaciones never en casos default de switch. Las nuevas variantes de enum causarán errores de compilación en lugar de errores silenciosos.
避免
- Usar propiedades opcionales y banderas booleanas para estados mutuamente excluyentes conduce a combinaciones inválidas.
- Omitir validación en tiempo de ejecución en límites de confianza permite que los desajustes de tipos causen fallos en tiempo de ejecución.
- Acceder a process.env en toda la base de código crea dependencias de configuración que no pueden tipificarse.