Js的FileReader读取文件内容（async/await）

 

要通过FileReader判断上传的文件是否为图片，可以使用FileReader读取文件内容，并判断文件的MIME类型是否为图片类型。

以下是一个示例代码，可以在文件上传时触发change事件，并检查上传的文件是否为图片类型：

1. <input type="file" id="fileInput" onchange="checkFile(event)">
3. function checkFile(event) {
4. const file = event.target.files[0];
5. const reader = new FileReader();
6. reader.onload = function() {
7. const uint = new Uint8Array(reader.result);
8. let bytes = [];
9. uint.forEach((byte) => {
10. bytes.push(byte.toString(16));
11. })
12. const hex = bytes.join('').toUpperCase();
13. const fileType = getFileType(hex);
14. if (fileType !== 'image') {
15. alert('Please upload an image file');
16. return;
17. }
18. getImageSize(file);
19. }
20. reader.readAsArrayBuffer(file);
21. }
23. function getFileType(hex) {
24. const fileTypes = {
25. 'FFD8FF': 'image/jpeg',
26. '89504E': 'image/png',
27. '474946': 'image/gif',
28. '424D': 'image/bmp'
29. };
30. const fileTypeHex = hex.slice(0, 6);
31. const fileType = Object.keys(fileTypes).find(key => key === fileTypeHex);
32. return fileType ? fileTypes[fileType].split('/')[0] : 'unknown';
33. }
35. function getImageSize(file) {
36. const img = new Image();
37. img.onload = function() {
38. const width = img.width;
39. const height = img.height;
40. console.log('Image size: ', width, ' x ', height);
41. }
42. img.src = URL.createObjectURL(file);
43. }

上面的代码首先使用FileReader读取上传的文件，并将文件内容转换为Uint8Array类型。然后，它将文件内容的前6个字节转换为十六进制字符串，并使用该字符串获取文件类型。如果文件类型不是图片，则弹出警告消息并返回。

如果文件类型是图片，则使用Image对象获取图片的宽度和高度。在getImageSize函数中，我们创建一个Image对象，并将其src属性设置为URL.createObjectURL(file)以加载文件内容。当图像加载完成时，它将触发onload事件处理程序，该处理程序将获取图像的宽度和高度。

---

要使用FileReader获取音频或视频文件的时长，需要通过FileReader读取文件并将其转换为Blob对象，然后将Blob对象传递给一个新创建的HTML5音频或视频元素。

以下是一个获取音频或视频文件时长的示例代码：

1. <input type="file" id="fileInput" onchange="getDuration(event)">
2. <script>
3. function getDuration(event) {
4. const file = event.target.files[0];
5. const reader = new FileReader();
6. reader.onload = function() {
7. const blob = new Blob([reader.result], { type: file.type });
8. const mediaElement = document.createElement(file.type.startsWith('audio') ? 'audio' : 'video');
9. mediaElement.onloadedmetadata = function() {
10. console.log('Duration:', mediaElement.duration);
11. }
12. mediaElement.src = URL.createObjectURL(blob);
13. }
14. reader.readAsArrayBuffer(file);
15. }
16. </script>

上面的代码中，我们首先通过FileReader读取用户选择的文件，并将其转换为Blob对象。我们还创建了一个新的HTML5音频或视频元素，具体取决于文件的MIME类型。然后我们为该元素的onloadedmetadata事件处理程序设置一个函数，该函数在元数据加载完成后将打印出元素的duration属性值，即音频或视频文件的时长。

最后，我们将Blob对象的URL分配给mediaElement的src属性，以便浏览器可以加载媒体文件。在元数据加载完成后，它将自动调用onloadedmetadata事件处理程序，我们将在这里获取音频或视频文件的时长。

---

要同步获取音频或视频文件的时长，您可以使用HTML5中的MediaMetadata API。MediaMetadata API是一个新的API，用于获取媒体文件的元数据，其中包括媒体文件的时长。

以下是一个使用MediaMetadata API同步获取音频或视频文件时长的示例代码：

 

 

