Démarrage rapide : lecture et écriture de fichiers (HTML)

Article
12/11/2015

[ Cet article est destiné aux développeurs de Windows 8.x et Windows Phone 8.x qui créent des applications Windows Runtime. Si vous développez une application pour Windows 10, voir la Documentation ]

Lisez et écrivez un fichier à l’aide d’un objet StorageFile.

Prérequis

Comprendre la programmation asynchrone pour les applications Windows Runtime en JavaScript

Pour apprendre à écrire des applications asynchrones, voir Démarrage rapide : utilisation de promesses (« promises ») dans JavaScript.
Savoir obtenir le fichier que vous voulez lire et/ou dans lequel vous voulez écrire

Pour apprendre à obtenir un fichier en appelant un sélecteur de fichiers, voir Démarrage rapide : accès aux fichiers à l’aide de sélecteurs de fichiers.

Fichier utilisé dans les exemples

L’intégralité du code de ces exemples est tirée de l’exemple d’accès à un fichier et dépend de la variable globale sampleFile de l’exemple. Dans ces exemples, la variable représente le fichier (sample.dat) dans lequel des données sont écrites et lues.

L’exemple d’accès à un fichier crée le fichier sample.dat et stocke l’objet storageFile retourné, comme ceci :

Windows.Storage.ApplicationData.current.localFolder.createFileAsync("sample.dat",
    Windows.Storage.CreationCollisionOption.replaceExisting).then(function (file) {
        sampleFile = file;
    });

Remarque Pour créer des fichiers dans des bibliothèques, vous devez au préalable déclarer les fonctionnalités nécessaires dans le manifeste de votre application. Pour en savoir plus sur l’accès aux fichiers et à leurs fonctionnalités, voir Accès aux fichiers et autorisations et Accès aux ressources utilisateur à l’aide de Windows Runtime.

Écriture dans un fichier

Ces étapes vous montrent comment écrire dans un fichier inscriptible et un objet storageFile le représentant.

Écriture de texte dans un fichier

Écrivez du texte dans votre fichier en appelant les méthodes writeTextAsync de la classe fileIO.

L’exemple d’accès à un fichier montre comment appeler la méthode writeTextAsync(file, contents) pour écrire du texte arbitraire dans son sampleFile, comme ceci :

Windows.Storage.FileIO.writeTextAsync(sampleFile, "Swift as a shadow").then(function () {
    // Add code to do something after the text is written to the file
});

Bien que les méthodes writeTextAsync ne renvoient pas de valeur, vous pouvez utiliser la méthode then ou done pour déclarer une fonction et effectuer d’autres tâches après que le texte a été écrit dans le fichier, comme le montre l’exemple.

Écriture d’octets dans un fichier par le biais d’une mémoire tampon

Constituez une mémoire tampon des octets à écrire dans votre fichier.

Par exemple, l’exemple d’accès à un fichier appelle la méthode convertStringToBinary pour obtenir une mémoire tampon des octets d’après une chaîne arbitraire, comme ceci :
```
var buffer = Windows.Security.Cryptography.CryptographicBuffer.convertStringToBinary(
    'What fools these mortals be', Windows.Security.Cryptography.BinaryStringEncoding['']
);
```
Écrivez les octets de votre mémoire tampon dans votre fichier en appelant les méthodes writeBufferAsync de la classe fileIO.

L’exemple d’accès à un fichier montre comment utiliser la méthode writeBufferAsync pour écrire des octets depuis une mémoire tampon dans son objet sampleFile, comme ceci :
```
Windows.Storage.FileIO.writeBufferAsync(sampleFile, buffer).then(function () {
    // Add code to do something after the text is written to the file
});
```
Bien que la méthode writeBufferAsync ne renvoie pas de valeur, vous pouvez utiliser la méthode then ou done pour déclarer une fonction et effectuer d’autres tâches après que le texte a été écrit dans le fichier, comme le montre l’exemple.

Écriture de texte dans un fichier par le biais d’un flux fondé sur une transaction

Ouvrez un flux vers votre fichier en appelant la méthode storageFile.openTransactedWriteAsync. Cette dernière renvoie un flux du contenu du fichier lorsque l’opération d’ouverture se termine.

L’exemple d’accès à un fichier montre comment ouvrir un flux vers un fichier (sampleFile) en appelant la méthode storageFile.openTransactedWriteAsync, comme ceci :
```
sampleFile.openTransactedWriteAsync().then(writeToStream);
```
Vous devez déclarer une fonction (telle que writeToStream) qui capture la transaction (type StorageStreamTransaction) pour vous permettre d’écrire dans votre fichier une fois la méthode terminée, comme ceci :
```
function writeToStream(transaction) {
    // Add code to use the stream to write to your file
}
```
Suivez les étapes ci-après pour ajouter à votre fonction writeToStream du code qui écrit un texte dans votre fichier une fois la méthode storageFile.openAsyncterminée.
1. Utilisez la transaction pour écrire du texte en créant un objet dataWriter et en appelant la méthode dataWriter.writeString.
  
  L’exemple d’accès à un fichier montre comment écrire du texte dans le flux, comme ceci :
