How to Save Uploaded Images in an Array Javascript

Multer

Multer is a node.js middleware for handling multipart/grade-data, which is primarily used for uploading files. Information technology is written on top of busboy for maximum efficiency.

NOTE: Multer volition not process whatsoever class which is not multipart (multipart/course-data).

Translations

This README is also available in other languages:

Español (Spanish)
简体中文 (Chinese)
한국어 (Korean)
Русский язык (Russian)
Việt Nam (Vietnam)
Português (Portuguese Brazil)

Installation

          $ npm install --relieve multer

Usage

Multer adds a body object and a file or files object to the asking object. The body object contains the values of the text fields of the form, the file or files object contains the files uploaded via the course.

Basic usage case:

Don't forget the enctype="multipart/form-data" in your form.

          <course action="/profile" method="post" enctype="multipart/form-data">   <input type="file" name="avatar" /> </grade>

          const express = crave('express') const multer  = require('multer') const upload = multer({ dest: 'uploads/' })  const app = express()  app.post('/profile', upload.single('avatar'), function (req, res, next) {   // req.file is the `avatar` file   // req.torso will hold the text fields, if there were any })  app.post('/photos/upload', upload.array('photos', 12), office (req, res, next) {   // req.files is array of `photos` files   // req.body will comprise the text fields, if in that location were any })  const cpUpload = upload.fields([{ name: 'avatar', maxCount: 1 }, { name: 'gallery', maxCount: 8 }]) app.post('/cool-profile', cpUpload, role (req, res, side by side) {   // req.files is an object (String -> Array) where fieldname is the cardinal, and the value is array of files   //   // east.g.   //  req.files['avatar'][0] -> File   //  req.files['gallery'] -> Array   //   // req.body will contain the text fields, if in that location were whatever })

In case you need to handle a text-simply multipart course, you should apply the .none() method:

          const express = require('limited') const app = express() const multer  = require('multer') const upload = multer()  app.post('/profile', upload.none(), function (req, res, next) {   // req.trunk contains the text fields })

Here's an example on how multer is used an HTML grade. Take special annotation of the enctype="multipart/form-data" and proper name="uploaded_file" fields:

          <form activity="/stats" enctype="multipart/grade-data" method="post">   <div form="form-group">     <input type="file" class="form-control-file" name="uploaded_file">     <input type="text" class="grade-command" placeholder="Number of speakers" proper noun="nspeakers">     <input type="submit" value="Become me the stats!" course="btn btn-default">               </div> </class>

Then in your javascript file yous would add together these lines to access both the file and the trunk. It is important that you use the name field value from the course in your upload role. This tells multer which field on the request it should look for the files in. If these fields aren't the aforementioned in the HTML form and on your server, your upload volition fail:

          const multer  = require('multer') const upload = multer({ dest: './public/data/uploads/' }) app.post('/stats', upload.unmarried('uploaded_file'), function (req, res) {    // req.file is the name of your file in the course above, here 'uploaded_file'    // req.body will hold the text fields, if in that location were any     console.log(req.file, req.body) });

API

File information

Each file contains the post-obit information:

Fundamental	Clarification	Note
`fieldname`	Field name specified in the form
`originalname`	Proper noun of the file on the user's calculator
`encoding`	Encoding type of the file
`mimetype`	Mime type of the file
`size`	Size of the file in bytes
`destination`	The folder to which the file has been saved	`DiskStorage`
`filename`	The name of the file within the `destination`	`DiskStorage`
`path`	The full path to the uploaded file	`DiskStorage`
`buffer`	A `Buffer` of the entire file	`MemoryStorage`

`multer(opts)`

Multer accepts an options object, the most basic of which is the dest belongings, which tells Multer where to upload the files. In case y'all omit the options object, the files will be kept in retentivity and never written to disk.

By default, Multer will rename the files and then as to avert naming conflicts. The renaming function can be customized according to your needs.

The following are the options that can be passed to Multer.

Key	Clarification
`dest` or `storage`	Where to store the files
`fileFilter`	Function to control which files are accustomed
`limits`	Limits of the uploaded data
`preservePath`	Keep the full path of files instead of simply the base name

In an boilerplate web app, only dest might exist required, and configured as shown in the following example.

          const upload = multer({ dest: 'uploads/' })

If you want more control over your uploads, y'all'll want to use the storage selection instead of dest. Multer ships with storage engines DiskStorage and MemoryStorage; More engines are available from tertiary parties.

`.unmarried(fieldname)`

Accept a single file with the name fieldname. The single file volition be stored in req.file.

`.assortment(fieldname[, maxCount])`

Take an array of files, all with the name fieldname. Optionally error out if more than maxCount files are uploaded. The array of files will exist stored in req.files.

`.fields(fields)`

Have a mix of files, specified past fields. An object with arrays of files will exist stored in req.files.

fields should be an assortment of objects with name and optionally a maxCount. Example:

          [   { name: 'avatar', maxCount: i },   { name: 'gallery', maxCount: eight } ]

`.none()`

Accept but text fields. If any file upload is made, mistake with code "LIMIT_UNEXPECTED_FILE" will exist issued.

`.any()`

Accepts all files that comes over the wire. An array of files volition be stored in req.files.

Alarm: Make sure that you lot always handle the files that a user uploads. Never add multer every bit a global middleware since a malicious user could upload files to a road that you lot didn't anticipate. Only utilise this office on routes where you are handling the uploaded files.

`storage`

`DiskStorage`

The deejay storage engine gives you full control on storing files to deejay.

          const storage = multer.diskStorage({   destination: function (req, file, cb) {     cb(cypher, '/tmp/my-uploads')   },   filename: part (req, file, cb) {     const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9)     cb(zippo, file.fieldname + '-' + uniqueSuffix)   } })  const upload = multer({ storage: storage })

At that place are two options available, destination and filename. They are both functions that determine where the file should exist stored.

destination is used to determine within which folder the uploaded files should be stored. This can also be given as a string (due east.g. '/tmp/uploads'). If no destination is given, the operating system'south default directory for temporary files is used.

Note: You are responsible for creating the directory when providing destination every bit a function. When passing a string, multer will make sure that the directory is created for you.

filename is used to make up one's mind what the file should be named within the folder. If no filename is given, each file volition exist given a random proper name that doesn't include any file extension.

Note: Multer will non append any file extension for you lot, your function should return a filename consummate with an file extension.

Each function gets passed both the request (req) and some information about the file (file) to assistance with the conclusion.

Note that req.trunk might not have been fully populated yet. It depends on the order that the client transmits fields and files to the server.

For understanding the calling convention used in the callback (needing to laissez passer null as the first param), refer to Node.js error handling

`MemoryStorage`

The memory storage engine stores the files in retentiveness equally Buffer objects. It doesn't have any options.

          const storage = multer.memoryStorage() const upload = multer({ storage: storage })

When using memory storage, the file info will contain a field called buffer that contains the unabridged file.

WARNING: Uploading very large files, or relatively minor files in big numbers very quickly, can cause your application to run out of memory when memory storage is used.

`limits`

An object specifying the size limits of the post-obit optional properties. Multer passes this object into busboy directly, and the details of the backdrop can exist plant on busboy's folio.

The following integer values are available:

Key	Description	Default
`fieldNameSize`	Max field name size	100 bytes
`fieldSize`	Max field value size (in bytes)	1MB
`fields`	Max number of non-file fields	Infinity
`fileSize`	For multipart forms, the max file size (in bytes)	Infinity
`files`	For multipart forms, the max number of file fields	Infinity
`parts`	For multipart forms, the max number of parts (fields + files)	Infinity
`headerPairs`	For multipart forms, the max number of header central=>value pairs to parse	2000

Specifying the limits can assist protect your site against denial of service (DoS) attacks.

`fileFilter`

Fix this to a function to control which files should be uploaded and which should be skipped. The function should expect like this:

          function fileFilter (req, file, cb) {    // The function should call `cb` with a boolean   // to bespeak if the file should be accepted    // To reject this file laissez passer `false`, like so:   cb(null, simulated)    // To accept the file laissez passer `truthful`, similar so:   cb(null, truthful)    // You tin can always laissez passer an error if something goes wrong:   cb(new Error('I don\'t have a clue!'))  }

Error handling

When encountering an error, Multer will consul the error to Limited. You can display a overnice mistake folio using the standard express way.

If you want to take hold of errors specifically from Multer, you can call the middleware role by yourself. Also, if you want to take hold of but the Multer errors, you can employ the MulterError class that is attached to the multer object itself (e.1000. err instanceof multer.MulterError).

          const multer = crave('multer') const upload = multer().single('avatar')  app.mail('/profile', function (req, res) {   upload(req, res, part (err) {     if (err instanceof multer.MulterError) {       // A Multer error occurred when uploading.     } else if (err) {       // An unknown error occurred when uploading.     }      // Everything went fine.   }) })

Custom storage engine

For information on how to build your own storage engine, see Multer Storage Engine.

License

MIT

berlangadistaild68.blogspot.com

Source: http://expressjs.com/en/resources/middleware/multer.html