JavaScriptでGUID / UUIDを作成しますか?


Answers

RFC4122バージョン4に準拠したソリューションの場合、この1ライナー(ish)ソリューションは、私が思い付く最もコンパクトです。

function uuidv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
    var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}

console.log(uuidv4())

Update、2015-06-02 :UUIDの一意性は、基礎となる乱数ジェネレータ(RNG)に大きく依存していることに注意してください。 Math.random()は高品質のRNGであること保証されていませんが、上記の解は簡潔さのためにMath.random()を使用しています。 詳細については、Math.random()のAdam Hylandの素晴らしい記事を参照してください。 もっと頑強な解決策を考えるには、uuidモジュール [免責事項:私は作者だ]と考えてみてください。利用できる場合は、より高品質のRNG APIを使用しています。

Update、2015-08-26 :サイドノートとして、特定の衝突確率に達する前に生成できるIDの数を決定する方法について説明します。 たとえば、3.26x10 15バージョン4のRFC4122 UUIDでは、100万の衝突の可能性があります。

アップデート、2017-06-28 :Chrome、Firefox、SafariのMath.random PRNGの品質についてChrome開発者が優れた記事を投稿しました。 tl; dr - 2015年末の時点では「かなり良い」と言われていますが、暗号の品質はありません。 この問題に対処するために、ここではES6、 crypto API、および少しのJSウィザードを使用する上記のソリューションの最新バージョンがあります。 私は信用できません

function uuidv4() {
  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
  )
}

console.log(uuidv4());

Question

JavaScriptでグローバルに一意の識別子を作成しようとしています。 私はどのようなルーチンがすべてのブラウザで利用可能であるか、どのように "ランダムに"組み込みの乱数ジェネレータがシードされているかなどはわかりません。

GUID / UUIDは32文字以上でなければならず、渡す際のトラブルを避けるためにASCII範囲にとどまるべきです。




It is important that to use well tested code that is maintained by more than 1 contributors instead of whipping your own stuff for this. This is one of the places where you probably want to prefer most stable code than shortest possible clever version that works in X browser but doesn't take in to account idiosyncrasies of Y which would often lead to very hard to investigate bugs than manifests only randomly for some users. Personally I use uuid-js at https://github.com/aurigadl/uuid-js which bower enabled so I can take updates easily.




一番上の投票回答とChromeの衝突の回避策の組み合わせは次のとおりです。

generateGUID = (typeof(window.crypto) != 'undefined' && 
                typeof(window.crypto.getRandomValues) != 'undefined') ?
    function() {
        // If we have a cryptographically secure PRNG, use that
        // https://.com/questions/6906916/collisions-when-generating-uuids-in-javascript
        var buf = new Uint16Array(8);
        window.crypto.getRandomValues(buf);
        var S4 = function(num) {
            var ret = num.toString(16);
            while(ret.length < 4){
                ret = "0"+ret;
            }
            return ret;
        };
        return (S4(buf[0])+S4(buf[1])+"-"+S4(buf[2])+"-"+S4(buf[3])+"-"+S4(buf[4])+"-"+S4(buf[5])+S4(buf[6])+S4(buf[7]));
    }

    :

    function() {
        // Otherwise, just use Math.random
        // https://.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
            var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
            return v.toString(16);
        });
    };

jsbinでテストしたい場合。




The better way:

function(
  a,b                // placeholders
){
  for(               // loop :)
      b=a='';        // b - result , a - numeric variable
      a++<36;        // 
      b+=a*51&52  // if "a" is not 9 or 14 or 19 or 24
                  ?  //  return a random number or 4
         (
           a^15      // if "a" is not 15
              ?      // genetate a random number from 0 to 15
           8^Math.random()*
           (a^20?16:4)  // unless "a" is 20, in which case a random number from 8 to 11
              :
           4            //  otherwise 4
           ).toString(16)
                  :
         '-'            //  in other cases (if "a" is 9,14,19,24) insert "-"
      );
  return b
 }

Minimized:

function(a,b){for(b=a='';a++<36;b+=a*51&52?(a^15?8^Math.random()*(a^20?16:4):4).toString(16):'-');return b}



