Análisis de lógica compleja mediante el modo Ask de GitHub Copilot

  • 8 minutos

La identificación de condicionales complejos que pueden y deben simplificarse no siempre es fácil. Planear cómo refactorizar el código puede ser aún más difícil.

Los desarrolladores pueden usar el modo Preguntar de GitHub Copilot para refactorizar condicionales complejos y mejorar la calidad del código.

¿Qué es el modo Preguntar?

El modo Ask de GitHub Copilot es una interfaz de chat conversacional. Realiza preguntas y GitHub Copilot responde utilizando el contexto que proporciones. Es como tener un compañero con conocimientos que pueda leer el código y dar consejos. Por ejemplo, puede usar el modo Preguntar para explicar lo que hace una función, identificar posibles problemas o sugerir mejoras.

El modo Preguntar responde con explicaciones, conclusiones o ejemplos de código que puede usar para mejorar el código. En el modo Ask, GitHub Copilot no realiza ningún cambio en los archivos de código.

Análisis de condicionales complejos mediante el modo Ask

Puede usar el modo Preguntar para identificar y analizar condicionales complejos en el código. GitHub Copilot puede ayudarle a comprender la lógica condicional, identificar posibles problemas y evaluar las oportunidades de mejora.

Estrategias para analizar condicionales complejas

Estas son algunas estrategias para usar el modo Preguntar para analizar condicionales complejos:

  • Explicar el código: pida a GitHub Copilot que explique lo que hace el condicional complejo. Esta pregunta ayuda a asegurarse de que comprende la lógica actual antes de realizar cambios.

  • Identificar la complejidad: pida a GitHub Copilot que identifique qué partes del condicional lo hacen complejo. Esta pregunta puede ayudarle a identificar las áreas en las que centrarse.

  • Buscar casos perimetrales: pida a GitHub Copilot que identifique los casos perimetrales o posibles errores en la lógica condicional. Esta pregunta puede ayudarle a asegurarse de que el código refactorizado controla todos los escenarios.

  • Sugerir refactorización: solicite sugerencias a GitHub Copilot sobre cómo simplificar o refactorizar la lógica condicional. GitHub Copilot podría sugerir el uso de cláusulas de guardia, la extracción de métodos u otras técnicas para mejorar la claridad.

  • Preguntar ejemplos: si no está seguro de cómo implementar una sugerencia, pida a GitHub Copilot ejemplos de código. Esta pregunta puede ayudarle a comprender cómo aplicar los consejos en su contexto específico.

  • Explorar riesgos: pregunte a GitHub Copilot sobre posibles riesgos o efectos secundarios de la refactorización de la lógica condicional. Esta pregunta puede ayudarle a evitar introducir nuevos errores.

  • Iterar: use preguntas de seguimiento para explorar en profundidad sugerencias específicas o áreas de interés. Un enfoque iterativo puede ayudarle a refinar su comprensión y planear su enfoque de forma más eficaz.

Indicaciones del modo de pregunta para condicionales complejos

Las indicaciones que se usan para analizar condicionales complejos deben reflejar el código y los objetivos específicos. Sin embargo, estos son algunos procedimientos recomendados sugeridos que se deben tener en cuenta:

  • Céntrese en técnicas de análisis específicas en lugar de solicitudes genéricas para obtener ayuda.
  • Referencia a prácticas establecidas como principios SÓLIDOs, patrones de diseño y convenciones de codificación.
  • Incluya métricas de calidad como complejidad ciclomática y olores de código.
  • Resalte las pruebas y la mitigación de riesgos, que son cruciales para la refactorización segura.
  • Promueva los procedimientos recomendados para código seguro, fácil de mantener y legible.
  • Fomentar el pensamiento sistemático sobre los requisitos empresariales y la implementación técnica.
  • Cuando proceda, aborde las consideraciones de rendimiento que son importantes para el código de producción.

Establecimiento del contexto de chat necesario

