을 만들 GUID/UUID 에서 JavaScript?
https://stackoverflow.com/questions/105034
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
내가 만들려고 세계적으로 독특한 식별자에서 JavaScript.나는 확실하지 않은 무엇인 루틴이 사용할 수 있는 모든 브라우저에서,방법이"무작위"뿌린 내장 임의의 번호 생성기입니다,등등....
GUID/UUID 해야에 최소 32 자고 있어야에서 ASCII 범위를 문제를 방지하고 전달할 때 그들 주변에 있다.
해결책
Uuid(Universally Unique IDentifier),also known as Guid(전 세계적으로 독특한 식별자)에 따라, RFC4122, 는 식별자는 특정성 보장합니다.
을 생성하는 가장 좋은 방법이 따라 구현에서 지침을 말하는 RFC 중 하나를 사용하여 많은 커뮤니티 심사픈 소스를 구현합니다..
인기 있는 오픈 소스 도구는 작업에 대한 표에서 JavaScript 노드-uuid
참고가 무작위로 생성한 식별자를 바이트별로,또는 문자,제공하지 않습니다 당신은 동일한 보장으로 따르는 구현합니다.또한,매우 중요한,시스템과 함께 작업을 준수 표지 않도록 선택할 수 있습을 받아들이 무작위로 생성된 사람,그리고 많은 오픈 소스 검사기는 것입니다 실제로 유효한지 확인 구조입니다.
는 UUID 해야 합 형식은 다음과 같습니다.
xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
가 M 고 N 위치가있을 수 있습니다 특정한 값입니다.이 시간에만 유효한 값 M 은 1,2,3,4,5,그래서 무작위로 생성되는 위치는 것이 대부분을 만들 결과가 없습니다.
다른 팁
대 RFC4122 버전 4 준수하는 솔루션,하이라이너(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())업데이트 2015-06-02:식 UUID 성에 크게 의존하고 기본 random number generator(RNG).위의 솔루션 사용 Math.random() 간단하게 나타내기 위해,그러나이 Math.random() 가 지 을 보장하는 높은-품질 RNG.시 아담이 하이랜드 우수한 보고서 나에서 수학이다.random() 자세한 내용은.에 대한 보다 강력한 솔루션 같은 것을 고려 uuid 모듈[면책 조항:나는 저자],사용하는 높은 품질 RNG Api 를 이용하실 수 있습니다.
업데이트 2015-08-26:로 측-이 gist 를 결정하는 방법에 대해 설명합니다 얼마나 많은 Id 를 생성할 수 있습에 도달하기 전에 일정을 확률의 충돌이 발생합니다.예를 들어,3.26x1015 버전 4RFC4122Uuid1-에만의 충돌이 발생합니다.
업데이트 2017-06-28:A 좋은 기사에서 Chrome 개발 을 논의 상태의 수학이다.random PRNG 품질에서 Chrome,Firefox,Safari.tl;dr-로의 늦-2015 년 그것은"pretty good"지만,암호화 품질입니다.을 주는,다음의 업데이트 버전을 위한 솔루션을 사용하는 ES6,the crypto API 비 JS wizardy 나는 받을 수 없용:
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());정말 어떻게 깨끗한 Broofa 의 응답 이지만,그것은 불행한 가난한 구현 Math.random 기회를 떠나를 위해 충돌이 발생합니다.
비슷한 RFC4122 4 버전을 준수하는 솔루션을 해결하는 문제에 의해 상쇄하는 첫 번째 13 진수 숫자에 의해 진수 부분의 타임 스탬프.는 방법,경우에도 Math.random 같은 씨앗을 모두 클라이언트는 것을 생성합니다 정확 밀리초(또는 10,000 개 이상의 년 후)동일한 UUID:
function generateUUID() { // Public Domain/MIT
var d = new Date().getTime();
if (typeof performance !== 'undefined' && typeof performance.now === 'function'){
d += performance.now(); //use high-precision timer if available
}
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
});
}
broofa 의 대답은 매우 매끄러운-실제로,인상적으로 영리,정말...rfc4122 준수하고,다소 읽을 수 있는,그리고 컴팩트합니다.니다!
하지만 찾고 있는 경우에는 정규 표현식,많은 사람들 replace() 콜백, toString()'s Math.random() 함수 호출(여기서 그만 사용하는 4 비트의 결과이며 낭비하고 나머지),을 시작할 수 있을지 궁금에 대한 성과입니다.실제로,joelpt 도하기로 결정했 던져 RFC 에 대한 일반적인 GUID 속도 generateQuickGUID.
지만,우리가 속도 고 RFC compliance?I say,YES! 해를 유지할 수 있습니 readability?음...정말이지만,그것은 당신은 당신을 따라.
하지만 먼저,내 결과,비교하 broofa, guid (허용되는 답변),그리고 비 rfc compliant 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: 500k iterations, results will vary by browser/cpu.
그래서에 의해 나는 6 반복의 최적화,내가 이길 가장 인기있는 대답하여 이상 12X, 로,받아들이 대답하여 이상 9X, 고 빠르게 비준수 응답 2-3.그리고 나는 아직도 rfc4122 규정을 준수합니다.
에 관심있는 방법?내가 전체 소스 http://jsfiddle.net/jcward/7hyaC/3/ 에 http://jsperf.com/uuid-generator-opt/4
에 대한 설명을 시작하자 broofa 의 코드:
'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 과 함께 모든 임의의 진수 숫자 y 랜덤 데이터(를 제외하고 강제로 상위 2 비트 10 당 RFC 사양),및 regex 일치하지 않은 - 나 4 문자,그래서 그는 없는 그들과 거래를 할 수 있습니다.매우,매우 매끄럽습니다.
첫번째 것을 알고있는 함수 호출은 비용으로는 정규 표현식(비록 그만 사용하는 1 는 32 개의 콜백을,하나를 위해 각 경기,그리고 각각의 32 개의 콜백을 호출하는 수학이다.random()및 v.toString(16)).
첫 번째 단계로 성능을 제거하는 것입니 RegEx 와의 콜백 함수를 사용이 간단합니다.즉 우리가 처리 - 고 4 문자를 반면 broofa 하지 않았다.또한,주는 우리가 사용할 수 있는 문자열을 배열 색인 유지하는 그의 매끄러운 문자열 템플링
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, 을 사용하는 동안 반복(대 replace() 콜백)얻는 우리에게 거의 3 배선!
다음 단계는 작은 하나의 데스크톱에서 하지만 괜찮은 차이 모바일에 있습니다.만들자는 적은 수학이다.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 와는 비트이지만,그것은 너무 어렵습니다.우리는 다음을 더 큰 조회 테이블(16x16,또는 256)저장 0x00-0xff,그리고 우리는 그것을 구축 한 번만,외부 e5()함수입니다.
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
}
나는 e6()는 프로세스에 16-비트 시간에 여전히 사용하 256 요소 LUT,그리고 보여 감소하는 반환 최적화할 수 있습니다.하지만 그것이 적어 반복,이너 논리에 의해 복잡하게 증가 처리하며,그것은 같은 수행에,바탕 화면 및만~10%빨리 모바일에 있습니다.
최종 최적화 기법을 적용하게 풀어줍니다.이후 우리는 반복 고정된 횟수,우리가 할 수 있는 기술적으로 쓰는 이 모두 있습니다.나는 이 한 번에 하나의 랜덤변수 r 는 내가 지켜 재 할당하고,성능 만취.하지만 네 개의 변수를 할당된 임의의 데이터 전면,다음 사용 조회 테이블,그리고 적용하는 적절한 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 - UUID.generate()
재미있는 것은,생성하는 16 바이트의 랜덤 데이터의 쉬운 부분입니다.전체릭을 표현하는 그것이 문자열 형식으로 RFC 준수,그리고 가장 단단하게 수행한 16 바이트의 랜덤 데이터 풀 루프와 조회이다.
나의 논리를 올바른-그것은 매우 쉽게 실수에 이런 종류의 지루한 비트입니다.하지만 출력이 좋아 보여요.I hope you enjoyed this mad 타고 코드를 통해 최적화!
사: 나의 기본 목표를 보여주고 가르치는 잠재적인 최적화 전략이 있습니다.다른 답변 중요한 주제를 다룹과 같은 충돌과 진정으로 임의의 숫자에 대한 중요성이 좋은 게임.
여기에 몇 가지를 기반으로 코드 RFC4122, 섹션 4.4(알고리즘을 만들기 위한 UUID 에서 진정으로 임의의 또는 의사 무작위 숫자).
function createUUID() {
// http://www.ietf.org/rfc/rfc4122.txt
var s = [];
var hexDigits = "0123456789abcdef";
for (var i = 0; i < 36; i++) {
s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
}
s[14] = "4"; // bits 12-15 of the time_hi_and_version field to 0010
s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01
s[8] = s[13] = s[18] = s[23] = "-";
var uuid = s.join("");
return uuid;
}
var uniqueId = Math.random().toString(36).substring(2) + (new Date()).getTime().toString(36);
는 경우 ID 생성되 이상 1 밀리 떨어져 그들이 100%고유합니다.
는 경우 두 ID 생성되는 짧은 간격으로,그리고 가정하면 임의의 방법은 진정으로,랜덤,이를 생성하 ID 는 99.99999999999999%될 가능성이 전 세계적으로 독특한(충돌에서 1of10^15)
할 수 있는 증가는 이 번호를 추가해 더 자리만을 생성하는 100%고유 ID 를 사용해야 합 글로벌 카운터입니다.
는 경우에 당신은 정말 필요 RFC 준수,이 서식을 통과으로 유효한 버전 4GUID:
const uid = (new Date()).getTime().toString(16) + Math.random().toString(16).substring(2) + "0".repeat(16);
const guid = uid.substr(0,8) + '-' + uid.substr(8,4) + '-4000-8' + uid.substr(12,3) + '-' + uid.substr(15,12);
var u = (new Date()).getTime().toString(16) +
Math.random().toString(16).substring(2) + "0".repeat(16);
var guid = u.substr(0,8) + '-' + u.substr(8,4) + '-4000-8' +
u.substr(12,3) + '-' + u.substr(15,12);
document.getElementById("unique").innerHTML = guid;<div id="unique">
</div>편집:위의 코드를 따라 긴장하지만,문자의 RFC.중 다른 차이는 그것의 몇 가지 숫자는 임의의 짧습니다.(더 추가한 임의의 숫자가 당신이 그것을 필요로 하는 경우)거꾸로 이것이 정말 빠르고,비교하여 100%준수하는 코드입니다.수 테스트 GUID 기
가장 빠른 GUID 같은 문자열 발전기 방법 형식 XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.이를 생성하지 않 표준을 준수하는 오류입니다.
천만 실행하는 이 구현을 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()반 진수 0 과 1 사진 16 이후의 숫자는 소수점(한 예0.4363923368509859). - 그런 우리가 이 번호 및 변환
이 문자열에 기초 16 조(위의 예에서 우리가 얻
0.6fb7687f).
Math.random().toString(16). - 그런 다음 우리는 잘라
0.접두사(0.6fb7687f=>6fb7687f고)문자열과 함께 여덟수 자입니다.
(Math.random().toString(16).substr(2,8). - 때때로
Math.random()기능 돌아 짧은 숫자를(예를 들어0.4363)때문에 영 끝에(위의 예에서,실제로 이번호0.4363000000000000).는 추가를 이 문자열"000000000"(문자열을 가진 나인 제로)그리고 그것을 절단된substr()기능 그것을 만들 문자(정확하게 작성 제로 오른쪽). - 는 이유에 대한 추가 정확히 나인 제로는 최악의 시나리오는 때입니다
Math.random()기능이 정확하게 반환 0 또는 1(의 확률 1/10^16 에 대한 그들 각각).그런 이유로 우리를 추가하는 데 필요한 아홉 제로 그것("0"+"000000000"나"1"+"000000000"고),그 다음 그것을 절단에서 두 번째 인덱스(3 캐릭터)길이의 여덟 문자입니다.의 나머지 부분에 대한 경우 이외의 제로에 해를 끼치지 않은 결과이기 때문에 그것을 절단 anyway.
Math.random().toString(16)+"000000000").substr(2,8).
어셈블리:
- GUID 형식이 다음과 같습니다.
XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX. - 나는 나누어 GUID4 조각으로,각각의 조각으로 나눌 2 종류(또는 포맷):
XXXXXXXX고-XXXX-XXXX. - 지금 나는 건물 GUID 를 사용하여 이러한 2 종류를 조립하 GUID 를 호출 4 개,다음과 같다:
XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX. - 다른 사이의 이러한 두 가지 유형,나는 추가 깃발을 매개 변수 한 쌍을 작성자 기능
_p8(s), 이,s매개 변수는 기능을 추가할지 여부를 대시거나지 않습니다. - 결국 우리가 구축 GUID 를 다음과 같은 체인:
_p8() + _p8(true) + _p8(true) + _p8(), 고 반환합니다.
을 즐길!:-)
여기에서의 조합 최고 투표에 응답, 과에 대한 해결책 크롬의 충돌:
generateGUID = (typeof(window.crypto) != 'undefined' &&
typeof(window.crypto.getRandomValues) != 'undefined') ?
function() {
// If we have a cryptographically secure PRNG, use that
// https://stackoverflow.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://stackoverflow.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 하려는 경우 그것을 테스트합니다.
여기에 완전히 비준수지만 매우 성능 구현을 생성하는 ASCII-안전 GUID 같은 독특한 식별자입니다.
function generateQuickGuid() {
return Math.random().toString(36).substring(2, 15) +
Math.random().toString(36).substring(2, 15);
}
생 26[a-z0-9]자,열매를 산출하는 UID 는 짧고 더 많은 독특한다 RFC 와 Guid.대시될 수 있는 사소하는 경우 추가 인간의 가독성을 중요합니다.
여기에는 사용 예제와 타이밍에 대한 이 함수의 여러 가지 이 질문의 답변이 있습니다.타이밍을 수행하였 크롬에서 m25,10 만 달러로 반복하는 각.
>>> 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');
여기에는 솔루션을자 Oct.9,2011 년에서 코멘트 사용자에 의해 jed 에 https://gist.github.com/982883:
UUIDv4 = function b(a){return a?(a^Math.random()*16>>a/4).toString(16):([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g,b)}
이를 달성과 같은 목표를 현재 가장 높은 등급 응답, 지만,50+의 바이트를 이용하여 강압,재귀,지수의 개념입니다.사람들을 위해 호기심이 어떻게 작동하는지,여기에 주석의 형태로 이전 버전의 기능:
UUIDv4 =
function b(
a // placeholder
){
return a // if the placeholder was passed, return
? ( // a random number from 0 to 15
a ^ // unless b is 8,
Math.random() // in which case
* 16 // a random number from
>> a/4 // 8 to 11
).toString(16) // in hexadecimal
: ( // or otherwise a concatenated string:
[1e7] + // 10000000 +
-1e3 + // -1000 +
-4e3 + // -4000 +
-8e3 + // -80000000 +
-1e11 // -100000000000,
).replace( // replacing
/[018]/g, // zeroes, ones, and eights with
b // random hex digits
)
}
function generateGuid() {
var result, i, j;
result = '';
for(j=0; j<32; j++) {
if( j == 8 || j == 12 || j == 16 || j == 20)
result = result + '-';
i = Math.floor(Math.random()*16).toString(16).toUpperCase();
result = result + i;
}
return result;
}
다른 방법이 있을 포함하는 ActiveX 컨트롤을 사용하여,그러나 멀리에서 이러한!
편집: 고 생각했 가치가 없 GUID 를 생성을 보장할 수 있는 독특한 키(확인 위키 문서).기회는 항상있의 충돌 사고로 이어질 수 있습니다.GUID 를 단순히 제공하는 큰 충분히는 우주의 키을 줄이 변화의 충돌을 거의 전무합니다.
할 수 있는 노드를 사용-uuid(https://github.com/kelektiv/node-uuid)
간단하고,빠른 차세대의 RFC4122 UUID.
기능:
- 생 RFC4122 버전 1 혹은 버전 4Uuid
- 실행 node.js 고 브라우저입니다.
- 강력한 암호 random#세대에서 지원하는 플랫폼입니다.
- 작은 크기(무언가를 원하니? 이!)
를 사용하여 설치 NPM:
npm install uuid
거나 사용하는 uuid 브라우저를 통해:
Raw 파일을 다운로드(uuid v1): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v1.js Raw 파일을 다운로드(uuid v4): https://raw.githubusercontent.com/kelektiv/node-uuid/master/v4.js
원하는 심지어 작은?이 체크아웃: https://gist.github.com/jed/982883
사용법:
// 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'
ES6:
import uuid from 'uuid/v4';
const id = uuid();
웹사 서비스는 것이 유용합니다.
빠른 Google 발견: http://www.hoskinson.net/GuidGenerator/
보증할 수 없습이 구현,하지만 사람에 게시해야 합 선 GUID 를 생성기입니다.
이러한 웹 서비스를 개발할 수 있 나머지는 웹 인터페이스를 사용하는 GUID 웹 서비스를 제공 그것은 AJAX 를 통해 자바스크립트에서는 브라우저입니다.
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);
});
};
편집:
재 내 프로젝트는 이 기능을 사용하고 싫어하는 자세한 정도.-그러나 필요한 적절한 랜덤.
버전에 따라 Briguy37 의 답변과 일부는 비트 or 연산자를 추출하는 한입 크기로 윈도우에서 버퍼입니다.
을 준수해야 합 RFC 유형 4(random),스키마에 있었기 때문에 문제 마지막 시간이 구문 분석 non-compliant uuid 으로 자바의 UUID.
간단한 자바 스크립트는 모듈의 조합으로 최상의 답변에서 이 thread.
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());사용법:
입니다.newGuid()
"c6c2d12f-d76b-5739-e551-07e6de5b0807"
입니다.빈
"00000000-0000-0000-0000-000000000000"
서 좋은 ol'위키백과 에 대한 링크가있 javascript 의 구현 UUID.
그것은 상당히 보이는 우아한,그리고할 수 있도 개선에 의해 소금에 절인 해시의 클라이언트의 IP 주소입니다.이 해시할 수 있을 삽입할 html 문서를 서버측에서 사용하는 클라이언트 측 javascript.
업데이트:원래 사이트가 셔플,기 업데이트 버전
만,이는 무리의 대답이 이미 있지만,불행하게도 없"true"랜덤에서 무리입니다.버전에 아래의 적응 broofa 의 대답이지만,업데이트를 포함하"true"는 임의의 기능을 사용하는 암호화 라이브러리를 사용할 수 있고 Alea()함수로 대체입니다.
Math.log2 = Math.log2 || function(n){ return Math.log(n) / Math.log(2); }
Math.trueRandom = (function() {
var crypt = window.crypto || window.msCrypto;
if (crypt && crypt.getRandomValues) {
// if we have a crypto library, use it
var random = function(min, max) {
var rval = 0;
var range = max - min;
if (range < 2) {
return min;
}
var bits_needed = Math.ceil(Math.log2(range));
if (bits_needed > 53) {
throw new Exception("We cannot generate numbers larger than 53 bits.");
}
var bytes_needed = Math.ceil(bits_needed / 8);
var mask = Math.pow(2, bits_needed) - 1;
// 7776 -> (2^13 = 8192) -1 == 8191 or 0x00001111 11111111
// Create byte array and fill with N random numbers
var byteArray = new Uint8Array(bytes_needed);
crypt.getRandomValues(byteArray);
var p = (bytes_needed - 1) * 8;
for(var i = 0; i < bytes_needed; i++ ) {
rval += byteArray[i] * Math.pow(2, p);
p -= 8;
}
// Use & to apply the mask and reduce the number of recursive lookups
rval = rval & mask;
if (rval >= range) {
// Integer out of acceptable range
return random(min, max);
}
// Return an integer that falls within the range
return min + rval;
}
return function() {
var r = random(0, 1000000000) / 1000000000;
return r;
};
} else {
// From http://baagoe.com/en/RandomMusings/javascript/
// Johannes Baagøe <baagoe@baagoe.com>, 2010
function Mash() {
var n = 0xefc8249d;
var mash = function(data) {
data = data.toString();
for (var i = 0; i < data.length; i++) {
n += data.charCodeAt(i);
var h = 0.02519603282416938 * n;
n = h >>> 0;
h -= n;
h *= n;
n = h >>> 0;
h -= n;
n += h * 0x100000000; // 2^32
}
return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
};
mash.version = 'Mash 0.9';
return mash;
}
// From http://baagoe.com/en/RandomMusings/javascript/
function Alea() {
return (function(args) {
// Johannes Baagøe <baagoe@baagoe.com>, 2010
var s0 = 0;
var s1 = 0;
var s2 = 0;
var c = 1;
if (args.length == 0) {
args = [+new Date()];
}
var mash = Mash();
s0 = mash(' ');
s1 = mash(' ');
s2 = mash(' ');
for (var i = 0; i < args.length; i++) {
s0 -= mash(args[i]);
if (s0 < 0) {
s0 += 1;
}
s1 -= mash(args[i]);
if (s1 < 0) {
s1 += 1;
}
s2 -= mash(args[i]);
if (s2 < 0) {
s2 += 1;
}
}
mash = null;
var random = function() {
var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32
s0 = s1;
s1 = s2;
return s2 = t - (c = t | 0);
};
random.uint32 = function() {
return random() * 0x100000000; // 2^32
};
random.fract53 = function() {
return random() +
(random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
};
random.version = 'Alea 0.9';
random.args = args;
return random;
}(Array.prototype.slice.call(arguments)));
};
return Alea();
}
}());
Math.guid = function() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
var r = Math.trueRandom() * 16 | 0,
v = c == 'x' ? r : (r & 0x3 | 0x8);
return v.toString(16);
});
};
이들 버전 4UUID(에서 만들어 의사 무작위 숫자):
function uuid()
{
var chars = '0123456789abcdef'.split('');
var uuid = [], rnd = Math.random, r;
uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
uuid[14] = '4'; // version 4
for (var i = 0; i < 36; i++)
{
if (!uuid[i])
{
r = 0 | rnd()*16;
uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r & 0xf];
}
}
return uuid.join('');
}
여기에서의 샘플 Uuid 생성된:
682db637-0f31-4847-9cdf-25ba9613a75c
97d19478-3ab2-4aa1-b8cc-a1c3540f54aa
2eed04c9-2692-456d-a0fd-51012f947136
JavaScript 프로젝트에 GitHub- https://github.com/LiosK/UUID.js
UUID.js RFC 준수 UUID 발전기를 위한 자바 스크립트.
RFC4122 http://www.ietf.org/rfc/rfc4122.txt.
기능을 생성하는 RFC4122 준수 Uuid.
버전 4Uuid(바둑에서는 무작위 숫자)및 버전 1Uuid (시간-기반 Uuid)를 사용할 수 있습니다.
UUID 개체할 수 있는 다양한 액세스를 UUID 에 대한 액세스를 포함하여 UUID 필드가 있습니다.
저렴한 타임스탬프도의 자바 스크립트는 보상하여 임의의 숫자입니다.
// 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('-');
내 자신의 UUID/GUID 발전기와 함께 일부 엑스트라 기.
내가 사용하는 다음 Kybos 난수를 발전기를 조금 더 암호화 소리입니다.
아래 내용한 스크립트와 매쉬 Kybos 방법 baagoe.com 지 않습니다.
//UUID/Guid Generator
// use: UUID.create() or UUID.createSequential()
// convenience: UUID.empty, UUID.tryParse(string)
(function(w){
// From http://baagoe.com/en/RandomMusings/javascript/
// Johannes Baagøe <baagoe@baagoe.com>, 2010
//function Mash() {...};
// From http://baagoe.com/en/RandomMusings/javascript/
//function Kybos() {...};
var rnd = Kybos();
//UUID/GUID Implementation from http://frugalcoder.us/post/2012/01/13/javascript-guid-uuid-generator.aspx
var UUID = {
"empty": "00000000-0000-0000-0000-000000000000"
,"parse": function(input) {
var ret = input.toString().trim().toLowerCase().replace(/^[\s\r\n]+|[\{\}]|[\s\r\n]+$/g, "");
if ((/[a-f0-9]{8}\-[a-f0-9]{4}\-[a-f0-9]{4}\-[a-f0-9]{4}\-[a-f0-9]{12}/).test(ret))
return ret;
else
throw new Error("Unable to parse UUID");
}
,"createSequential": function() {
var ret = new Date().valueOf().toString(16).replace("-","")
for (;ret.length < 12; ret = "0" + ret);
ret = ret.substr(ret.length-12,12); //only least significant part
for (;ret.length < 32;ret += Math.floor(rnd() * 0xffffffff).toString(16));
return [ret.substr(0,8), ret.substr(8,4), "4" + ret.substr(12,3), "89AB"[Math.floor(Math.random()*4)] + ret.substr(16,3), ret.substr(20,12)].join("-");
}
,"create": function() {
var ret = "";
for (;ret.length < 32;ret += Math.floor(rnd() * 0xffffffff).toString(16));
return [ret.substr(0,8), ret.substr(8,4), "4" + ret.substr(12,3), "89AB"[Math.floor(Math.random()*4)] + ret.substr(16,3), ret.substr(20,12)].join("-");
}
,"random": function() {
return rnd();
}
,"tryParse": function(input) {
try {
return UUID.parse(input);
} catch(ex) {
return UUID.empty;
}
}
};
UUID["new"] = UUID.create;
w.UUID = w.Guid = UUID;
}(window || this));더 나은 방법:
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
}
소:
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}
내가 이해하고 싶 broofa 의 대답이다,그래서 나는 그것을 확장하고 추가 코멘트:
var uuid = function () {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(
/[xy]/g,
function (match) {
/*
* Create a random nibble. The two clever bits of this code:
*
* - Bitwise operations will truncate floating point numbers
* - For a bitwise OR of any x, x | 0 = x
*
* So:
*
* Math.random * 16
*
* creates a random floating point number
* between 0 (inclusive) and 16 (exclusive) and
*
* | 0
*
* truncates the floating point number into an integer.
*/
var randomNibble = Math.random() * 16 | 0;
/*
* Resolves the variant field. If the variant field (delineated
* as y in the initial string) is matched, the nibble must
* match the mask (where x is a do-not-care bit):
*
* 10xx
*
* This is achieved by performing the following operations in
* sequence (where x is an intermediate result):
*
* - x & 0x3, which is equivalent to x % 3
* - x | 0x8, which is equivalent to x + 8
*
* This results in a nibble between 8 inclusive and 11 exclusive,
* (or 1000 and 1011 in binary), all of which satisfy the variant
* field mask above.
*/
var nibble = (match == 'y') ?
(randomNibble & 0x3 | 0x8) :
randomNibble;
/*
* Ensure the nibble integer is encoded as base 16 (hexadecimal).
*/
return nibble.toString(16);
}
);
};
ES6 샘플
const guid=()=> {
const s4=()=> Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;
}
그것은 단순한 AJAX call...
사람은 여전히 관심이 여기 나의 솔루션입니다.
서버측에서:
[WebMethod()]
public static string GenerateGuid()
{
return Guid.NewGuid().ToString();
}
클라이언트 측에서:
var myNewGuid = null;
PageMethods.GenerateGuid(
function(result, userContext, methodName)
{
myNewGuid = result;
},
function()
{
alert("WebService call failed.");
}
);
원하는 사람들을 위해 야 rfc4122 버전 4 준수 솔루션과 속도를 고려 사항(전화하여 수학이다.random()):
function UUID() {
var nbr, randStr = "";
do {
randStr += (nbr = Math.random()).toString(16).substr(2);
} while (randStr.length < 30);
return [
randStr.substr(0, 8), "-",
randStr.substr(8, 4), "-4",
randStr.substr(12, 3), "-",
((nbr*4|0)+8).toString(16), // [89ab]
randStr.substr(15, 3), "-",
randStr.substr(18, 12)
].join("");
}
위의 기능을 가지고 있어야 괜찮은 사이의 균형 속도와 임의.
에서 날짜,그리고 임의의 접미사"확인"특별합니다.잘 작동한 css 식별자가 있습니다.항상 그것은 다음과 같은 결과를 반환합니다 쉽게 해킹:
uid-139410573297741
var getUniqueId = function (prefix) {
var d = new Date().getTime();
d += (parseInt(Math.random() * 100)).toString();
if (undefined === prefix) {
prefix = 'uid-';
}
d = prefix + d;
return d;
};
내가 알고,그것은 오래된 질문입니다.그냥 완전성을 위해,당신의 환경을 SharePoint 에 있는 유틸리티라는 기능 SP.Guid.newGuid (msdn 링크 는)새로 생성입니다.이 함수 안에 sp.init.js 파일입니다.는 경우 다시 이수(일부를 제거하는 다른 의존성에서 다른 개인 함수),그것은 다음과 같습니다:
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;
};
가 jQuery 플러그인이 처리하는 Guid 를 잘@ http://plugins.jquery.com/project/GUID_Helper
jQuery.Guid.Value()
반환 값은 내부입니다.지 않은 경우 guid 를 지정되어 반환하는 새로운 중 하나(값은 다음 저장된 내부적으로).
jQuery.Guid.New()
을 반환하는 새로운 Guid 를 설정 값이 내부적으로 합니다.
jQuery.Guid.Empty()
반 빈 Guid00000000-0000-0000-0000-000000000000.
jQuery.Guid.IsEmpty()
반환합니다.진실한 경우 빈/undefined/빈/null 입니다.
jQuery.Guid.IsValid()
반환합니다.진정한 유효한 guid,false 하지 않습니다.
jQuery.Guid.Set()
Retrns 입니다.트 Guid 를 지정된 사용자 Guid,잘못된 경우,반 빈입니다.
간단한 코드를 사용하는 crypto.getRandomValues(a) 에 지원되는 브라우저 (IE11+,iOS7+,FF21+,크롬,안드로이드롬).를 사용하지 않기 Math.random() 기 때문에 일으킬 수 있는 충돌을(예를 들어 20 위해 충돌 4000 생성 된 바둑에서 실제 상황에 의해 Muxa).
function uuid() {
function randomDigit() {
if (crypto && crypto.getRandomValues) {
var rands = new Uint8Array(1);
crypto.getRandomValues(rands);
return (rands[0] % 16).toString(16);
} else {
return ((Math.random() * 16) | 0).toString(16);
}
}
var crypto = window.crypto || window.msCrypto;
return 'xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx'.replace(/x/g, randomDigit);
}
Notes:
- 최적화된 코드를 읽지 않는 속도는,그래서 적합한 말 몇 백 uuid 의합니다.성에 대한 10000uuid()당에서 두 번째로 크롬에서 노트북을 사용하여 http://jsbin.com/fuwigo/1 성능을 측정할 수 있습니다.
- 사용 8"y"기 때문에 단순화하는 코드가 가독성 y(수 있 8,9,A 또는 B).
