จะตรวจสอบไฟล์ประเภท MIME ด้วย javascript ก่อนทำการอัพโหลดได้อย่างไร?


177

ฉันได้อ่านสิ่งนี้และสิ่งนี้แล้วคำถามซึ่งดูเหมือนว่าจะชี้ให้เห็นว่าไฟล์ประเภท MIME จะถูกตรวจสอบโดยใช้จาวาสคริปต์ในฝั่งไคลเอ็นต์ ตอนนี้ฉันเข้าใจว่าการตรวจสอบความถูกต้องจริงยังคงต้องทำในฝั่งเซิร์ฟเวอร์ ฉันต้องการทำการตรวจสอบฝั่งไคลเอ็นต์เพื่อหลีกเลี่ยงการสูญเสียทรัพยากรเซิร์ฟเวอร์โดยไม่จำเป็น

เพื่อทดสอบว่าสิ่งนี้สามารถทำได้ในฝั่งไคลเอ็นต์ฉันเปลี่ยนนามสกุลของJPEGไฟล์ทดสอบเป็น.pngและเลือกไฟล์สำหรับอัพโหลด ก่อนที่จะส่งไฟล์ฉันสอบถามวัตถุไฟล์โดยใช้คอนโซลจาวาสคริปต์:

document.getElementsByTagName('input')[0].files[0];

นี่คือสิ่งที่ฉันได้รับจาก Chrome 28.0:

ไฟล์ {webkitRelativePath: "", LastModifiedDate: อ. ต.ค. 16 2012 10:00:00 GMT + 0000 (UTC), ชื่อ: "test.png", พิมพ์: "image / png", ขนาด: 5,00055 ... }

มันแสดงประเภทimage/pngที่ดูเหมือนจะบ่งบอกว่าการตรวจสอบเสร็จสิ้นตามนามสกุลไฟล์แทนที่จะเป็นชนิด MIME ฉันลอง Firefox 22.0 และให้ผลลัพธ์เหมือนกัน แต่ตามข้อมูลจำเพาะของ W3Cนั้นMIME Sniffingควรจะดำเนินการ

ฉันถูกต้องไหมที่จะบอกว่าไม่มีวิธีการตรวจสอบประเภท MIME ด้วย javascript ในขณะนี้? หรือฉันกำลังพลาดอะไรอยู่?


5
I want to perform a client side checking to avoid unnecessary wastage of server resource.ฉันไม่เข้าใจว่าทำไมคุณถึงบอกว่าต้องทำการตรวจสอบความถูกต้องทางฝั่งเซิร์ฟเวอร์ แต่ถ้าคุณต้องการลดทรัพยากรของเซิร์ฟเวอร์ กฎทอง: ไม่เคยไว้วางใจที่ผู้ใช้ป้อน จุดประสงค์ของการตรวจสอบประเภท MIME บนฝั่งไคลเอ็นต์คืออะไรถ้าคุณเพิ่งทำบนฝั่งเซิร์ฟเวอร์ แน่นอนว่าเป็น "การสูญเสียทรัพยากรของลูกค้าที่ไม่จำเป็น"?
เอียนคลาร์ก

7
การให้การตรวจสอบประเภทไฟล์ที่ดีขึ้น / ข้อเสนอแนะให้กับผู้ใช้ฝั่งไคลเอ็นต์เป็นความคิดที่ดี อย่างไรก็ตามตามที่คุณได้ระบุไว้เบราว์เซอร์จะใช้ส่วนขยายของไฟล์เมื่อพิจารณามูลค่าของtypeคุณสมบัติสำหรับFileวัตถุ ตัวอย่างเช่นซอร์สโค้ด webkit เปิดเผยความจริงนี้ สามารถระบุไฟล์ที่ฝั่งไคลเอ็นต์ได้อย่างถูกต้องโดยค้นหา "magic bytes" ในไฟล์และอื่น ๆ ปัจจุบันฉันกำลังทำงานกับห้องสมุด MIT (ในเวลาว่างฉันมี) ที่จะทำเช่นนั้น หากคุณสนใจในความคืบหน้าของฉันมีลักษณะที่github.com/rnicholus/determinater
เรย์นิโคลัส

