Firebase est une plate-forme de développement de Google rapide et facile à configurer. Dans ce tutoriel, nous allons mettre en place une application de base intégrant Firebase / Firestore et Angular. Nous utiliserons un package appelé AngularFire — la bibliothèque angulaire officielle de Firebase – ainsi que le SDK Firebase lui-même.

L’utilisation des services cloud devient de plus en plus populaire, car cela permet de gagner du temps sans avoir à créer votre propre sécurité, maintenance, etc. Avec Firebase de Google, nous allons mettre en place un Firestore gratuit pour servir de base de données.

Firebase offre également une base de données en temps réel, mais elle stocke tout dans un grand arbre JSON.

Cela rend la base de données plus simple, mais avec le cloud Firestore, qui est ce que nous utiliserons, il existe des documents flexibles, ce qui le rend plus évolutif pour des données plus volumineuses. Firestore est également plus rapide et globalement plus intuitif si vous ne connaissez pas les bases de données.

Configurer la console Firebase

Vous devrez commencer par configurer votre projet sur la console Firebase. Tout d’abord, allez ici pour trouver la console.

Créez un projet, donnez-lui un nom et suivez les étapes. Une fois que vous avez terminé, vous serez à la vue d’ensemble du projet.

Non, nous devons ajouter une application. Vous devriez être sur la page Aperçu du projet. Ici, vous verrez « Commencez par ajouter Firebase à votre application » »

Pour ce faire, cliquez sur le bouton « <> » (il s’agit d’ajouter une application Web). Vous pouvez configurer l’hébergement ici, mais nous ne couvrirons pas cela dans ce tutoriel.

Allez-y et enregistrez l’application. Sur la page suivante, vous verrez des scripts pour configurer le SDK Firebase. Ceux-ci sont utiles, mais nous verrons plus tard comment obtenir tout ce dont nous avons besoin si vous les manquez sur cette page. Allez-y et continuez à consoler.

Initialisez Firestore et créez les premiers documents

Dans la console Firebase, dans le volet gauche, sous Développer, vous pouvez trouver l’onglet Base de données. Cliquez dessus et vous serez redirigé vers une page où vous pourrez cliquer sur « Créer une base de données ». Un modal apparaîtra où vous pouvez sélectionner le mode de production ou le mode test; nous voulons le mode test. Ce n’est pas sûr, mais bien pour les tests.

Si vous continuez, il vous sera demandé de sélectionner un emplacement. Allez-y et choisissez celui qui convient. Une fois que vous appuyez sur terminé, la configuration du Firestore prendra quelques minutes.

Une fois terminé, vous serez à votre Firestore. Allez-y et sélectionnez « Démarrer la collecte ».

Une capture d'écran de la console pour configurer votre projet Firebase.

Une capture d'écran de la console pour configurer votre projet Firebase.

Il vous demandera de créer un ID de collection; pour notre exemple, nommons-le simplement « testCollection ». Cliquez sur suivant et cela vous amènera au formulaire pour créer votre premier document.

Nous laisserons l’ID du document vide — Firestore le générera automatiquement pour vous. Sous Champ, tapez simplement « champ ». Ensuite, vous verrez « string » comme type par défaut. Il n’y a aucune raison de changer cela pour l’instant, alors laissez-le tel quel. Sous Valeur, tapez « value1 ». Cliquez sur enregistrer et vous verrez que vous avez créé votre premier document!

Pour notre exemple plus tard, créons un deuxième document. Dans la colonne du milieu, vous verrez « + Ajouter un document. »allez-y et cliquez dessus et vous serez ramené au formulaire de création de document.

Ici, tapez simplement « champ » sous Champ et « value2 » sous Valeur. Cliquez sur Enregistrer. Maintenant, nous avons deux documents.

Démarrons un nouveau projet Angular

Faisons notre projet frontend avec l’interface de ligne de commande Angular CLI (interface de ligne de commande). Ouvrez la fenêtre du terminal et installez l’interface de ligne de commande angulaire globalement :

npm install -g @angular/cli

Avec cela installé, vous pouvez exécuter la commande ng.

Dans le terminal, tapez ce qui suit:

ng new your-app-name

Vous pouvez nommer votre projet comme vous le souhaitez.

Une fois que vous l’aurez démarré, l’interface de ligne de commande angulaire vous guidera à travers quelques options de configuration.

