Exemple avec node.js fs.read ()

app=function(req,res)
{
 res.writeHead(200,{'Content-Type':'text/plain'})
 var buffer=new Buffer(100)
 var fs=require('fs')
 fs.open('.'+req.url,'r',function(err,fd){
  fs.fstat(fd,function(err, stats){
   var i=0
   var s=stats.size
   console.log('.'+req.url+' '+s)
   for(i=0;i<s;console.log(i)){
    i=i+buffer.length
    fs.read(fd,buffer,0,buffer.length,i,function(e,l,b){
     res.write(b.toString('utf8',0,l))
     console.log(b.toString('utf8',0,l))
    })
   }
   res.end()
   fs.close(fd)
  })
 })
}
http = require('http')
server = http.createServer(app)
server.listen(8000,"127.0.0.1")
console.log('GET http://127.0.0.1:8000/appwsgi/www/index.htm')

Pourquoi est-ce seulement de montrer les 100 derniers octets à plusieurs reprises à partir d'une 979 octets fichier?

Pourquoi ne le navigateur google chrome, de ne pas montrer à n'importe quelle sortie?

gert@node:~/http$ node server.js 
GET http://127.0.0.1:8000/appwsgi/www/index.htm
./appwsgi/www/index.htm 979
100
200
300
400
500
600
700
800
900
1000
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

oad.<br/>
   <a href=
"vi/vi.htm">vi</a> Edit online files on the server.
  </div>
 </body>
</html>

source d'informationauteur Gert Cuykens | 2011-05-12

node.js

8

Toutes les lectures sont émis de manière asynchrone en utilisant le même tampon (c'est à dire fs.read renvoie immédiatement et la boucle continue). Par le temps de l'asynchrone en fonction de rappel est appelée la première fois, apparemment, tous les dix lectures ont terminé (de sorte que le tampon contient les résultats de la dernière lecture). Depuis que vous avez appelé la fs.lire 10 fois, vous aurez en arrière appelé 10 fois. Ainsi, vous obtenez ce que vous voyez.

Le navigateur ne montre rien, parce que vous avez terminé la réponse avant le premier rappel retourne.

Je sais que cette question n'est pas le plus récent, mais je vais chuck ce, jusqu'ici, parce que quand j'ai été les problèmes comment l'ouvrir (et de lire) un système de fichiers de l'objet, une recherche rapide m'a toujours semblé à me diriger ici.

De toute façon, cela devrait aider avec les OP, et d'autres dans l'avenir.

(filepath est le nom réel du fichier, chemin d'accès compris)

fs.open(filepath, 'r', function(err, fd) {
    fs.fstat(fd, function(err, stats) {
        var bufferSize=stats.size,
            chunkSize=512,
            buffer=new Buffer(bufferSize),
            bytesRead = 0;

        while (bytesRead < bufferSize) {
            if ((bytesRead + chunkSize) > bufferSize) {
                chunkSize = (bufferSize - bytesRead);
            }
            fs.read(fd, buffer, bytesRead, chunkSize, bytesRead);
            bytesRead += chunkSize;
        }
        console.log(buffer.toString('utf8', 0, bufferSize));
        fs.close(fd);
    });
});

J'ai utilisé le @user1256169 exemple ci-dessus pour créer ce dont j'avais besoin. Ici, je suis en utilisant async.tandis que pour gérer la async flux de contrôle plus proprement. En haut de l'exemple que je suis en train de lire le fichier et ses stats de façon synchronemais qui peut être changé si il y a un besoin de.

var fs = require('fs');
var async = require('async');

var fd = fs.openSync('/path/to/cat.png', 'r');
var stats = fs.fstatSync(fd);


var bufferSize = stats.size,
    chunkSize = 512,//bytes
    buffer = new Buffer(bufferSize),
    bytesRead = 0;

async.whilst(
    function () {
        return bytesRead < bufferSize;
    },
    function (done) {
        if ((bytesRead + chunkSize) > bufferSize) {
            chunkSize = (bufferSize - bytesRead);
        }
        //fd, buffer, offset, length, position, callback
        fs.read(fd, buffer, bytesRead, chunkSize, bytesRead,
        function (err, bytes, buff) {
            if (err) return done(err);
            var buffRead = buff.slice(bytesRead, bytesRead+chunkSize);
            //do something with buffRead
            bytesRead += chunkSize;
            done();
        });
    },
    function (err) {
        if (err) console.log(err);
        fs.close(fd);
    }
);

0

Depuis que vous avez conçu votre application de traitement des fichiers l'un après l'autre (de façon synchrone), vous devez utiliser le fs.readSync() mais soyez averti que, pendant que votre application est la lecture d'un fichier de cette façon, il ne peut rien faire d'autre.

Une meilleure approche serait de traiter les fichiers dans le "nœud de chemin", c'est de manière asynchrone.

-- nœud.fs - une ligne, pas d'attente

Vous devez vous connecter pour publier un commentaire.