Compétences kotlin-coroutines-expert
📦

kotlin-coroutines-expert

Sûr

Maîtriser les Kotlin Coroutines et Flow

Les Kotlin Coroutines et Flow peuvent être complexes à maîtriser. Cette skill fournit des modèles experts pour la concurrence structurée, la gestion des erreurs et le test du code asynchrone.

Prend en charge: Claude Codex Code(CC)
🥉 73 Bronze
1

Télécharger le ZIP du skill

2

Importer dans Claude

Allez dans Paramètres → Capacités → Skills → Importer un skill

3

Activez et commencez à utiliser

Tester

Utilisation de "kotlin-coroutines-expert". How do I run two API calls in parallel and handle errors independently?

Résultat attendu:

Use supervisorScope to run async tasks where failure of one does not cancel the others. Example: val task1 = async { api.fetchA() }; val task2 = async { api.fetchB() }; Both can fail independently without affecting each other.

Utilisation de "kotlin-coroutines-expert". When should I use StateFlow vs SharedFlow?

Résultat attendu:

Use StateFlow for UI state that needs to be retained and always has a current value. Use SharedFlow for one-time events like navigation or showing toast messages.

Audit de sécurité

Sûr
v1 • 2/25/2026

Static analysis flagged 26 potential issues (24 external_commands, 2 weak cryptographic). Manual review confirms all are FALSE POSITIVES. The 'external_commands' detections are markdown backtick formatting (e.g., `coroutineScope`) not shell execution. The 'weak cryptographic' detections are misidentified content. This is a legitimate Kotlin Coroutines documentation skill with no security risks.

1
Fichiers analysés
101
Lignes analysées
0
résultats
1
Total des audits
Aucun problème de sécurité trouvé
Audité par: claude

Score de qualité

38
Architecture
100
Maintenabilité
85
Contenu
50
Communauté
100
Sécurité
83
Conformité aux spécifications

Ce que vous pouvez construire

Développeur Backend

Implémenter des appels API asynchrones et la récupération parallèle de données dans les microservices Kotlin

Développeur Android

Gérer les mises à jour UI asynchrones et les flux de données réactifs dans les applications Android

Réviseur de code

Examiner le code des coroutines pour une bonne gestion des erreurs et des modèles de concurrence structurée

Essayez ces prompts

Configuration de base des Coroutines 
Show me how to set up a CoroutineScope for parallel API calls in Kotlin
Gestion des erreurs dans Flow 
How do I handle errors in a Kotlin Flow pipeline?
Test des Coroutines 
Write a unit test for a suspending function using TestScope
Gestion de l'annulation 
Explain how to properly handle coroutine cancellation without catching CancellationException

Bonnes pratiques

  • Utilisez toujours Dispatchers.IO pour les opérations d'E/S bloquantes afin d'éviter de bloquer le thread principal
  • Annulez les scopes de coroutines quand ils ne sont plus nécessaires (par exemple, dans ViewModel.onCleared)
  • Utilisez TestScope et runTest pour des tests de coroutines déterministes avec le temps virtuel

Éviter

  • Évitez GlobalScope - cela brise la concurrence structurée et peut entraîner des fuites de mémoire
  • Ne capturez pas CancellationException à moins de la relancer - cela brise l'annulation cooperative
  • Évitez d'utiliser suspendCoroutine ou suspendCancellableCoroutine quand des API de plus haut niveau suffisent

Foire aux questions

Qu'est-ce que la concurrence structurée dans Kotlin ?
La concurrence structurée garantit que les coroutines sont liées à un scope de cycle de vie. Quand le scope annule, toutes ses coroutines enfants sont annulées, évitant les fuites.
Quand dois-je utiliser supervisorScope vs coroutineScope ?
Utilisez coroutineScope quand vous voulez que n'importe quelle échec annule tous les enfants. Utilisez supervisorScope quand vous voulez que les enfants échouent indépendamment sans affecter les frères et sœurs.
Comment tester les coroutines ?
Utilisez TestScope et runTest de kotlinx.coroutines.test. Injectez TestDispatcher pour contrôler le temps virtuel pour des tests déterministes.
Quelle est la différence entre Flow et StateFlow ?
Flow est froid - il produit des valeurs seulement quand il est collecté. StateFlow est chaud - il conserve une valeur actuelle et émet vers tous les collecteurs.
Comment gérer les exceptions dans Flow ?
Utilisez l'opérateur catch à la fin du pipeline, ou utilisez try-cash dans le constructeur de flux. Pour réessayer, utilisez les opérateurs retry ou retryWhen.
Quelles sont les causes courantes des fuites de mémoire dans les coroutines ?
L'utilisation de GlobalScope, ne pas annuler les scopes quand ils sont faits, capturer le contexte incorrectement, ou maintenir des références vers des actors qui ne sont jamais complétés.

Détails du développeur

Auteur

sickn33

Licence

MIT

Dépôt

https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/kotlin-coroutines-expert

Réf

main

Structure de fichiers

📄 SKILL.md