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 : Mise à jour des tâches en 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

Mise à jour des tâches en React Native

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

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.

Table de matière
Mise à jour des tâches React NativeModifier une tâche React NativeDonnées de PROPS à l'éditionRésultat d'une interface dynamiqueFAQConclusion

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

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 :

Interface de liste de tâches sur mobile

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 (
<View style={styles.main}>
<Text>Listes des tâches:</Text>
<ToDoList todos={todos} handleEditTodo={handleEditTodo} />
{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 :

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.

Diagramme relation index.js toDoList.js

voyons la modification maintenant:

				
					
 import React from "react";
import { View, StyleSheet } from "react-native";
import ToDoItem from "@/components/toDoItem";
const ToDoList = ({ todos, handleEditTodo }) => {
return (
<View style={styles.list}>
{todos.map((todo) => (
<ToDoItem
item={todo}
key={todo.key}
handleEditTodo={handleEditTodo}
/>
))}
</View>
);
};
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.

Diagramme des composants React Native

Voyons la modification maintenant :

				
					
 import React from "react";
import { View, Text, StyleSheet, TouchableOpacity } from "react-native";
const ToDoItem = ({ item, handleEditTodo }) => {
return (
<View style={styles.item}>
<Text style={styles.text}>{item.text}</Text>
<TouchableOpacity
style={styles.editButton}
onPress={() => handleEditTodo(item.key)}
>
<Text style={styles.editButtonText}>Modifier</Text>
</TouchableOpacity>
</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,
},
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.

Interface tâches React Native avec actions

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.

Interface de liste des tâches React Native

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.

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

FAQ

Comment mettre à jour une tâche dans React Native ?
Pour mettre à jour une tâche dans React Native, vous devez implémenter un formulaire d’édition. Cela inclut l’utilisation des hooks d’état pour gérer le texte de la tâche en cours d’édition. Utilisez un TextInput pour permettre à l’utilisateur de modifier le texte et des boutons pour enregistrer ou annuler les modifications. Ce processus garantit une interface utilisateur flexible et réactive.
Quelles sont les étapes pour ajouter une fonctionnalité d'édition de tâche ?
Les étapes pour ajouter une fonctionnalité d’édition de tâche en React Native incluent la création d’un nouvel état pour stocker le texte en cours d’édition et la tâche. Ensuite, vous devez implémenter des fonctions pour commencer l’édition, enregistrer les modifications et annuler l’édition. Enfin, modifiez l’interface utilisateur pour afficher un formulaire d’édition lorsque nécessaire.
Quels composants React Native sont utilisés pour la mise à jour des tâches ?
Les composants React Native utilisés pour la mise à jour des tâches incluent TextInput pour la saisie du texte, Button pour les actions d’enregistrement et d’annulation, et View pour structurer l’interface utilisateur. Le composant ToDoList gère l’affichage des tâches tandis que ToDoItem gère l’édition individuelle des tâches.
Comment gérer l'état des tâches dans React Native ?
Pour gérer l’état des tâches dans React Native, utilisez le hook useState. Créez un tableau pour stocker les tâches avec des propriétés comme le texte et une clé unique. Définissez également des états pour le texte de la nouvelle tâche, la tâche en cours d’édition, et les clés des nouvelles tâches. Cela permet de suivre et de mettre à jour les tâches efficacement.
Comment tester la fonctionnalité de mise à jour des tâches ?
Pour tester la fonctionnalité de mise à jour des tâches dans React Native, exécutez l’application localement avec la commande ‘npm run android’. Vérifiez si l’application affiche correctement la liste des tâches, si le formulaire d’édition s’ouvre correctement, et si les modifications peuvent être enregistrées ou annulées. Assurez-vous que l’interface réagit comme prévu lors de l’ajout ou de l’édition 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 ?

É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 : Mise à jour des tâches en React Native

© Alphorm - Tous droits réservés