node.js löst das Problem, den tatsächlichen Dateityp von images_node.js zu erhalten

Auf eine Anforderung gestoßen: Angenommen, es gibt eine Bilddatei, der tatsächliche Typ ist JPG, und jemand ist zu faul, das JPG direkt zu kopieren und als PNG-Datei mit demselben Namen zu speichern, sodass es kein Problem gibt AS3 liest die Datei. Beim Lesen der Dateien sind jedoch Probleme beim Mobiltelefon C aufgetreten - -!

Jetzt müssen Sie ein Programm schreiben, um die Dateien in allen Ordnern zu durchsuchen und Dateien mit „abnormalen“ Dateiformaten zu finden. Unsere Ressourcen sind hauptsächlich GIF, PNG und JPG. Zuerst habe ich einen Artikel im Internet gefunden: Ermitteln Sie den Mime-Typ des Dateityps basierend auf dem Binärstream und dem Dateiheader und lesen Sie dann die Binärheaderinformationen der zu erhaltenden Datei sein wahrer Dateityp, vergleichen Sie mit dem Dateityp, der durch den Suffixnamen erhalten wird.

Code kopieren Der Code lautet wie folgt:

var fd = fs.openSync(new_file_path, 'r');
var buffer = new 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];
if (!tempFileType) {
head_iden = head_3;

tempFileType = FILE_TYPE_CONFIG[head_iden];

if (!tempFileType) {
          var msg = "Unknow fileType " new_file_path '-' fileType;
         showLog(msg);
Weiter;
}
}

if (tempFileType != fileType) {
var msg = „Error fileType“ new_file_path '-' fileType '|' tempFileType '--korrektes Bilddateiformat';
ShowLog(msg);

g_errorFileTypArr.push(msg);
}

Als ich später nach Informationen zum Knotenbild suchte, fand ich diesen Artikel: node.js-Modulranking>>

Dann habe ich ein Modul „node-imageinfo“ herausgefiltert und ein Beispiel zum Testen geschrieben (wobei ich bewusst das Suffix der JPG-Datei direkt in PNG geändert habe):

Wenn Sie interessiert sind, können Sie den Quellcode studieren:

Code kopieren Der Code lautet wie folgt:

Funktion readUInt32(buffer, offset, bigEndian) {
    if (buffer.readUInt32) {
        return buffer.readUInt32(offset, bigEndian);
    }

    var value;
    if (bigEndian) {
        if (buffer.readUInt32BE) {
            return buffer.readUInt32BE(offset);
        }
        value = (buffer[offset] << 24) (buffer[offset 1] << 16) (buffer[offset 2] << 8) buffer[offset 3];
    }
    sonst {
        if (buffer.readUInt32LE) {
            return buffer.readUInt32LE(offset);
        }
        value = buffer[offset] (buffer[offset 1] << 8) (buffer[offset 2] << 16) (buffer[offset 3] << 24);
    }
    Rückgabewert;
}

Funktion readUInt16(buffer, offset, bigEndian) {
    if (buffer.readUInt16) {
        return buffer.readUInt16(offset, bigEndian);
    }

    var value;
    if (bigEndian) {
        if (buffer.readUInt16BE) {
            return buffer.readUInt16BE(offset);
        }
        value = (buffer[offset] << 8) buffer[offset 1];
    }
    sonst {
        if (buffer.readUInt16LE) {
            return buffer.readUInt16LE(offset);
        }
        value = buffer[offset] (buffer[offset 1] << 8);
    }
    Rückgabewert;
}

Funktion readBit(buffer, offset, bitOffset) {
    if (bitOffset > 7) {
        offset = Math.floor(bitOffset / 8);
        bitOffset = bitOffset % 8;
    }

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

    var val = b & 0x01;
    Rückgabewert;
}

Funktion readBits(buffer, offset, bitOffset, bitLen, signiert) {
    var val = 0;
   
    var neg = false;
    if (signiert) {
        if (readBit(buffer, offset, bitOffset) > 0) {
            neg = true;
        }
        bitLen--;
        bitOffset ;
    }

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

    val = neuer Puffer (Bytes);
    val.negative = neg?true:false;
    Rückgabewert;
}

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

    if (!checkSig(buffer, pos, imageHeader)) {
        return false;
    }

    pos = 4;
    zurück {
        Typ: 'Bild',
        Format: 'PNG',
        mimeType: 'image/png',
        Breite: readUInt32(buffer, pos, true),
        Höhe: readUInt32(buffer, pos 4, true),
    };
}

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

    while (pos < len) {
        if (checkSig(buffer, pos, sizeSig)) {
            pos = 5;
            zurück {
                Typ: 'Bild',
                Format: 'JPG',
                mimeType: 'image/jpeg',
                Breite: readUInt16(buffer, pos 2, true),
                Höhe: readUInt16(buffer, pos, true),
            };
        }

        pos = 2;
        var size = readUInt16(buffer, pos, true);
        pos = Größe;
    }
}

Funktion imageInfoGif(buffer) {
    var pos = 6;

    zurück {
        Typ: 'Bild',
        Format: 'GIF',
        mimeType: 'image/gif',
        Breite: readUInt16(buffer, pos, false),
        Höhe: readUInt16(buffer, pos 2, false),
    };
}

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

    if (buffer[0] === 0x43) {
        versuche es mit {
            // Wenn Sie zlib zur Verfügung haben (npm install zlib), können wir komprimierte Flash-Dateien lesen
            buffer = require('zlib').inflate(buffer.slice(8, 100));
            pos = 0;
        }
        fangen (ex) {
            // Breite/Höhe komprimierter Flash-Dateien kann noch nicht ermittelt werden (zlib erforderlich)
            zurück {
                Typ: 'Flash',
                Format: 'SWF',
                mimeType: 'application/x-shockwave-flash',
                Breite: null,
                Höhe: null,
            }
        }
    }

    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);

    zurück {
        Typ: 'Flash',
        Format: 'SWF',
        mimeType: 'application/x-shockwave-flash',
        Breite: Math.ceil((xMax - xMin) / 20),
        Höhe: Math.ceil((yMax - yMin) / 20),
    };
}

Funktion checkSig(buffer, offset, sig) {
    var len = sig.length;
    für (var i = 0; i < len; i ) {
        var b = buffer[i offset],
            s = sig[i],
            m = falsch;

        if ('number' == typeof s) {
            m = s === b;
        }
        sonst {
            für (var k in s) {
                var o = s[k];
                if (o === b) {
                    m = wahr;
                }
            }
        }

        if (!m) {
            return false;
        }
    }

    true zurückgeben;
}

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);

    false zurückgeben;
};