How to Read File When Uploaded Javascript

Read files in JavaScript

How to select files, read file metadata and content, and monitor read progress.

Jun 18, 2010 — Updated Mar 29, 2021

Being able to select and collaborate with files on the user's local device is ane of the most unremarkably used features of the web. It allows users to select files and upload them to a server, for example, uploading photos, or submitting tax documents, etc. But, information technology also allows sites to read and dispense them without ever having to transfer the information across the network.

The modern File System Admission API #

The File Organization Access API provides an easy fashion to both read and write to files and directories on the user's local system. It's currently available in most Chromium-derived browsers like Chrome or Edge. To learn more than nearly it, see the File System Access API article.

Since the File System Admission API is not uniform with all browsers yet, check out browser-fs-access, a helper library that uses the new API wherever information technology is available, only falls back to legacy approaches when information technology is non.

Working with files, the classic way #

This guide shows y'all how to:

• Select files
  • Using the HTML input element
  • Using a drag-and-drop zone
• Read file metadata
• Read a file'south content

Select files #

HTML input element #

The easiest fashion to let users to select files is using the <input type="file"> element, which is supported in every major browser. When clicked, it lets a user select a file, or multiple files if the multiple attribute is included, using their operating system's built-in file selection UI. When the user finishes selecting a file or files, the element'southward change event is fired. Yous can access the list of files from event.target.files, which is a FileList object. Each particular in the FileList is a File object.

                          <!-- The `multiple` attribute lets users select multiple files. -->              
                                                <input                type                                  =                  "file"                                id                                  =                  "file-selector"                                multiple                >                            
                                                <script                >                                                              
                  const                  fileSelector                  =                  document.                  getElementById                  (                  'file-selector'                  )                  ;                  
                  fileSelector.                  addEventListener                  (                  'alter'                  ,                  (                  issue                  )                  =>                  {                  
                  const                  fileList                  =                  effect.target.files;                  
                  console.                  log                  (fileList)                  ;                  
                  }                  )                  ;                  
                                                                              </script                >                                    

This instance lets a user select multiple files using their operating system'due south built-in file selection UI and then logs each selected file to the console.

Limit the types of files user can select #

In some cases, you may want to limit the types of files users can select. For example, an image editing app should only accept images, not text files. To do that, you tin can add an accept attribute to the input element to specify which files are accepted.

                                                            <input                type                                  =                  "file"                                id                                  =                  "file-selector"                                accept                                  =                  ".jpg, .jpeg, .png"                                >                                    

Custom drag-and-drop #

In some browsers, the <input type="file"> element is likewise a driblet target, allowing users to elevate-and-drop files into your app. But, the driblet target is small, and can be hard to utilize. Instead, once you've provided the core functionality using an <input blazon="file"> chemical element, you tin can provide a large, custom drag-and-drop surface.

Choose your drop zone #

Your drop surface will depend on the design of your application. You may only want part of the window to exist a drop surface, or potentially the entire window.

Squoosh makes the entire window a drop zone.

Squoosh allows the user to drag-and-driblet an image anywhere into the window, and clicking select an prototype invokes the <input type="file"> element. Whatever you choose as your driblet zone, make certain information technology'due south articulate to the user that they tin can elevate-and-drib files onto that surface.

Define the drop zone #

To enable an element to exist a elevate-and-driblet zone, you'll need to heed for two events, dragover and driblet. The dragover result updates the browser UI to visually bespeak that the drag-and-drib activity is creating a re-create of the file. The drib event is fired subsequently the user has dropped the files onto the surface. Like to the input element, you lot can access the list of files from issue.dataTransfer.files, which is a FileList object. Each item in the FileList is a File object.

                          const              dropArea              =              document.              getElementById              (              'drib-area'              )              ;              
dropArea.                addEventListener                (                'dragover'                ,                (                event                )                =>                {                
                effect.                stopPropagation                (                )                ;                
                event.                preventDefault                (                )                ;                
                // Fashion the elevate-and-drop as a "copy file" performance.                
                event.dataTransfer.dropEffect                =                'copy'                ;                
                }                )                ;              
              
