Blog Alphorm Logo de blog informatique spécialisé en technologie et solutions IT
  • Développement
  • 3D et Animation
  • Cybersécurité
  • Infrastructure
  • Virtualisation
  • Réseaux
  • Bureautique
  • BDD
En cours de lecture : Supprimer une tâche dans React Native
Agrandisseur de policeAa
Blog AlphormBlog Alphorm
  • Développement
  • 3D et Animation
  • Cybersécurité
  • Infrastructure
  • Virtualisation
  • Réseaux
  • Bureautique
  • BDD
Search
  • Développement
  • 3D et Animation
  • Cybersécurité
  • Infrastructure
  • Virtualisation
  • Réseaux
  • Bureautique
  • BDD
Suivez-nous
© Alphorm 2024 - Tous droits réservés
Développement

Supprimer une tâche dans React Native

L'Équipe Alphorm Par L'Équipe Alphorm 9 janvier 2025
Partager
Partager

La gestion des tâches dans une application peut devenir ingérable si l’on ne peut pas supprimer les tâches obsolètes.

Sans cette capacité, les utilisateurs se retrouvent avec des listes encombrées et inefficaces, réduisant l’efficacité de l’application.

Cet article vous montre comment implémenter une fonctionnalité de suppression de tâche dans React Native, améliorant ainsi la gestion des tâches.

Table de matière
Supprimer tâche dans React NativeImplémentation gestion de tâchesRésultat suppression tâche ReactFAQConclusion

Formation Créer une Application Simple avec React Native

Développez votre première application mobile en un rien de temps !

Découvrir cette formation

Supprimer tâche dans React Native

Dans cette section, nous allons ajouter la fonctionnalité permettant de retirer une tâche de la liste. Cette action est essentielle pour permettre à l’utilisateur de gérer ses tâches efficacement en supprimant celles qui ne sont plus nécessaires. Voici un visuel concrétisant cette idée :

Liste tâches avec options supprimer React Native

Implémentation gestion de tâches

Nous verrons comment implémenter cette fonctionnalité de manière simple et intuitive, offrant ainsi une expérience utilisateur fluide et interactive.

Voyons maintenant la modification dans les fichiers pour implémenter cette fonctionnalité.

Index.js :

				
					
 import React, { useState } from "react";
import { Text, View, StyleSheet, TextInput, Button } from "react-native";
import ToDoList from "@/components/toDoList";
export default function Index() {
const [todos, setTodos] = useState([
{ text: "Apprendre le React Native", key: "1" },
{ text: "Construire ma première application  React Native", key: "2" },
]);
const [newToDoText, setNewToDoText] = useState("");
const [nextKey, setNextKey] = useState(3);
const [editingText, setEditingText] = useState("");
const [editingToDo, setEditingToDo] = useState(null);
// Ajouter une tâche
const handleAddTodo = () => {
setTodos((prevTodos) => [
...prevTodos,
{ text: newToDoText, key: String(nextKey) },
]);
setNewToDoText("");
setNextKey(nextKey + 1);
};
// Supprimer une tâche
const handleDeleteTodo = (key) => {
setTodos((prevTodos) => prevTodos.filter((todo) => todo.key !== key));
};
// Commencer l'édition d'une tâche
const handleEditTodo = (key) => {
const todoToEdit = todos.find((todo) => todo.key === key);
if (todoToEdit) {
setEditingText(todoToEdit.text);
setEditingToDo(todoToEdit);
}
};
// Enregistrer les modifications
const handleSaveEdit = () => {
if (editingToDo) {
setTodos((prevTodos) =>
prevTodos.map((todo) =>
todo.key === editingToDo.key
? { ...todo, text: editingText }
: todo
)
);
setEditingToDo(null);
setEditingText("");
}
};
// Annuler l'édition
const handleCancelEdit = () => {
setEditingToDo(null);
setEditingText("");
};
// Affichage
return (
<View style={styles.main}>
<Text>Listes des tâches:</Text>
<ToDoList
todos={todos}
handleEditTodo={handleEditTodo}
handleDeleteTodo={handleDeleteTodo}
/>
{editingToDo ? (
<View>
<TextInput
style={styles.inputMargin}
value={editingText}
onChangeText={setEditingText}
placeholder="Modifier la tâche"
/>
<Button title="Enregistrer" onPress={handleSaveEdit} />
<Button title="Annuler" onPress={handleCancelEdit} />
</View>
) : (
<View>
<TextInput
style={styles.inputMargin}
value={newToDoText}
onChangeText={setNewToDoText}
placeholder="Entrer une nouvelle tâche"
/>
<Button title="Ajouter" onPress={handleAddTodo} />
</View>
)}
</View>
);
}
const styles = StyleSheet.create({
main: {
flex: 1,
justifyContent: "center",
alignItems: "center",
},
inputMargin: {
marginBottom: 4,
},
});

				
			