1. <input type="file" id="fileInput" onchange="getDuration(event)">
2. <script>
3. async function getDuration(event) {
4. const file = event.target.files[0];
5. const reader = new FileReader();
6. reader.onload = async function() {
7. const blob = new Blob([reader.result], { type: file.type });
8. const mediaElement = document.createElement(file.type.startsWith('audio') ? 'audio' : 'video');
9. mediaElement.src = URL.createObjectURL(blob);
10. await mediaElement.play();
11. const metadata = mediaElement.getMetadata();
12. console.log('Duration:', metadata.duration);
13. }
14. reader.readAsArrayBuffer(file);
15. }
16. </script>

上面的代码中，我们首先通过FileReader读取用户选择的文件，并将其转换为Blob对象。我们还创建了一个新的HTML5音频或视频元素，具体取决于文件的MIME类型。然后我们将Blob对象的URL分配给mediaElement的src属性，以便浏览器可以加载媒体文件。

在文件加载完成后，我们使用MediaMetadata API中的play()方法开始播放媒体文件。由于该方法返回一个promise，因此我们使用await关键字等待该promise完成。在媒体文件播放期间，MediaMetadata API会自动获取媒体文件的元数据，其中包括媒体文件的时长。最后，我们可以使用getMetadata()方法获取元数据，并打印出音频或视频文件的时长。

请注意，MediaMetadata API目前不受所有浏览器的支持，因此在使用它时请务必检查浏览器兼容性。

---

要在FileReader获取完图片长宽后执行后续语句，您可以将后续语句放在FileReader的onload事件处理程序中。

onload事件处理程序会在文件读取完成后立即执行，因此您可以在其中获取图片的长宽，并执行后续语句。以下是一个示例代码：

1. "file" id="fileInput" onchange="getImageSize(event)">
2. <script>
3. function getImageSize(event) {
4. const file = event.target.files[0];
5. const reader = new FileReader();
6. reader.onload = function() {
7. const image = new Image();
8. image.onload = function() {
9. const width = this.width;
10. const height = this.height;
11. console.log('Image size:', width, height);
12. // 执行后续语句
13. }
14. image.src = reader.result;
15. }
16. reader.readAsDataURL(file);
17. }
18. script>

上面的代码中，我们首先通过FileReader读取用户选择的文件，并将其转换为数据URL。然后，我们创建了一个新的Image对象，并在其onload事件处理程序中获取图像的宽度和高度。最后，我们将数据URL分配给图像对象的src属性，以便浏览器可以加载图像文件。

当图像加载完成后，onload事件处理程序将执行，并打印出图像的宽度和高度。您可以在此处添加后续语句来执行您需要在获取图像大小后执行的任何操作。

---

如果您需要在FileReader获取完图片长宽后执行的后续语句不在onload事件处理程序内部执行，而是在onload事件处理程序之后执行，您可以将这些后续语句封装到一个函数中，并在onload事件处理程序中调用该函数，如下所示： 

1. "file" id="fileInput" onchange="getImageSize(event)">
2. <script>
3. function getImageSize(event) {
4. const file = event.target.files[0];
5. const reader = new FileReader();
6. reader.onload = function() {
7. const image = new Image();
8. image.onload = function() {
9. const width = this.width;
10. const height = this.height;
11. console.log('Image size:', width, height);
12. handleImageSize(width, height); // 调用后续处理函数
13. }
14. image.src = reader.result;
15. }
16. reader.readAsDataURL(file);
17. }
19. function handleImageSize(width, height) {
20. // 在这里执行需要在获取图像大小后执行的操作
21. console.log('Image size is ready');
22. }
23. script>

在上面的代码中，我们将后续语句封装到名为handleImageSize的函数中，并在图像的onload事件处理程序中调用它。由于onload事件处理程序是异步的，因此可以在图像加载完成后执行后续语句。

当onload事件处理程序完成后，将调用handleImageSize函数，并在其中执行需要在获取图像大小后执行的操作。在这个例子中，我们只是简单地在控制台输出了一条消息。