```
var dataWriter = new Windows.Storage.Streams.DataWriter(transaction.stream);
dataWriter.writeString("Swift as a shadow");
```
2. Enregistrez le texte dans votre fichier, puis fermez le flux en appelant les méthodes .dataWriter.storeAsync et transaction.commitAsync.
  
  L’exemple d’accès à un fichier vous explique comment enregistrer du texte dans votre fichier et fermer le flux, comme ceci :
```
dataWriter.storeAsync().then(function () {
    transaction.commitAsync().done(function () {
        // Text in stream has been saved to the file
        transaction.close();
    });
});
```

Vous pouvez télécharger l’exemple d’accès à un fichier pour examiner ces exemples de code en contexte, à l’intérieur de fonctions.

Lecture d’un fichier

Ces étapes vous montrent comment lire depuis un fichier lisible et un objet storageFile le représentant.

Lecture de texte d’un fichier

Lisez du texte de votre fichier en appelant les méthodes readTextAsync de la classe fileIO.

L’exemple d’accès à un fichier vous montre comment lire du texte dans un fichier en appelant la méthode readTextAsync(file) pour lire dans sampleFile, comme ceci :

Windows.Storage.FileIO.readTextAsync(sampleFile).then(function (contents) {
    // Add code to process the text read from the file
});

Vous pouvez utiliser la méthode then ou done pour déclarer une fonction qui capture et traite le texte ayant été lu dans le fichier. Une fois la méthode readTextAsync terminée, le texte est transmis à cette fonction en tant qu’objet String (contents dans l’exemple).

Lecture d’octets depuis un fichier par le biais d’une mémoire tampon

Lisez les octets de votre fichier pour les écrire dans votre mémoire tampon en appelant la méthode readBufferAsync de la classe fileIO.

L’exemple d’accès à un fichier montre comment lire des octets depuis un fichier et les placer dans une mémoire tampon en appelant la méthode readBufferAsync, comme ceci :

Windows.Storage.FileIO.readBufferAsync(sampleFile).then(function (buffer) {
    // Add code to process the text read from the file
});

Vous pouvez utiliser la méthode then ou done pour déclarer une fonction qui capture et traite le buffer (type IBuffer) une fois la méthode readBufferAsync terminée.

L’exemple d’accès à un fichier capture le buffer et utilise un objet dataReader pour lire la longueur de la mémoire tampon (buffer), comme ceci :

Windows.Storage.FileIO.readBufferAsync(sampleFile).then(function (buffer) {
    var dataReader = Windows.Storage.Streams.DataReader.fromBuffer(buffer);
    var output = dataReader.readString(buffer.length);
});

Bien entendu, ce type de lecture du buffer n’est pas particulièrement utile, mais vous avez le choix d’imaginer une manière plus appropriée pour traiter le buffer. Pour vous donner des idées, vous pouvez consulter les méthodes disponibles dans la classe dataReader.

Lecture de texte depuis un fichier par le biais d’un flux

Ouvrez un flux depuis votre fichier en appelant la méthode storageFile.openAsync. Cette dernière renvoie un flux du contenu du fichier lorsque l’opération d’ouverture se termine.

L’exemple d’accès à un fichier montre comment ouvrir un flux sur un fichier (sampleFile) en appelant la méthode storageFile.openAsync, comme ceci :
```
sampleFile.openAsync(Windows.Storage.FileAccessMode.readWrite).then(readFromStream);
```
Vous devez déclarer une fonction (telle que readFromStream) qui capture le flux (type IRandomAccessStream) pour vous permettre de lire depuis votre fichier une fois la méthode terminée, comme ceci :
```
function readFromStream(readStream) {
    // Add code to use the stream to read text from your file
}
```
Suivez les étapes ci-après pour ajouter à votre fonction readFromStream du code qui lit du texte dans votre fichier une fois la méthodestorageFile.openAsync terminée.
1. Obtenez un objet dataReader pour lire depuis readStream.
  
  L’exemple d’accès à un fichier montre comment créer un objet dataReader, comme ceci :
```
var dataReader = new Windows.Storage.Streams.DataReader(readStream);
```
2. Lisez le texte en appelant les méthodes dataReader.loadAsync et dataReader.readString.
  
  L’exemple d’accès à un fichier montre comment écrire du texte, comme ceci :
```
dataReader.loadAsync(readStream.size).done(function (numBytesLoaded) {
    var fileContent = dataReader.readString(numBytesLoaded);
    // Process text read from the file
    dataReader.close();
});
```