32
@IanClark จุดคือถ้าไฟล์เป็นประเภทที่ไม่ถูกต้องฉันสามารถปฏิเสธมันในฝั่งไคลเอ็นต์แทนที่จะเสียแบนด์วิดท์อัพโหลดเพียงเพื่อปฏิเสธมันในฝั่งเซิร์ฟเวอร์
คำถามมากเกิน

@ RayNicholus เพื่อนสุดยอด! จะมองผ่านมันเมื่อฉันมีเวลา ขอบคุณ :)
คำถามมากเกิน

คุณแน่ใจหรือว่าไฟล์ทดสอบของคุณยังมีชนิดไฟล์อยู่image/jpegและคุณไม่ได้ทำการแก้ไขโดยการเปลี่ยนนามสกุลหรือไม่
Bergi

คำตอบ:


343

คุณสามารถกำหนดประเภทไฟล์ MIME ด้วย JavaScript FileReaderก่อนที่จะอัปโหลดไปยังเซิร์ฟเวอร์ ฉันยอมรับว่าเราควรเลือกการตรวจสอบฝั่งเซิร์ฟเวอร์มากกว่าฝั่งไคลเอ็นต์ แต่การตรวจสอบฝั่งไคลเอ็นต์ยังคงเป็นไปได้ ฉันจะแสดงให้คุณเห็นและสาธิตการทำงานที่ด้านล่าง


ตรวจสอบว่าเบราว์เซอร์ของคุณสนับสนุนทั้งสองและFile Blobทุกคนที่สำคัญควร

if (window.FileReader && window.Blob) {
    // All the File APIs are supported.
} else {
    // File and Blob are not supported
}

ขั้นตอนที่ 1:

คุณสามารถดึงFileข้อมูลจาก<input>องค์ประกอบเช่นนี้ ( อ้างอิง ):

<input type="file" id="your-files" multiple>
<script>
var control = document.getElementById("your-files");
control.addEventListener("change", function(event) {
    // When the control has changed, there are new files
    var files = control.files,
    for (var i = 0; i < files.length; i++) {
        console.log("Filename: " + files[i].name);
        console.log("Type: " + files[i].type);
        console.log("Size: " + files[i].size + " bytes");
    }
}, false);
</script>

นี่คือเวอร์ชันการลากและวางของด้านบน (การอ้างอิง ):

<div id="your-files"></div>
<script>
var target = document.getElementById("your-files");
target.addEventListener("dragover", function(event) {
    event.preventDefault();
}, false);

target.addEventListener("drop", function(event) {
    // Cancel default actions
    event.preventDefault();
    var files = event.dataTransfer.files,
    for (var i = 0; i < files.length; i++) {
        console.log("Filename: " + files[i].name);
        console.log("Type: " + files[i].type);
        console.log("Size: " + files[i].size + " bytes");
    }
}, false);
</script>

ขั้นตอนที่ 2:

ตอนนี้เราสามารถตรวจสอบไฟล์และแซวส่วนหัวและประเภท MIME

method วิธีการด่วน

คุณสามารถขอBlobสำหรับไฟล์ MIME ประเภทใดก็ได้ที่ใช้แทนรูปแบบนี้:

var blob = files[i]; // See step 1 above
console.log(blob.type);

สำหรับภาพประเภท MIME จะกลับมาดังต่อไปนี้:

ภาพ / jpeg
ภาพ / png
...

Caveat:ตรวจพบชนิด MIME จากนามสกุลไฟล์และสามารถถูกหลอกหรือปลอมแปลงได้ หนึ่งสามารถเปลี่ยนชื่อ.jpgไปและชนิดไมม์จะได้รับการรายงานว่า.pngimage/png


✓วิธีการตรวจสอบส่วนหัวที่เหมาะสม