请注意，如果您需要在多个onload事件处理程序中执行后续语句，则必须确保它们是按照正确的顺序执行的。否则可能会导致错误的行为。

 

---

您也可以使用async/await来处理FileReader获取图片长宽的异步操作。

下面是一个示例代码，使用async/await在获取图片大小后执行后续操作：

 

 

1. async function getImageSize(file) {
2. const reader = new FileReader();
3. reader.readAsDataURL(file);
5. await new Promise((resolve, reject) => {
6. reader.onload = resolve;
7. reader.onerror = reject;
8. });
10. const image = new Image();
11. image.src = reader.result;
13. await new Promise((resolve, reject) => {
14. image.onload = resolve;
15. image.onerror = reject;
16. });
18. const width = image.width;
19. const height = image.height;
20. console.log('Image size:', width, height);
22. // 执行后续操作
23. }

 

在上面的代码中，我们首先将FileReader对象读取的数据转换为数据URL，并使用Promise等待读取操作完成。然后，我们创建了一个新的Image对象，并使用Promise等待图像加载完成。最后，我们获取图像的宽度和高度，并执行需要在获取图像大小后执行的操作。

请注意，async/await在这里用于等待异步操作完成，并在操作完成后执行后续语句。这个示例代码中的getImageSize函数是一个异步函数，可以使用await等待异步操作完成。

如果您需要在多个onload事件处理程序中执行后续语句，则必须使用Promise等待这些异步操作完成，并确保它们是按照正确的顺序执行的。否则可能会导致错误的行为。

 

---

您可以使用async/await和FileReader对象的readAsArrayBuffer方法来获取文件类型。

下面是一个示例代码，使用async/await同步获取文件类型：

 

1. async function getFileType(file) {
2. const reader = new FileReader();
3. reader.readAsArrayBuffer(file.slice(0, 4));
5. await new Promise((resolve, reject) => {
6. reader.onload = resolve;
7. reader.onerror = reject;
8. });
10. const buffer = reader.result;
11. const view = new DataView(buffer);
12. const type = view.getUint32(0, false);
14. switch(type) {
15. case 0x89504E47:
16. return 'image/png';
17. case 0xFFD8FFE0:
18. case 0xFFD8FFE1:
19. case 0xFFD8FFE2:
20. return 'image/jpeg';
21. case 0x47494638:
22. return 'image/gif';
23. case 0x49443303:
24. return 'audio/mp3';
25. case 0x57415645:
26. return 'audio/wav';
27. case 0x4D546864:
28. return 'audio/midi';
29. case 0x666F6D73:
30. return 'video/quicktime';
31. case 0x3026B275:
32. return 'video/wmv';
33. case 0x464C5601:
34. return 'video/flv';
35. default:
36. return 'unknown';
37. }
38. }

 

在上面的代码中，我们使用FileReader对象的readAsArrayBuffer方法读取文件的前4个字节，并使用DataView对象读取文件类型。然后，我们使用switch语句判断文件类型，并返回对应的 MIME 类型。

请注意，await用于等待异步操作完成，并在操作完成后执行后续语句。getFileType函数是一个异步函数，可以使用await等待异步操作完成。

最后，我们可以在需要获取文件类型的地方调用该函数，如下所示：

1. const fileInput = document.querySelector('input[type="file"]');
2. fileInput.addEventListener('change', async function() {
3. const file = fileInput.files[0];
4. const fileType = await getFileType(file);
5. console.log('File type:', fileType);
6. // 执行后续操作
7. });

 在上面的代码中，我们监听文件选择器的change事件，并在事件处理程序中调用getFileType函数，等待获取文件类型，并执行需要在获取文件类型后执行的后续操作。

---

您可以使用async/await和FileReader对象的readAsDataURL方法来判断是否是图片，并获取图片的宽高。

下面是一个示例代码，使用async/await判断是否是图片，并获取图片的宽高：

 