Vous pouvez ajouter un routage, puis choisir le format de feuille de style que vous souhaitez qu’Angular génère pour votre application.

Après cela, il parcourra le reste et créera votre application Angulaire.

Une fois cela terminé, allez-y et remplacez le répertoire du terminal par celui que nous venons de créer:

cd your-app-name

Dans le répertoire de l’application Angular, vous pouvez exécuter ng serve construire et servir votre application localement.

Configurez Firebase dans l’application Angular

Obtenons le SDK Firebase en exécutant ce qui suit dans votre terminal dans le répertoire de votre projet Angular:

npm i --save firebase

Maintenant Firebase est ajouté à votre projet.

Accédez à la console Firebase. Dans le menu de gauche, vous verrez « Aperçu du projet » avec une icône d’engrenage à côté. Cliquez sur l’icône, puis Paramètres du projet dans la fenêtre contextuelle. Ici, allez dans l’onglet Général et faites défiler vers le bas.

Sous « extrait de SDK Firebase », cliquez sur le bas de la radio à côté de CDN (sa valeur par défaut est Automatique). Ici, vous trouverez tout ce dont vous avez besoin pour connecter votre application à Firebase. F

ind la variable firebaseConfig — nous devrons copier ces informations dans l’application Angular. Cela ressemble à ceci (sauf que tout sera rempli correctement):

var firebaseConfig = { apiKey: "************************************", authDomain: "*************.firebaseapp.com", databaseURL: "https://************.firebaseio.com", projectId: "***************", storageBucket: "****************.appspot.com", messagingSenderId: "*************", appId: "********************************", measurementId: "****************",};

Dans votre application Angular, accédez au fichier généré app.module.ts (si vous avez créé votre projet Angular via la CLI: src > app > app.module.ts). Dans ce fichier, vous pouvez coller l’intégralité de la variable firebaseConfig (juste sous les importations, c’est bien).

L’ordre du jour suivant consiste à télécharger le package npm angular/fire. Avec ce package, vous pourrez interagir facilement avec Firebase.

Vous pouvez installer le paquet dans votre projet avec la ligne de code suivante:

npm i angular/fire

Avec cela installé, nous pouvons l’ajouter ici dans le fichier app.module.ts:

import { AngularFireModule } from @angular/fire';

Maintenant, dans le tableau imports, initialisez Firebase dans votre application en ajoutant la ligne de code suivante:

AngularFireModule.initializeApp(firebaseConfig)

Cette importation est pour Firebase en général, mais si nous voulons ajouter certains services, vous devrez les ajouter individuellement.

Pour le Firestore, ajoutez ceci en haut du fichier:

import { AngularFirestoreModule } from '@angular/fire/firestore';

Ensuite, dans le tableau des importations près du bas:

AngularFirestoreModule

Implémenter dans l’application

À ce stade, il peut être logique de créer un composant ou deux dans notre application Angulaire. Vous pouvez créer un nouveau composant dans votre application à l’aide de l’interface de ligne de commande de votre projet.

Faisons un composant home en tapant la commande dans le terminal :

ng g c home

Le « g c » signifie « générer un composant ». Cela générera un dossier d’accueil avec quatre fichiers en dessous: un fichier HTML, un fichier SCSS (ou quel que soit le style que vous utilisez), un fichier TypeScript et un.fichier de spécifications.

Si vous souhaitez ignorer l’ajout du .fichier spec, propendez cet indicateur à votre commande generate:

ng g c home --skipTests=true

Nous allons faire notre logique dans notre composant home, mais n’oublions pas de l’ajouter dans notre fichier app.component.html. Vous pouvez toujours ajouter un composant home au routeur, mais pour plus de simplicité, ajoutons-le simplement dans le code HTML.

Si vous configurez un composant home comme je l’ai fait, le sélecteur sera « app-home », vous pourrez donc l’ajouter quelque part dans le fichier app.component.html comme ceci

<app-home></app-home>

Après cela, passons à nos opérations dans le composant home.

Plus tôt, nous avons créé une collection dans notre Firestore nommée testCollection; à l’intérieur, il y a deux documents ou objets. Examinons d’abord la « lecture » de ces deux documents de notre Firestore.

Lire

Dans le fichier home.component.ts, nous pouvons importer le Firestore via notre package Angular/fire:

import { AngularFirestore } from "@angular/fire/firestore";

Après l’importation, nous pouvons l’initialiser dans notre constructeur comme ceci:

constructor(private firestore: AngularFirestore) {}

div>

Qui attribue à notre AngularFirestore importé l’alias de « Firestore » — donnez-lui le nom que vous voulez.

La fonction ngOnInit est un endroit idéal pour lire depuis le Firestore juste à côté du gitgo.

Jetez un coup d’œil à ce code:

this.firestore .collection("testCollection") .get() .subscribe((ss) => { ss.docs.forEach((doc) => { this.myArray.push(doc.data()); }); });

Passons en revue cette étape par étape: comme vous le savez probablement, this.firestore fait référence à l’alias que nous avons créé pour notre AngularFirestore dans notre constructeur.

Le .collection('testCollection') est la façon dont nous nous référons à la collection que nous avons créée précédemment, et le .get() nous permet simplement d’obtenir toute cette collection (nous couvrirons l’interrogation de documents uniques dans la collection plus tard).

Lorsque nous .subscribe vers le firestore, il attend essentiellement de manière asynchrone l’API pour renvoyer les données. Techniquement, subscribe provient de RxJS et est un Observable qui se mettra à jour en cas de changement.

Maintenant, le Firestore renvoie toujours des instantanés de données, c’est pourquoi nous lui avons donné l’alias de ss. Sous l’instantané de notre base de données se trouvent les documents, qui sont les données que nous voulons, et nous pouvons utiliser la méthode de tableau .forEach pour parcourir le tableau de documents.

Dans l’exemple ci-dessus, nous avons obtenu le doc.data() de Firebase Firestore. Ce sera le document entier, qui dans notre cas est un objet avec une propriété. Par conséquent, lorsque nous le poussons dans notre tableau, nous devrons initialiser notre tableau comme le code suivant:

myArray: any = 

Cela nous permet de le voir dans notre code HTML, d’effacer ce qui s’y trouve et de le remplacer par ce qui suit:

<ul> <li *ngFor='let doc of myArray'> {{doc.field}} </li> </ul

Une liste complète en HTML avec deux valeurs.

Une liste complète en HTML avec deux valeurs.

Super! Nous avons lu avec succès les données de notre Firestore.

Écrivez

Tout d’abord, ajoutons ReactFormsModuleapp.module.ts, comme ceci:

import { ReactiveFormsModule } from "@Angular/forms";

Ajoutez également ReactiveFormsModule au tableau d’importation situé en bas.

Dans notre fichier home.component.html, ajoutons un formulaire pour capturer et envoyer de nouvelles données. Écrivez quelque chose comme ceci:

<form ="this.form"> <input placeholder="New Value" formControlName="newValue" type="text" class="input-field col s12" /> <button (click)="onSubmit()"> Submit </button></form>

Maintenant, si vous avez utilisé le code HTML ci-dessus, ajoutez l’importation suivante à notre fichier home.component.ts:

import { FormControl, FormGroup } from "@Angular/forms";

Ensuite, dans notre classe, ajoutez:

form = new FormGroup({ newValue: new FormControl('') })`

Cela acceptera à partir du HTML, du formulaire et de l’entrée que nous avons faite, avec le formControlName de newValue.

Ainsi, nous obtiendrons la chaîne saisie par l’utilisateur dans le HTML et l’enverrons comme valeur d’un nouveau document dans notre Firestore. Nous pouvons le faire en utilisant la fonction suivante:

onSubmit() { this.firestore.collection('testCollection').add({ field: this.form.value.newValue }) .then(res => { console.log(res); this.form.reset(); }) .catch(e => { console.log(e); }) }

De la même manière que nous lisons dans notre Firestore, nous écrirons cette fois en utilisant la même référence pour obtenir notre collection:

this.firestore.collection('testCollection')

Cette fois, nous ajouterons un document avec .add

div>. Nous voulons ajouter l’objet avec notre texte que nous avons reçu:

.add({field: this.form.valule.newValue})

Cela peut sembler étrange, mais c’est parce que nous obtenons la valeur du formulaire. Là, nous obtenons la propriété que nous avons nommée newValue. C’est pourquoi il s’agit de value.newValue.

Le reste de la fonction est simplement un .then et .catch pour gérer la réponse du Firestore.

Lors de l’écriture sur le Firestore, la réponse (en cas de succès) sera un objet volumineux et étrange.

Comme nous ne lisons rien, la seule utilisation de ces gestionnaires est si nous voulons faire quelque chose immédiatement après avoir écrit dans le Firestore (comme nous le faisons lorsque nous appelons .reset() pour effacer le formulaire).

Si vous allez de l’avant et exécutez l’application telle quelle (ng serve), vous remarquerez qu’elle n’apparaîtra pas sur notre liste après avoir entré une nouvelle valeur et l’avoir soumise à Firebase. Vous pouvez actualiser la page et elle devrait apparaître si l’écriture a réussi. Pourquoi ça ?

C’est parce qu’après avoir écrit à notre Firestore, nous n’avons pas lu le nouveau changement. Avec la façon dont notre fonction ngOnInit actuelle est configurée, nous n’observons pas de changements.

Pour voir les nouvelles données, nous devons changer la façon dont nous lisons les données:

ngOnInit() { this.docs = ; const collectionRef = this.db.collection('testCollection'); const collectionInstance = collectionRef.valueChanges(); collectionInstance.subscribe(ss => this.myArray = ss); }

Maintenant nous sommes abonnés. Vous verrez qu’après avoir ajouté un nouveau document à la base de données, il sera également ajouté à la liste dans notre application. La principale différence est que nous sommes maintenant abonnés à .valueChanges().

Query

Ajoutons un autre formulaire que nous pouvons utiliser pour interroger le Firestore en fonction de la valeur d’un document:

<form ="this.secondForm"> <input placeholder="value1" formControlName="valueToGet" type="text" class="input-field col s12" /> <button (click)="onQuery()"> Query </button></form>

Pour plus de simplicité, c’est exactement comme la première forme, mais avec des noms différents et une fonction différente. Allez-y et nommez-le à votre guise, mais assurez-vous simplement d’utiliser les nouveaux noms et non ceux que nous avons utilisés dans le formulaire précédent.

Dans le fichier typescript, assurez-vous d’initialiser le formulaire en haut de la classe:

secondForm = new FormGroup({ valueToGet: new FormControl('') })

De plus, ici où nous initialisons tout, ajoutez single: any; en tant que variable pour mettre notre document interrogé, et message: string; en tant que variable pour les messages d’erreur.

Avec cela, commençons à construire notre fonction onQuery.

onQuery() { if (!this.secondForm.value.valueToGet) { this.message = 'Cannot be empty'; this.single = null; } else { this.firestore.collection('testCollection', ref => ref.where("field", "==", this.secondForm.value.valueToGet)).get() .subscribe(ss => { if (ss.docs.length === 0) { this.message = 'Document not found! Try again!'; this.single = null; } else { ss.docs.forEach(doc => { this.message = ''; this.single = doc.data(); }) } }) } }

Tout d’abord, nous voyons si l’utilisateur a saisi quoi que ce soit. L’entrée peut être trouvée dans this.secondForm.value.valueToGet.

Donc, si cela est vide, nous voulons renvoyer un message et ne pas envoyer de chaîne vide pour interroger Firebase. Dans cette vérification « si », je m’assure également que notre variable « unique » est vide, car nous aurions pu l’interroger avec succès auparavant, mais maintenant nous voulons seulement envoyer le message que le formulaire ne peut pas être vide.

S’il n’est pas vide, nous allons de l’avant et interrogeons notre Firestore. Vous remarquerez quelque chose de nouveau dans le paramètre « collection » — dans Angular, nous faisons la requête directement à l’intérieur de ce paramètre. ref est une référence à la collection, et .where est le moyen le plus courant d’interroger des documents dans une collection Firestore.

Dans la méthode .where, nous indiquons d’abord à Firebase quel champ interroger dans chaque document. Tous nos champs sont simplement des « champs », ce qui facilite la tâche.

Ensuite, nous utilisons un comparateur, ==, qui consiste à demander si le champ isEqual. Vous pouvez également utiliser d’autres comparateurs comme <>=, et ainsi de suite.

Enfin, le troisième paramètre indique à Firebase à quoi comparer le champ — dans notre cas, nous voulons mettre la valeur d’entrée de l’utilisateur ici et voir si elle apparaît comme une valeur n’importe où dans notre Firestore.

Une note rapide sur une limitation de Firestore : l’interrogation avec la méthode .where est limitée.

Vous pouvez vérifier quelque chose qui est désactivé par une lettre, ou qui est en minuscule où le Firestore l’a enregistré en majuscules, et il ne le retournera pas. Vous pouvez faire des choses sur le frontend pour vous aider, comme rendre chaque entrée utilisateur minuscule pour correspondre au Firestore, mais cela ne peut aller que jusqu’à présent.

Bien sûr, vous pouvez tirer tout le Firestore dans le frontend (comme nous le faisons). Bien qu’interroger serait mieux, ce n’est peut-être pas idéal si votre Firestore est gigantesque. La façon suggérée de faire une recherche en texte intégral est d’utiliser Algolia.

Nous .get()puisque nous lisons la valeur, et nous .subscribe comme nous l’avons fait lors de la lecture de la collection entière.

Cependant, après avoir obtenu l’instantané du Firestore, nous voulons mettre une vérification « si », pour voir si quelque chose est retourné. Vous pouvez console.log l’instantané et voir s’il ne sera pas vide même s’il n’y avait pas de correspondance dans le Firestore.

Mais, la propriété docs sur l’instantané sera vide (un tableau vide pour être exact) s’il n’y a pas de correspondance pour notre requête. C’est ainsi que nous pouvons dire si notre requête correspond à quelque chose ou non.

Encore une fois, nous renverrons le message et définissons la variable single sur null. Si nous trouvons une correspondance, nous voulons faire le contraire, en définissant le message sur vide et en définissant la variable single sur les données renvoyées.

Maintenant que nous avons les données, revenons à home.component.html. Ajoutons du HTML pour gérer nos variables « message » et « single »:

<p style="color: red;">{{message || null}}</p><div *ngIf="single"> <h1>{{single.field}}</h1> <button style="background-color: lightblue">Edit</button> <button style="background-color: red">Delete</button></div>

Assez simple ici. Nous utilisons la directive *ngIf pour afficher uniquement le document correspondant s’il est trouvé. Comme vous vous en souviendrez, nous avons défini « single » sur null s’il n’était pas trouvé, ainsi l’intégralité de *ngIfdiv serait masquée. Idem avec le « message » — s’il est défini sur une chaîne vide.

Vous remarquerez également que nous avons ajouté des boutons pour notre section suivante, car nous devons encore pouvoir modifier et supprimer!

Mise à jour

Quelque chose qui nous aidera grandement à partir de maintenant est d’obtenir le id du document que nous avons interrogé.

Nous savons que nous ne modifierons ou ne supprimerons que le document interrogé, alors obtenons son id. Comme vous le remarquerez peut-être, lorsque nous créons des documents à partir de notre application, nous ne leur donnons pas de id.

De plus, lorsque nous avons créé nos documents dans le Firestore au début, nous laissons le Firestore générer automatiquement les ids; la même chose se produit avec ceux que nous créons à partir de notre application. Alors, comment obtenons-nous le id s?

Dans notre fonction onQuery, définissons une référence à notre requête de base de données comme ceci:

const docRef = this.firestore.collection('testCollection', ref => ref.where("field", "==", this.secondForm.value.valueToGet));

Rompez le .get() et tout ce qui suit, puis, sur une autre ligne, utilisez notre référence, comme ceci:

.get()et tout ce qui suit, puis, sur une autre ligne, utilisez notre référence, comme ceci:

docRef.get().subscribe(ss => ...)

… Et ainsi de suite. C’est essentiellement la même chose.

Maintenant, sous la méthode subscribe, ajoutons une autre ligne pour obtenir le document id:

docRef.snapshotChanges().forEach((changes) => { changes.map((a) => { this.id = a.payload.doc.id; });});

Évidemment, nous devrons initialiser this.id en haut: id: string = ''. Mais, maintenant, nous avons l’ID à utiliser dans nos fonctions d’édition et de suppression que nous allons créer.

De retour dans notre fichier home.component.html, changez le bouton d’édition que nous avons précédemment créé pour le suivant:

<button style='background-color: lightblue' (click)='openEdit()'>Edit</button>

Avec cette fonction openEdit(), dans notre fichier TypeScript, nous pouvons initialiser une variable d’édition:

edit: boolean = false

Et créez la fonction openEdit pour la basculer:

openEdit() { this.edit = !this.edit};

Chaque fois que la fonction est appelée, la variable d’édition passera de false à true, ou true à false.

Maintenant, dans notre fichier HTML, ajoutez le formulaire suivant. Il apparaîtra lorsque edit est vrai:

<form *ngIf="edit" ="this.editForm"> <input placeholder="{{single.field}}" formControlName="replaceValue" type="text" class="input-field col s12" /> <button (click)="onRename()"> Rename </button></form><p style="color: red;">{{message2 || null}}</p>

Encore une fois, une autre forme. La chose importante ici est que nous n’allons pas écraser tout le document — nous garderons le id, mais le champ changera pour tout ce que nous insérons ici — c’est le but.

Dans home.component.ts, initialisez la variable message2 pour gérer une entrée vide et initialiser le formulaire comme nous l’avons fait avec les autres. Créez ensuite une fonction onRename.

onRename() { if (!this.editForm.value.replaceValue) { this.message2 = "Cannot Be Empty!"; } else { this.firestore.collection('testCollection').doc(this.id).update({ field: this.editForm.value.replaceValue }); this.edit = false; this.message2 = ''; this.single = null; } }

Il y a quelques nouvelles choses à remarquer ici.

Tout d’abord, nous utilisons la méthode .doc et mettons la méthode id que nous avons obtenue des étapes précédentes. Cela obtient le document basé sur id, pas une requête.

Ensuite, nous utilisons la méthode .update. Cela écrasera uniquement la propriété que nous spécifions, au lieu de .set qui écrase tout le document. En d’autres termes, si nous avions trois champs dans le document, nous pourrions en écraser un seul avec la méthode update comme ceci.

Encore une fois, nous relisons notre liste de documents du Firestore. Ensuite, nous pouvons compresser la requête unique, la zone d’édition et tous les messages précédemment présents.

Delete

La suppression que nous ferons est fondamentalement la même que notre mise à jour, sauf que nous utiliserons la méthode delete.

Tout d’abord, dans notre html, changeons le bouton supprimer:

<button style='background-color: red' (click)='delete()'>Delete</button>

Maintenant, tout ce qu’il y a, c’est de créer la fonction delete.

Il peut être judicieux de mettre un avertissement avant de permettre à l’utilisateur de supprimer l’objet. Ajoutez le code suivant au fichier TypeScript:

delete() { if (confirm('Delete?')) { this.db.collection('testCollection').doc(this.id).delete(); this.edit = false; this.single = null; } }

Le confirm('Delete') affichera une alerte qui doit être confirmée avant de la supprimer — cela évite simplement à l’utilisateur de supprimer accidentellement quelque chose par inadvertance.

Après cela, nous obtenons simplement le document par le id que nous avons stocké, et appelons la méthode delete dessus. Aussi simple que ça.

Conclusion

Vous avez maintenant créé avec succès une application Angular qui peut Créer, Lire, Mettre à jour et Supprimer des documents Firestore! Comme vous pouvez le voir, Firebase Firestore est facile à utiliser et prêt à l’emploi. Cela peut facilement être étendu à des milliers de documents complexes.

Maintenant que vous avez une bonne idée des bases de Firestore, consultez les documents officiels pour des sujets plus avancés.

Découvrez vos applications Angulaires exactement comme le fait un utilisateur

Le débogage d’applications Angulaires peut être difficile, en particulier lorsque les utilisateurs rencontrent des problèmes difficiles à reproduire. Si vous souhaitez surveiller et suivre l’état angulaire et les actions de tous vos utilisateurs en production, essayez LogRocket. Bannière d'essai gratuite du tableau de bord LogRockethttps://logrocket.com/signup/

LogRocket est comme un DVR pour les applications Web, enregistrant littéralement tout ce qui se passe sur votre site, y compris les demandes réseau, les erreurs JavaScript, et bien plus encore. Au lieu de deviner pourquoi des problèmes surviennent, vous pouvez agréger et rendre compte de l’état dans lequel se trouvait votre application lorsqu’un problème s’est produit.

Le plugin LogRocket NgRx enregistre l’état angulaire et les actions dans la console LogRocket, vous donnant un contexte autour de ce qui a conduit à une erreur et de l’état dans lequel se trouvait l’application lorsqu’un problème s’est produit.

Modernisez la façon dont vous déboguez vos applications Angular – Commencez la surveillance gratuitement.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.