Instructions d'utilisation de la méthode fs.write dans node.js_node.js

Description de la méthode :

Écrire dans un fichier (selon le descripteur de fichier). La fonction est similaire à fs.writeFile(), mais cette méthode fournit des opérations de niveau inférieur dans les applications réelles, il est recommandé d'utiliser davantage de fs.writeFile(). .

Cette méthode a deux formes :

1. fs.write(fd, buffer, offset, length[, position], [callback(err, bytesWritten, buffer)])

Cette façon d'écrire écrit le tampon dans un fichier (recherche du fichier en fonction du descripteur de fichier fd).

2. fs.write(fd, data[, position[, encoding]], [callback(err, writing, string)])

Cette façon d'écrire écrit des données dans un fichier (recherche du fichier en fonction du descripteur de fichier fd). Si les données ne sont pas une instance de tampon, la valeur sera convertie en chaîne.

Grammaire :

Copier le code Le code est le suivant :

fs.write(fd, buffer, offset, length[, position], [callback(err, bytesWritten, buffer)])

fs.write(fd, data[, position[, encoding]], [callback(err, written, string)])

Puisque cette méthode appartient au module fs, le module fs doit être introduit avant utilisation (var fs= require(“fs”) )

Paramètres de réception :

fd Descripteur de fichier.

buffer Le tampon dans lequel les données seront écrites. Il est préférable de définir la taille du tampon sur un multiple de 8, ce qui est plus efficace.

offset Le décalage écrit dans le tampon

length (integer) Spécifie la longueur du fichier lu en octets

position (entier) Spécifie la position de départ de la lecture du fichier. Si cet élément est nul, les données seront lues à partir de la position du pointeur de fichier actuel.

callback Le rappel passe trois paramètres, err, bytesRead, buffer

· erreur Exception

· bytesRead : Nombre d'octets lus

·buffer : objet tampon

Deuxième forme :

encodage Encodage des caractères

rappel

· erreur Exception

· writing Spécifie combien de caractères seront écrits dans le fichier.

· chaîne Returned Buffer

Exemple :

Copier le code Le code est le suivant :

//fs.write(fd, buffer, offset, length[, position], [callback(err, bytesWritten, buffer)])
//Résultat de l'exécution : bytesWritten = 8, buffer =

var fs = require('fs');
fs.open('content.txt', 'a', function(err,fd){
si (erreur) {
jetez une erreur ;
>
var data = '123123123 bonjour tout le monde';
var buf = nouveau Buffer(8);
fs.write(fd, buf, 0, 8, 0, function(err, bytesWritten, buffer){
si (erreur) {
jetez une erreur ;
>
console.log(bytesWritten);
console.log(buffer);

fs.close(fd,function(err){
si (erreur) {
Jetez une erreur ;
>
console.log('fichier fermé');
})
})
})

//fs.write(fd, data[, position[, encoding]], [callback(err, writing, string)])
//Résultat de l'exécution : écrit = 21, chaîne =
var fs = require('fs');
fs.open('content.txt', 'a', function(err,fd){
si (erreur) {
jetez une erreur ;
>
var data = '123123123 bonjour tout le monde';
fs.write(fd, data, 0, 'utf-8', function(err, écrit, chaîne){
si (erreur) {
jetez une erreur ;
>
console.log(écrit);
console.log(string);

fs.close(fd,function(err){
si (erreur) {
Jetez une erreur ;
>
console.log('fichier fermé');
})
})
})

Code source :

Copier le code Le code est le suivant :

// utilisation :
// fs.write(fd, buffer, offset, length[, position], callback);
// OU
// fs.write(fd, string[, position[, encoding]], callback);
fs.write = function(fd, buffer, offset, length, position, callback) {
  if (util.isBuffer(buffer)) {
    // si aucune position n'est passée alors supposez null
    if (util.isFunction(position)) {
      rappel = position;
      position = nul;
    >
    rappel = peut-êtreCallback(rappel);
    var wrapper = function(err, écrit) {
      // Conserve une référence au tampon afin qu'elle ne puisse pas être GC trop tôt.
      callback(err, écrit || 0, buffer);
    };
    return bind.writeBuffer(fd, buffer, offset, length, position, wrapper);
  >
  if (util.isString(buffer))
    tampon = '';
  si (!util.isFunction(position)) {
    if (util.isFunction(offset)) {
      position = décalage ;
      décalage = nul;
    } autre {
      position = longueur;
    >
    longueur = 'utf8';
  >
  rappel = peut-êtreCallback(position);
  position = fonction (erreur, écrit) {
    // conserve la référence à la chaîne au cas où elle serait externe
    callback(err, écrit || 0, buffer);
  };
  return bind.writeString(fd, buffer, offset, length, position);
};