UUID එකක් බාෂ් වලින් සාදා ගන්නේ කෙසේද?

ජාවා හි අහඹු UUID නිර්මාණය කළ හැකිය :

UUID uuid = UUID.randomUUID();

Bash හි මෙය කරන්නේ කෙසේද?

E2fsprogs පැකේජයේ uuidgenකොටසක් වන වැඩසටහන බලන්න .

අනුව මෙම , libuuidදැන් කොටසක් util-linux සහ e2fsprogs දී ඇතුලත් කාලාන්තරයක් තිස්සේ කොට ඇත. කෙසේ වෙතත්, නව උබුන්ටු පද්ධති වල, uuidgenදැන් uuid-runtimeපැකේජයේ ඇත.

Uuid නිර්මාණය කර එය විචල්‍යයකින් සුරැකීමට:

uuid=$(uuidgen)

මගේ උබුන්ටු පද්ධතියේ, ඇල්ෆා අක්ෂර කුඩා අක්ෂර ලෙස ප්‍රතිදානය වන අතර මගේ OS X පද්ධතියේ ඒවා ඉහළ අකුරක් ලෙස ප්‍රතිදානය වේ (මෙය අදහස් දැක්වීමකදී ඩේවිඩ්ට ස්තූතියි).

සියලුම ඉහළ අකුරුවලට මාරුවීමට (ඉහත පරිදි එය ජනනය කිරීමෙන් පසුව):

uuid=${uuid^^}

සියලුම කුඩා අකුරුවලට මාරුවීමට:

uuid=${uuid,,}

උදාහරණයක් ලෙස, ඔබට UUID දෙකක් ඇති අතර ඒවා Bash හි සංසන්දනය කිරීමට ඔබට අවශ්‍ය නම්, ඔවුන්ගේ නඩුව නොසලකා හරිමින්, ඔබට මේ ආකාරයට tolower()ශෛලීය සංසන්දනයක් කළ හැකිය :

if [[ ${uuid1,,} == ${uuid2,,} ]]

බාහිර පරායත්තයන් එකතු නොකර විවිධත්වය එක් කිරීමට, ලිනක්ස් මත ඔබට කළ හැක්කේ:

UUID=$(cat /proc/sys/kernel/random/uuid)

මත, නරක පුරුදු ව්යාප්ත කිරීමට ඒ අතරින් කිහිපයකි හට linux ගැළපුම ස්ථරය (linuxulator?) යටතේ,

UUID=$(cat /compat/linux/proc/sys/kernel/random/uuid)

යොමුව:

• විකිපීඩියාවේ UUID .
• FreeBSD Bug # 186187 - [linprocfs] [patch] emulate / proc / sys / kernel / random / uuid

සම්පූර්ණත්වය උදෙසා ... dbusඩේබියන් පැකේජය සමඟ UUID උත්පාදක යන්ත්රයක් ස්ථාපනය කර ඇත . කලින් වටපිට බැලීමෙන් මට එය මග හැරුණි. එය බොහෝ විට e2fsprogs පැකේජයට සමාන ඇල්ගොරිතමයක් විය හැකි නමුත් එය ඉරක් එකතු නොකරයි, එබැවින් එය ඔබට ටිකක් පිරිසිදු විය හැකිය:

$ uuidgen
387ee6b9-520d-4c51-a9e4-6eb2ef15887d

$ dbus-uuidgen
d17b671f98fced5649a856a54b51c9e6

ගුරුත්වාකර්ෂණය ආරක්ෂිත තොරතුරක් එක් කරයි: "DBus UUIDs RFC 4122 සමඟ සම්බන්ධ හෝ අනුකූල නොවේ . මීට අමතරව, dbus-uuidgen සෑම විටම යුනික්ස් කාලරාමුව අවසාන බයිට් 4 ලෙස භාවිතා කරයි. එබැවින් ඒවා සමහර භාවිතයන් සඳහා නුසුදුසු විය හැකිය." (ස්තූතියි, ගුරුත්වාකර්ෂණය, මම එය මෑන් පිටුවේ දැකිය යුතුව තිබුණි.)

ඔබට වෙනත් ක්‍රියාත්මක කළ හැකි දේ මත යැපීමට අවශ්‍ය නැතිනම් හෝ ඔබට ඒවා භාවිතා කළ නොහැකි නම්, මෙහි පිරිසිදු බාෂ් අනුවාදය මෙන්න :

