Projet Todo
Explication du projet
Le projet consiste à créer une application multiplateforme de type Todo Liste avec les particularités suivantes:
- Présence d'un splash screen
- Persistance des données
- Possibilité de filtrer les tâches

Étape 1: Création du projet
Dans le command line de windows (CMD), nous allons nous positioner dans notre répertoire de travail et taper la commande suivante:
npx create-expo-app react-native-todolist
Ceci aura pour effet de créer un nouveau projet :

À l'aide de la commande cd, nous allons nous déplacer dans notre projet et démarrer celui-ci
cd react-native-todolist
npm run web

Le résultat sur le mobile:

Nous allons faire un reset de l'application:
npm run reset-project
Vous devriez avoir le résultat suivant:

Nous pouvons exécuter l'étape 1 de l'image ci-dessus:
npx expo start
Le résultat devrait ressembler à ceci:

Et sur le mobile:

Finalement, nous pouvons ouvrir le code dans VSCode (File - Add Folder to Workspace…):

Finalement, il faut rajouter le Safe-Area-Context (afin d'assurer que la app n'empiète pas sur le notch du téléphone):
npm i react-native-safe-area-context

Si l'installation se passe bien, nous devrions avoir dans le package.json le fichier suivant:

Nous pouvons maintenant importer le composant et le mettre dans notre application de base (index.tsx):

Voici le code:
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
export default function Index() {
return (
<SafeAreaProvider>
<SafeAreaView>
<Text>Hello</Text>
</SafeAreaView>
</SafeAreaProvider>
);
}
Étape 2: Théorie
Map
La méthode map() est une fonction très utile qui permet de transformer chaque élément d'un tableau pour créer un nouveau tableau. Elle parcourt le tableau original et applique une fonction de transformation à chaque élément.
const nombres = [1, 2, 3, 4, 5];
const doubles = nombres.map(nombre => nombre * 2);
// doubles est maintenant [2, 4, 6, 8, 10]
Voici un exemple visuel de la fonction:

La fonction map prend en paramètre une fonction de callback qui peut recevoir jusqu'à trois arguments :
- L'élément courant en cours de traitement (CurrentItem)
- L'index de l'élément (optionnel)
- Le tableau d'origine (optionnel)
Voici un exemple plus complet :
const personnes = [
{ nom: 'Pierre', age: 25 },
{ nom: 'Marie', age: 30 },
{ nom: 'Jean', age: 35 }
];
const noms = personnes.map((personne, index) => {
return `${index + 1}. ${personne.nom}`;
});
// noms est maintenant ['1. Pierre', '2. Marie', '3. Jean']
Points importants à retenir :
map()crée toujours un nouveau tableau et ne modifie pas le tableau original- La longueur du nouveau tableau sera toujours égale à celle du tableau original
- Chaque élément du tableau original sera transformé selon la fonction fournie
Find
La méthode find() en JavaScript est une fonction qui permet de rechercher et retourner le premier élément d'un tableau qui satisfait une condition donnée.
Voici sa syntaxe de base :
const element = tableau.find(element => condition);
Pour les gens plus visuel, voici un exemple de find:

Exemple visuel de l'utilisation de la méthode find()
Quelques exemples concrets :
// Exemple 1 : Trouver le premier nombre supérieur à 10
const nombres = [5, 8, 12, 15, 20];
const premierNombreSup10 = nombres.find(nombre => nombre > 10);
console.log(premierNombreSup10); // Affiche : 12
// Exemple 2 : Trouver un utilisateur par son id
const utilisateurs = [
{ id: 1, nom: 'Pierre' },
{ id: 2, nom: 'Marie' },
{ id: 3, nom: 'Jean' }
];
const utilisateurRecherche = utilisateurs.find(user => user.id === 2);
console.log(utilisateurRecherche); // Affiche : { id: 2, nom: 'Marie' }
Points importants à noter :
find()retourne le premier élément qui correspond à la condition- Si aucun élément ne correspond, elle retourne
undefined - La fonction s'arrête dès qu'elle trouve le premier élément correspondant
- La fonction callback peut recevoir trois paramètres : l'élément courant, l'index, et le tableau d'origine
Voici un dernier exemple plus spécifique:
// Dans une application de gestion de tâches
const taches = [
{ id: 1, titre: 'Courses', complete: false },
{ id: 2, titre: 'Sport', complete: true },
{ id: 3, titre: 'Lecture', complete: false }
];
// Rechercher une tâche spécifique
const tacheRecherchee = taches.find(tache => tache.id === 2);
console.log(tacheRecherchee); // Affiche : { id: 2, titre: 'Sport', complete: true }
La différence avec
filter()est quefind()ne retourne que le premier élément trouvé, alors quefilter()retourne tous les éléments qui correspondent à la condition dans un nouveau tableau.
Reduce
La fonction reduce() est une méthode qui permet de réduire un tableau à une seule valeur. Elle parcourt chaque élément du tableau et accumule un résultat.
Voici sa syntaxe de base :
array.reduce((accumulateur, elementCourant) => {
// logique de réduction
return nouvelleValeurAccumulateur;
}, valeurInitiale);
Voici une représentation visuelle de la fonction:

Voici quelques exemples concrets :
1. Somme des nombres d'un tableau :
const nombres = [1, 2, 3, 4, 5];
const somme = nombres.reduce((acc, curr) => acc + curr, 0);
console.log(somme); // 15
2. Création d'un objet à partir d'un tableau :
const fruits = ['pomme', 'banane', 'pomme', 'orange', 'banane'];
const compteur = fruits.reduce((acc, fruit) => {
acc[fruit] = (acc[fruit] || 0) + 1;
return acc;
}, {});
console.log(compteur); // { pomme: 2, banane: 2, orange: 1 }
3. Calcul du total d'un panier d'achats :
const panier = [
{ produit: 'T-shirt', prix: 15 },
{ produit: 'Pantalon', prix: 25 },
{ produit: 'Chaussures', prix: 50 }
];
const total = panier.reduce((acc, item) => acc + item.prix, 0);
console.log(total); // 90
Points importants à noter :
- L'accumulateur est la valeur retournée à chaque itération
- La valeur initiale est optionnelle mais recommandée pour éviter les erreurs
- Si aucune valeur initiale n'est fournie, le premier élément du tableau sera utilisé comme valeur initiale
reduce()peut transformer un tableau en n'importe quel type de valeur (nombre, string, objet, tableau...)
Filter
La fonction filter() en JavaScript permet de créer un nouveau tableau contenant tous les éléments qui satisfont une condition donnée.
Voici sa syntaxe de base :
const nouveauTableau = tableau.filter(element => condition);
Exemples concrets :
1. Filtrer les nombres pairs :
const nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const nombresPairs = nombres.filter(nombre => nombre % 2 === 0);
console.log(nombresPairs); // [2, 4, 6, 8, 10]
2. Filtrer des objets selon une propriété :
const utilisateurs = [
{ nom: 'Pierre', age: 25 },
{ nom: 'Marie', age: 17 },
{ nom: 'Jean', age: 30 },
{ nom: 'Sophie', age: 15 }
];
// Filtrer les utilisateurs majeurs
const utilisateursMajeurs = utilisateurs.filter(user => user.age >= 18);
console.log(utilisateursMajeurs);
// [{ nom: 'Pierre', age: 25 }, { nom: 'Jean', age: 30 }]
3. Filtrer les tâches non complétées :
const taches = [
{ id: 1, titre: 'Courses', complete: true },
{ id: 2, titre: 'Sport', complete: false },
{ id: 3, titre: 'Lecture', complete: false }
];
const tachesIncompletes = taches.filter(tache => !tache.complete);
console.log(tachesIncompletes);
// [{ id: 2, titre: 'Sport', complete: false },
// { id: 3, titre: 'Lecture', complete: false }]
Points importants :
filter()crée toujours un nouveau tableau- Le tableau original n'est pas modifié
- Si aucun élément ne correspond à la condition, un tableau vide est retourné
- La fonction callback peut recevoir trois paramètres : l'élément courant, l'index, et le tableau d'origine
Pour rappel, la différence principale avec find() est que filter() retourne tous les éléments qui correspondent à la condition, alors que find() ne retourne que le premier élément trouvé.
Alert
La fonction Alert dans React Native est un système de notification qui permet d'afficher des boîtes de dialogue modales natives sur iOS et Android.
Voici sa syntaxe de base :
Alert.alert(
titre, // String
message, // String (optionnel)
boutons, // Array de boutons (optionnel)
options // Objet d'options (optionnel)
);
Exemples concrets :
- Alert simple avec un seul bouton :
Alert.alert(
"Succès",
"La tâche a été créée avec succès",
[
{ text: "OK" }
]
);
2. Alert avec plusieurs boutons :
Alert.alert(
"Supprimer la tâche",
"Êtes-vous sûr de vouloir supprimer cette tâche ?",
[
{
text: "Annuler",
style: "cancel"
},
{
text: "Supprimer",
onPress: () => supprimerTache(id),
style: "destructive" // Rouge sur iOS
}
]
);
3. Alert avec callback :
Alert.alert(
"Déconnexion",
"Voulez-vous vraiment vous déconnecter ?",
[
{
text: "Non",
onPress: () => console.log("Annulation"),
style: "cancel"
},
{
text: "Oui",
onPress: () => {
// Code de déconnexion
logout();
navigation.navigate('Login');
}
}
]
);
Points importants :
- Les styles disponibles sont : 'default', 'cancel', 'destructive'
- L'ordre des boutons s'affiche différemment selon la plateforme (iOS/Android)
- Sur iOS, vous pouvez avoir jusqu'à 3 boutons
- Chaque bouton peut avoir une fonction
onPresspour gérer le clic
L'Alert est utile pour :
- Confirmer des actions importantes
- Afficher des messages d'erreur
- Demander une confirmation avant une action destructive
- Informer l'utilisateur du succès d'une opération
Pour plus d'info sur la fonction Alert: https://reactnative.dev/docs/alert
Étape 3: Le layout
Layout de base
Le layout est séparé en 3 parties:
- Header (qui va être l'en-tête de notre app)
- Body (qui va contenir la lsite)
- Footer (qui va être notre menu de navigation)

Nous allons créer un fichier de style vide (App.style.js) avec le code suivant:

Voici le code:
//App.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
app: { backgroundColor: 'F9F9F9' },
header: { backgroundColor: 'red' },
body: { backgroundColor: 'blue' },
footer: { backgroundColor: 'green' },
});
Dans index.tsx, nous allons rajouter nos 3 views (ne pas oublier d'importer le style!):
//index.tsx
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
export default function Index() {
return (
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Text>Header</Text>
</View>
<View style={s.body}>
<Text>Body</Text>
</View>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</SafeAreaView>
</SafeAreaProvider>
);
}
Le résultat sur mobile:

Layout avec les flexbox
Nous allons maintenant jouer avec les flexbox afin d'avoir une division similaire à celle-ci:
Android

Iphone:

Le code à rajouter dans App.style.js sera:
//App.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
app: { flex: 1, backgroundColor: 'F9F9F9' },
header: { flex: 1, backgroundColor: 'red' },
body: { flex: 5, backgroundColor: 'blue' },
footer: { flex: 1, backgroundColor: 'green' },
});
Footer et Safe Area View
Pour les iphones, le footer empiète avec le SafeAreaView. Nous allons donc sortir celui-ci de la SafeAreaView et rajotuer des fragment parent:


Voici le code dans index.tsx:
//index.tsx
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
export default function Index() {
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Text>Header</Text>
</View>
<View style={s.body}>
<Text>Body</Text>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
En sortant le footer du SafeAreaView, les proportions avec les flexblox ne sont plus respectées. Nous allons imposer une hauteur au footer afin de garder des proptions respectables:
//App.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
app: { flex: 1, backgroundColor: 'F9F9F9' },
header: { flex: 1, backgroundColor: 'red' },
body: { flex: 5, backgroundColor: 'blue' },
footer: { height: 70, backgroundColor: 'green' },
});
Le résultat sur Iphone est maintenant:

Nous pouvons maintenant retiré les couleurs de background:
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
app: { flex: 1, backgroundColor: 'F9F9F9' },
header: { flex: 1 },
body: { flex: 5 },
footer: { height: 70 },
});
Étape 4: Les images
Pour les besoins de projet, nous allons importer les deux images suivantes:
logo.png:

splash.png

check.png

Vous pouvez importer les images avec un drag and drop de l'exporateur de fichier vers votre projet dans VSCode (assets/images/):

Nous pouvons maintenant configurer notre splash screen pour le projet. Cette action fait en sorte de prendre notre image splash.png lorsque l'application se télécharge.

Plus d'info sur le splash screen: https://docs.expo.dev/develop/user-interface/splash-screen-and-app-icon/
Étape 5: Le header
Comme nous avons l'habitude maintenant, nous allons nous construire un composant Header.jsx avec son style associé (Header.style.js) vide dans components/Header/:

Nous allons profiter de l'occasion pour importer notre image et lui mettre un slogan extraordinaire:
//Header.jsx
import { Image, Text } from 'react-native';
import { s } from './Header.style';
import headerLogo from '../../assets/images/logo.png';
export function Header() {
return (
<>
<Image style={s.img} source={headerLogo} resizeMode="contain" />
<Text style={s.subtitle}>Brought you by PabloTheGod</Text>
</>
);
}
Pour le style:
//Header.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
img: {
width: 170,
},
subtitle: {
marginTop: -20,
fontSize: 20,
color: '#ABABAB',
},
});
Et finalement, nous allons appeler notre composante <Header /> à partir index.tsx:
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
export default function Index() {
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<Text>Body</Text>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
Padding pour respirer un peu
Nous allons nous rajouter un petit padding tout à l'entoure de l'app afin de laisser ‘respirer’ celle-ci un peu:

//App.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
app: {
flex: 1,
backgroundColor: 'F9F9F9',
padding: 10,
},
header: { flex: 1 },
body: { flex: 5 },
footer: { height: 70 },
});
Étape 6: Tâche - Card
Nous allons maintenant nous attaquer à la liste de tâche à faire, plus précisément au card (le fameux rectagle avec la tâche à faire et son statut):