Explication de code :

Comme modification dans le code, nous avons ajouter cette handleDeleteTodo qui nous permet de filtrer et supprimer une tache ciblée.

  • Cette fonction met à jour l’état todos en filtrant la liste des tâches existantes.
  • Elle conserve toutes les tâches sauf celle qui a la clé ( key ) correspondante à celle à supprimer.
  • En utilisant filter (), la fonction crée une nouvelle liste de tâches qui exclut la tâche à supprimer, et cette liste est ensuite définie comme nouvel état ( setTodos ).

La fonction handleDeleteTodo est passée en prop au composant ToDoList.

Voici un visuel montrant comment cette fonction pourra filtrer et supprimer la tache ciblée.

Diagramme suppression tâche React Native

Dans le fichier toDoList.js

				
					
 import React from "react";
import { View, StyleSheet } from "react-native";
import ToDoItem from "@/components/toDoItem";
const ToDoList = ({ todos, handleEditTodo, handleDeleteTodo }) => {
return (
<View style={styles.list}>
{todos.map((todo) => (
<ToDoItem
item={todo}
key={todo.key}
handleEditTodo={handleEditTodo}
handleDeleteTodo={handleDeleteTodo}
/>
))}
</View>
);
};
const styles = StyleSheet.create({
list: {
marginTop: 20,
},
});
export default ToDoList;

				
			

Explication de code :

Dans ce fichier, nous avons simplement passé la fonction handleDeleteTodo en tant que props afin qu’elle soit transmise au composant ToDoItem , où elle sera appliquée à l’élément correspondant de la tâche.

Dans le ficihier toDoItem .js

				
					
 import React from "react";
import { View, Text, StyleSheet, TouchableOpacity } from "react-native";
const ToDoItem = ({ item, handleEditTodo, handleDeleteTodo }) => {
return (
<View style={styles.item}>
<Text style={styles.text}>{item.text}</Text>
<View style={styles.buttons}>
<TouchableOpacity
style={styles.editButton}
onPress={() => handleEditTodo(item.key)}
>
<Text style={styles.editButtonText}>Modifier</Text>
</TouchableOpacity>
<TouchableOpacity
style={styles.deleteButton}
onPress={() => handleDeleteTodo(item.key)}
>
<Text style={styles.deleteButtonText}>Supprimer</Text>
</TouchableOpacity>
</View>
</View>
);
};
const styles = StyleSheet.create({
item: {
padding: 10,
marginVertical: 8,
marginHorizontal: 16,
borderBottomWidth: 1,
borderBottomColor: "#ccc",
flexDirection: "row",
justifyContent: "space-between",
alignItems: "center",
},
text: {
fontSize: 16,
},
buttons: {
flexDirection: "row",
gap: 10,
},
editButton: {
backgroundColor: "#007BFF",
padding: 5,
borderRadius: 5,
},
editButtonText: {
color: "#FFF",
fontWeight: "bold",
},
deleteButton: {
backgroundColor: "#FF4D4D",
padding: 5,
borderRadius: 5,
},
deleteButtonText: {
color: "#FFF",
fontWeight: "bold",
},
});
export default ToDoItem;

				
			

Explication du code :

Dans ce composant, nous avons simplement ajouté un bouton  » Supprimer  » et appelé la fonction handleDeleteTodo passée via les props , afin de permettre la suppression de la tâche lorsque l’utilisateur clique sur le bouton. Des propriétés CSS ont également été ajoutées pour améliorer la mise en forme du composant.

Résultat suppression tâche React