# Generate a pseudo UUID
uuid()
{
    local N B T

    for (( N=0; N < 16; ++N ))
    do
        B=$(( $RANDOM%255 ))

        if (( N == 6 ))
        then
            printf '4%x' $(( B%15 ))
        elif (( N == 8 ))
        then
            local C='89ab'
            printf '%c%x' ${C:$(( $RANDOM%${#C} )):1} $(( B%15 ))
        else
            printf '%02x' $B
        fi

        for T in 3 5 7 9
        do
            if (( T == N ))
            then
                printf '-'
                break
            fi
        done
    done

    echo
}

[ "$0" == "$BASH_SOURCE" ] && uuid

Uuidgen ලබා ගත නොහැකි තැන මෙම ස්ක්‍රිප්ට් “වන්-ලයිනර්” ප්‍රයෝජනවත් බව මට පෙනී ගියේය. පර්ල් හෝ පයිතන් සඳහා බාහිර මොඩියුල ස්ථාපනය කිරීම සඳහා වන ඕනෑම අවශ්‍යතාවයක් ද මෙය මග හැරේ.

od -x /dev/urandom | head -1 | awk '{OFS="-"; print $2$3,$4,$5,$6,$7$8$9}'

ස්නෝලියෝපාර්ඩ්, රෙඩ් හැට් වල්හල්ලා, සොලාරිස් 9 4/04 සහ නවතම ඒවා අත්හදා බැලීය. මෙය අද්විතීය නොවන බව මට කුතුහලයක් ඇත, නමුත් මම පසුගිය අවුරුදු 10 තුළ 'තිත්ත වී නැත. ඇත්ත වශයෙන්ම, head -1එය ද ආදේශ කළ හැකිය head -_other-value_ | tail -1.

පැහැදිලි කිරීමට,

/dev/randomහා /dev/urandomඅහඹු ජනක කර්නලය වේ.

od (ඔක්ටල් ඩම්ප්) හෙක්ස් නිමැවුම් ස්විචයක් (-x) ඇති අතර එය එක් පේළියකට බයිට් 16 ක් නිපදවයි.

head-n [| වලිගය -1] (එහිදී n> 0) පෙර නිමැවුමේ එක් පේළියක් පමණක් උකහා ගනී.

awkමුද්‍රණ ප්‍රකාශයේ කොමාව ඇති සෑම තැනකම OutputFieldSeparator යටි ඉරක් ලෙස සකසයි. ක්ෂේත්‍ර 2-9 ස්වාධීනව නියම කිරීමෙන්, අපි යටි ඉර පාලනය කර එක් එක් නිමැවුම් රේඛාව සමඟ 'ඔඩ්' උපසර්ගය දක්වන දර්ශක / ඕෆ්සෙට් කවුන්ටරය ඉවත් කරමු.

ප්‍රති result ලය 8-4-4-4-12කුඩා අකුරු වල රටාවකි a-f0-9.

993bb8d7-323d-b5ee-db78-f976a59d8284

පයිතන් අතහැර දමා ඇති බවක් දැනෙන්නේ නැත:

python  -c 'import uuid; print uuid.uuid1()'
2d96768e-02b3-11df-bec2-001e68b9d147

කවචයේ එය භාවිතා කිරීමට:

myvar=$(python  -c 'import uuid; print uuid.uuid1()')

ජනනය කළ හැකි UUIDS වර්ග සඳහා පයිතන් ප්‍රලේඛනය UUID බලන්න .

පද්ධතිමය නොවන යන්ත්‍රයක systemd machine-id අනුකූල ගොනුවක් ජනනය කිරීම සඳහා, ඔබට මේ ආකාරයෙන් කිරීමට python භාවිතා කළ හැකිය:

python -c 'import re; import uuid; print re.sub("-","",str(uuid.uuid4()))' \
 > /etc/machine-id

පර්ල් e2fsprogsපැකේජය මත පදනම්ව UUID පුස්තකාලයක් සපයයි . මගේ ඩේබියන් පද්ධතියේ එය libuuid-perlපැකේජයයි. මෙන්න එක්-ලයිනර් උදාහරණයක්; man uuidවැඩි විස්තර සඳහා බලන්න :

$ perl -e 'use UUID;  UUID::generate($uuid);  UUID::unparse($uuid, $string);  print "my new UUID is $string \n";'
my new UUID is 3079e9ce-41d4-4cf3-9f90-d12f8bb752e4

පසුපෙළ හෝ $()අංකනය සහිත ෂෙල්ස් ස්ක්‍රිප්ටයකට එක් කිරීම මෙය ඉතා සුළු දෙයක් වනු ඇත :

#!/bin/bash
# ...do some stuff
$myvar = $(perl -e 'use UUID;  UUID::generate($uuid);  UUID::unparse($uuid, $string);  print "$string";')
# ...do some more stuff

apt-get install uuid

මා වෙනුවෙන් වැඩ කළා, පසුව මම දිව්වා uuid

UUIDs අත්තනෝමතික ලෙස තොග වශයෙන් උත්පාදනය කිරීම සඳහා මම පයිතන් භාවිතයෙන් කුඩා බාෂ් ශ්‍රිතයක් ලිවීය:

# uuid [count]
#
# Generate type 4 (random) UUID, or [count] type 4 UUIDs.
function uuid()
{
    local count=1
    if [[ ! -z "$1" ]]; then
        if [[ "$1" =~ [^0-9] ]]; then
            echo "Usage: $FUNCNAME [count]" >&2
            return 1
        fi

        count="$1"
    fi

    python -c 'import uuid; print("\n".join([str(uuid.uuid4()).upper() for x in range('"$count"')]))'
}

ඔබ කුඩා අකුරු වලට කැමති නම්, වෙනස් කරන්න:

python -c 'import uuid; print("\n".join([str(uuid.uuid4()).upper() for x in range('"$count"')]))'

වෙත:

python -c 'import uuid; print("\n".join([str(uuid.uuid4()) for x in range('"$count"')]))'

කරුණාකර OSSP UUID පුස්තකාලය ( http://www.ossp.org/pkg/lib/uuid/ ) දෙස බලා එය ස්ථාපනය කිරීම ගැන සලකා බලන්න. සමහර ව්‍යාපෘති එය විකල්පයක් ලෙස ඉදිරිපත් කරයි (උදා: PostgreSQL). එය 3 වන අනුවාදය සහ 5 UUID අනුවාදය නිසියාකාරව හසුරුවයි , එය මගේ ස්ථාපිත (උදා: e2fsprogs) පුස්තකාලයට හැසිරවිය හැකි ප්‍රමාණයට වඩා වැඩි විය. වාසනාවකට මෙන්, openSUSE එය එක් ප්‍රධාන ගබඩාවක ඇත. W / Windows (උදා: සිග්වින්) හෝ MySQL වැඩ කිරීමට අනුවාදයක් ලබා ගැනීම දෝෂයකි. මට ඇත්ත වශයෙන්ම v3 සහ v5 UUIDs අවශ්‍ය බැවින් ලිනක්ස් / පෝස්ට්ග්‍රෙස්ක්එල් / පයිතන් වෙත මාරු වීමට කාලය පැමිණ ඇති බව පෙනේ (සහ මම SQLyog GUI ට MySQL / MariaDB වෙත ප්‍රිය කළෙමි).

සමහරු මෙහි පැමිණෙනු ඇතැයි මට විශ්වාසයි, ඔවුන්ගේ ස්ක්‍රිප්ට් වල භාවිතා කිරීම සඳහා අද්විතීය හැඳුනුම්පතක් ජනනය කිරීමට පහසු ක්‍රමයක් සොයමින් සිටින අතර එය සත්‍ය UUID එකක් වීමට අවශ්‍ය නොවේ.

එසේ නම්, ඔබට පහත සඳහන් දෑ කළ හැකිය, එමඟින් තත්පරයට අනන්‍ය වූ හැඳුනුම්පතක් ජනනය වනු ඇත - එබැවින් ඔබ මෙය තත්පරයක් තුළ කිහිප වතාවක් ධාවනය කළහොත් ඔබට තවමත් එකම ප්‍රති .ලය ලැබෙනු ඇත.

MYID="U$(date +%s)"
echo $MYID

වත්මන් පද්ධති වේලාව මත පදනම්ව පහත සඳහන් පරිදි අයිඩී ජනනය කරනු ඇත:

U1454423662

සටහන: ඔබ ලිනක්ස් හි සිටී නම් හෝ මැක්හි කොරූටිල්ස් ස්ථාපනය කර ඇත්නම්, නැනෝ තත්පරයට අද්විතීය හැඳුනුම්පතක් ජනනය කිරීමට ඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය:

MYID="U$(date +%s%N)"
echo $MYID

නැතහොත් සෑම තැනකම පාහේ ක්‍රියා කළ යුතු නැනෝ තත්පරයට පයිතන් පදනම් කරගත් විසඳුමක් ඔබ කැමති නම්, ධාවනය කරන්න:

MYUID=U$(python -c'import time; print repr(time.time())')
echo $MYUID

මෙම ත්‍රෙඩ් එක විවිධාකාර උදාහරණ සහිතව මට ඇත්තෙන්ම ප්‍රයෝජනවත් විය. මට නිතරම විවිධ පරිසරයන්ගෙන් uuid කාර්යයන් අවශ්‍ය වේ. මම පිරිසිදු බාෂ් උදාහරණ වලට ඇලුම් කරන අතර, සමහර විට වෙනත් භාෂාවකින් පුස්තකාලයක් භාවිතා කිරීම වඩාත් පහසු වේ.

එබැවින් සම්පූර්ණත්වය සඳහා, රුබී (1.9.3+) හි ආරක්ෂිත හැන්ඩම් මොඩියුලය ඇත, එහි ප්‍රයෝජනවත් හැෂ් සහ හැඳුනුම් කාර්යයන් ගණනාවක් අඩංගු වේ. Bash cli වෙතින් ඔබට මෙය කළ හැකිය.

ruby -r securerandom -e 'puts SecureRandom.uuid'

ran=`od -X -A n /dev/random | head -1 | cut -c3-38`

correlation_id=`echo ${ran} | cut -c1-8`-`echo ${ran} | cut -c10-13`-`echo ${ran} | cut -c14-17`-`echo ${ran} | cut -c19-22`-`echo ${ran} | cut -c23-26``echo ${ran} | cut -c28-35`

ඔබ ජාවා 10 භාවිතා කරන්නේ නම්.

$ jshell
jshell> import java.util.*
jshell> String id = UUID.randomUUID().toString();