var uuid = function() {
    var buf = new Uint32Array(4);
    window.crypto.getRandomValues(buf);
    var idx = -1;
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        idx++;
        var r = (buf[idx>>3] >> ((idx%8)*4))&15;
        var v = c == 'x' ? r : (r&0x3|0x8);
        return v.toString(16);
    });
};

編集:

Revisited my project that was using this function and disliked the verbosity. - But needed proper randomness.

A version based on Briguy37's answer and some bitwise operators to extract nibble sized windows from the buffer.

Should adhere to the RFC Type 4 (random) schema, since I had Problems last time parsing non-compliant uuids with Java's UUID.




このスレッドのベストアンサーを組み合わせた単純なJavaScriptモジュール。

var crypto = window.crypto || window.msCrypto || null; // IE11 fix

var Guid = Guid || (function() {

  var EMPTY = '00000000-0000-0000-0000-000000000000';

  var _padLeft = function(paddingString, width, replacementChar) {
    return paddingString.length >= width ? paddingString : _padLeft(replacementChar + paddingString, width, replacementChar || ' ');
  };

  var _s4 = function(number) {
    var hexadecimalResult = number.toString(16);
    return _padLeft(hexadecimalResult, 4, '0');
  };

  var _cryptoGuid = function() {
    var buffer = new window.Uint16Array(8);
    window.crypto.getRandomValues(buffer);
    return [_s4(buffer[0]) + _s4(buffer[1]), _s4(buffer[2]), _s4(buffer[3]), _s4(buffer[4]), _s4(buffer[5]) + _s4(buffer[6]) + _s4(buffer[7])].join('-');
  };

  var _guid = function() {
    var currentDateMilliseconds = new Date().getTime();
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(currentChar) {
      var randomChar = (currentDateMilliseconds + Math.random() * 16) % 16 | 0;
      currentDateMilliseconds = Math.floor(currentDateMilliseconds / 16);
      return (currentChar === 'x' ? randomChar : (randomChar & 0x7 | 0x8)).toString(16);
    });
  };

  var create = function() {
    var hasCrypto = crypto != 'undefined' && crypto !== null,
      hasRandomValues = typeof(window.crypto.getRandomValues) != 'undefined';
    return (hasCrypto && hasRandomValues) ? _cryptoGuid() : _guid();
  };

  return {
    newGuid: create,
    empty: EMPTY
  };
})();

// DEMO: Create and show GUID
console.log(Guid.newGuid());

使用法:

Guid.newGuid()

"c6c2d12f-d76b-5739-e551-07e6de5b0807"

Guid.empty

"00000000-0000-0000-0000-000000000000"




ブローファの答えはかなり滑らかです、実際には印象的な賢さ、本当に... rfc4122準拠、やや可読性、コンパクト。 驚くばかり!

しかし、あなたがその正規表現を見ているなら、多くのreplace()コールバック、 toString()Math.random()関数呼び出し(ここでは4ビットの結果しか使用せず残りを無駄にしています)を開始することもできますパフォーマンスについて不思議に思う 確かに、joelptはgenerateQuickGUIDを使って一般的なGUID速度のrfcを投げ捨てることにしました。

しかし、スピード rfcへの準拠は可能ですか? 私は言う、はい! 読みやすさを維持できますか? まあ...実際はそうですが、あなたが一緒に従うならば簡単です。

しかし、まず、ブローファ、 guid (受け入れられた回答)、および非rfc準拠のgenerateQuickGuidと比較した私の結果:

                  Desktop   Android
           broofa: 1617ms   12869ms
               e1:  636ms    5778ms
               e2:  606ms    4754ms
               e3:  364ms    3003ms
               e4:  329ms    2015ms
               e5:  147ms    1156ms
               e6:  146ms    1035ms
               e7:  105ms     726ms
             guid:  962ms   10762ms
generateQuickGuid:  292ms    2961ms
  - Note that results will vary by browser/cpu.

だから私の6回目の最適化では、最も一般的な回答を12倍以上、受け入れた回答を9倍以上、速い順応しない回答を2〜3倍で打ちました 。 私はまだrfc4122に準拠しています。

どのように興味がありますか? 私はhttp://jsfiddle.net/jcward/7hyaC/3/http://jsfiddle.net/jcward/7hyaC/3/完全なソースを載せました

説明のために、ブローファのコードから始めましょう:

'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
  var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
  return v.toString(16);
});

したがって、 xをランダムな16進数で置き換え、 yをランダムなデータで置き換える(ただし、rfcの仕様では上位2ビットを10することを除いて)。正規表現は-または4文字と一致しないので、処理する必要はないそれらと一緒に。 非常に、非常に滑らか。

最初に知っておくべきことは、正規表現(ただし、彼は1だけを使用しますが、32個のコールバック、それぞれのマッチに対して1つ、Math.random()およびv .toString(16))。

パフォーマンスへの第一歩は、RegExとそのコールバック関数を削除し、代わりに単純なループを使用することです。 これは、ブローファがしなかったのに対し、 -4文字を扱わなければならないことを意味します。 また、String Arrayの索引付けを使用して、洗練されたStringテンプレート・アーキテクチャーを保つこともできます。

function e1() {
  var u='',i=0;
  while(i++<36) {
    var c='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'[i-1],r=Math.random()*16|0,v=c=='x'?r:(r&0x3|0x8);
    u+=(c=='-'||c=='4')?c:v.toString(16)
  }
  return u;
}

基本的には同じ内部ロジック(ただし、 -または4をチェックする点と、コールバックを置き換える代わりにループ構造)は、ほぼ3倍の改善をもたらします。

次のステップはデスクトップ上の小さなものですが、モバイルではまったく違いがあります。 より少ない数のMath.random()呼び出しを行い、それらの87%をそれぞれの反復からシフトアウトされるランダムなバッファで投げるのではなく、これらのランダムなビットをすべて利用します。 テンプレート定義をループの外に移動してみましょう。

function e2() {
  var u='',m='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx',i=0,rb=Math.random()*0xffffffff|0;
  while(i++<36) {
    var c=m[i-1],r=rb&0xf,v=c=='x'?r:(r&0x3|0x8);
    u+=(c=='-'||c=='4')?c:v.toString(16);rb=i%8==0?Math.random()*0xffffffff|0:rb>>4
  }
  return u
}

これにより、プラットフォームに応じて10〜30%節約できます。 悪くない。 しかし、次の大きなステップでは、toString関数呼び出しをすべて最適化の古典であるルックアップテーブルで取り除きます。 シンプルな16要素ルックアップテーブルは、はるかに短い時間でtoString(16)のジョブを実行します:

function e3() {
  var h='0123456789abcdef';
  var k='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
  /* same as e4() below */
}
function e4() {
  var h=['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'];
  var k=['x','x','x','x','x','x','x','x','-','x','x','x','x','-','4','x','x','x','-','y','x','x','x','-','x','x','x','x','x','x','x','x','x','x','x','x'];
  var u='',i=0,rb=Math.random()*0xffffffff|0;
  while(i++<36) {
    var c=k[i-1],r=rb&0xf,v=c=='x'?r:(r&0x3|0x8);
    u+=(c=='-'||c=='4')?c:h[v];rb=i%8==0?Math.random()*0xffffffff|0:rb>>4
  }
  return u
}

次の最適化はもう一つの古典です。 各ループ反復では4ビットの出力しか処理していないので、ループの数を半分に減らして、反復ごとに8ビットを処理してみましょう。 これは、依然としてrfc準拠のビット位置を処理する必要があるため、扱いにくいですが、それほど難しくありません。 次に、0x00〜0xffを格納するために、より大きなルックアップテーブル(16x16または256)を作成しなければならず、e5()関数の外部で1回しか構築しません。

var lut = []; for (var i=0; i<256; i++) { lut[i] = (i<16?'0':'')+(i).toString(16); }
function e5() {
  var k=['x','x','x','x','-','x','x','-','4','x','-','y','x','-','x','x','x','x','x','x'];
  var u='',i=0,rb=Math.random()*0xffffffff|0;
  while(i++<20) {
    var c=k[i-1],r=rb&0xff,v=c=='x'?r:(c=='y'?(r&0x3f|0x80):(r&0xf|0x40));
    u+=(c=='-')?c:lut[v];rb=i%4==0?Math.random()*0xffffffff|0:rb>>8
  }
  return u
}

