node.js résout le problème d'obtention du type de fichier réel d'images_node.js

J'ai rencontré une exigence : supposons qu'il existe un fichier image, le type réel est jpg, et que quelqu'un est trop paresseux pour copier le jpg directement et l'enregistrer sous un fichier png du même nom, afin qu'il n'y ait aucun problème lorsque AS3 lit le fichier Mais le téléphone mobile C a rencontré des problèmes lors de la lecture des fichiers - -!

Vous devez maintenant écrire un programme pour parcourir les fichiers dans tous les dossiers et trouver les fichiers avec des formats de fichiers « anormaux ». Nos ressources sont principalement gif, png et jpg. Au début, j'ai trouvé un article sur Internet : Obtenez le type de fichier mime en fonction du flux binaire et de l'en-tête du fichier, puis lisez les informations d'en-tête binaire du fichier pour obtenir. son vrai type de fichier, comparez-le avec le type de fichier obtenu via le nom de suffixe.

Copier le code Le code est le suivant :

var fd = fs.openSync(new_file_path, 'r');
var tampon = nouveau Buffer(8);

var mineType = mime.lookup(new_file_path);
var fileType = mime.extension(mineType);

fs.readSync(fd, buffer, 0, 8, 0);
var newBuf = buffer.slice(0, 4);
var head_1 = newBuf[0].toString(16);
var head_2 = newBuf[1].toString(16);
var head_3 = newBuf[2].toString(16);
var head_4 = newBuf[3].toString(16);
var head_iden = head_1 head_2;