เพื่อให้ได้ชนิดสุจริต MIME ของไฟล์ฝั่งไคลเอ็นต์เราสามารถไปอีกขั้นและตรวจสอบไม่กี่ไบต์แรกของไฟล์ที่กำหนดเพื่อเปรียบเทียบกับสิ่งที่เรียกว่าหมายเลขมายากล ถูกเตือนว่าไม่ตรงไปตรงมาทั้งหมดเพราะเช่นJPEGมี "หมายเลขวิเศษ" ไม่กี่ตัว นี่เป็นเพราะรูปแบบนั้นมีวิวัฒนาการมาตั้งแต่ปี 1991 คุณอาจเลี่ยงการตรวจสอบเพียงสองไบต์แรก แต่ฉันชอบการตรวจสอบอย่างน้อย 4 ไบต์เพื่อลดผลบวกปลอม

ตัวอย่างลายเซ็นไฟล์ของ JPEG (4 ไบต์แรก):

FF D8 FF E0 (ซอย + ADD0)
FF D8 FF E1 (ซอย + ADD1)
FF D8 FF E2 (ซอย + ADD2)

นี่คือรหัสที่จำเป็นในการดึงส่วนหัวของไฟล์:

var blob = files[i]; // See step 1 above
var fileReader = new FileReader();
fileReader.onloadend = function(e) {
  var arr = (new Uint8Array(e.target.result)).subarray(0, 4);
  var header = "";
  for(var i = 0; i < arr.length; i++) {
     header += arr[i].toString(16);
  }
  console.log(header);

  // Check the file signature against known types

};
fileReader.readAsArrayBuffer(blob);

จากนั้นคุณสามารถกำหนดประเภท MIME จริงเช่นนี้ (ลายเซ็นไฟล์เพิ่มเติมที่นี่และที่นี่ ):

switch (header) {
    case "89504e47":
        type = "image/png";
        break;
    case "47494638":
        type = "image/gif";
        break;
    case "ffd8ffe0":
    case "ffd8ffe1":
    case "ffd8ffe2":
    case "ffd8ffe3":
    case "ffd8ffe8":
        type = "image/jpeg";
        break;
    default:
        type = "unknown"; // Or you can use the blob.type as fallback
        break;
}

ยอมรับหรือปฏิเสธการอัปโหลดไฟล์ตามที่คุณต้องการตามประเภท MIME ที่คาดไว้


การสาธิต

นี่คือตัวอย่างการทำงานสำหรับไฟล์ในเครื่องและไฟล์ระยะไกล (ฉันต้องข้าม CORS สำหรับการสาธิตนี้เท่านั้น) เปิดตัวอย่างเรียกใช้และคุณควรเห็นภาพระยะไกลสามประเภทที่แตกต่างกันปรากฏขึ้น ที่ด้านบนคุณสามารถเลือกภาพในระบบหรือไฟล์ข้อมูลจากนั้นไฟล์ลายเซ็นและ / หรือประเภท MIME จะปรากฏขึ้น

โปรดสังเกตว่าแม้ว่ารูปภาพจะถูกเปลี่ยนชื่อ แต่สามารถกำหนดประเภท MIME จริงได้ ดูด้านล่าง

ภาพหน้าจอ

ผลลัพธ์ที่คาดหวังจากการสาธิต



8
2 ความคิดเห็นเล็กน้อย (1) จะดีกว่าหรือไม่ที่จะแบ่งไฟล์เป็น 4 ไบต์แรกก่อนอ่าน fileReader.readAsArrayBuffer(blob.slice(0,4))? (2) เพื่อที่จะคัดลอก / วางลายเซ็นของไฟล์ส่วนหัวไม่ควรถูกสร้างขึ้นด้วย 0 ชั้นนำ for(var i = 0; i < bytes.length; i++) { var byte = bytes[i]; fileSignature += (byte < 10 ? "0" : "") + byte.toString(16); }?
Matthew Madson

1
@Deadpool ดูที่นี่ มีมากกว่าปกติน้อยกว่ารูปแบบ JPEG จากผู้ผลิตที่แตกต่างกัน ตัวอย่างเช่นFF D8 FF E2= CANNON EOS JPEG FILE, FF D8 FF E3= SAMSUNG D500 JPEG FILE ส่วนสำคัญของลายเซ็น JPEG คือเพียง 2 ไบต์ แต่เพื่อลดผลบวกปลอมฉันได้เพิ่มลายเซ็น 4 ไบต์ที่พบมากที่สุด ฉันหวังว่าจะช่วย
Drakes