Le card est un rectangle arrondi avec une ombre composé un texte au milieu et une image de type ‘Checked’ (icône vous sera fournie). Nous pouvons voir le composant comme un gros bouton. Lorsque nous avons plusieurs tâches, nous avons alors un tableau de tâche. Chaque tâche est composé de:
- Un id
- Titre
- Booléen pour connaître son statut (complété ou pas)

Création du composant CardTodo
Commencons par nous créer un composant de type CardTodo:

Voici l'image check.png (à importer dans votre projet)

La composant va recevoir une props { todo } avec les 3 élèments mentionnés précédemment (id, Titre et Booléen).
//CardTodo.jsx
import { Image, Text } from 'react-native';
import { TouchableOpacity } from 'react-native';
import checkImg from '../../assets/images/check.png';
export function CardTodo({ todo }) {
return (
<TouchableOpacity>
<Text>{todo.title}</Text>
<Image source={checkImg} />
</TouchableOpacity>
);
}
Et son style associé:
//CardTodo.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({});
Et finalement importons la composante dans notre projet principal (ne pas oublier d'importer le composant et de rajouter un tableau de tâche). Comme props, nous allons envoyer le premier élément de notre tableau <CardTodo todo={TODO_LIST[0]} />
//index.jsx
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
const TODO_LIST = [
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
];
export default function Index() {
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<CardTodo todo={TODO_LIST[0]} />
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
Le résultat sur mobile est:

Côté design, cela laisse à désirer. Il faut se créer un style pour pour le bouton, le texte et l'image et aligner le tout.
//CardTodo.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
card: {},
txt: {},
img: {},
});
Ne pas oublier d'importer le style dans la composant:
//CardTodo.jsx
import { Image, Text } from 'react-native';
import { TouchableOpacity } from 'react-native';
import checkImg from '../../assets/images/check.png';
import { s } from './CardTodo.style';
export function CardTodo({ todo }) {
return (
<TouchableOpacity style={s.card}>
<Text style={s.txt}>{todo.title}</Text>
<Image style={s.img} source={checkImg} />
</TouchableOpacity>
);
}
Exercice: Trouver les styles appropriés
Pour l'ombre, voici un outil intéressant:
https://ethercreative.github.io/react-native-shadow-generator/