var tempFileType = FILE_TYPE_CONFIG[head_iden];
si (!tempFileType) {
head_iden = head_3;

tempFileType = FILE_TYPE_CONFIG[head_iden];

si (!tempFileType) {
          var msg = "Type de fichier inconnu " new_file_path '-' fileType;
         showLog(msg);
Continuer ;
>
>

if (tempFileType != fileType) {
var msg = "Erreur fileType" new_file_path '-' fileType '|' tempFileType '--correct format de fichier image';
ShowLog(msg);

g_errorFileTypArr.push(msg);
>

Plus tard, lorsque j'ai recherché des informations relatives à l'image du nœud, j'ai trouvé cet article : classement du module node.js>>

Ensuite, j'ai filtré un module "node-imageinfo" et écrit un exemple de test (en changeant délibérément et directement le suffixe du fichier jpg en png) :

Si vous êtes intéressé, vous pouvez étudier son code source :

Copier le code Le code est le suivant :

fonction readUInt32 (tampon, offset, bigEndian) {
    si (buffer.readUInt32) {
        return buffer.readUInt32(offset, bigEndian);
    >

    valeur var ;
    si (bigEndian) {
        si (buffer.readUInt32BE) {
            return buffer.readUInt32BE(offset);
        >
        valeur = (buffer[offset] << 24) (buffer[offset 1] << 16) (buffer[offset 2] << 8) buffer[offset 3];
    >
    sinon {
        si (buffer.readUInt32LE) {
            return buffer.readUInt32LE(offset);
        >
        valeur = buffer[offset] (buffer[offset 1] << 8) (buffer[offset 2] << 16) (buffer[offset 3] << 24);
    >
    valeur de retour ;
>

fonction readUInt16(buffer, offset, bigEndian) {
    si (buffer.readUInt16) {
        return buffer.readUInt16(offset, bigEndian);
    >

    valeur var ;
    si (bigEndian) {
        si (buffer.readUInt16BE) {
            return buffer.readUInt16BE(offset);
        >
        valeur = (buffer[offset] << 8) buffer[offset 1];
    >
    sinon {
        si (buffer.readUInt16LE) {
            return buffer.readUInt16LE(offset);
        >
        value = buffer[offset] (buffer[offset 1] << 8);
    >
    valeur de retour ;
>

fonction readBit(buffer, offset, bitOffset) {
    si (bitOffset > 7) {
        offset = Math.floor(bitOffset / 8);
        bitOffset = bitOffset % 8;
    >

    var b = buffer[offset];
    si (bitOffset < 7) {
        b >>>= (7 - bitOffset);
    >

    var val = b & 0x01;
    val de retour ;
>

fonction readBits(buffer, offset, bitOffset, bitLen, signé) {
    var val = 0;
   
    var négatif = faux;
    si (signé) {
        if (readBit(buffer, offset, bitOffset) > 0) {
            négatif = vrai ;
        >
        bitLen--;
        bitOffset ;
    >

    var octets = [];
    pour (var je = 0; je < bitLen; je ) {
        var b = readBit(buffer, offset, bitOffset i);
        if (i>0 && (bitLen - i) % 8 == 0) {
            octets.push(val);
            val = 0;
        >
        val <<= 1;
        val |= b;
    >
    octets.push(val);

    val = new Buffer(bytes);
    val.negative = neg?true:false;
    val de retour ;
>

fonction imageInfoPng(buffer) {
    var imageHeader = [0x49, 0x48, 0x44, 0x52],
        pos = 12;

    if (!checkSig(buffer, pos, imageHeader)) {
        retourner faux ;
    >

   pos = 4;
    revenir {
        tapez : 'image',
        format : 'PNG',
        mimeType : 'image/png',
        largeur : readUInt32 (buffer, pos, true),
        hauteur : readUInt32 (tampon, pos 4, vrai),
    };
>

fonction imageInfoJpg(buffer) {
    var pos = 2,
        len = tampon.longueur,
        sizeSig = [0xff, [0xc0, 0xc2]];

    while (pos < len) {
        if (checkSig(buffer, pos, sizeSig)) {
            pos = 5;
            revenir {
                tapez : 'image',
                format : 'JPG',
                mimeType : 'image/jpeg',
                largeur : readUInt16(buffer, pos 2, true),
                hauteur : readUInt16(buffer, pos, true),
            };
        >

        pos = 2 ;
        var size = readUInt16(buffer, pos, true);
        pos = taille ;
    >
>

fonction imageInfoGif(buffer) {
    var pos = 6;

    revenir {
        tapez : 'image',
        format : 'GIF',
        mimeType : 'image/gif',
        largeur : readUInt16(buffer, pos, false),
        hauteur : readUInt16 (buffer, pos 2, false),
    };
>

fonction imageInfoSwf(buffer) {
    var pos = 8,
        bitPos = 0,
        val;

    if (buffer[0] === 0x43) {
        essayez {
            // Si vous avez zlib disponible ( npm install zlib ) alors nous pouvons lire les fichiers flash compressés
            buffer = require('zlib').inflate(buffer.slice(8, 100));
            pos = 0;
        >
        attraper (ex) {
            // Impossible d'obtenir la largeur/hauteur des fichiers flash compressés... pour le moment (besoin de zlib)
            revenir {
                tapez : 'flash',
                format : 'SWF',
                mimeType : 'application/x-shockwave-flash',
                largeur : nulle,
                hauteur : nulle,
            >
        >
    >

    var numBits = readBits(buffer, pos, bitPos, 5)[0];
    bitPos = 5;
   
    val = readBits(buffer, pos, bitPos, numBits, true);
    var xMin = (numBits > 9 ? readUInt16(val, 0, true) : val[0]) * (val.negative ? -1 : 1);
    bitPos = numBits;

    val = readBits(buffer, pos, bitPos, numBits, true);
    var xMax = (numBits > 9 ? readUInt16(val, 0, true) : val[0]) * (val.negative ? -1 : 1);
    bitPos = numBits;

    val = readBits(buffer, pos, bitPos, numBits, true);
    var yMin = (numBits > 9 ? readUInt16(val, 0, true) : val[0]) * (val.negative ? -1 : 1);
    bitPos = numBits;

    val = readBits(buffer, pos, bitPos, numBits, true);
    var yMax = (numBits > 9 ? readUInt16(val, 0, true) : val[0]) * (val.negative ? -1 : 1);

    revenir {
        tapez : 'flash',
        format : 'SWF',
        mimeType : 'application/x-shockwave-flash',
        largeur : Math.ceil((xMax - xMin) / 20),
        hauteur : Math.ceil((yMax - yMin) / 20),
    };
>

fonction checkSig(buffer, offset, sig) {
    var len = sig.longueur;
    pour (var je = 0; je < len; je ) {
        var b = tampon[i offset],
            s = sig[je],
            m = faux ;

        if ('number' == typeof s) {
            m = s === b;
        >
        sinon {
            pour (var k en s) {
                var o = s[k];
                si (o === b) {
                    m = vrai ;
                >
            >
        >

        si (!m) {
            retourner faux ;
        >
    >

    renvoie vrai ;
>

module.exports = function imageInfo(buffer, path) {
    var pngSig = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
    var jpgSig = [0xff, 0xd8, 0xff];
    var gifSig = [0x47, 0x49, 0x46, 0x38, [0x37, 0x39], 0x61];
    var swfSig = [[0x46, 0x43], 0x57, 0x53];

    if (checkSig(buffer, 0, pngSig)) return imageInfoPng(buffer);
    if (checkSig(buffer, 0, jpgSig)) return imageInfoJpg(buffer);
    if (checkSig(buffer, 0, gifSig)) return imageInfoGif(buffer);
    if (checkSig(buffer, 0, swfSig)) return imageInfoSwf(buffer);

    return false ;
};