23
คุณภาพของคำตอบนี้วิเศษมาก
Luca

2
คุณไม่ต้องโหลด blob ที่สมบูรณ์ในฐานะ ArrayBuffer เพื่อพิจารณา mimeType คุณสามารถแบ่งและส่ง 4 ไบต์แรกของ blob ดังนี้:fileReader.readAsArrayBuffer(blob.slice(0, 4))
codeVerine

2
สิ่งที่ควรตรวจสอบเพื่อให้ข้อความล้วนเท่านั้น? 4 ไบต์แรกสำหรับไฟล์ข้อความดูเหมือนจะเป็นอักขระ 4 ตัวแรกในไฟล์ข้อความ
MP Droid

19

ตามที่ระบุไว้ในคำตอบอื่น ๆ คุณสามารถตรวจสอบประเภท mime โดยการตรวจสอบลายเซ็นของไฟล์ในไบต์แรกของไฟล์

แต่สิ่งที่คำตอบอื่น ๆ ที่ทำคือการโหลดไฟล์ทั้งหมดในหน่วยความจำเพื่อตรวจสอบลายเซ็นซึ่งสิ้นเปลืองมากและสามารถหยุดเบราว์เซอร์ของคุณได้อย่างง่ายดายหากคุณเลือกไฟล์ขนาดใหญ่โดยบังเอิญหรือไม่

/**
 * Load the mime type based on the signature of the first bytes of the file
 * @param  {File}   file        A instance of File
 * @param  {Function} callback  Callback with the result
 * @author Victor www.vitim.us
 * @date   2017-03-23
 */
function loadMime(file, callback) {
    
    //List of known mimes
    var mimes = [
        {
            mime: 'image/jpeg',
            pattern: [0xFF, 0xD8, 0xFF],
            mask: [0xFF, 0xFF, 0xFF],
        },
        {
            mime: 'image/png',
            pattern: [0x89, 0x50, 0x4E, 0x47],
            mask: [0xFF, 0xFF, 0xFF, 0xFF],
        }
        // you can expand this list @see https://mimesniff.spec.whatwg.org/#matching-an-image-type-pattern
    ];

    function check(bytes, mime) {
        for (var i = 0, l = mime.mask.length; i < l; ++i) {
            if ((bytes[i] & mime.mask[i]) - mime.pattern[i] !== 0) {
                return false;
            }
        }
        return true;
    }

    var blob = file.slice(0, 4); //read the first 4 bytes of the file

    var reader = new FileReader();
    reader.onloadend = function(e) {
        if (e.target.readyState === FileReader.DONE) {
            var bytes = new Uint8Array(e.target.result);

            for (var i=0, l = mimes.length; i<l; ++i) {
                if (check(bytes, mimes[i])) return callback("Mime: " + mimes[i].mime + " <br> Browser:" + file.type);
            }

            return callback("Mime: unknown <br> Browser:" + file.type);
        }
    };
    reader.readAsArrayBuffer(blob);
}


//when selecting a file on the input
fileInput.onchange = function() {
    loadMime(fileInput.files[0], function(mime) {

        //print the output to the screen
        output.innerHTML = mime;
    });
};
<input type="file" id="fileInput">
<div id="output"></div>


ฉันคิดว่าreadyStateจะอยู่FileReader.DONEในตัวจัดการเหตุการณ์ ( ข้อมูลจำเพาะ W3C ) เสมอแม้ว่าจะมีข้อผิดพลาด - ไม่ควรตรวจสอบ(!e.target.error)แทนหรือไม่
boycy

5

สำหรับใครก็ตามที่กำลังมองหาที่จะไม่ใช้สิ่งนี้เอง Sindresorhus ได้สร้างยูทิลิตี้ที่ใช้งานได้ในเบราว์เซอร์และมีการแมปแบบหัวต่อหนึ่งนาทีสำหรับเอกสารส่วนใหญ่ที่คุณต้องการ

