【问题标题】:How to check file MIME type with javascript before upload?上传前如何使用 javascript 检查文件 MIME 类型?
【发布时间】:2021-08-09 23:02:28
【问题描述】:

我已阅读 thisthis 问题,这些问题似乎表明可以在客户端使用 javascript 检查文件 MIME 类型。现在,我知道真正的验证仍然必须在服务器端完成。我想执行客户端检查以避免不必要的服务器资源浪费。

为了测试这是否可以在客户端完成,我将JPEG 测试文件的扩展名更改为.png 并选择要上传的文件。在发送文件之前,我使用 javascript 控制台查询文件对象:

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

这是我在 Chrome 28.0 上得到的:

文件 {webkitRelativePath: "", lastModifiedDate: 2012 年 10 月 16 日星期二 10:00:00 GMT+0000 (UTC),名称:“test.png”,类型:“image/png”,大小: 500055…}

它显示类型为image/png,这似乎表明检查是基于文件扩展名而不是 MIME 类型完成的。我尝试了 Firefox 22.0,它给了我相同的结果。但是根据the W3C spec,应该实现MIME Sniffing

我是否正确地说目前无法使用 javascript 检查 MIME 类型?还是我错过了什么?

【问题讨论】:

  • I want to perform a client side checking to avoid unnecessary wastage of server resource. 我不明白你为什么说必须在服务器端进行验证,然后又说你想减少服务器资源。黄金法则:永远不要相信用户输入。如果您只是在服务器端进行检查,那么在客户端检查 MIME 类型有什么意义。这肯定是“对 client 资源的不必要浪费”?
  • 在客户端向用户提供更好的文件类型检查/反馈是个好主意。但是,正如您所说,浏览器在确定 File 对象的 type 属性的值时仅依赖文件扩展名。例如,webkit 源代码就揭示了这个事实。通过在文件中查找“魔术字节”等,可以准确地识别客户端文件。我目前正在研究一个可以做到这一点的 MIT 图书馆(在我的空闲时间很少)。如果您对我的进展感兴趣,请查看github.com/rnicholus/determinater
  • @IanClark,关键是如果文件的类型无效,我可以在客户端拒绝它,而不是浪费上传带宽只在服务器端拒绝它。
  • @RayNicholus,帅哥!有时间会看的。谢谢:)
  • @QuestionOverflow 有点晚了,但我在答案中添加了一个完整的解决方案和一个实时的工作演示。享受吧。

标签: javascript html file-upload mime-types


【解决方案1】:

我需要检查更多文件类型。

根据Drakes 给出的excellent answer,在我发现this website 具有非常广泛的文件类型及其标题表之后,我想出了以下代码。十六进制和字符串。

我还需要一个异步函数来处理与我正在工作的项目相关的许多文件和其他问题,这些问题在这里无关紧要。

这是原版 javascript 中的代码。

// getFileMimeType
// @param {Object} the file object created by the input[type=file] DOM element.
// @return {Object} a Promise that resolves with the MIME type as argument or undefined
// if no MIME type matches were found.
const getFileMimeType = file => {

    // Making the function async.
    return new Promise(resolve => {
        let fileReader = new FileReader();
        fileReader.onloadend = event => {
            const byteArray = new Uint8Array(event.target.result);

            // Checking if it's JPEG. For JPEG we need to check the first 2 bytes.
            // We can check further if more specific type is needed.
            if(byteArray[0] == 255 && byteArray[1] == 216){
                resolve('image/jpeg');
                return;
            }

            // If it's not JPEG we can check for signature strings directly.
            // This is only the case when the bytes have a readable character.
            const td = new TextDecoder("utf-8");
            const headerString = td.decode(byteArray);

            // Array to be iterated [<string signature>, <MIME type>]
            const mimeTypes = [
                // Images
                ['PNG', 'image/png'],
                // Audio
                ['ID3', 'audio/mpeg'],// MP3
                // Video
                ['ftypmp4', 'video/mp4'],// MP4
                ['ftypisom', 'video/mp4'],// MP4
                // HTML
                ['<!DOCTYPE html>', 'text/html'],
                // PDF
                ['%PDF', 'application/pdf']
                // Add the needed files for your case.
            ];

            // Iterate over the required types.
            for(let i = 0;i < mimeTypes.length;i++){
                // If a type matches we return the MIME type
                if(headerString.indexOf(mimeTypes[i][0]) > -1){
                    resolve(mimeTypes[i][1]);
                    return;
                }
            }

            // If not is found we resolve with a blank argument
            resolve();

        }
        // Slice enough bytes to get readable strings.
        // I chose 32 arbitrarily. Note that some headers are offset by
        // a number of bytes.
        fileReader.readAsArrayBuffer(file.slice(0,32));
    });

};