Al usar el modo Ask, es importante proporcionar suficiente contexto para Que GitHub Copilot comprenda el código que está analizando. Estas son algunas sugerencias:

  • Use el botón Agregar contexto en la interfaz de chat para incluir archivos o carpetas relevantes del código base.
  • Incluya fragmentos de código relevantes o ejemplos que muestren los puntos.
  • Describir los objetivos específicos que tiene para el análisis (por ejemplo, simplificar la lógica, identificar errores).
  • Mencione las restricciones o requisitos que son importantes para el análisis (por ejemplo, consideraciones de rendimiento, estándares de codificación).

Estos son algunos ejemplos de texto de lenguaje natural que puede incluir en el mensaje al analizar condicionales complejos:

Descripción y análisis

  • "Analice la lógica condicional seleccionada y explique lo que hace cada rama".
  • "¿Cuál es la complejidad ciclomática del bloque condicional seleccionado y por qué?"
  • "Revise el condicional seleccionado e identifique las condiciones principales que se evalúan y sus relaciones".
  • "¿Qué reglas de negocios o requisitos implementa la lógica condicional seleccionada?"

Evaluación de calidad

  • "Evalúe el condicional seleccionado para detectar posibles problemas de mantenimiento".
  • "¿Hay algún código en mal estado o antipatrones en la lógica condicional seleccionada?"
  • "Revise el condicional seleccionado e identifique los casos perimetrales o las condiciones de error que podrían no controlarse correctamente".
  • "¿El condicional seleccionado sigue los principios SOLID? Si no es así, ¿cómo podría mejorarse?"

Oportunidades de refactorización

  • "Sugerir técnicas de refactorización específicas para simplificar las cláusulas condicionales seleccionadas (cláusulas de protección, polimorfismo, patrón de estrategia, etc.)."
  • "¿Cómo puedo dividir el condicional complejo seleccionado en funciones más pequeñas y centradas?"
  • "¿Qué patrones de diseño podrían ayudar a eliminar o reducir la complejidad del condicional seleccionado?"
  • Muéstrame cómo aplicar el principio de "fallar rápido" a la lógica condicional seleccionada.

Prueba y evaluación de riesgos

  • "¿Qué casos de prueba necesitaría para asegurarse de que la lógica condicional seleccionada funcione correctamente después de refactorizar?"
  • "¿Cuáles son los riesgos de refactorizar el condicional seleccionado y cómo puedo mitigarlos?"
  • "¿Cómo puedo comprobar que el código refactorizado mantiene el mismo comportamiento que el original?"
  • "Revise los enfoques sugeridos para refactorizar el condicional seleccionado. ¿Cuáles son las implicaciones de rendimiento asociadas a cada uno de los enfoques sugeridos?"

Aplicación de procedimientos recomendados

  • "¿El condicional seleccionado sigue las convenciones de codificación de C# de Microsoft? ¿Qué mejoras son necesarias?"
  • "¿Cómo puedo hacer que el condicional seleccionado sea más legible y autodocumentado?"
  • "¿Qué mejoras de nomenclatura harían más clara la lógica condicional seleccionada?"
  • "¿Cómo puedo reducir la carga cognitiva al leer el condicional seleccionado?"

Flujo de trabajo en modo de pregunta para condicionales complejos

En el flujo de trabajo siguiente se muestra cómo usar el modo Ask en un condicional complejo:

  1. Abrir el código problemático

    Vaya al archivo y a la función que contiene la lógica condicional compleja que pretende refactorizar. Por ejemplo, supongamos que tiene un método CalculateDiscount() que ha evolucionado con el tiempo con numerosas condiciones anidadas.

  2. Selección del código pertinente

    Al seleccionar el bloque específico de código (las instrucciones anidadas if , por ejemplo), le da a Copilot un enfoque claro. Copilot usa esta selección como contexto para responder.

  3. Pedir una explicación del código

    Empiece por algo simple. Por ejemplo:

    "Copilot, ¿puede explicar qué hace este CalculateDiscount método?"

    En el modo Preguntar, Copilot lee el código y genera una explicación en inglés claro. Este paso es útil para asegurarse de que (y GitHub Copilot) comprendan completamente la lógica actual antes de cambiarla. La explicación podría ser:

    "Este método calcula un descuento para un pedido. En primer lugar, comprueba si el usuario es miembro premium; Si es así, establece baseDiscount en 10%. A continuación, comprueba si se proporciona un código de cupón. Si existe un cupón, valida la fecha de expiración del cupón, aplicando un descuento adicional si es válido. También tiene casos especiales para ventas durante las vacaciones y pedidos al por mayor...

    Use la explicación para confirmar la intención del código. La explicación podría incluso identificar dónde la lógica está enredada.

  4. Formular preguntas puntuales sobre la complejidad

    Ahora puede dedicarse al análisis. Por ejemplo:

    • "¿Hay comprobaciones redundantes o repetidas en este código?"
    • "¿Qué partes de esta lógica lo hacen complejo?"
    • ¿Qué casos límite maneja este código?

    Use las respuestas de GitHub Copilot para identificar las oportunidades de mejora. Por ejemplo:

    El elemento anidado if dentro de la sección de cupones agrega complejidad. Además, hay cinco if niveles profundos para las ventas vacacionales: considere la posibilidad de simplificar eso".

    Use los comentarios para continuar el análisis.

  5. Solicitar sugerencias de refactorización

    Ahora la pregunta clave:

    "¿Cómo puedo simplificar o refactorizar esta lógica condicional?"

    Copilot, en modo Preguntar, podría responder con una lista de sugerencias. Por ejemplo:

    • Usa cláusulas de guarda para manejar los casos cuando no se aplica ningún descuento (por ejemplo, si el cupón no es válido, devuelve pronto).
    • Extraiga la validación del cupón y el cálculo del descuento en una función propia por claridad.
    • Combine las dos comprobaciones de miembro premium independientes en un solo lugar para evitar la duplicación.
    • Use un cambio o diccionario para los multiplicadores de venta de vacaciones en lugar de if/else.

    Incluso podría dibujar un pseudocódigo breve o mostrar cómo un fragmento del código se vería después de aplicar estas ideas.

  6. Iteración con preguntas de seguimiento

    Puede explorar en profundidad cualquier sugerencia:

    • "¿Qué condiciones de esta función serían buenas cláusulas de protección?"
    • "¿Puede mostrarme qué aspecto podría tener una función extraída para el cálculo del cupón?"
    • "¿Qué escenarios de descuento diferentes tiene en cuenta este código?"

    A través de este diálogo, GitHub Copilot ayuda a formar un plan de refactorización. Al final de la exploración del modo Preguntar, es posible que tenga una lista de cambios específicos que se van a implementar, como:

    • Agregue una devolución anticipada para cupones no válidos.
    • Mueva el cálculo del descuento de vacaciones a una función independiente.
    • Elimine la duplicación de la comprobación en IsPremium realizando esta acción una sola vez al inicio.
    • Utilice una sola condición combinada para pedidos en grandes cantidades en lugar de dos instrucciones anidadas if.

Este enfoque estructurado ayuda a garantizar que cualquier refactorización mantenga la intención original al tiempo que mejora la claridad y el mantenimiento del código.

Tratar las sugerencias de Copilot de GitHub como guía

Aunque las sugerencias de GitHub Copilot suelen ser buenas, no son infalibles. Tratarlos como guía, no como verdad absoluta. Por ejemplo, GitHub Copilot podría sugerir un cambio que modificaría ligeramente el comportamiento si malinterpretaba el código. Compruebe siempre los cambios lógicos críticos.

Dado que el modo Ask no modifica el código, puede explorar diferentes enfoques y evaluar sugerencias sin ningún riesgo.

Resumen

El uso del modo Ask de GitHub Copilot es una manera eficaz de analizar y planear la refactorización de condicionales complejos. Al interactuar de forma conversacional, puede obtener información sobre la lógica existente, identificar los puntos débiles y recibir sugerencias personalizadas para la simplificación. Este enfoque ayuda a garantizar que cualquier refactorización mantenga la intención original al tiempo que mejora la claridad y el mantenimiento del código.