1. async function getImageWidthAndHeight(file) {
2. return new Promise((resolve, reject) => {
3. const reader = new FileReader();
5. reader.onload = async function(e) {
6. const image = new Image();
7. image.src = e.target.result;
9. image.onload = function() {
10. resolve({ width: this.width, height: this.height });
11. };
12. image.onerror = reject;
13. };
15. reader.onerror = reject;
16. reader.readAsDataURL(file);
17. });
18. }

在上面的代码中，我们使用FileReader对象的readAsDataURL方法将文件读取为一个data:URL，并使用Image对象的onload事件获取图片的宽高。如果读取文件或加载图片时出现错误，则使用onerror事件返回错误。

请注意，await用于等待异步操作完成，并在操作完成后执行后续语句。getImageWidthAndHeight函数是一个异步函数，可以使用await等待异步操作完成。

最后，我们可以在需要获取图片宽高的地方调用该函数，如下所示：

1. const fileInput = document.querySelector('input[type="file"]');
2. fileInput.addEventListener('change', async function() {
3. const file = fileInput.files[0];
4. const fileType = await getFileType(file);
5. if (fileType.startsWith('image/')) {
6. const { width, height } = await getImageWidthAndHeight(file);
7. console.log('Image width:', width, 'height:', height);
8. // 执行后续操作
9. } else {
10. console.log('Not an image file');
11. }
12. });

 在上面的代码中，我们先使用getFileType函数判断文件是否为图片，如果是图片，则使用getImageWidthAndHeight函数获取图片的宽高，并执行需要在获取图片宽高后执行的后续操作。如果不是图片，则打印错误信息。

---

可以使用JavaScript中的数学运算和字符串操作来将时长从小数形式转换为时分秒形式。下面是一种实现方法：