Réponse:
//CardTodo.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
card: {
backgroundColor: 'white',
display: 'flex',
flexDirection: 'row',
height: 115,
borderRadius: 13,
alignItems: 'center',
justifyContent: 'space-between',
paddingHorizontal: 20,
shadowColor: '#000',
shadowOffset: {
width: 0,
height: 2,
},
shadowOpacity: 0.25,
shadowRadius: 3.84,
elevation: 5,
},
txt: { fontSize: 25 },
img: {
height: 25,
width: 25,
},
});
CardTodo.jsx
//CardTodo.jsx
import { Image, Text, TouchableOpacity } from 'react-native';
import checkImg from '../../assets/images/check.png';
import { s } from './CardTodo.style';
export function CardTodo({ todo }) {
return (
<TouchableOpacity style={s.card}>
<Text
style={[
s.txt,
todo.isCompleted && { textDecorationLine: 'line-through' },
]}
>
{todo.title}
</Text>
{todo.isCompleted && <Image style={s.img} source={checkImg} />}
</TouchableOpacity>
);
}
Et l'index.tsx
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
const TODO_LIST = [
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
];
export default function Index() {
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<CardTodo todo={TODO_LIST[0]} />
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
Étape 7: Afficher une liste
Il est temps d'afficher l'ensemble des tâches dans notre application. Pour ce faire, nous allons créer un state pour la liste et ne pas oublier d'envoyer ee props le state <CardTodo todo={todoList[0]} />

Voici le code (ne pas oublier d'importer useState):
//index.tsx
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
export default function Index() {
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<CardTodo todo={todoList[0]} />
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
RenderTodoList: Utilisation de MAP
Nous allons utiliser la fonction MAP afin de lister l'ensemble des tâches à faire (chaque card):

//index.tsx
import { Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
export default function Index() {
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function renderTodoList() {
return todoList.map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>{renderTodoList()}</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
Et nous allons faire l'appel de la fonction dans index.tsx:

La fonction renderTodoList() est utilisée pour afficher une liste de tâches (todos). Analysons-la étape par étape :
renderTodoList(): C'est une fonction qui s'occupe du rendu de la liste des tâchestodoList.map(): La fonction parcourt un tableautodoListqui contient des objets représentant chaque tâche- Pour chaque tâche (
todo) dans le tableau, la fonction crée :- Un composant
<View>(l'équivalent d'une<div>en React Native) - Avec un style défini dans l'objet
s.cardItem(permet d'avoir un espacement à la fin de la tâche avec la propriété marginBottom) - Une propriété
key={todo.id}qui est nécessaire en React pour identifier uniquement chaque élément de la liste - À l'intérieur du
View, elle rend un composant<CardTodo>en lui passant la tâche courante comme prop :todo={todo}
- Un composant
Il faudra modifier App.style.js pour tenir en compte du marginBotton:
//App.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
app: { flex: 1, backgroundColor: 'F9F9F9', padding: 10 },
cardItem: {
marginBottom: 20,
},
header: { flex: 1 },
body: { flex: 5 },
footer: { height: 70 },
});
Voici le résultat sur mobile:

Défilement
Comme vous pouvez le constater, la liste est fixe et il serait agréable de pouvoir la faire défiler afin de voir tous nos éléments. Pour ce faire, il faut utiliser le composant ScrollView (il va falloir l'importer aussi!)


Voici le code:
//index.tsx
import { ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
export default function Index() {
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function renderTodoList() {
return todoList.map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
Étape 8: Update d'une tâche
Dans cette étape, nous allons mettre à jour le statut d'une tâche à travers la fonction updateTodo():
- si une tâche est complétée, elle va être raillée + l'icône check.png va être affiché
- si une tâche n'est pas complétée, le texte reste lisible et il n'y a pas d'icône d'affiché
Pour le moment, la fonction se limite à faire un affichage à la console:

Aussi nous allons utiliser la propriété onPress afin de détecter que nous avons appuyé sur une tâche (card) et faire un callback à la fonction updateTodo().

Finalement, il faut modifier la composant CardTodo.jsx puisqu'elle recoit maintenant en props la propriété onPress

Attention, le code suivant n'est pas bon (pourquoi???):

Nous n'avons pas accès à la todo!
Ni celui-ci (pourquoi???):

Le code est exécuté instantanément
Voici le code propre au besoin:
//index.tsx
import { ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
export default function Index() {
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function updateTodo(todo) {
console.log(todo);
}
function renderTodoList() {
return todoList.map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
Pour le composant:
//CardTodo.jsx
import { Image, Text, TouchableOpacity } from 'react-native';
import checkImg from '../../assets/images/check.png';
import { s } from './CardTodo.style';
export function CardTodo({ todo, onPress }) {
return (
<TouchableOpacity onPress={() => onPress(todo)} style={s.card}>
<Text
style={[
s.txt,
todo.isCompleted && { textDecorationLine: 'line-through' },
]}
>
{todo.title}
</Text>
{todo.isCompleted && <Image style={s.img} source={checkImg} />}
</TouchableOpacity>
);
}
Le résultat est le suivant (si je clique sur une tâche, j'affiche ses infos dans la console):

Exercice: Écrire le code pour updater une tâche
Solutionnaire:

Décomposons la solution:
Création d'une fonction qui met à jour une tâche (todo)
function updateTodo(todo) {
Création d'un nouvel objet avec les propriétés mises à jour
const updatedTodo = {
...todo, // Copie toutes les propriétés existantes
isCompleted: !todo.isCompleted, // Inverse l'état de complétion
};
Recherche de l'index de la tâche à mettre à jour
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
findIndex retourne l'index du premier élément qui correspond à la condition (ici, quand les IDs correspondent)
Mise à jour de la liste
const updatedTodoList = [...todoList]; // Crée une copie du tableau original
updatedTodoList[indexToUpdate] = updatedTodo; // Remplace l'ancien todo par le nouveau
setTodoList(updatedTodoList); // Met à jour l'état avec la nouvelle liste (il faut utiliser la fonction du state!!!)
Cette fonction sert à basculer l'état de complétion d'une tâche (todo). Voici ce qui se passe quand on l'appelle :
- Elle reçoit une tâche en paramètre
- Elle crée une nouvelle version de cette tâche avec l'état de complétion inversé
- Elle trouve où se trouve cette tâche dans la liste
- Elle crée une nouvelle liste avec la tâche mise à jour
- Elle met à jour l'état de l'application avec cette nouvelle liste
C'est une approche immutable qui respecte les bonnes pratiques de React en ne modifiant pas directement l'état mais en créant de nouvelles copies des objets.
Voici le code:
//index.tsx
import { ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
export default function Index() {
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function renderTodoList() {
return todoList.map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<Text>Footer</Text>
</View>
</>
);
}
Étape 9: Le footer
Design initial
Pour le moment, nous allons construire notre footer avec 3 tabs (3 boutons) et mettre en bleu la tab qui est active (cliqué)

Nous devons créer un composant TabBottomMenu avec son style associé vide:

Voici le code pour TabBottomMenu
//TabBottomMenu.jsx
export function TabBottomMenu() {
return <></>;
}
Voici son style:
//TabBottomMenu.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({});
Et voici son appel dans index.tsx (ne pas oublier d'importer le composant):


Voici le code:
//index.tsx
import { ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
export default function Index() {
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function renderTodoList() {
return todoList.map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu />
</View>
</>
);
}
Voici le résultat sur mobile:

Exercice: Design avec les boutons
Nous pouvons maintenant remplir notre footer avec les 3 boutons suivants:

Voici le code du composant (avec 3 boutons):
//TabBottomMenu.jsx
import { Text, TouchableOpacity, View } from 'react-native';
import { s } from './TabBottomMenu.style';
export function TabBottomMenu() {
return (
<View style={s.container}>
<TouchableOpacity>
<Text>All</Text>
</TouchableOpacity>
<TouchableOpacity>
<Text>progress</Text>
</TouchableOpacity>
<TouchableOpacity>
<Text>Done</Text>
</TouchableOpacity>
</View>
);
}
Et le style associé (notez que le flexDirection est en row!):
//TabBottomMenu.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
container: {
flexDirection: 'row',
backgroundColor: 'white',
justifyContent: 'space-evenly',
paddingVertical: 20,
shadowColor: '#000',
shadowOffset: {
width: 0,
height: 5,
},
shadowOpacity: 0.34,
shadowRadius: 6.27,
elevation: 10,
},
});
Le code d'index.tsx (qui reste inchangé par rapport au code précédent):
//index.tsx
import { ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
export default function Index() {
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function renderTodoList() {
return todoList.map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu />
</View>
</>
);
}
Nous avons comme résultat sur mobile:

Exercice: Bouton bleu pour la tab active
Afin de connaître la tab qui sera active (cliqué), il faut se créer un state dans index.jsx. Par défaut, c'est la tab all qui sera sélectionnée:

L'appel du footer sera alors:

Il faudra se faire une fonction dans le composant (TabBottomMenu.jsx)qui va détecter la tabulation active afin de mettre celle-ci en bleu (#2F76E5):

Voici le code du composant:
//TabBottomMenu.jsx
import { Text, TouchableOpacity, View } from 'react-native';
import { s } from './TabBottomMenu.style';
export function TabBottomMenu({ selectedTabName }) {
function getTextStyle(tabName) {
return {
fontWeight: 'bold',
color: tabName === selectedTabName ? '#2F76E5' : 'black',
};
}
return (
<View style={s.container}>
<TouchableOpacity>
<Text style={getTextStyle('all')}>All</Text>
</TouchableOpacity>
<TouchableOpacity>
<Text style={getTextStyle('inProgress')}>In progress</Text>
</TouchableOpacity>
<TouchableOpacity>
<Text style={getTextStyle('done')}>Done</Text>
</TouchableOpacity>
</View>
);
}
Voici le résultat sur mobile (le bouton ALL est en bleu par défaut):

Exercice: Bouton bleu sur onPress
Rajoutons la propriété onPress pour détecter le bouton qui a été cliqué dans le footer. L'appel à parti de l'index devient:

Le composant recoit maintenant en props onPress et doit gérer celui-ci:
//TabBottomMenu.jsx
import { Text, TouchableOpacity, View } from 'react-native';
import { s } from './TabBottomMenu.style';
export function TabBottomMenu({ selectedTabName, onPress }) {
function getTextStyle(tabName) {
return {
fontWeight: 'bold',
color: tabName === selectedTabName ? '#2F76E5' : 'black',
};
}
return (
<View style={s.container}>
<TouchableOpacity onPress={() => onPress('all')}>
<Text style={getTextStyle('all')}>All</Text>
</TouchableOpacity>
<TouchableOpacity onPress={() => onPress('inProgress')}>
<Text style={getTextStyle('inProgress')}>In progress</Text>
</TouchableOpacity>
<TouchableOpacity onPress={() => onPress('done')}>
<Text style={getTextStyle('done')}>Done</Text>
</TouchableOpacity>
</View>
);
}
Exercice: Activités par bouton
Le filtrge de la liste de tâche peut être accompli de plusieurs manières. Nous pourrions utiliser la fonction filter(). Mais pour les besoin du cours, nous allons utiliser la fonction reduce() et envoyer par props la todoList pour que celle-ci soit manipulé par le composant:
Dans l'index.tsx nous avons:

Dans le composant TabBottomMenu.jsx nous rajoutons une fonction qui calcul le nombre d'éléments pour chaque boutons (all, inProgress et done) à l'aide de la fonction reduce():

Cette fonction utilise reduce pour compter le nombre de tâches selon leur statut.
- L'accumulateur (acc) est initialisé avec un objet contenant trois compteurs :
all: nombre total de tâches (égal à la longueur du tableau todoList)inProgress: nombre de tâches en cours (initialisé à 0)done: nombre de tâches terminées (initialisé à 0)
- Pour chaque tâche (todo) dans la liste :
- Si
todo.isCompletedest vrai : incrémente le compteurdone - Sinon : incrémente le compteur
inProgress
- Si
- L'opérateur ternaire
todo.isCompleted ? acc.done++ : acc.inProgress++est utilisé pour cette logique
À la fin, la fonction retourne un objet avec :
- Le nombre total de tâches (all)
- Le nombre de tâches en cours (inProgress)
- Le nombre de tâches terminées (done)
Nous pouvons maintenant utiliser l'objet countByStatus pour aller renseigner chacun des boutons:

Voici le code au complet:
//TabBottomMenu.jsx
import { Text, TouchableOpacity, View } from 'react-native';
import { s } from './TabBottomMenu.style';
export function TabBottomMenu({ selectedTabName, onPress, todoList }) {
const countByStatus = todoList.reduce(
(acc, todo) => {
todo.isCompleted ? acc.done++ : acc.inProgress++;
return acc;
},
{ all: todoList.length, inProgress: 0, done: 0 }
);
function getTextStyle(tabName) {
return {
fontWeight: 'bold',
color: tabName === selectedTabName ? '#2F76E5' : 'black',
};
}
return (
<View style={s.container}>
<TouchableOpacity onPress={() => onPress('all')}>
<Text style={getTextStyle('all')}>All ({countByStatus.all})</Text>
</TouchableOpacity>
<TouchableOpacity onPress={() => onPress('inProgress')}>
<Text style={getTextStyle('inProgress')}>
In progress ({countByStatus.inProgress})
</Text>
</TouchableOpacity>
<TouchableOpacity onPress={() => onPress('done')}>
<Text style={getTextStyle('done')}>Done ({countByStatus.done})</Text>
</TouchableOpacity>
</View>
);
}
Pour l'index:
//index.tsx
import { ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
export default function Index() {
const [selectedTabName, setSelectedTabName] = useState('all');
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function renderTodoList() {
return todoList.map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu
todoList={todoList}
onPress={setSelectedTabName}
selectedTabName={selectedTabName}
/>
</View>
</>
);
}
Et voici le résulat sur le mobile:

Filtrage des tâches
Le filtrage des tâches proprement dit va se faire dans l'app principale (index.tsx) à l'aide de la fonction getFilteredList() et l'utilisation de la fonction filter():

Cette fonction getFilteredList() sert à filtrer la liste des tâches en fonction d'un onglet sélectionné (selectedTabName). Elle utilise une structure switch pour déterminer quel filtre appliquer.
Analysons chaque cas :
case "all":- Retourne simplement
todoListsans filtre - Affiche toutes les tâches
- Retourne simplement
case "inProgress":- Utilise
filter()pour retourner uniquement les tâches où!todo.isCompletedest vrai - Donc retourne toutes les tâches qui ne sont PAS complétées
!todo.isCompletedsignifie "tâche non complétée"
- Utilise
case "done":- Utilise
filter()pour retourner uniquement les tâches oùtodo.isCompletedest vrai - Donc retourne toutes les tâches qui sont complétées
- Utilise
Cette liste filtré peut maintenant être utilisé par la fonction renderTodoList().

devient (notez que malgré le signe d'erreur, getFilteredList(0 s'exécute sans problème)

Voici le code final:
//index.tsx
import { ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
export default function Index() {
const [selectedTabName, setSelectedTabName] = useState('all');
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function getFilteredList() {
switch (selectedTabName) {
case 'all':
return todoList;
case 'inProgress':
return todoList.filter(todo => !todo.isCompleted);
case 'done':
return todoList.filter(todo => todo.isCompleted);
}
}
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function renderTodoList() {
return getFilteredList().map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu
todoList={todoList}
onPress={setSelectedTabName}
selectedTabName={selectedTabName}
/>
</View>
</>
);
}
Voici l'app sur mobile (fonctionnelle avec le filtrage):

Étape 10: Supprimer une tâche
La suppression d'une tâche aura lieu lorsque l'utilisateur appui pour un long moment sur une tâche. Pour détecter ce comportement, il existe la propriété onLongPress sur le bouton que nous allons implémenter dans le composant CardTodo.

Voici le code du composant (CardTodo.jsx):
//CardTodo.jsx
import { Image, Text, TouchableOpacity } from 'react-native';
import checkImg from '../../assets/images/check.png';
import { s } from './CardTodo.style';
export function CardTodo({ todo, onPress, onLongPress }) {
return (
<TouchableOpacity
onLongPress={() => onLongPress(todo)}
onPress={() => onPress(todo)}
style={s.card}
>
<Text
style={[
s.txt,
todo.isCompleted && { textDecorationLine: 'line-through' },
]}
>
{todo.title}
</Text>
{todo.isCompleted && <Image style={s.img} source={checkImg} />}
</TouchableOpacity>
);
}
Dans index.tsx, nous allons envoyer la props onLongPress mais aussi implémenter la fonction d'alerte et le filtrage grâce à la méthode filter().

La fonction deleteTodo gère la suppression d'une tâche avec une confirmation via une alerte. La fonction fait deux choses principales :
- Affiche une alerte de confirmation avec :
- Deux boutons : "Supprimer" et "Annuler"
- Le bouton "Supprimer" est en rouge (style 'destructive')
- Le bouton "Annuler" a un style de type 'cancel'
- Si l'utilisateur clique sur "Supprimer" :
- Utilise
filterpour créer une nouvelle liste excluant la tâche à supprimer todo.id !== todoToDelete.idgarde toutes les tâches dont l'ID est différent de celui de la tâche à supprimer- Met à jour la liste avec
setTodoList
- Utilise
Si l'utilisateur clique sur "Annuler", rien ne se passe et l'alerte se ferme simplement.
Voici le code final:
//index.tsx
import { Alert, ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
export default function Index() {
const [selectedTabName, setSelectedTabName] = useState('all');
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function getFilteredList() {
switch (selectedTabName) {
case 'all':
return todoList;
case 'inProgress':
return todoList.filter(todo => !todo.isCompleted);
case 'done':
return todoList.filter(todo => todo.isCompleted);
}
}
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function deleteTodo(todoToDelete) {
Alert.alert('Suppression', ' Supprimer cette tâche ?', [
{
text: 'Supprimer',
style: 'destructive',
onPress: () => {
setTodoList(todoList.filter(todo => todo.id !== todoToDelete.id));
},
},
{
text: 'Annuler',
style: 'cancel',
},
]);
}
function renderTodoList() {
return getFilteredList().map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onLongPress={deleteTodo} onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu
todoList={todoList}
onPress={setSelectedTabName}
selectedTabName={selectedTabName}
/>
</View>
</>
);
}
Étape 11: Bouton ajouter une tâche
Il est temps de faire la logique afin de rajouter une tâche à notre application. Pour ce faire, nous allons construire un bouton qui permettra une telle action:

Nous allons nous créer un composant ButtonAdd.jsx avec son style:

Voici le code du composant:
//ButtonAdd.jsx
import { Text, TouchableOpacity } from 'react-native';
import { s } from './ButtonAdd.style';
export function ButtonAdd() {
return (
<TouchableOpacity style={s.btn}>
<Text style={s.txt}>+ New todo</Text>
</TouchableOpacity>
);
}
Et le code du style (prendre note que le bouton est dans une position absolue):
//ButtonAdd.style.js
import { StyleSheet } from 'react-native';
export const s = StyleSheet.create({
btn: {
position: 'absolute',
bottom: 60,
right: 20,
backgroundColor: '#C2DAFF',
alignItems: 'center',
borderRadius: 7,
},
txt: {
color: '#2F76E5',
fontWeight: 'bold',
fontSize: 18,
paddingVertical: 15,
paddingHorizontal: 30,
},
});
Finalement, nous importons notre composant et appelons celle-ci dans index.tsx:


Voici le code d'index.tsx:
//index.tsx
import { Alert, ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
import { ButtonAdd } from '../components/ButtonAdd/ButtonAdd';
export default function Index() {
const [selectedTabName, setSelectedTabName] = useState('all');
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function getFilteredList() {
switch (selectedTabName) {
case 'all':
return todoList;
case 'inProgress':
return todoList.filter(todo => !todo.isCompleted);
case 'done':
return todoList.filter(todo => todo.isCompleted);
}
}
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function deleteTodo(todoToDelete) {
Alert.alert('Suppression', ' Supprimer cette tâche ?', [
{
text: 'Supprimer',
style: 'destructive',
onPress: () => {
setTodoList(todoList.filter(todo => todo.id !== todoToDelete.id));
},
},
{
text: 'Annuler',
style: 'cancel',
},
]);
}
function renderTodoList() {
return getFilteredList().map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onLongPress={deleteTodo} onPress={updateTodo} todo={todo} />
</View>
));
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
<ButtonAdd />
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu
todoList={todoList}
onPress={setSelectedTabName}
selectedTabName={selectedTabName}
/>
</View>
</>
);
}
Voici le résultat sur mobile:

Étape 12: Logique pour rajouter une tâche
Lorsque nous appuyons sur le bouton, nous voulons une intéraction avec l'utilisateur. Afin de ne pas réinventer la roue, nous allons réutiliser le code suivant: https://www.npmjs.com/package/react-native-dialog
Commencons par installer le composant:
npm install react-native-dialog

Importons le composant dans index.tsx

import Dialog from "react-native-dialog";
Il va falloir se faire un state pour connaître l'état d'affichage du dialogue. Par défaut, celui-ci ne sera pas affiché:

const [isAddDialogVisible, setIsAddDialogVisible] = useState(false);
En suivant le guide d'utilisation, nous rajoutons le code suivant à la fin de notre index.tsx et nous nous rajoutons une fonction showAddDialog qui sera appelé par le bouton lorsque celui-ci est apppuyé (onPress) et qui aura comme fonction d'afficher le dialogue à l'utilisateur:

Voici le code:
<Dialog.Container
visible={isAddDialogVisible}
onBackdropPress={() => setIsAddDialogVisible(false)}
>
<Dialog.Title>Créer une tâche</Dialog.Title>
<Dialog.Description>
Choisi un nom pour la nouvelle tâche
</Dialog.Description>
<Dialog.Input onChangeText={() => ''} />
<Dialog.Button label="Créer" onPress={() => ''} />
</Dialog.Container>
Le bouton appelle la fonction showAddDialog qui a comme unique fonction de setter la variable booléenne du state à TRUE afin que le dialogue apparaise à l'écran .


Ne pas oublier de rajouter le props onPress au composant ButtonAdd.jsx:

Voici le code:
//ButtonAdd.jsx
import { Text, TouchableOpacity } from 'react-native';
import { s } from './ButtonAdd.style';
export function ButtonAdd({ onPress }) {
return (
<TouchableOpacity onPress={onPress} style={s.btn}>
<Text style={s.txt}>+ New todo</Text>
</TouchableOpacity>
);
}
Voici le résultat sur mobile:

Et le code au complet:
//index.tsx
import { Alert, ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
import { ButtonAdd } from '../components/ButtonAdd/ButtonAdd';
import Dialog from 'react-native-dialog';
export default function Index() {
const [selectedTabName, setSelectedTabName] = useState('all');
const [isAddDialogVisible, setIsAddDialogVisible] = useState(false);
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function getFilteredList() {
switch (selectedTabName) {
case 'all':
return todoList;
case 'inProgress':
return todoList.filter(todo => !todo.isCompleted);
case 'done':
return todoList.filter(todo => todo.isCompleted);
}
}
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function deleteTodo(todoToDelete) {
Alert.alert('Suppression', ' Supprimer cette tâche ?', [
{
text: 'Supprimer',
style: 'destructive',
onPress: () => {
setTodoList(todoList.filter(todo => todo.id !== todoToDelete.id));
},
},
{
text: 'Annuler',
style: 'cancel',
},
]);
}
function renderTodoList() {
return getFilteredList().map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onLongPress={deleteTodo} onPress={updateTodo} todo={todo} />
</View>
));
}
function showAddDialog() {
setIsAddDialogVisible(true);
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
<ButtonAdd onPress={showAddDialog} />
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu
todoList={todoList}
onPress={setSelectedTabName}
selectedTabName={selectedTabName}
/>
</View>
<Dialog.Container
visible={isAddDialogVisible}
onBackdropPress={() => setIsAddDialogVisible(false)}
>
<Dialog.Title>Créer une tâche</Dialog.Title>
<Dialog.Description>
Choisi un nom pour la nouvelle tâche
</Dialog.Description>
<Dialog.Input onChangeText={() => ''} />
<Dialog.Button label="Créer" onPress={() => ''} />
</Dialog.Container>
</>
);
}
Attention, le menu Dialog est incompatible avec les navigateurs web. Vous pourriez avoir l'erreur suivante:

Menu et rajout d'une tâche
Lorsque nous rajoutons une tâche, il faut stocker l'information de la nouvelle tâche dans un state:

Nous allons nous rajouter un state:

Au moment où le texte change, nous allons affecter la propriété onChangeText et appeler setInputValue:

Nous allons aussi nous programmer une fonction (addTodo()) qui rajoute la tâche à la liste.
Par défaut, la tâche est non-complété (isCompleted: false) et uuid.v4() t'assurer d'avoir un identifiant unique:

- La fonction crée un nouvel objet
newTodoqui représente une nouvelle tâche avec :- Un
idunique généré paruuid.v4()(un générateur d'identifiants uniques) - Un
titlequi prend la valeur deinputValue(probablement une variable contenant le texte saisi par l'utilisateur) - Un état
isCompletedinitialisé àfalse(la tâche n'est pas terminée par défaut)
- Un
- Ensuite, elle fait deux actions :
setTodoList([...todoList, newTodo]): met à jour la liste des tâches en ajoutant la nouvelle tâche. La syntaxe[...todoList, newTodo]crée un nouveau tableau contenant toutes les tâches existantes plus la nouvellesetIsAddDialogVisible(false): ferme la boîte de dialogue d'ajout de tâche en mettant sa visibilité àfalse
Afin de nous assurer d'avoir un identifiant unique, nous utilisons le composant react-native-uuid:
https://www.npmjs.com/package/react-native-uuid
Il va donc falloir préalablement l'installer:
npm install react-native-uuid

Et l'importer dans index.tsx:

Finalement, nous allons aussi nous assurer d'avoir un contenu lors de la création de la tâche (afin d'éviter de créer une tâche vide). Le bouton va être DISABLE si aucun texte n'est détecté et onPress, nous allons appeler la fonction addTodo:

Voici le code final:
//index.tsx
import { Alert, ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
import { ButtonAdd } from '../components/ButtonAdd/ButtonAdd';
import Dialog from 'react-native-dialog';
import uuid from 'react-native-uuid';
export default function Index() {
const [selectedTabName, setSelectedTabName] = useState('all');
const [isAddDialogVisible, setIsAddDialogVisible] = useState(false);
const [inputValue, setInputValue] = useState('');
const [todoList, setTodoList] = useState([
{ id: 1, title: 'Sortir le chien', isCompleted: true },
{ id: 2, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 3, title: 'Faire les courses', isCompleted: true },
{ id: 4, title: 'Appeler le vétérinaire', isCompleted: true },
{ id: 5, title: 'Sortir le chien', isCompleted: true },
{ id: 6, title: 'Aller chez le garagiste', isCompleted: false },
{ id: 7, title: 'Faire les courses', isCompleted: true },
{ id: 8, title: 'Appeler le vétérinaire', isCompleted: true },
]);
function getFilteredList() {
switch (selectedTabName) {
case 'all':
return todoList;
case 'inProgress':
return todoList.filter(todo => !todo.isCompleted);
case 'done':
return todoList.filter(todo => todo.isCompleted);
}
}
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function deleteTodo(todoToDelete) {
Alert.alert('Suppression', ' Supprimer cette tâche ?', [
{
text: 'Supprimer',
style: 'destructive',
onPress: () => {
setTodoList(todoList.filter(todo => todo.id !== todoToDelete.id));
},
},
{
text: 'Annuler',
style: 'cancel',
},
]);
}
function renderTodoList() {
return getFilteredList().map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onLongPress={deleteTodo} onPress={updateTodo} todo={todo} />
</View>
));
}
function showAddDialog() {
setIsAddDialogVisible(true);
}
function addTodo() {
const newTodo = {
id: uuid.v4(),
title: inputValue,
isCompleted: false,
};
setTodoList([...todoList, newTodo]);
setIsAddDialogVisible(false);
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
<ButtonAdd onPress={showAddDialog} />
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu
todoList={todoList}
onPress={setSelectedTabName}
selectedTabName={selectedTabName}
/>
</View>
<Dialog.Container
visible={isAddDialogVisible}
onBackdropPress={() => setIsAddDialogVisible(false)}
>
<Dialog.Title>Créer une tâche</Dialog.Title>
<Dialog.Description>
Choisi un nom pour la nouvelle tâche
</Dialog.Description>
<Dialog.Input onChangeText={setInputValue} />
<Dialog.Button
disabled={inputValue.trim().length === 0}
label="Créer"
onPress={addTodo}
/>
</Dialog.Container>
</>
);
}
Étape 13: Persistance des données
Jusqu'à présent, nos données étaient créé au démarrage de l'application et mis dans un tableau. Nous allons mettre ces données dans l'espace (storage) du téléphone. Pour ce faire, nous allons utiliser le composant AsyncStorage (https://docs.expo.dev/versions/latest/sdk/async-storage/). L'installation se fait par la ligne de code suivante :
npx expo install @react-native-async-storage/async-storage

Nous allons importer le composant dans notre index.tsx:

import AsyncStorage from '@react-native-async-storage/async-storage';
AsyncStorage est une API de stockage local simple et asynchrone qui permet de stocker des données sous forme de paires clé-valeur de manière persistante dans l'application.
Voici un exemple de son utilisation:
// Importer AsyncStorage
import AsyncStorage from '@react-native-async-storage/async-storage';
// Stocker une donnée
const storeData = async (key, value) => {
try {
// Les valeurs doivent être stockées sous forme de chaînes
await AsyncStorage.setItem(key, JSON.stringify(value));
} catch (error) {
console.error('Erreur lors du stockage:', error);
}
};
// Récupérer une donnée
const getData = async (key) => {
try {
const value = await AsyncStorage.getItem(key);
// Convertir la chaîne JSON en objet JavaScript
return value != null ? JSON.parse(value) : null;
} catch (error) {
console.error('Erreur lors de la récupération:', error);
return null;
}
};
// Supprimer une donnée
const removeData = async (key) => {
try {
await AsyncStorage.removeItem(key);
} catch (error) {
console.error('Erreur lors de la suppression:', error);
}
};
Points importants à retenir :
- Toutes les opérations sont asynchrones et renvoient des Promises
- Les valeurs doivent être stockées sous forme de chaînes/texte (d'où l'utilisation de JSON.stringify)
- Vous pouvez stocker plusieurs types de données après les avoir sérialisées
Nos changements
Pour les besoins de notre application, nous allons nous créer 2 fonctions ainsi que 2 variables globales afin de connaître l'état du rendering:
Deux fonctions:
- saveTodoList()
- loadTodoList()
2 variables globales:

La fonction saveTodoList()

C'est une fonction async (asynchrone) permet d'utiliser await pour gérer les opérations asynchrones
- Elle commence par afficher 'SAVE' dans la console (pour le débogage)
- Un bloc
try/catchest utilisé pour gérer les erreurs potentielles :- Dans le
try:JSON.stringify(todoList)convertit l'objettodoListen chaîne JSONAsyncStorage.setItem()sauvegarde cette chaîne dans le stockage local sous la clé '@todolist'awaitest utilisé carsetItemest une opération asynchrone- Le préfixe '@' dans '@todolist' est une convention de nommage courante dans React Native
- Dans le
catch:- Si une erreur survient, elle est capturée dans
err - Une alerte est affichée avec le message d'erreur
- Si une erreur survient, elle est capturée dans
- Dans le
La fonction loadTodoList()

La fonction commence par afficher 'LOAD' dans la console (pour le débogage)
- Dans le bloc
try:await AsyncStorage.getItem('@todolist')récupère la chaîne JSON stockée- La fonction vérifie si la liste existe (
!= null) - Si elle existe :
JSON.parse()convertit la chaîne JSON en objet JavaScript- Un flag
isLoadUpdateest mis àtrue(pour indiquer que c'est un chargement initial) setTodoList()met à jour l'état de l'application avec les données chargées
- Dans le bloc
catch:- Si une erreur survient pendant le chargement, une alerte est affichée avec le message d'erreur
Finalement, afin de refaire un rendering à chaque modification de la todo liste, nous allons utiliser deux useEffect.
Premier use effect

Le premier useEffect :
- Est exécuté une seule fois au montage du composant (grâce au tableau de dépendances vide
[]) - Appelle
loadTodoList()pour charger les tâches depuis le stockage local
Deuxième useEffect

- Le deuxième
useEffect:- Est exécuté chaque fois que
todoListchange (indiqué dans le tableau de dépendances[todoList]) - Contient une logique pour éviter des sauvegardes inutiles :
- Si
isLoadUpdateest vrai (cas d'un chargement initial), il le remet à faux - Sinon :
- Si ce n'est pas le premier rendu (
!isFirstRender), sauvegarde la liste - Si c'est le premier rendu, marque
isFirstRendercomme faux
- Si ce n'est pas le premier rendu (
- Si
- Est exécuté chaque fois que
Cette structure permet de :
- Charger les données au démarrage
- Éviter une sauvegarde lors du chargement initial
- Sauvegarder automatiquement à chaque modification de la liste après le premier rendu
Finalement, nous pouvons changer le code du state du todoList:

Par le code suivant:

Voici le code final:
//index.tsx
import { Alert, ScrollView, Text, View } from 'react-native';
import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
import { s } from '../App.style';
import { Header } from '../components/Header/Header';
import { CardTodo } from '../components/CardTodo/CardTodo';
import { useEffect, useState } from 'react';
import { TabBottomMenu } from '../components/TabBottomMenu/TabBottomMenu';
import { ButtonAdd } from '../components/ButtonAdd/ButtonAdd';
import Dialog from 'react-native-dialog';
import uuid from 'react-native-uuid';
import AsyncStorage from '@react-native-async-storage/async-storage';
let isFirstRender = true;
let isLoadUpdate = false;
export default function Index() {
const [selectedTabName, setSelectedTabName] = useState('all');
const [isAddDialogVisible, setIsAddDialogVisible] = useState(false);
const [inputValue, setInputValue] = useState('');
const [todoList, setTodoList] = useState([]);
useEffect(() => {
loadTodoList();
}, []);
useEffect(() => {
if (isLoadUpdate) {
isLoadUpdate = false;
} else {
if (!isFirstRender) {
saveTodoList();
} else {
isFirstRender = false;
}
}
}, [todoList]);
async function saveTodoList() {
console.log('SAVE');
try {
await AsyncStorage.setItem('@todolist', JSON.stringify(todoList));
} catch (err) {
alert('Erreur ' + err);
}
}
async function loadTodoList() {
console.log('LOAD');
try {
const stringifiedTodoList = await AsyncStorage.getItem('@todolist');
if (stringifiedTodoList !== null) {
const parsedTodoList = JSON.parse(stringifiedTodoList);
isLoadUpdate = true;
setTodoList(parsedTodoList);
}
} catch (err) {
alert('Erreur ' + err);
}
}
function getFilteredList() {
switch (selectedTabName) {
case 'all':
return todoList;
case 'inProgress':
return todoList.filter(todo => !todo.isCompleted);
case 'done':
return todoList.filter(todo => todo.isCompleted);
}
}
function updateTodo(todo) {
const updatedTodo = {
...todo,
isCompleted: !todo.isCompleted,
};
const indexToUpdate = todoList.findIndex(
todo => todo.id === updatedTodo.id
);
const updatedTodoList = [...todoList];
updatedTodoList[indexToUpdate] = updatedTodo;
setTodoList(updatedTodoList);
}
function deleteTodo(todoToDelete) {
Alert.alert('Suppression', ' Supprimer cette tâche ?', [
{
text: 'Supprimer',
style: 'destructive',
onPress: () => {
setTodoList(todoList.filter(todo => todo.id !== todoToDelete.id));
},
},
{
text: 'Annuler',
style: 'cancel',
},
]);
}
function renderTodoList() {
return getFilteredList().map(todo => (
<View style={s.cardItem} key={todo.id}>
<CardTodo onLongPress={deleteTodo} onPress={updateTodo} todo={todo} />
</View>
));
}
function showAddDialog() {
setIsAddDialogVisible(true);
}
function addTodo() {
const newTodo = {
id: uuid.v4(),
title: inputValue,
isCompleted: false,
};
setTodoList([...todoList, newTodo]);
setIsAddDialogVisible(false);
}
return (
<>
<SafeAreaProvider>
<SafeAreaView style={s.app}>
<View style={s.header}>
<Header />
</View>
<View style={s.body}>
<ScrollView>{renderTodoList()}</ScrollView>
</View>
<ButtonAdd onPress={showAddDialog} />
</SafeAreaView>
</SafeAreaProvider>
<View style={s.footer}>
<TabBottomMenu
todoList={todoList}
onPress={setSelectedTabName}
selectedTabName={selectedTabName}
/>
</View>
<Dialog.Container
visible={isAddDialogVisible}
onBackdropPress={() => setIsAddDialogVisible(false)}
>
<Dialog.Title>Créer une tâche</Dialog.Title>
<Dialog.Description>
Choisi un nom pour la nouvelle tâche
</Dialog.Description>
<Dialog.Input onChangeText={setInputValue} />
<Dialog.Button
disabled={inputValue.trim().length === 0}
label="Créer"
onPress={addTodo}
/>
</Dialog.Container>
</>
);
}
Étape 14: Déploiement
Avant de déployer notre app, nous allons configurer quelques paramètres dans le fichier app.json:

Création d'un projet
Il faut dans un premier temps nous créer un projet (à partir du site web d'Expo):


À la création du projet, une image similaire à celle-ci devrait apparaître:

On effectue la première ligne de commande:
npm install --global eas-cli
On navigue dans notre projet (pas besoin de faire les deux prochaines lignes de commande puisque notre projet existe déjà)

On effectue la dernière ligne de commande (afin de binder notre projet au code d'Expo):
eas init --id xxxxles_numeros_de_votre_projetxxxxxx
Déploiement de notre projet
Pour le déploiement, nous allons suivre les étapes suivantes:
https://docs.expo.dev/eas/hosting/get-started/
Tout d'abord, il faut installer l'outil (si ce n'est pas déjà fait précédemment):
npm install --global eas-cli
Par la suite, il faut se logger sur notre compte Expo:
eas login
Nous allons construire notre build selon notre plateforme (ex: IOS):
eas build --platform ios
Nous aurions aussi pu le faire pour toutes les plateformes:
eas build --platform all
Le CLI va vous générer l'url de votre application:

Il suffit maintenant de faire pointer Expo de votre mobile sur le lien URL: