Débogage avec support IA
astuce
Les fonctionnalités de débogage assistées par IA de Cursor vous aident à identifier et résoudre les problèmes plus rapidement en fournissant des analyses et des suggestions intelligentes.
Premiers pas
Activer le support de débogage IA
- Ouvrez la palette de commandes (Ctrl/Cmd + Shift + P)
- Tapez "Enable AI Debug"
- Sélectionnez pour activer la fonctionnalité
Fonctionnalités de base
1. Analyse d'erreurs
Lorsque vous rencontrez une erreur, l'IA peut vous aider à l'analyser :
example-error.js
// Erreur dans le code
const user = getUserData();
console.log(user.name.toLowerCase());
// Analyse IA
// ⚠️ Référence potentiellement nulle
// - user pourrait être null/undefined
// - user.name pourrait être null/undefined
// Suggestion : Ajouter des vérifications de nullité
2. Corrections rapides
L'IA suggère des corrections pour les problèmes courants :
component.tsx
// Avant : Erreur de type
const handleClick = (event) => {
console.log(event.value);
};
// Suggestion IA
const handleClick = (event: React.MouseEvent) => {
console.log(event.currentTarget.value);
};
Fonctionnalités avancées
1. Analyse d'exécution
L'IA peut analyser le comportement à l'exécution :
performance.py
# Problème de performance
def process_data(items):
result = []
for item in items:
result.append(transform(item))
return result
# Suggestion IA
def process_data(items):
return [transform(item) for item in items]
# 🚀 Amélioration de performance :
# - La compréhension de liste est plus rapide
# - Réduit l'allocation de mémoire
2. Débogage contextuel
L'IA comprend le contexte de votre base de code :
auth.service.ts
// Code original avec bug
async function validateUser(token) {
const user = await getUser(token);
return user.isValid;
}
// Analyse de débogage IA
/**
* Problèmes trouvés :
* 1. Pas de gestion d'erreur pour les tokens invalides
* 2. Pas de vérification de type pour l'objet user
* 3. Vérification de nullité manquante pour user
*/
// Correction suggérée par l'IA
async function validateUser(token: string): Promise<boolean> {
try {
const user = await getUser(token);
return user?.isValid ?? false;
} catch (error) {
console.error('Échec de validation utilisateur :', error);
return false;
}
}
Flux de débogage
1. Débogage interactif
Utilisez l'IA pendant les sessions de débogage :
// Placez des points d'arrêt assistés par IA
debugger; // L'IA analysera les états des variables
// Console de débogage IA
> ai.analyze(variableName)
> ai.suggest.fix()
> ai.explain.state()
2. Analyse de logs
L'IA peut aider à analyser des logs complexes :
# Sortie de log complexe
[2024-03-20T10:15:30] Erreur : Connexion refusée...
[2024-03-20T10:15:31] Tentative de nouvelle connexion 1...
[2024-03-20T10:15:32] Erreur : Délai d'attente dépassé...
# Analyse IA
"""
Problème détecté : Problème de connectivité réseau
- Connexion initialement refusée
- Délai d'attente dépassé lors de la nouvelle tentative
Suggestion : Vérifiez les paramètres réseau et les règles de pare-feu
"""
Fonctionnalités spécifiques aux langages
JavaScript/TypeScript
- JavaScript
- TypeScript
// Inférence de type
function processData(data) {
// L'IA suggère des types basés sur l'utilisation
return data.map(item => item.value);
}
// Vérification de type
interface DataItem {
value: string;
}
function processData(data: DataItem[]) {
return data.map(item => item.value);
}
Python
# Annotations de type et vérifications à l'exécution
def calculate_average(numbers: List[float]) -> float:
# L'IA suggère une validation d'entrée
if not numbers:
raise ValueError("Liste vide fournie")
return sum(numbers) / len(numbers)
Bonnes pratiques
1. Prévention des erreurs
Utilisez l'IA pour détecter les erreurs potentielles :
// Prévention d'erreur suggérée par l'IA
function divideNumbers(a: number, b: number): number {
// L'IA ajoute des vérifications de sécurité
if (typeof a !== 'number' || typeof b !== 'number') {
throw new TypeError('Les arguments doivent être des nombres');
}
if (b === 0) {
throw new Error('Division par zéro');
}
return a / b;
}
2. Qualité du code
L'IA aide à maintenir la qualité du code :
// Avant
function fn(x) {
var res = x + 1;
return res;
}
// Après (amélioré par l'IA)
const increment = (value: number): number => {
return value + 1;
};
3. Optimisation des performances
L'IA identifie les problèmes de performance :
// Problème de performance
const results = data
.filter(item => item.active)
.map(item => transform(item))
.filter(item => item !== null);
// Optimisation IA
const results = data.reduce((acc, item) => {
if (item.active) {
const transformed = transform(item);
if (transformed !== null) {
acc.push(transformed);
}
}
return acc;
}, []);
Techniques de débogage avancées
1. Détection de fuites mémoire
L'IA aide à identifier les fuites mémoire :
// Détection de fuite mémoire
class Component {
constructor() {
// Avertissement IA : Fuite mémoire potentielle
window.addEventListener('resize', this.onResize);
}
// Suggestion IA
cleanup() {
window.removeEventListener('resize', this.onResize);
}
}
2. Débogage asynchrone
Déboguez les opérations asynchrones avec l'IA :
// Débogage asynchrone
async function fetchData() {
try {
const response = await api.get('/data');
return response.data;
} catch (error) {
// L'IA fournit une gestion d'erreur contextuelle
if (error.response?.status === 404) {
return [];
}
throw new Error(`Échec de récupération des données : ${error.message}`);
}
}
Intégration avec les outils
1. Contrôle de version
L'IA aide à déboguer les problèmes liés à git :
# Conflit git
<<<<<<< HEAD
const config = { port: 3000 };
=======
const config = { port: 8080 };
>>>>>>> feature-branch
# Analyse IA
"""
Type de conflit : Valeur de configuration
Recommandation : Utiliser une variable d'environnement
Solution : const config = { port: process.env.PORT || 3000 };
"""
2. Tests
L'IA aide au débogage des tests :
user.test.ts
describe('Authentification utilisateur', () => {
it('devrait valider les identifiants utilisateur', async () => {
// L'IA suggère des améliorations de test
const result = await auth.validate(credentials);
expect(result).toBe(true);
// IA : Ajouter des tests de cas limites
// IA : Ajouter une gestion des délais d'attente
});
});
Résolution des problèmes de débogage IA
Problèmes courants
-
L'IA ne répond pas
# Réinitialiser la session de débogage IA
> ai.debug.reset() -
Suggestions incorrectes
# Fournir plus de contexte
> ai.debug.context.add(fileContent) -
Problèmes de performance
# Optimiser l'analyse IA
> ai.debug.optimize()
Conseils pour réussir
-
Fournir un contexte clair
- Inclure le code pertinent
- Décrire le comportement attendu
- Partager les messages d'erreur
-
Débogage itératif
- Commencer par des cas simples
- Ajouter de la complexité progressivement
- Valider les suggestions de l'IA
-
Maintenir la documentation
- Documenter les problèmes résolus
- Suivre les suggestions de l'IA
- Partager les solutions
astuce
Utilisez ai.debug.explain() pour obtenir des explications détaillées sur les suggestions de l'IA !