Après avoir implémenté le code, nous allons maintenant vérifier si l’application répond bien à nos besoins en permettant de supprimer une tâche. Pour cela, commençons par lancer l’application avec la commande habituelle : npm run android.

Liste de tâches avec options de modification et suppression

Parfait ! Le résultat correspond parfaitement à nos attentes. L’application fonctionne comme prévu en permettant de supprimer une tâche.

Manipulons maintenant l’application en testant de supprimer une tache en cliquant sur le bouton « Supprimer ».

Application de gestion de tâches avec options

Et voilà ! La tâche ciblée a été supprimée avec succès. Nous avons donc achevé cette section avec succès.

Formez-vous gratuitement avec Alphorm !

Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.

Démarrer gratuitement
illustration processus de paiement en ligne avec étapes claires et convivialité

FAQ

Comment supprimer une tâche dans React Native ?
Pour supprimer une tâche dans React Native, utilisez la fonction `handleDeleteTodo`. Cette fonction filtre la liste des tâches pour exclure la tâche sélectionnée, en mettant à jour l’état `todos` avec une nouvelle liste qui ne contient pas la tâche à éliminer. En intégrant cette fonctionnalité, vous pouvez gérer efficacement votre liste de tâches.
Quel est le code pour supprimer une tâche ?
Le code pour supprimer une tâche utilise la fonction `handleDeleteTodo` qui se base sur le filtre des clés. Voici un exemple : `const handleDeleteTodo = (key) => { setTodos((prevTodos) => prevTodos.filter((todo) => todo.key !== key)); };`. Ce code permet de mettre à jour la liste des tâches en excluant la tâche avec la clé correspondante.
Comment intégrer la suppression dans ToDoList ?
Pour intégrer la suppression dans `ToDoList`, passez la fonction `handleDeleteTodo` comme prop. Dans le composant `ToDoItem`, liez cette fonction au bouton de suppression. Cela permet d’appeler `handleDeleteTodo` avec la clé de la tâche lorsque le bouton est cliqué, supprimant ainsi la tâche de la liste.
Quelles sont les étapes pour tester la suppression ?
Pour tester la suppression, implémentez le code et exécutez l’application en utilisant `npm run android`. Ensuite, dans l’application, cliquez sur le bouton « Supprimer » à côté de la tâche que vous souhaitez enlever. Vérifiez que la tâche disparaît de la liste, confirmant ainsi le bon fonctionnement de la fonctionnalité.
Pourquoi utiliser filter pour supprimer une tâche ?
L’utilisation de `filter` pour supprimer une tâche permet de créer une nouvelle liste qui exclut la tâche ciblée, sans modifier l’état original directement. Cela garantit une mise à jour efficace de l’état `todos` en React, en suivant les principes de l’immuabilité, ce qui est crucial pour une gestion d’état réactive et performante.

Conclusion

Vous savez maintenant comment supprimer une tâche dans React Native. Quelles autres fonctionnalités envisagez-vous d’ajouter pour améliorer votre application ?

ÉTIQUETÉ : React Native
Facebook
Twitter
LinkedIn
Email
WhatsApp
Par L'Équipe Alphorm
Démocratiser la Connaissance Informatique pour Tous !
Suivre :
L'Équipe Alphorm, c'est la démocratisation de la connaissance informatique. Passionnés et dévoués, nous sommes là pour vous guider vers le succès en rendant la technologie accessible à tous. Rejoignez notre aventure d'apprentissage et de partage. Avec nous, le savoir IT devient une ressource inspirante et ouverte à tous dans un monde numérique en constante évolution.

Derniers Articles

  • Techniques pour gérer les fichiers texte en C#
  • Créer et lire un fichier CSV avec C#
  • JSON : Comprendre et Utiliser Efficacement
  • Créer une Base SQLite dans C#
  • Lecture des données SQLite simplifiée
Laisser un commentaire Laisser un commentaire

Laisser un commentaire Annuler la réponse

Vous devez vous connecter pour publier un commentaire.

Blog Alphorm
  • Développement
  • 3D et Animation
  • Cybersécurité
  • Infrastructure
  • Virtualisation
  • Réseaux
  • Bureautique
  • BDD
En cours de lecture : Supprimer une tâche dans React Native

© Alphorm - Tous droits réservés