dropArea.                addEventListener                (                'drop'                ,                (                effect                )                =>                {                
                upshot.                stopPropagation                (                )                ;                
                event.                preventDefault                (                )                ;                
                const                fileList                =                event.dataTransfer.files;                
                console.                log                (fileList)                ;                
                }                )                ;              
                      

consequence.stopPropagation() and event.preventDefault() stop the browser'southward default behavior from happening, and allow your code to run instead. Without them, the browser would otherwise navigate abroad from your page and open the files the user dropped into the browser window.

Check out Custom elevate-and-drop for a live demonstration.

What about directories? #

Unfortunately, today there isn't a good way to get access to a directory.

The webkitdirectory aspect on the <input type="file"> element allows the user to choose a directory or directories. It is supported in some Chromium-based browsers, and possibly desktop Safari, but has conflicting reports of browser compatibility.

If drag-and-drib is enabled, a user may try to drag a directory into the drib zone. When the drop event is fired, it will include a File object for the directory, but volition exist unable to access any of the files within the directory.

The File object contains a number of metadata backdrop almost the file. Well-nigh browsers provide the file proper name, the size of the file, and the MIME type, though depending on the platform, dissimilar browsers may provide dissimilar, or additional data.

                          function              getMetadataForFileList              (              fileList              )              {              
              for              (              const              file              of              fileList)              {              
              // Non supported in Safari for iOS.              
              const              name              =              file.name              ?              file.name              :              'Not SUPPORTED'              ;              
              // Non supported in Firefox for Android or Opera for Android.              
              const              type              =              file.type              ?              file.blazon              :              'NOT SUPPORTED'              ;              
              // Unknown cross-browser support.              
              const              size              =              file.size              ?              file.size              :              'Not SUPPORTED'              ;              
              console.              log              (              {file,              name,              blazon,              size}              )              ;              
              }              
              }                      

Yous can run into this in action in the input-blazon-file Glitch demo.

Read a file'south content #

To read a file, utilise FileReader, which enables you to read the content of a File object into memory. You lot can instruct FileReader to read a file as an array buffer, a data URL, or text.

                          function              readImage              (              file              )              {              
              // Check if the file is an image.              
              if              (file.type              &&              !file.type.              startsWith              (              'image/'              )              )              {              
              panel.              log              (              'File is not an image.'              ,              file.type,              file)              ;              
              return              ;              
              }              
                const                reader                =                new                FileReader                (                )                ;                
                reader.                addEventListener                (                'load'                ,                (                event                )                =>                {                
                img.src                =                consequence.target.result;                
                }                )                ;                
                reader.                readAsDataURL                (file)                ;                
                }              
                      

The example to a higher place reads a File provided by the user, then converts information technology to a data URL, and uses that data URL to display the image in an img element. Check out the read-image-file Glitch to see how to verify that the user has selected an image file.

Monitor the progress of a file read #

When reading large files, it may be helpful to provide some UX to indicate how far the read has progressed. For that, use the progress event provided by FileReader. The progress consequence provides 2 properties, loaded, the amount read, and total, the total amount to read.

                                          office                readFile                (                file                )                {                            
                              const                reader                =                new                FileReader                (                )                ;                            
                              reader.                addEventListener                (                'load'                ,                (                consequence                )                =>                {                            
                              const                result                =                upshot.target.result;                            
                              // Practice something with result                            
                              }                )                ;                            
                            
                              reader.                addEventListener                (                'progress'                ,                (                event                )                =>                {                            
                              if                (result.loaded                &&                event.total)                {                            
                              const                percent                =                (event.loaded                /                event.full)                *                100                ;                            
                              console.                log                (                                  `                  Progress:                                                        ${Math.                    round                    (percent)                    }                                    `                                )                ;                            
                              }                            
                              }                )                ;                            
                              reader.                readAsDataURL                (file)                ;                            
                              }                                    

Hero image by Vincent Botta from Unsplash

Last updated: Mar 29, 2021 — Improve article

Render to all articles

beforgeddiaz.blogspot.com

Source: https://web.dev/read-files/