私は一度に16ビットを処理するe6()を試しましたが、それでも256要素のLUTを使用していました。最適化のリターンが小さくなっています。 反復回数は少なくなりましたが、内部ロジックは処理が複雑になると複雑になり、デスクトップでも同じように実行され、モバイルでは10%しか高速化されませんでした。

適用するための最終的な最適化テクニック - ループを展開します。 私たちは一定回数ループしているので、技術的にはすべて手作業で書くことができます。 私はこれを一度ランダム変数rを使って再試行しました。 しかし、4つの変数にランダムなデータを割り当て、ルックアップテーブルを使用し、適切なrfcビットを適用することで、このバージョンはすべてを吸います。

var lut = []; for (var i=0; i<256; i++) { lut[i] = (i<16?'0':'')+(i).toString(16); }
function e7()
{
  var d0 = Math.random()*0xffffffff|0;
  var d1 = Math.random()*0xffffffff|0;
  var d2 = Math.random()*0xffffffff|0;
  var d3 = Math.random()*0xffffffff|0;
  return lut[d0&0xff]+lut[d0>>8&0xff]+lut[d0>>16&0xff]+lut[d0>>24&0xff]+'-'+
    lut[d1&0xff]+lut[d1>>8&0xff]+'-'+lut[d1>>16&0x0f|0x40]+lut[d1>>24&0xff]+'-'+
    lut[d2&0x3f|0x80]+lut[d2>>8&0xff]+'-'+lut[d2>>16&0xff]+lut[d2>>24&0xff]+
    lut[d3&0xff]+lut[d3>>8&0xff]+lut[d3>>16&0xff]+lut[d3>>24&0xff];
}

Modualized: http://jcward.com/UUID.js ://jcward.com/UUID.js - UUID.generate()

面白いのは、16バイトのランダムデータを生成するのが簡単なことです。 トリック全体は、RFC準拠のString形式で表現されています.16バイトのランダムデータ、展開されていないループ、ルックアップテーブルを使用しています。

私の論理が正しいことを願っています。このような退屈なビットワークを間違えてしまうのはとても簡単です。 しかし、出力は私によく見える。 私はあなたがコード最適化を通してこの狂った乗り物を楽しんでくれたことを願っています

私の第一の目標は、潜在的な最適化戦略を示し、教えることでした。 その他の回答には、衝突や本当に乱数などの重要なトピックが含まれています。これらは良好なUUIDを生成する上で重要です。




I know, it is an old question. Just for completeness, if your environment is SharePoint, there is a utility function called SP.Guid.newGuid ( msdn link ) which creates a new guid. This function is inside the sp.init.js file. If you rewrite this function (to remove some other dependencies from other private functions), it looks like this:

var newGuid = function () {
    var result = '';
    var hexcodes = "0123456789abcdef".split("");

    for (var index = 0; index < 32; index++) {
        var value = Math.floor(Math.random() * 16);

        switch (index) {
        case 8:
            result += '-';
            break;
        case 12:
            value = 4;
            result += '-';
            break;
        case 16:
            value = value & 3 | 8;
            result += '-';
            break;
        case 20:
            result += '-';
            break;
        }
        result += hexcodes[value];
    }
    return result;
};



ここには完全に準拠していないが、ASCII安全なGUIDのようなユニークな識別子を生成するための非常に実行可能な実装があります。

function generateQuickGuid() {
    return Math.random().toString(36).substring(2, 15) +
        Math.random().toString(36).substring(2, 15);
}

26 [a-z0-9]文字を生成し、RFCに準拠したGUIDよりも短くユニークなUIDを生成します。 人間の可読性が重要な場合は、ダッシュを簡単に追加できます。

ここでは、この関数の使用例とタイミングと、この質問のその他の回答のいくつかを示します。 タイミングはChrome m25の下でそれぞれ1千万回繰り返し実行されました。

>>> generateQuickGuid()
"nvcjf1hs7tf8yyk4lmlijqkuo9"
"yq6gipxqta4kui8z05tgh9qeel"
"36dh5sec7zdj90sk2rx7pjswi2"
runtime: 32.5s

>>> GUID() // John Millikin
"7a342ca2-e79f-528e-6302-8f901b0b6888"
runtime: 57.8s

>>> regexGuid() // broofa
"396e0c46-09e4-4b19-97db-bd423774a4b3"
runtime: 91.2s

