---
title: Mejorar y refactorizar código
description: Mejores prácticas para mejorar y refactorizar código con Verdent
---
Verdent for VS Code te ayuda a refactorizar y mejorar código de forma segura en varios archivos preservando la funcionalidad. Al usar Plan Mode con el subagente Explorer, puedes identificar todos los archivos afectados antes de hacer cambios, lo que garantiza una refactorización completa sin omitir instancias.
### Lo que aprenderás
- Solicitar refactorizaciones efectivas centradas en resultados, no en la implementación
- Refactorizar de forma segura en varios archivos con gestión de dependencias
- Solicitar mejoras de calidad de código y sugerencias de optimización
- Manejar proyectos de refactorización a gran escala con enfoques multifase
- Optimizar el rendimiento mediante mejoras algorítmicas y arquitectónicas
- Preservar la funcionalidad del código durante las operaciones de refactorización
### Requisitos previos
Antes de refactorizar con Verdent:
- Visual Studio Code con la extensión Verdent instalada
- Una base de código o espacio de trabajo de proyecto abierto en VS Code
- Un plan de suscripción activo de Verdent con créditos disponibles
- Control de versiones (Git) recomendado para revertir de forma segura si es necesario
---
## Solicitar refactorizaciones efectivas
Describe **qué quieres mejorar y por qué**, en lugar de **cómo arreglarlo**. Deja que Verdent analice el código y proponga el mejor enfoque según los patrones de tu proyecto.
**Solicitudes de refactorización efectivas:**
Céntrate en el resultado que deseas, no en la implementación:
```
Refactor the UserController to improve readability and reduce duplication
```
```
This authentication logic is scattered across multiple files. Consolidate it into a single module
```
```
Improve error handling in the API layer to be more consistent and informative
```
Verdent analiza el código, identifica todos los archivos afectados, examina los patrones y propone estrategias de refactorización específicas alineadas con las convenciones de tu base de código.
**Mejor práctica: usa Plan Mode**
Inicia las solicitudes de refactorización en Plan Mode. Verdent hará lo siguiente:
1. Analizar el código e identificar todos los archivos afectados
2. Presentar un plan de refactorización detallado antes de hacer cambios
3. Hacer preguntas aclaratorias sobre las preferencias de implementación
4. Mostrar exactamente qué cambiará y en qué orden
5. Permitirte revisar y refinar el enfoque
**Ejemplo con Plan Mode:**
```
In Plan Mode: Refactor authentication logic to use a centralized authentication utility
```
Verdent hará lo siguiente:
- Usar Explorer para encontrar todas las ubicaciones del código de autenticación
- Identificar patrones e inconsistencias
- Proponer una interfaz de autenticación unificada
- Mostrar qué archivos se modificarán
- Explicar la secuencia de refactorización
Puedes solicitar a Verdent que guarde el plan en un archivo `plan.md` para una revisión adicional y la discusión con el equipo antes de la ejecución.
**Usar Explorer para búsquedas exhaustivas:**
Para refactorizaciones complejas, pide explícitamente a Verdent que use el agente Explorer para buscar a fondo:
```
Use the Explorer agent to find all places where we manually validate email addresses, then refactor them to use a centralized validation utility
```
Esto garantiza que Verdent descubra todas las ubicaciones que necesitan actualizarse, evitando una refactorización inconsistente en la base de código.
Plan Mode es esencial para refactorizar. Evita sorpresas al mostrar exactamente qué cambiará antes de la ejecución, y te permite refinar el enfoque según consideraciones arquitectónicas.
---
## Refactorización de varios archivos
Verdent refactoriza en varios archivos manteniendo las importaciones, dependencias y referencias entre archivos. Identifica todos los archivos afectados, los actualiza en el orden correcto y garantiza la coherencia en toda la base de código.
**Cómo funciona la refactorización de varios archivos:**
1. **Fase de descubrimiento**: Verdent (usando Explorer) encuentra todos los archivos que necesitan cambios
2. **Análisis de dependencias**: identifica las dependencias entre archivos para determinar el orden de actualización
3. **Creación del plan**: muestra todos los archivos que se modificarán y la secuencia de cambios
4. **Actualizaciones secuenciales**: modifica los archivos en orden de dependencia (por ejemplo, los tipos antes que los componentes que los usan)
5. **Gestión de importaciones**: actualiza automáticamente las importaciones, exportaciones y referencias entre archivos
6. **Verificación**: comprueba que los cambios sean coherentes en todos los archivos
La refactorización de varios archivos preserva la funcionalidad mediante un seguimiento automatizado de dependencias; Verdent actualiza todos los archivos afectados de forma atómica.
**Ejemplo:**
```
Rename the User interface to UserProfile across the entire project
```
Verdent hará lo siguiente:
- Encontrar todos los archivos que importan o usan `User`
- Identificar las definiciones de tipos, implementaciones y usos
- Actualizar primero las definiciones de tipos, luego las implementaciones y finalmente los usos
- Ajustar todas las sentencias de importación
- Garantizar la coherencia en toda la base de código
**Usa Plan Mode para revisar el alcance:**
Antes de ejecutar la refactorización de varios archivos, revisa el alcance completo en Plan Mode:
```
In Plan Mode: Extract the authentication logic from UserController into a separate AuthService
```
Verdent mostrará:
- Qué archivos se crearán (el nuevo AuthService)
- Qué archivos se modificarán (UserController y todos los que lo importan)
- Qué código se moverá de UserController a AuthService
- Cómo se actualizarán las importaciones y dependencias
Esto evita la expansión accidental del alcance y garantiza que comprendas el impacto completo antes de continuar.
---
## Solicitar mejoras de calidad de código
Verdent no sugiere mejoras de forma proactiva sin que se le pida. Sin embargo, puedes solicitar revisiones de calidad de código y sugerencias de mejora en cualquier momento.
Solicita revisiones amplias de calidad de código:
```
Review this code for potential improvements
```
```
Suggest ways to improve code quality in the UserService module
```
```
Are there any performance optimizations we could make here?
```
```
Analyze the PaymentController for maintainability issues
```
Verdent analiza el código y ofrece sugerencias específicas para:
- **Legibilidad**: nombres de variables, descomposición de funciones, claridad de comentarios
- **Rendimiento**: complejidad de algoritmos, operaciones redundantes, oportunidades de almacenamiento en caché
- **Mantenibilidad**: duplicación de código, acoplamiento, separación de responsabilidades
- **Mejores prácticas**: patrones de diseño, manejo de errores, cobertura de pruebas
- **Seguridad**: validación de entradas, comprobaciones de autenticación, exposición de datos
Para obtener comentarios dirigidos, haz referencia a archivos específicos:
```
@services/UserService.js Review this module for dependency injection improvements
```
```
@controllers/PaymentController.js Identify opportunities to reduce complexity
```
Verdent examina el código especificado en el contexto de los patrones de tu proyecto y ofrece recomendaciones prácticas.
---
## Proyectos de refactorización a gran escala
Para la refactorización a gran escala, usa Plan Mode con un **enfoque multifase** para obtener los resultados más fiables. Verdent divide la refactorización en etapas manejables, lo que te permite revisar y aprobar cada fase antes de continuar.
**Flujo de trabajo de refactorización multifase:**
#### Fase 1: Análisis inicial
Usa Plan Mode con el agente Explorer para identificar todos los archivos afectados y las dependencias:
```
In Plan Mode: Use Explorer to analyze our codebase and create a plan to replace our custom authentication with OAuth 2.0
```
Verdent realiza un análisis exhaustivo:
- Identifica todo el código relacionado con la autenticación
- Mapea las dependencias y los puntos de integración
- Evalúa la complejidad y las áreas de riesgo
- Propone la división en fases
#### Fase 2: Planificación de fases
Verdent crea un plan multifase para su revisión:
**Plan de ejemplo:**
- **Fase 1**: agregar la biblioteca OAuth y configurar los endpoints
- **Fase 2**: actualizar el modelo de usuario y el esquema de la base de datos
- **Fase 3**: migrar la lógica de autenticación existente
- **Fase 4**: eliminar el código de autenticación obsoleto
- **Fase 5**: actualizar las pruebas y la documentación
Cada fase incluye:
- Archivos que se modificarán
- Complejidad estimada
- Dependencias de las fases anteriores
- Evaluación de riesgos
#### Fase 3: Ejecución fase por fase
Ejecuta una fase a la vez, probando entre fases:
1. Aprueba la Fase 1 en Plan Mode
2. Cambia a Agent Mode y ejecuta
3. Prueba a fondo para verificar que la Fase 1 funciona
4. Vuelve a Plan Mode para la Fase 2
5. Repite hasta completar todas las fases
#### Fase 4: Refinamiento iterativo
Revisa los resultados después de cada fase. Si surgen problemas:
- Ajusta el plan para las fases restantes
- Agrega fases correctivas si es necesario
- Refina el enfoque según los descubrimientos
Este enfoque por fases garantiza la seguridad y permite corregir el rumbo si surgen problemas durante proyectos de refactorización a gran escala.
La refactorización a gran escala siempre debe hacerse con control de versiones. Haz un commit después de cada fase para poder revertir si surgen problemas sin perder todo el progreso.
---
## Optimización del rendimiento
Verdent analiza el código en busca de cuellos de botella de rendimiento y sugiere optimizaciones, incluidas mejoras en la complejidad de los algoritmos, estructuras de datos eficientes y reducción del uso de recursos.
Mejora la complejidad algorítmica:
```
Analyze the performance of this data processing function and suggest improvements
```
```
Can we improve the time complexity of this search algorithm?
```
**Lo que Verdent identifica:**
- **Complejidad de algoritmos**: bucles O(n²), iteraciones anidadas, búsquedas ineficientes
- **Cálculos redundantes**: cálculos repetidos, operaciones innecesarias
- **Problemas de memoria**: fugas de memoria, asignaciones excesivas, retención de objetos grandes
**Ejemplo:**
```
Optimize the searchProducts function that's currently O(n²)
```
Verdent analiza la función, identifica la ineficiencia (bucles anidados o búsquedas lineales repetidas) y propone mejoras específicas:
- Reemplazar el bucle anidado con un hash map para búsquedas O(n)
- Usar búsqueda binaria después de ordenar para una complejidad O(log n)
- Almacenar en caché los resultados calculados para evitar cálculos redundantes
- Implementar memoización para operaciones costosas
La respuesta incluye:
- **Complejidad actual**: explicación de por qué el código actual es lento
- **Solución propuesta**: cambio específico de algoritmo o estructura de datos
- **Ganancia de rendimiento**: mejora estimada (por ejemplo, O(n²) → O(n log n))
- **Compensaciones**: consideraciones de uso de memoria, complejidad del código y mantenibilidad
Optimiza los componentes de la interfaz de usuario y el renderizado:
```
Optimize this component to reduce unnecessary re-renders
```
**Lo que Verdent identifica:**
- **Rendimiento del frontend**: re-renderizados innecesarios, tamaños de bundle grandes, operaciones bloqueantes
- **Ciclo de vida de los componentes**: dependencias ineficientes de useEffect, memoización faltante
- **Gestión del estado**: actualizaciones de estado redundantes, prop drilling
Verdent analiza tu componente y sugiere optimizaciones como React.memo, useMemo, useCallback o la división de componentes.
Identifica y corrige los cuellos de botella de API y de las bases de datos:
```
Identify performance bottlenecks in the API request handler
```
**Lo que Verdent identifica:**
- **Rendimiento de la base de datos**: consultas N+1, índices faltantes, joins ineficientes
- **Rendimiento de API**: endpoints lentos, obtención de datos ineficiente, falta de almacenamiento en caché
Verdent examina los patrones de consulta y sugiere índices de base de datos, estrategias de almacenamiento en caché y técnicas de optimización de API.
Para la optimización del rendimiento, proporciona contexto sobre los tamaños de datos típicos y las restricciones de rendimiento. Esto ayuda a Verdent a proponer soluciones apropiadas para tu escala (por ejemplo, 100 elementos frente a 1 millón de elementos).
Perfila antes de optimizar; mide el impacto en el rendimiento para asegurarte de que las optimizaciones aporten mejoras significativas.
---
## Preservar la funcionalidad durante la refactorización
Verdent busca preservar la funcionalidad del código durante la refactorización manteniendo las mismas entradas, salidas y comportamiento, al tiempo que mejora la implementación interna.
**Cómo Verdent preserva la funcionalidad:**
- **Análisis de entrada/salida**: identifica las firmas de funciones, los contratos de API y los comportamientos esperados
- **Conciencia de las pruebas**: considera las pruebas existentes como especificaciones de comportamiento
- **Cambios conservadores**: realiza cambios mínimos para lograr el objetivo de la refactorización
- **Verificación**: puede generar o ejecutar pruebas para verificar que la funcionalidad se conserva
**Mejores prácticas para una refactorización segura:**
1. **Siempre prueba el código refactorizado**: incluso con el análisis de Verdent, las pruebas manuales o automatizadas verifican que la funcionalidad se conserva, especialmente en refactorizaciones complejas
2. **Usa control de versiones**: haz un commit antes de refactorizar para poder revertir si surgen problemas
3. **Refactoriza de forma incremental**: divide las refactorizaciones grandes en pasos más pequeños, probando después de cada cambio
4. **Revisa los cambios con cuidado**: examina el diff para entender qué cambió y por qué
5. **Usa Plan Mode para refactorizaciones complejas**: revisa el enfoque antes de la ejecución para detectar posibles problemas
**Ejemplo: solicitud de refactorización segura**
```
Refactor the calculateOrderTotal function to use a more maintainable structure, but ensure it produces identical results for all input cases
```
Verdent hará lo siguiente:
- Analizar la implementación actual y los casos límite
- Proponer una estructura refactorizada
- Explicar por qué la versión refactorizada es equivalente
- Sugerir casos de prueba para verificar la equivalencia
**Cuándo podría cambiar la funcionalidad:**
En algunos casos, la refactorización cambia el comportamiento de forma intencional (corregir errores, mejorar la validación). Hazlo explícito:
```
Refactor the email validation function to correctly handle international domains, which the current implementation doesn't support
```
Esto indica que el cambio de comportamiento es esperado e intencional.
---
## Mejores prácticas
Deja que Verdent analice el código y proponga el mejor enfoque de refactorización en lugar de prescribir cambios específicos.
Revisa el plan completo antes de la ejecución. Esto evita sorpresas y te permite refinar el enfoque según consideraciones arquitectónicas.
Para una refactorización completa, pide a Verdent que use Explorer para encontrar todas las instancias: "Usa Explorer para encontrar todo el manejo manual de errores, luego refactoriza para usar nuestra utilidad de errores".
Los enfoques multifase con pruebas entre fases son más seguros y manejables que intentar hacer todo a la vez.
Verifica que cada fase funcione antes de pasar a la siguiente. Esto aísla los problemas y evita que se agraven.
Usa control de versiones para crear puntos de control después de cada fase o cambio importante. Esto permite revertir de forma segura sin perder todo el progreso.
Para refactorizaciones importantes, solicita a Verdent que guarde el plan en `plan.md` para la discusión con el equipo antes de la ejecución.
Al solicitar mejoras de rendimiento, incluye información sobre los tamaños de datos, las restricciones de rendimiento y las compensaciones aceptables.
---
## Consulta también
Genera pruebas para verificar que el código refactorizado funciona correctamente
Analiza la estructura del código antes de refactorizar para comprender el impacto