https://github.com/sindresorhus/file-type

คุณสามารถรวมคำแนะนำของ Vitim.us ของการอ่านใน X ไบต์แรกเท่านั้นเพื่อหลีกเลี่ยงการโหลดทุกสิ่งลงในหน่วยความจำด้วยการใช้ยูทิลิตี้นี้ (ตัวอย่างใน es6):

import fileType from 'file-type'; // or wherever you load the dependency

const blob = file.slice(0, fileType.minimumBytes);

const reader = new FileReader();
reader.onloadend = function(e) {
  if (e.target.readyState !== FileReader.DONE) {
    return;
  }

  const bytes = new Uint8Array(e.target.result);
  const { ext, mime } = fileType.fromBuffer(bytes);

  // ext is the desired extension and mime is the mimetype
};
reader.readAsArrayBuffer(blob);

สำหรับฉันเวอร์ชันล่าสุดของห้องสมุดไม่ทำงาน แต่ใช้"file-type": "12.4.0"งานได้และฉันต้องใช้import * as fileType from "file-type";
ssz

4

หากคุณเพียงแค่ต้องการตรวจสอบว่าไฟล์ที่อัปโหลดเป็นภาพหรือไม่คุณสามารถลองโหลดลงใน<img>แท็กตรวจสอบข้อผิดพลาดในการโทรกลับได้

ตัวอย่าง:

var input = document.getElementsByTagName('input')[0];
var reader = new FileReader();

reader.onload = function (e) {
    imageExists(e.target.result, function(exists){
        if (exists) {

            // Do something with the image file.. 

        } else {

            // different file format

        }
    });
};

reader.readAsDataURL(input.files[0]);


function imageExists(url, callback) {
    var img = new Image();
    img.onload = function() { callback(true); };
    img.onerror = function() { callback(false); };
    img.src = url;
}

1
ใช้งานได้ดีผมพยายามไฟล์ .gif อัปโหลดสับและมันโยนข้อผิดพลาด :)
เบิก

4

นี่คือสิ่งที่คุณต้องทำ

var fileVariable =document.getElementsById('fileId').files[0];

หากคุณต้องการตรวจสอบประเภทไฟล์ภาพแล้ว

if(fileVariable.type.match('image.*'))
{
 alert('its an image');
}

ขณะนี้ไม่สามารถใช้งานได้: Firefox สำหรับ Android, Opera สำหรับ Android และ Safari บน iOS developer.mozilla.org/en-US/docs/Web/API/File/type
Reid

3

นี่คือการใช้ typescript ที่รองรับ webp นี้จะขึ้นอยู่กับคำตอบ JavaScript โดย Vitim.us

interface Mime {
  mime: string;
  pattern: (number | undefined)[];
}

// tslint:disable number-literal-format
// tslint:disable no-magic-numbers
const imageMimes: Mime[] = [
  {
    mime: 'image/png',
    pattern: [0x89, 0x50, 0x4e, 0x47]
  },
  {
    mime: 'image/jpeg',
    pattern: [0xff, 0xd8, 0xff]
  },
  {
    mime: 'image/gif',
    pattern: [0x47, 0x49, 0x46, 0x38]
  },
  {
    mime: 'image/webp',
    pattern: [0x52, 0x49, 0x46, 0x46, undefined, undefined, undefined, undefined, 0x57, 0x45, 0x42, 0x50, 0x56, 0x50],
  }
  // You can expand this list @see https://mimesniff.spec.whatwg.org/#matching-an-image-type-pattern
];
// tslint:enable no-magic-numbers
// tslint:enable number-literal-format

function isMime(bytes: Uint8Array, mime: Mime): boolean {
  return mime.pattern.every((p, i) => !p || bytes[i] === p);
}