>>> createUUID() // Kevin Hakanson
"403aa1ab-9f70-44ec-bc08-5d5ac56bd8a5"
runtime: 65.9s

>>> UUIDv4() // Jed Schmidt
"f4d7d31f-fa83-431a-b30c-3e6cc37cc6ee"
runtime: 282.4s

>>> Math.uuid() // broofa
"5BD52F55-E68F-40FC-93C2-90EE069CE545"
runtime: 225.8s

>>> Math.uuidFast() // broofa
"6CB97A68-23A2-473E-B75B-11263781BBE6"
runtime: 92.0s

>>> Math.uuidCompact() // broofa
"3d7b7a06-0a67-4b67-825c-e5c43ff8c1e8"
runtime: 229.0s

>>> bitwiseGUID() // jablko
"baeaa2f-7587-4ff1-af23-eeab3e92"
runtime: 79.6s

>>>> betterWayGUID() // Andrea Turri
"383585b0-9753-498d-99c3-416582e9662c"
runtime: 60.0s

>>>> UUID() // John Fowler
"855f997b-4369-4cdb-b7c9-7142ceaf39e8"
runtime: 62.2s

ここにタイミングコードがあります。

var r;
console.time('t'); 
for (var i = 0; i < 10000000; i++) { 
    r = FuncToTest(); 
};
console.timeEnd('t');



ES6 sample

const guid=()=> {
  const s4=()=> Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);     
  return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;
}



It's just a simple AJAX call...

If anyone is still interested, here's my solution.

On the server side:

[WebMethod()]
public static string GenerateGuid()
{
    return Guid.NewGuid().ToString();
}

On the client side:

var myNewGuid = null;
PageMethods.GenerateGuid(
    function(result, userContext, methodName)
    {
        myNewGuid = result;
    },
    function()
    {
        alert("WebService call failed.");
    }
);



  // RFC 4122
  //
  // A UUID is 128 bits long
  //
  // String representation is five fields of 4, 2, 2, 2, and 6 bytes.
  // Fields represented as lowercase, zero-filled, hexadecimal strings, and
  // are separated by dash characters
  //
  // A version 4 UUID is generated by setting all but six bits to randomly
  // chosen values
  var uuid = [
    Math.random().toString(16).slice(2, 10),
    Math.random().toString(16).slice(2, 6),

    // Set the four most significant bits (bits 12 through 15) of the
    // time_hi_and_version field to the 4-bit version number from Section
    // 4.1.3
    (Math.random() * .0625 /* 0x.1 */ + .25 /* 0x.4 */).toString(16).slice(2, 6),

    // Set the two most significant bits (bits 6 and 7) of the
    // clock_seq_hi_and_reserved to zero and one, respectively
    (Math.random() * .25 /* 0x.4 */ + .5 /* 0x.8 */).toString(16).slice(2, 6),

    Math.random().toString(16).slice(2, 14)].join('-');



XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXという形式の最速GUIDストリングジェネレータメソッド。 標準に準拠したGUIDは生成されません。

この実装では1,000万回の実行には32.5秒しかかかりません。これはブラウザで見た中で最も速い(ループ/反復なしの唯一のソリューションです)。

この関数は次のように簡単です:

/**
 * Generates a GUID string.
 * @returns {String} The generated GUID.
 * @example af8a8416-6e18-a307-bd9c-f2c947bbb3aa
 * @author Slavik Meltser (slavik@meltser.info).
 * @link http://slavik.meltser.info/?p=142
 */
function guid() {
    function _p8(s) {
        var p = (Math.random().toString(16)+"000000000").substr(2,8);
        return s ? "-" + p.substr(0,4) + "-" + p.substr(4,4) : p ;
    }
    return _p8() + _p8(true) + _p8(true) + _p8();
}

パフォーマンスをテストするには、次のコードを実行します。

console.time('t'); 
for (var i = 0; i < 10000000; i++) { 
    guid(); 
};
console.timeEnd('t');

私はあなたのほとんどが私がそこで何をしたのか理解するだろうと確信していますが、多分説明が必要な人が少なくとも一人はいます:

アルゴリズム:

  • Math.random()関数は、小数点以下16桁の0から1の間の10進数を返します(たとえば、 0.4363923368509859 )。
  • 次に、この数値を基数16の文字列に変換します(上記の例では、 0.6fb7687fが得られ0.6fb7687f )。
    Math.random().toString(16)
  • その後、接頭辞( 0.6fb7687f => 6fb7687f )を6fb7687f 、8 6fb7687f 16進文字列を取得します。
    (Math.random().toString(16).substr(2,8)
  • 場合によっては、 Math.random()関数は最後のゼロ(実際には0.4363000000000000 )から短い数値(たとえば0.4363 )を返します。 だから、私はこの文字列"000000000" (9個の0を持つ文字列)を追加して、 substr()関数でそれを切り捨てて9個の文字を正確に(右にゼロを埋めてsubstr()作る。
  • 正確に9つのゼロを追加する理由は、 Math.random()関数が正確に0または1(それぞれのMath.random() ^ 16の確率Math.random()を返す悪いケースのシナリオのためです。 そのため、9個のゼロ( "0"+"000000000"または"1"+"000000000" )を追加し、8文字の長さの2番目のインデックス(3番目の文字)から切り捨てる必要がありました。 それ以外の場合は、ゼロを追加しても結果が損なわれることはありません。
    Math.random().toString(16)+"000000000").substr(2,8)

アセンブリ:

  • GUIDの形式はXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXです。
  • 私はGUIDを4つの部分に分けました。それぞれの部分は2つのタイプ(または形式): XXXXXXXX-XXXX-XXXX分かれていました。
  • 今度は、これらの2つのタイプを使用してGUIDを構築して、次のように4つの呼び出しでGUIDをアセンブルします-XXXX-XXXX -XXXX-XXXX XXXXXXXX
  • これらの2つのタイプを_p8(s)するために、私はペア作成者関数_p8(s)にフラグ・パラメーターを追加しました_p8(s)パラメーターは、ダッシュを追加するかどうかを関数に指示します。
  • 最終的に_p8() + _p8(true) + _p8(true) + _p8()チェーンを使用してGUIDを構築し、それを返します。

私のブログにこの記事へのリンク

楽しい! :-)




JavaScript project on GitHub - https://github.com/LiosK/UUID.js

UUID.js The RFC-compliant UUID generator for JavaScript.

See RFC 4122 ietf.org/rfc/rfc4122.txt .

Features Generates RFC 4122 compliant UUIDs.

Version 4 UUIDs (UUIDs from random numbers) and version 1 UUIDs (time-based UUIDs) are available.

UUID object allows a variety of access to the UUID including access to the UUID fields.

Low timestamp resolution of JavaScript is compensated by random numbers.




You can use node-uuid ( https://github.com/kelektiv/node-uuid )

Simple, fast generation of ietf.org/rfc/rfc4122.txt UUIDS.

特徴:

  • Generate RFC4122 version 1 or version 4 UUIDs
  • Runs in node.js and browsers.
  • Cryptographically strong random # generation on supporting platforms.
  • Small footprint (Want something smaller? https://gist.github.com/982883 )

Install Using NPM:

npm install uuid

Or Using uuid via browser:

Download Raw File (uuid v1): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v1.js Download Raw File (uuid v4): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v4.js

Want even smaller? Check this out: https://gist.github.com/jed/982883

Usage:

// Generate a v1 UUID (time-based)
const uuidV1 = require('uuid/v1');
uuidV1(); // -> '6c84fb90-12c4-11e1-840d-7b25c5ee775a'

// Generate a v4 UUID (random)
const uuidV4 = require('uuid/v4');
uuidV4(); // -> '110ec58a-a0f2-4ac4-8393-c866d813b8d1'

// Generate a v5 UUID (namespace)
const uuidV5 = require('uuid/v5');

// ... using predefined DNS namespace (for domain names)
uuidV5('hello.example.com', v5.DNS)); // -> 'fdda765f-fc57-5604-a269-52a7df8164ec'

// ... using predefined URL namespace (for, well, URLs)
uuidV5('http://example.com/hello', v5.URL); // -> '3bbcee75-cecc-5b56-8031-b6641c1ed1f1'

// ... using a custom namespace
const MY_NAMESPACE = '(previously generated unique uuid string)';
uuidV5('hello', MY_NAMESPACE); // -> '90123e1c-7512-523e-bb28-76fab9f2f73d'