// The input[type=file] DOM element.
const fileField = document.querySelector('#file-upload');
// Event to detect when the user added files.
fileField.onchange = event => {

    // We iterate over each file and log the file name and it's MIME type.
    // This iteration is asynchronous.
    Array.from(fileField.files, async file => {
        console.log(file.name, await getFileMimeType(file));
    });

};

请注意,在 getFileMimeType 函数中,您可以使用 2 种方法来查找正确的 MIME 类型。

  1. 直接搜索字节。
  2. 将字节转换为字符串后搜索字符串。

我对 JPEG 使用了第一种方法,因为使其可识别的是前 2 个字节,而这些字节不是可读的字符串字符。

对于其他文件类型,我可以检查可读的字符串字符签名。例如: [视频/mp4] -> 'ftypmp4' 或 'ftypisom'

如果您需要支持不在 Gary Kessler 列表中的文件,您可以 console.log() 字节或转换后的字符串为您需要支持的晦涩文件找到适当的签名。

注意 1:Gary Kessler 的列表已经更新,现在 mp4 签名不同了,你应该在实现时检查它。 注意 2:Array.from 旨在使用类似 .map 的函数作为第二个参数。

【讨论】:

    【解决方案2】:

    对于不希望自己实现此功能的任何人,Sindresorhus 创建了一个可在浏览器中运行的实用程序,并为您可能想要的大多数文档提供标题到 mime 的映射。

    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";
    【解决方案3】:

    这是一个支持 webp 的 Typescript 实现。 这是基于 Vitim.us 的 JavaScript 答案。

    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.');
        }
      });
    };
    

    &lt;input type="file" id="fileInput"&gt;

    【讨论】:

    • 问题严格在javascript中求解决。虽然我知道 typescript 很容易转换为 javascript,但它仍然是一个额外的步骤,可以避开原始问题的界限。
    【解决方案4】:

    如其他答案所述,您可以通过在文件的第一个字节中检查文件的 signature 来检查 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 在事件处理程序 (W3C spec) 中将始终是 FileReader.DONE,即使出现错误 - 不应该检查 (!e.target.error) 吗?
    【解决方案5】:

    在将文件上传到服务器之前,您可以使用 JavaScript 的 FileReader 轻松确定文件的 MIME 类型。我同意我们应该更喜欢服务器端检查而不是客户端检查,但是客户端检查仍然是可能的。我将向您展示如何操作并在底部提供一个工作演示。


    检查您的浏览器是否支持FileBlob。所有主要的都应该。

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

    第 1 步:

    您可以像这样从&lt;input&gt; 元素中检索File 信息 (ref):

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

    这是上述内容的拖放版本 (ref):

    <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 类型。

    ✘快速方法

    您可以天真地向Blob 询问它使用此模式表示的任何文件的 MIME 类型:

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

    对于图像,MIME 类型返回如下:

    图像/JPEG
    图片/png
    ...

    警告: MIME 类型是从文件扩展名中检测到的,可能会被欺骗或欺骗。可以将.jpg 重命名为.png,MIME 类型将报告为image/png


    ✓ 正确的标头检查方法

    要获得客户端文件的真正 MIME 类型,我们可以更进一步,检查给定文件的前几个字节,以与所谓的magic numbers 进行比较。请注意,这并不完全简单,因为例如,JPEG 有一些“幻数”。这是因为格式自 1991 年以来一直在发展。您可能只检查前两个字节就可以了,但我更喜欢检查至少 4 个字节以减少误报。

    JPEG 的示例文件签名(前 4 个字节):

    FF D8 FF E0 (SOI + ADD0)
    FF D8 FF E1 (SOI + ADD1)
    FF D8 FF E2 (SOI + 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 类型(更多文件签名 herehere):

    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 只是为了这个演示)。打开 sn-p,运行它,你应该会看到三个不同类型的远程图像显示。在顶部您可以选择本地图像数据文件,将显示文件签名和/或MIME类型。

    请注意,即使图像被重命名,也可以确定其真正的 MIME 类型。见下文。

    截图


    // Return the first few bytes of the file as a hex string
    function getBLOBFileHeader(url, blob, callback) {
      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);
        }
        callback(url, header);
      };
      fileReader.readAsArrayBuffer(blob);
    }
    
    function getRemoteFileHeader(url, callback) {
      var xhr = new XMLHttpRequest();
      // Bypass CORS for this demo - naughty, Drakes
      xhr.open('GET', '//cors-anywhere.herokuapp.com/' + url);
      xhr.responseType = "blob";
      xhr.onload = function() {
        callback(url, xhr.response);
      };
      xhr.onerror = function() {
        alert('A network error occurred!');
      };
      xhr.send();
    }
    
    function headerCallback(url, headerString) {
      printHeaderInfo(url, headerString);
    }
    
    function remoteCallback(url, blob) {
      printImage(blob);
      getBLOBFileHeader(url, blob, headerCallback);
    }
    
    function printImage(blob) {
      // Add this image to the document body for proof of GET success
      var fr = new FileReader();
      fr.onloadend = function() {
        $("hr").after($("<img>").attr("src", fr.result))
          .after($("<div>").text("Blob MIME type: " + blob.type));
      };
      fr.readAsDataURL(blob);
    }
    
    // Add more from http://en.wikipedia.org/wiki/List_of_file_signatures
    function mimeType(headerString) {
      switch (headerString) {
        case "89504e47":
          type = "image/png";
          break;
        case "47494638":
          type = "image/gif";
          break;
        case "ffd8ffe0":
        case "ffd8ffe1":
        case "ffd8ffe2":
          type = "image/jpeg";
          break;
        default:
          type = "unknown";
          break;
      }
      return type;
    }
    
    function printHeaderInfo(url, headerString) {
      $("hr").after($("<div>").text("Real MIME type: " + mimeType(headerString)))
        .after($("<div>").text("File header: 0x" + headerString))
        .after($("<div>").text(url));
    }
    
    /* Demo driver code */
    
    var imageURLsArray = ["http://media2.giphy.com/media/8KrhxtEsrdhD2/giphy.gif", "http://upload.wikimedia.org/wikipedia/commons/e/e9/Felis_silvestris_silvestris_small_gradual_decrease_of_quality.png", "http://static.giantbomb.com/uploads/scale_small/0/316/520157-apple_logo_dec07.jpg"];
    
    // Check for FileReader support
    if (window.FileReader && window.Blob) {
      // Load all the remote images from the urls array
      for (var i = 0; i < imageURLsArray.length; i++) {
        getRemoteFileHeader(imageURLsArray[i], remoteCallback);
      }
    
      /* Handle local files */
      $("input").on('change', function(event) {
        var file = event.target.files[0];
        if (file.size >= 2 * 1024 * 1024) {
          alert("File size must be at most 2MB");
          return;
        }
        remoteCallback(escape(file.name), file);
      });
    
    } else {
      // File and Blob are not supported
      $("hr").after( $("<div>").text("It seems your browser doesn't support FileReader") );
    } /* Drakes, 2015 */
    img {
      max-height: 200px
    }
    div {
      height: 26px;
      font: Arial;
      font-size: 12pt
    }
    form {
      height: 40px;
    }
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
    <form>
      <input type="file" />
      <div>Choose an image to see its file signature.</div>
    </form>
    <hr/>

    【讨论】:

    • 2 个次要 cmets。 (1) 在读取之前将文件切成前 4 个字节不是更好吗? fileReader.readAsArrayBuffer(blob.slice(0,4))? (2)为了复制/粘贴文件签名,不应该用前导0构造标题for(var i = 0; i &lt; bytes.length; i++) { var byte = bytes[i]; fileSignature += (byte &lt; 10 ? "0" : "") + byte.toString(16); }
    • @Deadpool 见here。有来自不同制造商的更多、不太常见的 JPEG 格式。例如,FF D8 FF E2 = CANNON EOS JPEG 文件,FF D8 FF E3 = SAMSUNG D500 JPEG 文件。 JPEG 签名的关键部分只有 2 个字节,但为了减少误报,我添加了最常见的 4 字节签名。我希望这会有所帮助。
    • 这个答案的质量太棒了。
    • 您不必将完整的 blob 作为 ArrayBuffer 加载来确定 mimeType。您可以像这样切片并传递 blob 的前 4 个字节:fileReader.readAsArrayBuffer(blob.slice(0, 4))
    • 只允许纯文本的检查应该是什么?文本文件的前 4 个字节似乎是文本文件中的前 4 个字符。
    【解决方案6】:

    正如 Drake 所说,这可以通过 FileReader 完成。但是,我在这里展示的是一个功能版本。考虑到使用 JavaScript 执行此操作的最大问题是重置输入文件。好吧,这仅限于 JPG(对于其他格式,您必须更改 mime typemagic number):

    <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 上测试的。

    For a complete list of mime types see Wikipedia.

    For a complete list of magic number see Wikipedia.

    【讨论】:

    • 上面的维基百科链接不再有效。
    • @BobQuinn 已修复,谢谢
    【解决方案7】:

    这是你必须做的

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

    如果您想检查图像文件类型,那么

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

    【讨论】:

    【解决方案8】:

    这是 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>
    

    【讨论】:

      【解决方案9】:

      如果您只想检查上传的文件是否为图像,您可以尝试将其加载到&lt;img&gt; 标记中并检查是否有任何错误回调。

      例子:

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

      【讨论】:

      • 效果很好,我尝试了 .gif 文件上传器 hack,但它抛出了一个错误 :)
      【解决方案10】:

      简短的回答是否定的。

      正如您所注意到的,浏览器从文件扩展名派生type。 Mac 预览似乎也运行了扩展。我假设它是因为它更快地读取指针中包含的文件名,而不是查找和读取磁盘上的文件。

      我复制了一个用 png 重命名的 jpg。

      我能够从 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] )) );

      • 拆分 base64 编码的 img 数据,留在图像上
      • Base64 对图像进行解码
      • 仅匹配图像数据的第一行

      小提琴代码使用在 IE9 中不起作用的 base64 解码,我确实找到了一个很好的例子,它使用 VB 脚本在 IE 中工作http://blog.nihilogic.dk/2008/08/imageinfo-reading-image-metadata-with.html

      加载图像的代码取自 Joel Vardy,他在上传之前正在做一些很酷的图像画布调整客户端大小,这可能会引起人们的兴趣 https://joelvardy.com/writing/javascript-image-upload

      【讨论】:

      • 请不要在 JPEG 中搜索“jpeg”子字符串,这只是您在评论中发现它的巧合。 JPEG 文件不必包含它(如果您正在考虑搜索 JFIF,那么 APP0 不必在 EXIF-JPEG 中包含 JFIF,所以它也被淘汰了)。
      • 见顶部“简短的回答是不”。
      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 2011-02-13
      • 2011-08-06
      • 2014-02-20
      • 2015-06-28
      相关资源
      最近更新 更多