function validateImageMimeType(file: File, callback: (b: boolean) => void) {
  const numBytesNeeded = Math.max(...imageMimes.map(m => m.pattern.length));
  const blob = file.slice(0, numBytesNeeded); // Read the needed bytes of the file

  const fileReader = new FileReader();

  fileReader.onloadend = e => {
    if (!e || !fileReader.result) return;

    const bytes = new Uint8Array(fileReader.result as ArrayBuffer);

    const valid = imageMimes.some(mime => isMime(bytes, mime));

    callback(valid);
  };

  fileReader.readAsArrayBuffer(blob);
}

// When selecting a file on the input
fileInput.onchange = () => {
  const file = fileInput.files && fileInput.files[0];
  if (!file) return;

  validateImageMimeType(file, valid => {
    if (!valid) {
      alert('Not a valid image file.');
    }
  });
};

<input type="file" id="fileInput">


1

เนื่องจาก Drake ระบุว่าสิ่งนี้สามารถทำได้ด้วย FileReader อย่างไรก็ตามสิ่งที่ฉันนำเสนอที่นี่เป็นรุ่นที่ใช้งานได้ พิจารณาว่าปัญหาใหญ่ในการทำเช่นนี้กับ JavaScript คือการรีเซ็ตไฟล์อินพุต นี่ จำกัด เฉพาะ JPG เท่านั้น (สำหรับรูปแบบอื่นคุณจะต้องเปลี่ยนประเภท mimeและหมายเลขเวทย์มนตร์ ):

<form id="form-id">
  <input type="file" id="input-id" accept="image/jpeg"/>
</form>

<script type="text/javascript">
    $(function(){
        $("#input-id").on('change', function(event) {
            var file = event.target.files[0];
            if(file.size>=2*1024*1024) {
                alert("JPG images of maximum 2MB");
                $("#form-id").get(0).reset(); //the tricky part is to "empty" the input file here I reset the form.
                return;
            }

            if(!file.type.match('image/jp.*')) {
                alert("only JPG images");
                $("#form-id").get(0).reset(); //the tricky part is to "empty" the input file here I reset the form.
                return;
            }

            var fileReader = new FileReader();
            fileReader.onload = function(e) {
                var int32View = new Uint8Array(e.target.result);
                //verify the magic number
                // for JPG is 0xFF 0xD8 0xFF 0xE0 (see https://en.wikipedia.org/wiki/List_of_file_signatures)
                if(int32View.length>4 && int32View[0]==0xFF && int32View[1]==0xD8 && int32View[2]==0xFF && int32View[3]==0xE0) {
                    alert("ok!");
                } else {
                    alert("only valid JPG images");
                    $("#form-id").get(0).reset(); //the tricky part is to "empty" the input file here I reset the form.
                    return;
                }
            };
            fileReader.readAsArrayBuffer(file);
        });
    });
</script>

พิจารณาว่าสิ่งนี้ได้รับการทดสอบใน Firefox และ Chrome เวอร์ชันล่าสุดและใน IExplore 10

สำหรับรายการประเภท mime ทั้งหมดดู Wikipediaสำหรับรายการที่สมบูรณ์ของประเภทละครใบ้ดูวิกิพีเดีย

สำหรับรายการที่สมบูรณ์ของจำนวนมายากลดูวิกิพีเดีย


ลิงก์ Wikipedia ด้านบนไม่ถูกต้องอีกต่อไป
Bob Quinn

@BobQuinn คงที่, thansk
lmiguelmh

0

นี่คือส่วนขยายของคำตอบของ Roberto14 ที่ทำสิ่งต่อไปนี้:

นี่จะเป็นเพียงภาพเท่านั้น

ตรวจสอบว่า FileReader พร้อมใช้งานหรือไม่และกลับไปสู่การตรวจสอบส่วนขยายหากไม่พร้อมใช้งาน

ให้การแจ้งเตือนข้อผิดพลาดหากไม่ใช่รูปภาพ

หากเป็นรูปภาพจะโหลดหน้าตัวอย่าง

** คุณควรทำการตรวจสอบฝั่งเซิร์ฟเวอร์เพื่อความสะดวกของผู้ใช้มากกว่าสิ่งอื่นใด แต่มันมีประโยชน์!

