CODEWITHSUNDEEP
node.jsfile-uploaduniqueidentifier
Erik
Erik

Reputation: 14780

How to generate short unique names for uploaded files in nodejs

I need to name uploaded files by short unique identifier like nYrnfYEv a4vhAoFG hwX6aOr7. How could I ensure uniqueness of files?

Upvotes: 22

Views: 47842

Answers (8)

Antony41
Antony41

Reputation: 1

function GetTempName()
{
    function gen(count) 
    { 
        let str = '';
        for (let i = 1; i <= count; i++) 
        {
            str += Math.floor(Math.random() * "0123456789abcdef".length).toString(36);
        }
        return  str;
    }
    return gen(8)+'-'+gen(4)+'-'+gen(4)+'-'+gen(4)+'-'+gen(12);
    //return gen(5);
    
}

console.log(GetTempName());

Upvotes: 0

Muhammad Rafeh Atique
Muhammad Rafeh Atique

Reputation: 872

export default generateRandom = () => Math.random().toString(36).substring(2, 15) + Math.random().toString(23).substring(2, 5);

As simple as that!

Upvotes: 2

ItalyPaleAle
ItalyPaleAle

Reputation: 7326

Update: shortid is deprecated. Use Nano ID instead. The answer below applies to Nano ID as well.

(Posting my comments as answer, with responses to your concerns)

You may want to check out the shortid NPM module, which generates short ids (shockingly, I know :) ) similar to the ones you were posting as example. The result is configurable, but by default it's a string between 7 and 14 characters (length is random too), all URL-friendly (A-Za-z0-9\_\- in a regex).

To answer your (and other posters') concerns:

  • Unless your server has a true random number generator (highly unlikely), every solution will use a PRNG (Pseudo-Random Number Generator). shortid uses Node.js crypto module to generate PRNG numbers, however, which is a much better generator than Math.random()
  • shortid's are not sequential, which makes it even harder to guess them
  • While shortid's are not guaranteed to be unique, the likelihood of a collision is extremely small. Unless you generate billions of entries per year, you could safely assume that a collision will never happen.
  • For most cases, relying on probability to trust that collisions won't happen is enough. If your data is too important to risk even that tiny amount, you could make the shortid basically 100% unique by just prepending a timestamp to it. As an additional benefit, the file names will be harder to guess too. (Note: I wrote "basically 100% unique" because you could still, in theory, have a collision if two items are generated in the same timestamp, i.e. the same second. However, I would never be concerned of this. To have a real 100% certainty your only option is to run a check against a database or the filesystem, but that requires more resources.)
  • The reason why shortid doesn't do that by itself is because for most applications the likelihood of a collision is too small to be a concern, and it's more important to have the shortest possible ids.

Upvotes: 26

Stephen Poole
Stephen Poole

Reputation: 189

function uniqueFileName( filePath, stub)
{
    let id = 0;
    let test = path.join(filePath, stub + id++);
    while (fs.existsSync(test))
    {
        test = path.join(filePath, stub + id++);
    }
    return test;
}

Upvotes: 0

serino lorenzo
serino lorenzo

Reputation: 51

Very simple code. produce a filename almost unique or if that's not enough you check if the file exists

function getRandomFileName() {
var timestamp = new Date().toISOString().replace(/[-:.]/g,"");  
var random = ("" + Math.random()).substring(2, 8); 
var random_number = timestamp+random;  
return random_number;
}

Upvotes: 5

user4695271
user4695271

Reputation:

One option could be to generate unique identifiers (UUID) and rename the file(s) accordingly.

Have a look at the kelektiv/node-uuid npm module.

EXAMPLE:

$ npm install uuid

...then in your JavaScript file:

const uuidv4 = require('uuid/v4'); // I chose v4 ‒ you can select others
var filename = uuidv4(); // '110ec58a-a0f2-4ac4-8393-c866d813b8d1'

Any time you execute uuidv4() you'll get a very-fresh-new-one.

NOTICE: There are other choices/types of UUIDs. Read the module's documentation to familiarize with those.

Upvotes: 21

Dineshaws
Dineshaws

Reputation: 2083

Try following snippet:-

    function getRandomSalt() {
    var milliseconds = new Date().getTime();
    var timestamp = (milliseconds.toString()).substring(9, 13)
    var random = ("" + Math.random()).substring(2, 8);
    var random_number = timestamp+random;  // string will be unique because timestamp never repeat itself
    var random_string = base64_encode(random_number).substring(2, 8); // you can set size here of return string
    var return_string = '';
    var Exp = /((^[0-9]+[a-z]+)|(^[a-z]+[0-9]+))+[0-9a-z]+$/i;
    if (random_string.match(Exp)) {                 //check here whether string is alphanumeric or not
        return_string = random_string;
    } else {
        return getRandomSalt();  // call recursivley again
    }
    return return_string;
}

File name might have an alphanumeric name with uniqueness according to your requirement. Unique name based on the concept of timestamp of current time because current time never repeat itself in future and to make it strong i have applied a base64encode which will be convert it into alphanumeric.

   var file = req.files.profile_image;
   var tmp_path = file.path;
   var fileName = file.name;
   var file_ext = fileName.substr((Math.max(0, fileName.lastIndexOf(".")) || Infinity) + 1);
   var newFileName = getRandomSalt() + '.' + file_ext;

Thanks

Upvotes: -6

zdszsdasd
zdszsdasd

Reputation: 18

I think you might be confused about true-random and pseudo-random.

Pseudo-random strings 'typically exhibit stastical randomness while being generated by an entirely deterministic casual process'. What this means is, if you are using these random values as entropy in a cryptographic application, you do not want to use a pseudo-random generator.

For your use, however, I believe it will be fine - just check for potential (highly unlikely) clashes.

All you are wanting to do is create a random string - not ensure it is 100% secure and completely random.

Upvotes: -5

Related Questions