与另一个uuid源(javascript)结合使用时的NewId与NewSequentialId
我需要在服务器端代码和客户端代码(在浏览器中)上创建UID。我目前使用NewID()作为默认值,但在客户端(在浏览器中)创建对象时,我使用uuid.js。我是否更有可能将NewSequentialId()作为默认值(在服务器端创建对象时将使用该值)发生冲突 仅供参考,这里是uuid.js代码,因为我记不起是在哪里下载的与另一个uuid源(javascript)结合使用时的NewId与NewSequentialId,javascript,sql-server,guid,uuid,Javascript,Sql Server,Guid,Uuid,我需要在服务器端代码和客户端代码(在浏览器中)上创建UID。我目前使用NewID()作为默认值,但在客户端(在浏览器中)创建对象时,我使用uuid.js。我是否更有可能将NewSequentialId()作为默认值(在服务器端创建对象时将使用该值)发生冲突 仅供参考,这里是uuid.js代码,因为我记不起是在哪里下载的 // uuid.js // // Copyright (c) 2010-2012 Robert Kieffer // MIT License - http
// uuid.js
//
// Copyright (c) 2010-2012 Robert Kieffer
// MIT License - http://opensource.org/licenses/mit-license.php
(function() {
var _global = this;
// Unique ID creation requires a high quality random # generator. We feature
// detect to determine the best RNG source, normalizing to a function that
// returns 128-bits of randomness, since that's what's usually required
var _rng;
// Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html
//
// Moderately fast, high quality
if (typeof(require) == 'function') {
try {
var _rb = require('crypto').randomBytes;
_rng = _rb && function() {return _rb(16);};
} catch(e) {}
}
if (!_rng && _global.crypto && crypto.getRandomValues) {
// WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
//
// Moderately fast, high quality
var _rnds8 = new Uint8Array(16);
_rng = function whatwgRNG() {
crypto.getRandomValues(_rnds8);
return _rnds8;
};
}
if (!_rng) {
// Math.random()-based (RNG)
//
// If all else fails, use Math.random(). It's fast, but is of unspecified
// quality.
var _rnds = new Array(16);
_rng = function() {
for (var i = 0, r; i < 16; i++) {
if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
_rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
}
return _rnds;
};
}
// Buffer class to use
var BufferClass = typeof(Buffer) == 'function' ? Buffer : Array;
// Maps for number <-> hex string conversion
var _byteToHex = [];
var _hexToByte = {};
for (var i = 0; i < 256; i++) {
_byteToHex[i] = (i + 0x100).toString(16).substr(1);
_hexToByte[_byteToHex[i]] = i;
}
// **`parse()` - Parse a UUID into it's component bytes**
function parse(s, buf, offset) {
var i = (buf && offset) || 0, ii = 0;
buf = buf || [];
s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
if (ii < 16) { // Don't overflow!
buf[i + ii++] = _hexToByte[oct];
}
});
// Zero out remaining bytes if string was short
while (ii < 16) {
buf[i + ii++] = 0;
}
return buf;
}
// **`unparse()` - Convert UUID byte array (ala parse()) into a string**
function unparse(buf, offset) {
var i = offset || 0, bth = _byteToHex;
return bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] + '-' +
bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]] +
bth[buf[i++]] + bth[buf[i++]];
}
// **`v1()` - Generate time-based UUID**
//
// Inspired by https://github.com/LiosK/UUID.js
// and http://docs.python.org/library/uuid.html
// random #'s we need to init node and clockseq
var _seedBytes = _rng();
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
var _nodeId = [
_seedBytes[0] | 0x01,
_seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
];
// Per 4.2.2, randomize (14 bit) clockseq
var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
// Previous uuid creation time
var _lastMSecs = 0, _lastNSecs = 0;
// See https://github.com/broofa/node-uuid for API details
function v1(options, buf, offset) {
var i = buf && offset || 0;
var b = buf || [];
options = options || {};
var clockseq = options.clockseq != null ? options.clockseq : _clockseq;
// UUID timestamps are 100 nano-second units since the Gregorian epoch,
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
var msecs = options.msecs != null ? options.msecs : new Date().getTime();
// Per 4.2.1.2, use count of uuid's generated during the current clock
// cycle to simulate higher resolution clock
var nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
// Time since last uuid creation (in msecs)
var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
// Per 4.2.1.2, Bump clockseq on clock regression
if (dt < 0 && options.clockseq == null) {
clockseq = clockseq + 1 & 0x3fff;
}
// Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
// time interval
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
nsecs = 0;
}
// Per 4.2.1.2 Throw error if too many uuids are requested
if (nsecs >= 10000) {
throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
}
_lastMSecs = msecs;
_lastNSecs = nsecs;
_clockseq = clockseq;
// Per 4.1.4 - Convert from unix epoch to Gregorian epoch
msecs += 12219292800000;
// `time_low`
var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
b[i++] = tl >>> 24 & 0xff;
b[i++] = tl >>> 16 & 0xff;
b[i++] = tl >>> 8 & 0xff;
b[i++] = tl & 0xff;
// `time_mid`
var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
b[i++] = tmh >>> 8 & 0xff;
b[i++] = tmh & 0xff;
// `time_high_and_version`
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
b[i++] = tmh >>> 16 & 0xff;
// `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
b[i++] = clockseq >>> 8 | 0x80;
// `clock_seq_low`
b[i++] = clockseq & 0xff;
// `node`
var node = options.node || _nodeId;
for (var n = 0; n < 6; n++) {
b[i + n] = node[n];
}
return buf ? buf : unparse(b);
}
// **`v4()` - Generate random UUID**
// See https://github.com/broofa/node-uuid for API details
function v4(options, buf, offset) {
// Deprecated - 'format' argument, as supported in v1.2
var i = buf && offset || 0;
if (typeof(options) == 'string') {
buf = options == 'binary' ? new BufferClass(16) : null;
options = null;
}
options = options || {};
var rnds = options.random || (options.rng || _rng)();
// Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
rnds[6] = (rnds[6] & 0x0f) | 0x40;
rnds[8] = (rnds[8] & 0x3f) | 0x80;
// Copy bytes to buffer, if provided
if (buf) {
for (var ii = 0; ii < 16; ii++) {
buf[i + ii] = rnds[ii];
}
}
return buf || unparse(rnds);
}
// Export public API
var uuid = v4;
uuid.v1 = v1;
uuid.v4 = v4;
uuid.parse = parse;
uuid.unparse = unparse;
uuid.BufferClass = BufferClass;
if (typeof define === 'function' && define.amd) {
// Publish as AMD module
define(function() {return uuid;});
} else if (typeof(module) != 'undefined' && module.exports) {
// Publish as node.js module
module.exports = uuid;
} else {
// Publish as global (in browsers)
var _previousRoot = _global.uuid;
// **`noConflict()` - (browser only) to reset global 'uuid' var**
uuid.noConflict = function() {
_global.uuid = _previousRoot;
return uuid;
};
_global.uuid = uuid;
}
}).call(this);
//uuid.js
//
//版权所有(c)2010-2012罗伯特·基弗
//麻省理工学院执照-http://opensource.org/licenses/mit-license.php
(功能(){
var _global=这个;
//独特的ID创建需要一个高质量的随机发生器
//检测以确定最佳RNG源,并将其规格化为
//返回128位随机性,因为这是通常需要的
var_rng;
//Node.js基于加密的RNG-http://nodejs.org/docs/v0.6.2/api/crypto.html
//
//速度适中,质量高
if(typeof(require)=“函数”){
试一试{
var_rb=require('crypto')。随机字节;
_rng=_rb&&function(){return_rb(16);};
}捕获(e){}
}
if(!\u rng&&u global.crypto&&crypto.getRandomValues){
//基于WHATWG加密的RNG-http://wiki.whatwg.org/wiki/Crypto
//
//速度适中,质量高
var _rnds8=新的UINT8阵列(16);
_rng=函数whatwgRNG(){
加密。获取随机值(_rnds8);
返回_rnds8;
};
}
如果(!\n rng){
//基于Math.random()的(RNG)
//
//如果所有其他方法都失败,请使用Math.random()。它很快,但没有指定
//质量。
var _rnds=新阵列(16);
_rng=函数(){
对于(变量i=0,r;i<16;i++){
如果((i&0x03)==0)r=Math.random()*0x100000000;
_rnds[i]=r>>>((i&0x03)&options.nsecs==null){
nsecs=0;
}
//根据4.2.1.2,如果请求的UUID太多,则抛出错误
如果(nsecs>=10000){
抛出新错误('uuid.v1():不能创建超过10M个uuid/sec');
}
_lastMSecs=毫秒;
_lastNSecs=nsecs;
_clockseq=clockseq;
//根据4.1.4-从unix纪元转换为公历纪元
毫秒+=12219292800000;
//“时间到了`
变量tl=((毫秒和0xfffffff)*10000+NSEC)%0x100000000;
b[i++]=tl>>>24&0xff;
b[i++]=tl>>>16&0xff;
b[i++]=tl>>>8&0xff;
b[i++]=tl&0xff;
//“时间到了`
变量tmh=(毫秒/0x100000000*10000)&0xfffffff;
b[i++]=tmh>>>8&0xff;
b[i++]=tmh&0xff;
//‘时间高’`
b[i++]=tmh>>>24&0xf | 0x10;//包含版本
b[i++]=tmh>>>16&0xff;
//‘时钟顺序高和保留’(根据4.2.2-包括变体)
b[i++]=clockseq>>>8 | 0x80;
//‘时钟_seq _low’`
b[i++]=clockseq&0xff;
//”“节点`
var node=options.node | | | u nodeId;
对于(变量n=0;n<6;n++){
b[i+n]=节点[n];
}
返回buf?buf:未解析(b);
}
//***`v4()`-生成随机UUID**
//看https://github.com/broofa/node-uuid 有关API的详细信息
功能v4(选项、buf、偏移){
//已弃用-“格式”参数,如v1.2所支持
变量i=buf&&offset | | 0;
if(typeof(options)=“string”){
buf=options==“binary”?新的BufferClass(16):null;
选项=空;
}
选项=选项| |{};
var rnds=options.random | | |(options.rng | | | u rng)();
//根据4.4,为版本和“时钟顺序、高电平”和“保留”设置位`
rnds[6]=(rnds[6]&0x0f)| 0x40;
rnds[8]=(rnds[8]&0x3f)| 0x80;
//将字节复制到缓冲区(如果提供)
如果(buf){
对于(var ii=0;ii<16;ii++){
buf[i+ii]=rnds[ii];
}
}
返回buf | | unpasse(rnds);
}
//导出公共API
var uuid=v4;
uuid.v1=v1;
uuid.v4=v4;
uuid.parse=parse;
uuid.unpasse=unpasse;
uuid.BufferClass=缓冲类;
if(typeof define=='function'&&define.amd){
//发布为AMD模块
定义(函数(){return uuid;});
}else if(模块的类型)!=“未定义”和&module.exports){
//发布为node.js模块
module.exports=uuid;
}否则{
//发布为全局(在浏览器中)
var\u previousRoot=\u global.uuid;
//***`noConflict()`-(仅限浏览器)重置全局“uuid”变量**
uuid.noConflict=函数(){
_global.uuid=\u previousRoot;
返回uuid;
};
_global.uuid=uuid;
}
}).打电话(这个);
这实际上是一个非常有趣的问题,涉及多个层次
首先,值得注意的是,uuid.js支持两种不同形式的id。uuid.v4()
使用随机数创建id,而uuid.v1()
基于时间戳创建idid的一部分实际上编码在id本身中,这保证了理论上v4 id不会与v1 id冲突。这是RFC4122 UUID规范的一部分
还值得注意的是,对于v1 id,每个id源都应该有一个唯一的“节点id”,也编码在id中,以保证由该源创建的id序列的唯一性。对于可以访问保证的唯一值(例如设备的MAC地址)的id源这很好。但是uuid.js无法访问这样的值,因此会为其节点id生成一个随机值。这会带来生成与服务器使用的节点id匹配的节点id的风险。节点id为48位值,这意味着节点id冲突的几率为281474976710656:1。因此,有可能,但它是太他妈的低了
…但这些都不重要!
事实证明,尽管NewSequentialID()
生成的ID表面上与v1 ID相似,但Microsoft决定交换ID中的各个字段,从而破坏RFC4122的兼容性。这意味着,根据序列号,ID可能会或可能会