1. // 定义时长为134.73913秒
2. const durationInSeconds = 134.73913;
4. // 计算小时、分钟和秒数
5. const hours = Math.floor(durationInSeconds / 3600);
6. const minutes = Math.floor((durationInSeconds - (hours * 3600)) / 60);
7. const seconds = Math.floor(durationInSeconds - (hours * 3600) - (minutes * 60));
9. // 格式化输出
10. const formattedDuration = `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
11. console.log(formattedDuration); // 输出 00:02:14

 这段代码首先将时长定义为134.73913秒。然后使用数学运算计算出时、分、秒数。最后使用字符串操作将时、分、秒数格式化成时分秒形式，并输出到控制台。输出结果为 00:02:14，表示时长为2分14秒。

---

使用 FileReader 和 async/await 可以异步读取文件并获取文件类型。下面是一个例子：

1. async function getFileType(file) {
2. return new Promise((resolve, reject) => {
3. const reader = new FileReader();
4. reader.onload = function() {
5. const arr = (new Uint8Array(reader.result)).subarray(0, 4);
6. let header = '';
7. for(let i = 0; i < arr.length; i++) {
8. header += arr[i].toString(16);
9. }
10. switch (header) {
11. case '89504e47':
12. resolve('image/png');
13. break;
14. case '47494638':
15. resolve('image/gif');
16. break;
17. case 'ffd8ffe0':
18. case 'ffd8ffe1':
19. case 'ffd8ffe2':
20. resolve('image/jpeg');
21. break;
22. default:
23. resolve('unknown');
24. break;
25. }
26. };
27. reader.readAsArrayBuffer(file);
28. });
29. }

这段代码定义了一个 getFileType 函数，接受一个 File 对象作为参数，并返回一个 Promise 对象。在函数内部，我们创建了一个 FileReader 对象，并设置了它的 onload 事件处理程序，以便在文件读取完成后获取文件类型。我们使用 Uint8Array 数组读取文件的前4个字节，将其转换为16进制字符串，并根据特定的字节码匹配文件类型。最后，我们使用 Promise 的 resolve 方法返回文件类型。

使用该函数的例子：

1. async function test() {
2. const file = new File(['test'], 'test.png', {type: 'image/png'});
3. const fileType = await getFileType(file);
4. console.log(fileType); // 输出 'image/png'
5. }
6. test();

 在这个例子中，我们创建了一个假的 File 对象，将其类型设置为 'image/png'，并将其作为参数传递给 getFileType 函数。通过 await 关键字等待函数的结果，获取文件类型，并输出到控制台。输出结果为 'image/png'，表示文件的类型为 PNG 图像。

---

可以通过文件的扩展名或者文件头信息（即文件的开头几个字节）来判断文件类型。下面是一个简单的判断图片、视频和音频文件类型的例子：

1. function getFileType(file) {
2. // 获取文件名和扩展名
3. const fileName = file.name;
4. const extension = fileName.slice((fileName.lastIndexOf('.') - 1 >>> 0) + 2).toLowerCase();
6. // 根据扩展名判断文件类型
7. switch (extension) {
8. case 'jpg':
9. case 'jpeg':
10. case 'png':
11. case 'gif':
12. case 'bmp':
13. return 'image';
14. case 'mp4':
15. case 'avi':
16. case 'wmv':
17. case 'mov':
18. case 'flv':
19. return 'video';
20. case 'mp3':
21. case 'wav':
22. case 'ogg':
23. return 'audio';
24. default:
25. return 'unknown';
26. }
27. }

在这个例子中，我们定义了一个 getFileType 函数，接受一个 File 对象作为参数，并返回一个字符串，表示文件的类型。在函数内部，我们先通过文件名获取文件的扩展名，并将其转换为小写字母。然后根据扩展名判断文件类型，返回对应的字符串。如果扩展名无法识别，返回 'unknown'。

注意，这种方式只是简单的根据扩展名来判断文件类型，有些文件可能没有扩展名，或者扩展名被篡改，此时就无法正确判断文件类型。为了更准确地判断文件类型，我们可以通过读取文件头信息来获取更详细的信息。前面提到的 getFileType 函数可以改写成异步函数，并通过 FileReader 对象读取文件头信息来判断文件类型，示例代码如下：

1. async function getFileType(file) {
2. const reader = new FileReader();
3. reader.readAsArrayBuffer(file.slice(0, 4));
4. return new Promise(resolve => {
5. reader.onload = () => {
6. const buffer = reader.result;
7. const uint8Array = new Uint8Array(buffer);
8. let header = '';
9. for (let i = 0; i < uint8Array.length; i++) {
10. header += uint8Array[i].toString(16);
11. }
12. switch (header) {
13. case '89504e47':
14. resolve('image/png');
15. break;
16. case '47494638':
17. resolve('image/gif');
18. break;
19. case 'ffd8ffe0':
20. case 'ffd8ffe1':
21. case 'ffd8ffe2':
22. resolve('image/jpeg');
23. break;
24. case '494433':
25. resolve('audio/mp3');
26. break;
27. case '524946':
28. resolve('audio/wav');
29. break;
30. case '4f676753':
31. resolve('audio/ogg');
32. break;
33. case '66747970':
34. resolve('video/mp4');
35. break;
36. case '774d5634':
37. resolve('video/webm');
38. break;
39. case '00018':
40. resolve('video/mov');
41. break;
42. default:
43. resolve('unknown');
44. break;
45. }
46. };
47. });
48. }

 在这个例子中，我们定义了一个异步函数 getFileType，接受一个 File 对象作为参数，并返回一个 Promise 对象，最终返回一个字符串，表示文件的类型。在函数内部，我们先创建一个 FileReader 对象，并通过 readAsArrayBuffer 方法读取文件的前四个字节（也就是文件头信息）。然后在 onload 回调函数中，将读取的字节转换为 16 进制字符串，并根据不同的字符串值判断文件类型，返回对应的 MIME 类型。如果无法识别文件类型，返回 'unknown'。

注意，这种方式虽然可以更准确地判断文件类型，但也有一些局限性。不同的文件格式可能有不同的文件头信息，如果要判断所有的文件类型，需要处理大量的情况，代码会比较复杂。而且有些文件头信息也可能被篡改，此时也无法正确判断文件类型。所以在实际应用中，需要根据具体的需求和情况来选择合适的方式来判断文件类型。