<form id="myform">
    <input type="file" id="myimage" onchange="readURL(this)" />
    <img id="preview" src="#" alt="Image Preview" />
</form>

<script>
function readURL(input) {
    if (window.FileReader && window.Blob) {
        if (input.files && input.files[0]) {
            var reader = new FileReader();
            reader.onload = function (e) {
                var img = new Image();
                img.onload = function() {
                    var preview = document.getElementById('preview');
                    preview.src = e.target.result;
                    };
                img.onerror = function() { 
                    alert('error');
                    input.value = '';
                    };
                img.src = e.target.result;
                }
            reader.readAsDataURL(input.files[0]);
            }
        }
    else {
        var ext = input.value.split('.');
        ext = ext[ext.length-1].toLowerCase();      
        var arrayExtensions = ['jpg' , 'jpeg', 'png', 'bmp', 'gif'];
        if (arrayExtensions.lastIndexOf(ext) == -1) {
            alert('error');
            input.value = '';
            }
        else {
            var preview = document.getElementById('preview');
            preview.setAttribute('alt', 'Browser does not support preview.');
            }
        }
    }
</script>

-1

คำตอบสั้น ๆ คือไม่

ตามที่คุณทราบเบราว์เซอร์ที่ได้รับ typeจากนามสกุลไฟล์ ดูตัวอย่าง Mac ก็ดูเหมือนจะวิ่งออกจากส่วนขยาย ฉันถือว่ามันเป็นเพราะมันเร็วกว่าการอ่านชื่อไฟล์ที่มีอยู่ในตัวชี้แทนที่จะค้นหาและอ่านไฟล์บนดิสก์

ฉันสร้างสำเนาของ jpg ที่เปลี่ยนชื่อด้วย png

ฉันสามารถรับภาพต่อไปนี้จากทั้งสองภาพใน chrome อย่างสม่ำเสมอ (ควรทำงานในเบราว์เซอร์สมัยใหม่)

ÿØÿàJFIFÿþ;CREATOR: gd-jpeg v1.0 (using IJG JPEG v62), quality = 90

ซึ่งคุณสามารถแฮ็ค String.indexOf ('jpeg') เพื่อตรวจสอบประเภทของภาพ

นี่คือซอที่จะสำรวจhttp://jsfiddle.net/bamboo/jkZ2v/1/

บรรทัดที่น่าผิดหวังที่ฉันลืมแสดงความคิดเห็นในตัวอย่าง

console.log( /^(.*)$/m.exec(window.atob( image.src.split(',')[1] )) );

  • แยกข้อมูล img ที่เข้ารหัส base64 ออกจากรูปภาพ
  • Base64 ถอดรหัสภาพ
  • จับคู่บรรทัดแรกของข้อมูลภาพ

รหัสซอใช้การถอดรหัสเบส 64 ซึ่งไม่ทำงานใน IE9 ฉันหาตัวอย่างที่ดีโดยใช้สคริปต์ VB ที่ทำงานใน IE http://blog.nihilogic.dk/2008/08/imageinfo-reading-image-metadata-with.html

รหัสที่ใช้ในการโหลดรูปภาพนั้นมาจาก Joel Vardy ซึ่งกำลังทำผ้าใบรูปภาพเจ๋ง ๆ ที่ปรับขนาดฝั่งไคลเอ็นต์ก่อนที่จะอัปโหลดซึ่งอาจเป็นที่สนใจhttps://joelvardy.com/writing/javascript-image-upload


1
โปรดอย่าค้นหา JPEG สำหรับสตริงย่อย "jpeg" นั่นเป็นเพียงเรื่องบังเอิญที่คุณพบในความคิดเห็น ไฟล์ JPEG ไม่จำเป็นต้องมีมัน (และหากคุณกำลังคิดเกี่ยวกับการค้นหาJFIFแทนAPP0ก็ไม่จำเป็นต้องมี JFIF ใน EXIF-JPEGs นั่นก็ออกมาด้วย)
Kornel

ดูด้านบน "คำตอบสั้น ๆ คือไม่"
Lex
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.