Tmp offers both an asynchronous and a synchronous API. For all API calls, all
the parameters are optional. There also exists a promisified version of the
API, see tmp-promise.
Tmp uses crypto for determining random file names, or, when using templates,
a six letter random identifier. And just in case that you do not have that much
entropy left on your system, Tmp will fall back to pseudo random numbers.
You can set whether you want to remove the temporary file on process exit or
not.
If you do not want to store your temporary directories and files in the
standard OS temporary directory, then you are free to override that as well.
An Important Note on Previously Undocumented Breaking Changes
All breaking changes that had been introduced, i.e.
tmpdir must be located under the system defined tmpdir root.
Spaces being collapsed into single spaces
Removal of all single and double quote characters
have been reverted in v0.2.2 and tmp should now behave as it did before the
introduction of these breaking changes.
Other breaking changes, i.e.
template must be relative to tmpdir
name must be relative to tmpdir
dir option must be relative to tmpdir
are still in place.
In order to override the system's tmpdir, you will have to use the newly
introduced tmpdir option.
If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary object removal.
To enforce this, you can call the setGracefulCleanup() method:
Simple temporary file creation, the file will be closed and unlinked on process exit.
const tmp = require('tmp');tmp.file(function _tempFileCreated(err, path, fd, cleanupCallback) { if (err) throw err; console.log('File: ', path); console.log('Filedescriptor: ', fd); // If we don't need the file anymore we could manually call the cleanupCallback // But that is not necessary if we didn't pass the keep option because the library // will clean after itself. cleanupCallback();});
Synchronous file creation
A synchronous version of the above.
const tmp = require('tmp');const tmpobj = tmp.fileSync();console.log('File: ', tmpobj.name);console.log('Filedescriptor: ', tmpobj.fd);// If we don't need the file anymore we could manually call the removeCallback// But that is not necessary if we didn't pass the keep option because the library// will clean after itself.tmpobj.removeCallback();
Note that this might throw an exception if either the maximum limit of retries
for creating a temporary name fails, or, in case that you do not have the permission
to write to the directory where the temporary file should be created in.
Asynchronous directory creation
Simple temporary directory creation, it will be removed on process exit.
If the directory still contains items on process exit, then it won't be removed.
Note that this might throw an exception if either the maximum limit of retries
for creating a temporary name fails, or, in case that you do not have the permission
to write to the directory where the temporary directory should be created in.
Asynchronous filename generation
It is possible with this library to generate a unique filename in the specified
directory.
As a side effect of creating a unique file tmp gets a file descriptor that is
returned to the user as the fd parameter. The descriptor may be used by the
application and is closed when the removeCallback is invoked.
In some use cases the application does not need the descriptor, needs to close it
without removing the file, or needs to remove the file without closing the
descriptor. Two options control how the descriptor is managed:
discardDescriptor - if true causes tmp to close the descriptor after the file
is created. In this case the fd parameter is undefined.
detachDescriptor - if true causes tmp to return the descriptor in the fd
parameter, but it is the application's responsibility to close it when it is no
longer needed.
const tmp = require('tmp');tmp.file({ discardDescriptor: true }, function _tempFileCreated(err, path, fd, cleanupCallback) { if (err) throw err; // fd will be undefined, allowing application to use fs.createReadStream(path) // without holding an unused descriptor open.});
const tmp = require('tmp');tmp.file({ detachDescriptor: true }, function _tempFileCreated(err, path, fd, cleanupCallback) { if (err) throw err; cleanupCallback(); // Application can store data through fd here; the space used will automatically // be reclaimed by the operating system when the descriptor is closed or program // terminates.});
Asynchronous directory creation
Creates a directory with mode 0755, prefix will be myTmpDir_.
const tmp = require('tmp');tmp.dir({ mode: 0o750, prefix: 'myTmpDir_' }, function _tempDirCreated(err, path) { if (err) throw err; console.log('Dir: ', path);});
Creates a new temporary directory with mode 0700 and filename like /tmp/tmp-nk2J1u.
IMPORTANT NOTE: template no longer accepts a path. Use the dir option instead if you
require tmp to create your temporary filesystem object in a different place than the
default tmp.tmpdir.
const tmp = require('tmp');tmp.dir({ template: 'tmp-XXXXXX' }, function _tempDirCreated(err, path) { if (err) throw err; console.log('Dir: ', path);});
mkstemp like, synchronously
This will behave similarly to the asynchronous version.
Using tmpName() you can create temporary file names asynchronously.
The function accepts all standard options, e.g. prefix, postfix, dir, and so on.
You can also leave out the options altogether and just call the function with a callback as first parameter.
const tmp = require('tmp');const options = {};tmp.tmpName(options, function _tempNameGenerated(err, path) { if (err) throw err; console.log('Created temporary filename: ', path);});
Synchronous filename generation
The tmpNameSync() function works similarly to tmpName().
Again, you can leave out the options altogether and just invoke the function without any parameters.
name: a fixed name that overrides random name generation, the name must be relative and must not contain path segments
mode: the file mode to create with, falls back to 0o600 on file creation and 0o700 on directory creation
prefix: the optional prefix, defaults to tmp
postfix: the optional postfix
template: mkstemp like filename template, no default, must include XXXXXX once for random name generation, e.g.
'foo-bar-XXXXXX'.
dir: the optional temporary directory that must be relative to the system's default temporary directory.
absolute paths are fine as long as they point to a location under the system's default temporary directory.
Any directories along the so specified path must exist, otherwise a ENOENT error will be thrown upon access,
as tmp will not check the availability of the path, nor will it establish the requested path for you.
tmpdir: allows you to override the system's root tmp directory
tries: how many times should the function try to get a unique filename before giving up, default 3
keep: signals that the temporary file or directory should not be deleted on exit, default is false
In order to clean up, you will have to call the provided cleanupCallback function manually.
unsafeCleanup: recursively removes the created temporary directory, even when it's not empty. default is false
detachDescriptor: detaches the file descriptor, caller is responsible for closing the file, tmp will no longer try closing the file during garbage collection
discardDescriptor: discards the file descriptor (closes file, fd is -1), tmp will no longer try closing the file during garbage collection