La gestion des tâches dans une application peut souvent manquer de flexibilité sans une fonctionnalité d’édition.
Cela entraîne une expérience utilisateur limitée, où les utilisateurs ne peuvent pas corriger ou mettre à jour les tâches existantes facilement.
Cet article propose d’explorer l’implémentation d’une fonctionnalité de mise à jour des tâches en React Native, créant ainsi une interface utilisateur plus dynamique et interactive.
Développez votre première application mobile en un rien de temps !
Mise à jour des tâches React Native
Modifier une tâche React Native
Dans cette section, nous allons ajouter une fonctionnalité permettant à l’utilisateur de mettre à jour une tâche existante dans la liste. Cette interaction est essentielle pour offrir une expérience utilisateur dynamique et flexible. Nous verrons comment implémenter un formulaire d’édition simple et intuitif, permettant à l’utilisateur de modifier le texte d’une tâche, puis de l’enregistrer ou d’annuler les modifications. Voici un visuel montrant cette idée :
Dans le fichier 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() {
// State for todos
const [todos, setTodos] = useState([
{ text: "Apprendre le React Native", key: "1" },
{ text: "Construire ma première application en 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);
};
// 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("");
};
// Display
return (
Listes des tâches:
{editingToDo ? (
) : (
)}
);
}
const styles = StyleSheet.create({
main: {
flex: 1,
justifyContent: "center",
alignItems: "center",
},
inputMargin: {
marginBottom: 4,
},
});
Explication de code :
State et initialisation :
- todos :Contient la liste des tâches avec un texte et une clé unique pour chaque tâche.
- newToDoText :Gère le texte de la nouvelle tâche à ajouter.
- nextKey :Sert à générer une nouvelle clé pour chaque tâche ajoutée.
- editingTextet editingToDo :Gèrent le texte et la tâche en cours de modification.
Fonctions principales :
- handleAddTodo :Ajoute une nouvelle tâche à la liste avec un texte et une clé unique, puis réinitialise le champ de saisie.
- handleEditTodo :Prend la clé d’une tâche et initialise le mode édition en préremplissant le texte de la tâche dans un champ de saisie.
- handleSaveEdit :Sauvegarde les modifications effectuées sur la tâche, remplaçant son texte par le nouveau texte édité.
- handleCancelEdit :Annule l’édition en réinitialisant l’état de la tâche en cours de modification.
Rendu (UI) :
- Si une tâche est en cours de modification ( editingToDo ), un champ de saisie et des boutons » Enregistrer » et » Annuler » sont affichés.
- Sinon, un champ de saisie pour ajouter une nouvelle tâche est affiché avec le bouton » Ajouter « .
Composant ToDoList :
Affiche la liste des tâches et permet de lancer l’édition d’une tâche en appuyant dessus.
Données de PROPS à l'édition
Ensuite, dans le fichier ToDoList.js, le fichier index.js transmet les données et la fonction au fichier ToDoList.js via les props.
voyons la modification maintenant:
import React from "react";
import { View, StyleSheet } from "react-native";
import ToDoItem from "@/components/toDoItem";
const ToDoList = ({ todos, handleEditTodo }) => {
return (
{todos.map((todo) => (
))}
);
};
const styles = StyleSheet.create({
list: {
marginTop: 20,
},
});
export default ToDoList;
Explication de code :
Composant ToDoList :
Il reçoit deux propriétés (props) :
- todos :un tableau contenant les tâches à afficher.
- handleEditTodo :une fonction qui permet de lancer l’édition d’une tâche spécifique.
Le composant retourne une View qui contient une liste de tâches générées à partir de todos .
Pour chaque tâche dans todos , il crée un composant ToDoItem en passant les données de la tâche ( item ) et la fonction handleEditTodo comme propriétés.
Chaque ToDoItem est associé à une clé unique (key) basée sur l’identifiant de la tâche (todo.key).
Style : styles.list ajoute un espace en haut de la liste ( marginTop: 20 ).
Enfin, le fichier ToDoList.js devient le composant parent du composant ToDoItem.js, afin de transmettre les données, qui seront ensuite reçues par ToDoItem.js.
Voyons la modification maintenant :
import React from "react";
import { View, Text, StyleSheet, TouchableOpacity } from "react-native";
const ToDoItem = ({ item, handleEditTodo }) => {
return (
{item.text}
handleEditTodo(item.key)}
>
Modifier
);
};
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,
},
editButton: {
backgroundColor: "#007BFF",
padding: 5,
borderRadius: 5,
},
editButtonText: {
color: "#FFF",
fontWeight: "bold",
},
});
export default ToDoItem;
Composant ToDoItem :
- Props :Le composant reçoit deuxprops: item, qui contient les données de la tâche (comme le texte de la tâche), ethandleEditTodo, une fonction pour modifier la tâche lorsque l’utilisateur appuie sur le bouton.
- Structure :UnViewqui contient unTextpour afficher le texte de la tâche.UnTouchableOpacityqui, lorsqu’il est pressé, appellehandleEditTodoavec la clé de la tâche (item.key).
- Styles :LeStyleSheet.createdéfinit des styles pour l’élément de la liste (espaces, couleurs, alignement), le texte, et le bouton de modification (editButton).
Résultat d'une interface dynamique
Parfait ! Tous les composants sont correctement implémentés. Testons maintenant si tout fonctionne bien en lançant l’application avec la commande : npm run android.
Parfait, notre application affiche bien le contenu correctement. Cela veut dire que tout fonctionne bien. Essayons de modifier une tache en cliquant sur le bouton « modifier » pour voir si cela réponds bien à notre besoins.
Très bien , nous avons pu modifier la tache et enregistrer par la suite la modification.
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.
FAQ
Comment mettre à jour une tâche dans React Native ?
Quelles sont les étapes pour ajouter une fonctionnalité d'édition de tâche ?
Quels composants React Native sont utilisés pour la mise à jour des tâches ?
Comment gérer l'état des tâches dans React Native ?
Comment tester la fonctionnalité de mise à jour des tâches ?
Conclusion
En intégrant une fonctionnalité de mise à jour des tâches, votre application React Native gagne en interactivité et en flexibilité. Quelle autre fonctionnalité pourrait enrichir encore plus votre application ?