enum - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

enum - seq- ഒപ്പം ജോട്ട് പോലെയുള്ള എണ്ണൽ

സിനോപ്സിസ്

പൊതുവായ
enum [ ഓപ്ഷനുകൾ ] ഇടത്തെ .. COUNTx ഘട്ടം .. ശരി

കുറുക്കുവഴികൾ
enum [ ഓപ്ഷനുകൾ ] ഇടത്തെ ഘട്ടം ശരി

enum [ ഓപ്ഷനുകൾ ] ഇടത്തെ ശരി

enum [ ഓപ്ഷനുകൾ ] ശരി

...

വിവരണം

enum മുതൽ മൂല്യങ്ങൾ (നമ്പറുകൾ) എണ്ണുന്നു ഇടത്തെ ലേക്ക് ശരി കൂട്ടിച്ചേർക്കൽ/കുറയ്ക്കൽ ഘട്ടം ഓരോ തവണയും. എങ്കിൽ
ഘട്ടം നൽകിയിട്ടില്ല ഒരു മൂല്യം സൂചിപ്പിച്ചിരിക്കുന്നു. അധികം ഇല്ല COUNT മൂല്യങ്ങൾ അച്ചടിക്കുന്നു. മുമ്പ്
പ്രിന്റിംഗ്, മൂല്യങ്ങൾ ഫോർമാറ്ററിലൂടെ കടന്നുപോകുന്നു. ദയവായി കാണുക ഓപ്ഷനുകൾ വിശദാംശങ്ങൾക്ക്
ഫോർമാറ്റർ നിയന്ത്രിക്കുന്നു അല്ലെങ്കിൽ ഉദാഹരണങ്ങൾ ഉപയോഗ കേസുകൾക്കായി.

കൂടുതൽ enum ഉപയോഗ വിശദാംശങ്ങൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട് USAGE IN DETAIL.

ഉദാഹരണങ്ങൾ

ഉപയോഗിക്കുക IN ഫോർ-ലൂപ്പുകൾ
എനിക്ക് $ (enum -e 1 20) ചെയ്യുക
ഫയൽ_${i} ടച്ച്
ചെയ്തു

ഉപയോഗിക്കുക വേണ്ടി RANDOM NUMBERS
നമ്പർ=$(enum --random 3 .. 10)

നേറ്റീവ് ബാഷ് ലൈക്കിന് പകരം

f() {മിനിറ്റ്=$1; പരമാവധി=$2; പ്രതിധ്വനി $((RANDOM * (പരമാവധി - മിനിറ്റ് + 1) / 32767 + മിനിറ്റ്)); }
നമ്പർ=$(f 3 10)

കാണിക്കുന്നു AN ASCII മേശ
enum -f '[%3i] "%c"' 0 127

ഓപ്ഷനുകൾ

RANDOM MODE
-r, --റാൻഡം
മോണോട്ടോണിക് സീക്വൻസുകൾക്ക് പകരം ക്രമരഹിതമായ സംഖ്യകൾ (ഡ്യൂപ്ലിക്കേറ്റുകൾക്കൊപ്പം) നിർമ്മിക്കുന്നു.

-i, --വിത്ത്=NUMBER
ചുരം NUMBER റാൻഡം നമ്പർ ജനറേറ്ററിലേക്കുള്ള ഇനീഷ്യലൈസർ ആയി. സ്ഥിരസ്ഥിതിയായി, RNG ആണ്
നിലവിലെ സമയത്തിൽ നിന്നും പ്രവർത്തനക്ഷമമായ സന്ദർഭത്തിന്റെ പ്രോസസ്സ് ഐഡിയിൽ നിന്നും ആരംഭിച്ചിരിക്കുന്നു enum.

ഫോർമാറ്റിംഗ്
-b, -- ഊമ=TEXT
ഔട്ട്പുട്ട് ഫോർമാറ്റ് അസാധുവാക്കുന്നു TEXT പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ ഇന്റർപോളേറ്റ് ചെയ്യാതെ. ഉദാഹരണത്തിന്,
enum -b "ഫൂ % ക്സനുമ്ക്സ " 3x "foo % 10" എന്ന സ്ട്രിംഗ് മൂന്ന് തവണ നിർമ്മിക്കുന്നു.

-c, --കഥാപാത്രങ്ങൾ
ഔട്ട്‌പുട്ട് ഫോർമാറ്റിനെ %c ഉത്പാദിപ്പിക്കുന്ന പ്രതീകങ്ങളിലേക്ക് അസാധുവാക്കുന്നു. ഉദാഹരണത്തിന്, enum -c 65 67
"A", "B", "C" എന്നീ അക്ഷരങ്ങൾ നിർമ്മിക്കുന്നു.

-e, --തുല്യ-വീതി
മുൻനിര പൂജ്യങ്ങൾ ഉപയോഗിച്ച് പാഡിംഗ് വഴി വീതി തുല്യമാക്കുക. ശ്രദ്ധിക്കുക: മിക്സഡ് നെഗറ്റീവിന്റെ കാര്യത്തിൽ ഒപ്പം
നെഗറ്റീവ് അല്ലാത്ത സംഖ്യകൾ (ഉദാ enum -e - -10 1), നെഗറ്റീവ് അല്ലാത്ത മൂല്യങ്ങൾ നഷ്ടപരിഹാരം നൽകും
ഒരു അധിക പൂജ്യത്തോടുകൂടിയ മുൻനിര മൈനസിന്റെ അഭാവത്തിന് തുല്യ വീതി ഉണ്ടായിരിക്കണം.

-f, --ഫോർമാറ്റ്=ഫോർമാറ്റ്
ഉപയോഗിച്ച് ഡിഫോൾട്ട് ഔട്ട്പുട്ട് ഫോർമാറ്റ് അസാധുവാക്കുന്നു ഫോർമാറ്റ്. അനുവദനീയമായ ഫോർമാറ്റുകളെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് ദയവായി
കാണുക printf(3).

ഫോർമാറ്റ് സി എസ്കേപ്പ് സീക്വൻസുകളുടെ പ്രോസസ്സിംഗിന് വിധേയമാണ് (ഉദാ: "\n" ഒരു ന്യൂലൈൻ ഉണ്ടാക്കുന്നു). എങ്കിൽ
ഫോർമാറ്റ് പ്ലെയ്‌സ്‌ഹോൾഡറുകളൊന്നും അടങ്ങിയിട്ടില്ല, enum അച്ചടിക്കും ഫോർമാറ്റ് ആവർത്തിച്ച്. ഇൻ
കോൺട്രാസ്റ്റ്, jot പകരം സംഖ്യയുടെ മൂല്യം ചേർക്കുമായിരുന്നു. നമ്പറുകൾ ദൃശ്യമാക്കാൻ
കൂടെ അവസാനം enum, ക്രമീകരിക്കുക ഫോർമാറ്റ് ഉചിതമായി.

-l, --ലൈൻ
" എന്നതിനായുള്ള കുറുക്കുവഴി-s ' '" അതിനർത്ഥം സെപ്പറേറ്ററായി ഒരു പുതിയ ലൈനിന് പകരം ഒരു സ്പേസ് ഉണ്ടെന്നാണ്.

-n, --ഒമിറ്റ്-ന്യൂലൈൻ
ഔട്ട്‌പുട്ടിൽ നിന്ന് ടെർമിനേറ്റിംഗ് സ്‌ട്രിംഗ് (ന്യൂലൈനിലേക്കുള്ള സ്ഥിരസ്ഥിതി) ഒഴിവാക്കുന്നു, അതായത് ഇതൊരു കുറുക്കുവഴിയാണ്
വരെ "-t ''".

-p, --കൃത്യത=COUNT
പ്രിന്റ് ചെയ്യാനുള്ള കൃത്യതയുടെ സ്വയമേവ തിരഞ്ഞെടുക്കുന്നതിനെ അസാധുവാക്കുന്നു COUNT ദശാംശ സ്ഥാനങ്ങൾ, ഉദാ "0.100"
വേണ്ടി COUNT = 3. ഡിഫോൾട്ടായി, പ്രിന്റ് ചെയ്യേണ്ട അക്കങ്ങളുടെ എണ്ണം ഇതിൽ നിന്ന് കണക്കാക്കുന്നു
നൽകിയ ആർഗ്യുമെന്റുകളും (നൽകിയതോ കണക്കാക്കിയതോ ആയ) സ്റ്റെപ്പ് വലുപ്പവും.

-s, --സെപ്പറേറ്റർ=TEXT
മൂല്യങ്ങൾക്കിടയിൽ അച്ചടിച്ച സെപ്പറേറ്ററിനെ അസാധുവാക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, മൂല്യങ്ങൾ
ഒരു പുതിയ ലൈൻ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു. TEXT സി എസ്കേപ്പ് സീക്വൻസുകളുടെ പ്രോസസ്സിംഗിന് വിധേയമാണ് (ഉദാ
"\n" ഒരു പുതിയ ലൈൻ ഉണ്ടാക്കുന്നു).

-t, --ടെർമിനേറ്റർ=TEXT
അവസാനം അച്ചടിച്ച ടെർമിനേറ്ററിനെ അസാധുവാക്കുന്നു. ഡിഫോൾട്ട് ഒരു പുതിയ ലൈൻ ആണ്. TEXT
സി എസ്കേപ്പ് സീക്വൻസുകളുടെ പ്രോസസ്സിംഗിന് വിധേയമാണ് (ഉദാ: "\n" ഒരു ന്യൂലൈൻ ഉണ്ടാക്കുന്നു).

-w, --വാക്ക്=ഫോർമാറ്റ്
ജോട്ടുമായുള്ള അനുയോജ്യതയ്ക്ക് --ഫോർമാറ്റിന്റെ അപരനാമം. GNU seq കൾക്കായി -w അർത്ഥം
--തുല്യ-വീതി, കാണുക -e.

-z, --പൂജ്യം, --ശൂന്യം
ന്യൂലൈനല്ല, സെപ്പറേറ്ററായി നൾ ബൈറ്റുകൾ പ്രിന്റ് ചെയ്യുക.

മറ്റുള്ളവ
-h, --സഹായിക്കൂ
ഉപയോഗ വിവരങ്ങൾ ഔട്ട്‌പുട്ട് ചെയ്യുകയും കോഡ് 0 ഉപയോഗിച്ച് പുറത്തുകടക്കുകയും ചെയ്യുന്നു (വിജയം).

-V, --പതിപ്പ്
പതിപ്പ് വിവരങ്ങൾ പ്രദർശിപ്പിക്കുകയും കോഡ് 0 ഉപയോഗിച്ച് പുറത്തുകടക്കുകയും ചെയ്യുന്നു (വിജയം).

USAGE IN DETAIL

വാദങ്ങൾ
എന്ന യുക്തി enumന്റെ കമാൻഡ് ലൈൻ പാരാമീറ്ററുകൾ:

enum [ ഓപ്ഷനുകൾ ] ഇടത്തെ .. COUNTx ഘട്ടം .. ശരി

നാല് വാദങ്ങൾ ഉൾപ്പെടുന്നു:

· ഇടത്തെ, എണ്ണൽ ആരംഭിക്കേണ്ട മൂല്യം

· COUNT, ഉൽപ്പാദിപ്പിക്കേണ്ട മൂല്യങ്ങളുടെ (പരമാവധി) എണ്ണം

· ഘട്ടം, ഒരു മൂല്യത്തിൽ നിന്ന് മറ്റൊന്നിലേക്കുള്ള വിടവ്

· ശരി, എണ്ണൽ നിർത്തേണ്ട മൂല്യം (ചില സന്ദർഭങ്ങളിൽ മുമ്പ്)

നാല് ആർഗ്യുമെന്റുകളും ആവശ്യമില്ല, എന്നിരുന്നാലും നാലെണ്ണം വ്യക്തമാക്കുന്നത് സാധ്യമാണ്. ഒരു ലിസ്റ്റിനായി
എല്ലാ സാധുവായ കോമ്പിനേഷനുകളും കാണുക സാധുവായ സംയോജനങ്ങൾ താഴെ. ഡിഫോൾട്ടുകളുടെ വ്യുൽപ്പന്നത്തെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾ
ൽ അഭിസംബോധന ചെയ്തു ഡെറിവേഷൻ OF ഡിഫോൾട്ടുകൾ.

സാധുവായ സംയോജനങ്ങൾ
നാല് വാദങ്ങൾക്കൊപ്പം:

· enum ഇടത്തെ .. COUNTx ഘട്ടം .. ശരി

മൂന്ന് വാദങ്ങൾക്കൊപ്പം:

· enum ഇടത്തെ COUNTx ശരി

· enum ഇടത്തെ .. COUNTx ഘട്ടം ..

· enum .. COUNTx ഘട്ടം .. ശരി

· enum ഇടത്തെ .. COUNTx .. ശരി

· enum ഇടത്തെ .. ഘട്ടം .. ശരി

· enum ഇടത്തെ ഘട്ടം ശരി (GNU seq അനുയോജ്യതയ്ക്കായി)

രണ്ട് വാദങ്ങൾക്കൊപ്പം:

· enum .. COUNTx ഘട്ടം ..

· enum .. COUNTx .. ശരി

· enum COUNTx .. ശരി

· enum .. ഘട്ടം .. ശരി

· enum ഇടത്തെ .. COUNTx ..

· enum ഇടത്തെ .. ഘട്ടം ..

· enum ഇടത്തെ .. ശരി

· enum ഇടത്തെ ശരി (GNU seq അനുയോജ്യതയ്ക്കായി)

ഒരു വാദത്തോടെ:

· enum .. ഘട്ടം ..

· enum .. COUNTx ..

· enum .. ശരി

· enum ശരി (GNU seq അനുയോജ്യതയ്ക്കായി)

· enum ഇടത്തെ ..

· enum COUNTx

മൂന്നിൽ താഴെ ആർഗ്യുമെന്റുകൾ ഉണ്ടെങ്കിൽ, ഡിഫോൾട്ടുകൾ ബാധകമാണ്. വിശദാംശങ്ങൾ വിവരിച്ചിരിക്കുന്നു ഡെറിവേഷൻ OF
ഡിഫോൾട്ടുകൾ താഴെ.

സാങ്കേതികമായി, കൂടുതൽ ഉപയോഗ കേസുകൾ സാധ്യമാണ്. ഉദാഹരണത്തിന്, COUNTx ഘട്ടം .. ശരി is
വാദങ്ങളുടെ ക്രമം നിശ്ചയിച്ചിരിക്കുന്നതിനാൽ അവ്യക്തമാണ്. എങ്കിലും, "enum 3x 4 .. 10" ഒരുപാട് വായിക്കുന്നു
"3 നും 4 നും ഇടയിലുള്ള 10 മൂല്യങ്ങൾ" എന്നാൽ യഥാർത്ഥത്തിൽ "3 മൂല്യങ്ങൾ 10 വരെയുള്ള ഘട്ടങ്ങളിൽ അർത്ഥമാക്കും.
4". enum-ന്റെ ഉപയോക്തൃ ഇന്റർഫേസ് കഴിയുന്നത്ര അവബോധജന്യമായി നിലനിർത്തുന്നതിന്, സാധ്യമായ കേസുകൾ
തെറ്റിദ്ധാരണകളിലേക്ക് നയിക്കുന്നു, അത് നടപ്പിലാക്കുന്നില്ല.

ഡെറിവേഷൻ OF ഡിഫോൾട്ടുകൾ
സ്വയമേവ തിരഞ്ഞെടുക്കൽ OF PRECISION
enum "2", "2.0", "2.00" എന്നിങ്ങനെ വേർതിരിക്കുന്നു:

# enum 1 2
1
2

# enum 1 2.0
1.0
1.1
[...]
1.9
2.0

കൂടാതെ, ഉരുത്തിരിഞ്ഞ ഘട്ടത്തിന് നിർദ്ദിഷ്ട മൂല്യങ്ങളേക്കാൾ കൂടുതൽ ദശാംശ സ്ഥാനങ്ങൾ ഉണ്ടെങ്കിൽ ഇടത്തെ
ഒപ്പം ശരി, ഔട്ട്‌പുട്ട് പ്രിസിഷൻ സ്റ്റെപ്പ് മൂല്യത്തിലേക്ക് ഉയർത്തും:

# enum 1 .. 3x .. 2
1.0
1.5
2.0

ഒരു നിർദ്ദിഷ്‌ട കൃത്യതയ്‌ക്ക് എപ്പോഴും മുൻഗണന ലഭിക്കുന്നു, എന്നിരുന്നാലും:

# enum -p 2 1 .. 3x .. 2
1.00
1.50
2.00

അധികാരം ഡിഫോൾട്ടുകൾ
പൊതുവേ, മൂന്ന് വാദങ്ങൾ ആവശ്യമാണ്; ഏതെങ്കിലും മൂന്ന് നാലാമത്തേതിനെ സൂചിപ്പിക്കുന്നു. ഈ സമവാക്യം
അവരെ ഒരുമിച്ച് കൊണ്ടുവരുന്നു:

ഇടത്തെ + ((COUNT - 1) * ഘട്ടം = ശരി

അവയിൽ മൂന്നിൽ താഴെ മാത്രം നിങ്ങൾ വ്യക്തമാക്കുകയാണെങ്കിൽ (കാണുക സാധുവായ സംയോജനങ്ങൾ), വ്യക്തമാക്കാത്തവ
ഉരുത്തിരിഞ്ഞത് അല്ലെങ്കിൽ അവയുടെ ഡിഫോൾട്ടിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു:

· ഇടത്തെ ഡിഫോൾട്ട് 1 ലേക്ക് (അല്ലാതെ ഘട്ടം ഒപ്പം ശരി വ്യക്തമാക്കിയിരിക്കുന്നു, കാണുക ഡെറിവേഷൻ OF ഇടത്തെ
താഴെ)

· COUNT അനന്തതയാണ്, മറ്റ് മൂന്ന് മൂല്യങ്ങളിൽ നിന്ന് ഉരുത്തിരിഞ്ഞത് സാധ്യമല്ലെങ്കിൽ.

· ഘട്ടം ഡിഫോൾട്ട് 1 ലേക്ക്, അത് ഉരുത്തിരിഞ്ഞു സാധ്യമല്ലെങ്കിൽ.

· ശരി +/-ഇൻഫിനിറ്റി ആണ്, മറ്റ് മൂന്ന് മൂല്യങ്ങളിൽ നിന്ന് അത് ഉരുത്തിരിഞ്ഞുവന്നില്ലെങ്കിൽ.

വ്യക്തമായും, എങ്കിൽ COUNT പൂജ്യമായി സജ്ജീകരിച്ചിരിക്കുന്നു (0x), enum പരിഗണിക്കാതെ ഒന്നും ഔട്ട്പുട്ട് ചെയ്യില്ല
മറ്റ് വാദങ്ങൾ.

ഡെറിവേഷൻ OF ഇടത്തെ
പൊതുവായി, ഇടത്തെ 1-ലേക്കുള്ള ഡിഫോൾട്ടുകൾ:

# enum .. 3
1
2
3

If ഘട്ടം ഒപ്പം ശരി നൽകിയിരിക്കുന്നു, അത് ഇങ്ങനെ ഉരുത്തിരിഞ്ഞതാണ്

ഇടത്തെ = ശരി - ഘട്ടം * നില (ശരി / ഘട്ടം)

# enum .. 4 .. 10
2
6
10

എങ്കിൽ, കൂടാതെ ഘട്ടം ഒപ്പം ശരി, COUNT നൽകിയിരിക്കുന്നു, ഇത് ഇങ്ങനെ ഉരുത്തിരിഞ്ഞതാണ്:

ഇടത്തെ = ശരി - (COUNT - 1) * ഘട്ടം

# enum .. 2x 4 .. 10
6
10

ജനറേഷൻ OF മൂല്യങ്ങൾ
ഒരു ഇഷ്‌ടാനുസൃത ഘട്ടം അഭ്യർത്ഥിക്കുമ്പോൾ, മൂല്യങ്ങൾ ഇനിപ്പറയുന്ന രീതിയിൽ നിർമ്മിക്കുന്നു:

മൂല്യം[0] = ഇടത് + 0 * ഘട്ടം
മൂല്യം[1] = ഇടത് + 1 * ഘട്ടം
..
മൂല്യം[i] = ഇടത് + i * ഘട്ടം

അല്ലാത്തപക്ഷം, കൃത്യത കൂടുന്നത് ഒഴിവാക്കാൻ, മൂല്യങ്ങൾ ഇനിപ്പറയുന്ന രീതിയിൽ നിർമ്മിക്കുന്നു:

മൂല്യം[0] = ഇടത് + (വലത് - ഇടത്) / (COUNT - 1) * 0
മൂല്യം[1] = ഇടത് + (വലത് - ഇടത്) / (COUNT - 1) * 1
..
മൂല്യം[i] = ഇടത് + (വലത് - ഇടത്) / (COUNT - 1) * i

ഒന്നുകിൽ ഉത്പാദനം നിലയ്ക്കും COUNT മൂല്യങ്ങൾ നിർമ്മിച്ചു അല്ലെങ്കിൽ ശരി എത്തിയിരിക്കുന്നു,
ഏതാണ് ആദ്യം അടിച്ചത്. നാല് മൂല്യങ്ങളും തികഞ്ഞ പൊരുത്തത്തിൽ നൽകുമ്പോൾ അവ ഒരേ നിലയിലാകും
സമയം.

RANDOM MODE

അടിസ്ഥാനപരമായി, റാൻഡം മോഡ് ഇക്കാര്യത്തിൽ വ്യത്യസ്തമാണ്:

· ഉൽപ്പാദിപ്പിച്ച മൂല്യങ്ങൾ ക്രമരഹിതമാണ്.

· വാദം COUNT 1 (ഒന്ന്) ലേക്ക് ഡിഫോൾട്ടുകൾ.

· വാദം ഇടത്തെ (എല്ലായ്‌പ്പോഴും!) ഡിഫോൾട്ടായി 1 (ഒന്ന്)

· വാദം ശരി ആവശ്യമാണ്: ക്രമരഹിതം അനന്തതയുമായി കലരുന്നില്ല.

ഈ വിഭാഗത്തിൽ ഈ വ്യത്യാസങ്ങൾ വിശദമായി പ്രതിപാദിക്കുന്നു.

COUNT ഡിഫോൾട്ടുകൾ TO 1 (ഒന്ന്)
റാൻഡം മോഡിൽ, സ്ഥിരസ്ഥിതിയായി ഒരു മൂല്യം മാത്രമേ ഉൽപ്പാദിപ്പിക്കപ്പെടുന്നുള്ളൂ:

# enum 1 4
1
2
3
4

# enum -r 1 4
3

വ്യക്തമാക്കുന്നതിലൂടെ COUNT നിങ്ങൾക്ക് ഒരു സമയം കൂടുതൽ മൂല്യങ്ങൾ നിർമ്മിക്കാൻ കഴിയും:

# enum -r 1 .. 3x .. 4
2
1
3

ഇടത്തെ എല്ലായ്പ്പോഴും ഡിഫോൾട്ടുകൾ TO 1 (ഒന്ന്)
നിങ്ങൾക്ക് ഒരു നിശ്ചിത പരമാവധി (10 എന്ന് പറയുക) വരെ സംഖ്യകൾ വർദ്ധിപ്പിക്കേണ്ടിവരുമ്പോൾ, ഓരോന്നും a കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു
ചില ഘട്ടം (പറയുക 4) നിങ്ങൾക്ക് അനുവദിക്കാം enum നിങ്ങൾക്ക് ആവശ്യമായ ആരംഭ മൂല്യം കണക്കാക്കുക:

# enum .. 4 .. 10
2
6
10

റാൻഡം മോഡിൽ ഇടത്തെ ഒരിക്കലും കണക്കാക്കില്ല, 1 (ഒന്ന്) ലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു:

# enum -r .. 5x 4 .. 10
1
1
9
1
5

RANDOM ഇല്ല ചെയ്യില്ല മിക്സ് ഉപയോഗിച്ച് അനന്തത
പൊതുവായി, enum അനന്തതയിലേക്ക് ഓടുന്നത് പിന്തുണയ്ക്കുന്നു:

# enum 1 .. 2.0 ..
1.0
3.0
5.0
[...]

എന്നിരുന്നാലും, റാൻഡം മോഡിൽ enum ഇപ്പോൾ 1 മുതൽ അനന്തത വരെയുള്ള ക്രമരഹിത സംഖ്യകൾ (അല്ലെങ്കിൽ വലുത്
നമ്പർ പോലെ FLT_MAX നിന്ന് ), ഞങ്ങൾ ഇതിനെതിരെ തീരുമാനിച്ചു.

ചരിത്രം

enum GNU seq, jot എന്നിവയുടെ സംയോജനമാണ്, ഫീച്ചർ തിരിച്ച്. കാമ്പിൽ രണ്ട് ടൂളുകളും സീക്വൻസുകൾ പ്രിന്റ് ചെയ്യുന്നു
സംഖ്യകളുടെ. GNU seq-ന് ശുദ്ധമായ ഒരു ഇന്റർഫേസ് ഉണ്ട്, എന്നാൽ വളരെ പരിമിതമായ പ്രവർത്തനക്ഷമതയുണ്ട്. മറുവശത്ത് കുത്തുക
പകരം ചിലവിൽ ക്രമരഹിത സംഖ്യകൾ നിർമ്മിക്കുന്നത് പോലെയുള്ള കൂടുതൽ നൂതനമായ ഫീച്ചറുകൾ ഹാൻഡ് വാഗ്ദാനം ചെയ്യുന്നു
സൗഹൃദപരമല്ലാത്ത ഇന്റർഫേസ്.

കൂടെ enum ജോട്ടിന്റെ ശക്തിയും ഉപയോഗയോഗ്യവും എളുപ്പത്തിൽ അവിസ്മരണീയവുമായ ഒരു ഉപകരണം നൽകാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു
ഇന്റർഫേസ്. enum ഒരു ബിഎസ്‌ഡി ലൈസൻസിന് കീഴിൽ ലൈസൻസുള്ളതും പരമാവധി C89 ൽ എഴുതിയതുമാണ്
പോർട്ടബിലിറ്റി.

ഇനിപ്പറയുന്ന വിഭാഗങ്ങൾ വ്യത്യാസങ്ങൾ വിശദമായി പരിശോധിക്കുന്നു.

താരതമ്യം TO ജോട്ട്

ഉപയോഗിക്കുന്നു enum ജോട്ടിന് പകരം രണ്ട് പ്രധാന നേട്ടങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു:

· മെച്ചപ്പെട്ട ഉപയോഗക്ഷമതയും

വിതരണങ്ങളിലും ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും ഉടനീളം ഏകീകൃത സ്വഭാവം.

2010-10-03 ലെ കണക്കനുസരിച്ച്, ഡ്രാഗൺഫ്ലൈബിഎസ്ഡി, ഫ്രീബിഎസ്ഡി, എന്നിവയ്ക്കിടയിൽ ജോട്ട് നടപ്പിലാക്കലുകൾ ഇപ്പോഴും സൂക്ഷ്മമായി വ്യത്യാസപ്പെട്ടിരിക്കുന്നു.
MirOS BSD, NetBSD, OpenBSD, OS X. ഉദാഹരണത്തിന് കമാൻഡ് ജോറ്റ് - 0 5 ഉത്പാദിപ്പിക്കുന്നു

· FreeBSD, OS X എന്നിവയിൽ 6 മുതൽ 0 വരെയുള്ള 5 പൂർണ്ണസംഖ്യകൾ,

0 1 2 XIX XIX 3

· NetBSD-യിൽ 100 മുതൽ 0 വരെയുള്ള 99 പൂർണ്ണസംഖ്യകൾ, കൂടാതെ

0 1 2 [..] 97 98 99

DragonFlyBSD, MirOS BSD എന്നിവയിൽ 100 മുതൽ 0 വരെയുള്ള 5 പൂർണ്ണസംഖ്യകൾ (തുടർച്ചയായ ഡ്യൂപ്ലിക്കേറ്റുകൾക്കൊപ്പം)
ഓപ്പൺബിഎസ്ഡി.

0 0 0 0 0 0 0 0 0 0 1 [..] 1 4 4 5 5 5 5 5 5 5 5 5

അടിസ്ഥാനപരമായി, ജോട്ടിന്റെ പൂർണ്ണ ഫീച്ചർ സെറ്റും കുറച്ച് മെച്ചപ്പെടുത്തലുകളും അടങ്ങിയിരിക്കുന്നു enum. പേരുകൾ
വർദ്ധിച്ച അനുയോജ്യതയ്ക്കായി പരാമീറ്ററുകൾ നിലനിർത്തിയിട്ടുണ്ട്, ഉദാ -p 2 പ്രവർത്തിക്കുന്നു enum as
ഇത് തമാശയോടെ ചെയ്യുന്നു:

# jot -p 2 3
1.00
2.00
3.00

# enum -p 2 3
1.00
2.00
3.00

കാണുക ഓപ്ഷനുകൾ കൂടുതൽ വിശദാംശങ്ങൾക്ക് മുകളിൽ.

അധിക സവിശേഷതകൾ
അത് അധിക സവിശേഷതകൾ enum ഓവർ ജോട്ട് ഓഫറുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

കൂടുതൽ അവിസ്മരണീയമായ കമാൻറ് LINE USAGE
3-നും 1-നും ഇടയിൽ (ഉൾപ്പെടെ) 10 ക്രമരഹിത സംഖ്യകൾ നിർമ്മിക്കുന്നതിന്, നിങ്ങൾ പ്രവർത്തിക്കും

jot -r 3 1 10

കൂടെ. ഈ ഇതര കോളുകൾ ഞങ്ങൾ കണ്ടെത്തുന്നു enum കൂടുതൽ അവബോധജന്യമായ:

enum -r 1 .. 3x .. 10
enum -r 1 3x 10

കസ്റ്റം പരിഹാരം OF RANDOM
കൂടെ enum ക്രമരഹിതമായി തിരഞ്ഞെടുക്കാൻ സാധ്യതയുള്ള മൂല്യങ്ങൾ a-ൽ നിന്ന് ഉണ്ടെന്ന് നിങ്ങൾക്ക് വ്യക്തമാക്കാം
പ്രത്യേക ഇടം. ഈ രണ്ട് കേസുകളും 2 ന്റെ വിടവും തമ്മിലുള്ള വ്യത്യാസം വ്യക്തമാക്കുന്നു
3:

# enum -r 4 .. 100x 2 .. 10 | അടുക്കുക -u -n
4
6
8
10

# enum -r 4 .. 100x 3 .. 10 | അടുക്കുക -u -n
4
7
10

പിന്തുണ വേണ്ടി SEVERAL സ്ഥലം ഉടമകൾ IN ഫോർമാറ്റ് സ്ട്രിംഗ്സ്
DragonFlyBSD, FreeBSD, MirOS BSD, OpenBSD, OS X എന്നിവയിൽ ജോട്ട് ചെയ്യുക:

# jot -w %g%g 3
jot: വളരെയധികം പരിവർത്തനങ്ങൾ

NetBSD-യിൽ രേഖപ്പെടുത്തുക:

# jot -w %g%g 3
jot: അജ്ഞാതമോ അസാധുവായ ഫോർമാറ്റ് `%g%g'

enum ഏതെങ്കിലും പ്ലാറ്റ്ഫോമിൽ:

# enum -f %g%g 3
11
22
33

പിന്തുണ വേണ്ടി ESCAPE സീക്വൻസുകൾ
ഞങ്ങൾ പരീക്ഷിച്ച പ്രധാന നടപ്പാക്കലുകളൊന്നും (DragonFlyBSD, FreeBSD, MirOS BSD, NetBSD,
OpenBSD, OS X) എസ്‌കേപ്പ് സീക്വൻസുകളെ പിന്തുണയ്ക്കുന്നു, "\n" എന്ന് പറയുക ഫോർമാറ്റ്:

# jot -w '%g\x41' 1
1\x41

enum "\x41" ശരിയായി അൺഎസ്കേപ്പ് ചെയ്യാൻ കഴിയും:

# enum -w '%g\x41' 1
1A

ഒരു സൈഡ് നോട്ടിൽ, "\x25" ഒരു അക്ഷരാർത്ഥത്തിൽ "%" ഉണ്ടാക്കുന്നു; ഇത് ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ ഉണ്ടാക്കുന്നില്ല:

# enum -w '%g \x25g' 1
1 % ഗ്രാം

NULL ബൈറ്റ്സ് AS സെപ്പറേറ്റർ
സ്‌പെയ്‌സുകൾ അടങ്ങിയ ഫോർമാറ്റ് സ്‌ട്രിംഗുകൾ ഉപയോഗിക്കുമ്പോൾ, ഇതുപോലുള്ള സന്ദർഭങ്ങളിൽ നിങ്ങൾക്ക് പ്രശ്‌നമുണ്ടായേക്കാം
ലൂപ്പുകൾക്കോ ​​സാർഗുകൾക്കോ ​​വേണ്ടി: സ്‌പെയ്‌സുകളെ നിങ്ങളുടെ സ്ട്രിംഗുകളെ വിഭജിക്കുന്ന സെപ്പറേറ്ററുകളായി കണക്കാക്കുന്നു
കഷണങ്ങൾ:

# enum -f 'ആടുകളുടെ നമ്പർ %d' 2 | xargs -n 1 എക്കോ
ആടുകൾ
അക്കം
1
ആടുകൾ
അക്കം
2

ഇത് തടയാൻ, നിങ്ങൾക്ക് കടന്നുപോകാം --ശൂന്യം രണ്ടു പേർക്കും enum കൂടാതെ xargs:

# enum --null -f 'ആടുകളുടെ നമ്പർ %d' 2 | xargs --null -n 1 എക്കോ
ആടുകളുടെ നമ്പർ 1
ആടുകളുടെ നമ്പർ 2

വ്യത്യാസങ്ങൾ
ഹാൻഡ്ലിംഗ് OF ഫോർമാറ്റുകൾ കൂടാതെ സ്ഥലം ഉടമകൾ
ജോട്ടിന് വിപരീതമായി, enum ഫോർമാറ്റിംഗ് സ്ട്രിംഗ് ആണെങ്കിൽ നിലവിലെ മൂല്യം ചേർക്കില്ല
ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ അടങ്ങിയിട്ടില്ല. ജോട്ടിന്റെ പെരുമാറ്റം:

# ജോട്ട് 3 -ഡബ്ല്യു ടെസ്റ്റ്_
test_1
test_2
test_3

യുടെ പെരുമാറ്റം enum:

# enum -w ടെസ്റ്റ്_ 3
ടെസ്റ്റ്_
ടെസ്റ്റ്_
ടെസ്റ്റ്_

ജോട്ടിന്റെ ഔട്ട്പുട്ട് നേടുന്നതിനായി enum, നിങ്ങൾ ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ സ്വമേധയാ ചേർക്കണം:

# enum -w test_%d 3
test_1
test_2
test_3

നോൺ-നമ്പർ മൂല്യങ്ങൾ വേണ്ടി ഇടത്തെ ഒപ്പം ശരി
enum അവയുടെ സംഖ്യാ മൂല്യങ്ങൾക്ക് പകരം ASCII പ്രതീകങ്ങൾ ഉപയോഗിക്കുന്നതിനെ പിന്തുണയ്ക്കുന്നില്ല (ഉദാ
"എ" 65) വേണ്ടി ഇടത്തെ ഒപ്പം ശരി. തമാശ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇവ ചെയ്യാനാകും:

# ജോട്ട് 3 എ
65
66
67

പൊരുത്തക്കേടില്ലാതെ,

# ജോട്ട് 3 0
0
1
2

0 കോഡ് ഉള്ള ASCII പ്രതീകമായി "48" എന്ന് jot വ്യാഖ്യാനിക്കുന്നില്ല. ഞങ്ങൾക്ക് ഉദ്ദേശ്യമില്ല
ഇപ്പോൾ ഈ മിശ്രിതം ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യുന്നു.

താരതമ്യം TO ഗ്നു SEQ

അടിസ്ഥാനപരമായി, enumന്റെ ഉപയോഗം GNU seq-ന്റെ ഉപയോഗം പിന്നിലേക്ക്-അനുയോജ്യമാണ്.

അധിക സവിശേഷതകൾ
അധിക സവിശേഷതകൾ enum GNU seq-ൽ ഉള്ള ഓഫറുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

RANDOM NUMBER MODE
enum നിയന്ത്രിത ക്രമരഹിത സംഖ്യകളുടെ ഔട്ട്പുട്ട് പിന്തുണയ്ക്കുന്നു, ഉദാ

enum -r 4 .. 3x 2.0 .. 11

{4.0, 6.0, 8.0, 10.0} എന്ന സെറ്റിൽ നിന്ന് മൂന്ന് (ഒരുപക്ഷേ ഡ്യൂപ്ലിക്കേറ്റ്) ക്രമരഹിത സംഖ്യകൾ നിർമ്മിക്കുന്നു.

പിന്തുണ വേണ്ടി വിപരീതം ഓർഡർ ചെയ്യുന്നു
GNU seq ന് വിപരീതമായി, enum കുറയുന്ന മൂല്യങ്ങൾ കണക്കാക്കുന്നത് പിന്തുണയ്ക്കുന്നു:

# seq 3 1

# enum 3 1
3
2
1

പിന്തുണ വേണ്ടി SEVERAL സ്ഥലം ഉടമകൾ IN ഫോർമാറ്റ് സ്ട്രിംഗ്സ്
# seq -f %g%g 3
seq: ഫോർമാറ്റ് `%g%g' ന് വളരെയധികം % നിർദ്ദേശങ്ങളുണ്ട്

# enum -f %g%g 3
11
22
33

പിന്തുണ വേണ്ടി ESCAPE സീക്വൻസുകൾ
GNU seq എസ്കേപ്പ് സീക്വൻസുകളെ പിന്തുണയ്ക്കുന്നില്ല, "\n" എന്ന് പറയുക, ഇൻ ഫോർമാറ്റ്:

# seq -f '%g\x41' 1
1\x41

നേരെമറിച്ച്, ചുറ്റുമുള്ള മറ്റ് ചില seq നടപ്പിലാക്കലുകൾ ചെയ്യുന്നു. ഈ മൂന്ന് സ്വഭാവങ്ങളും
നിരീക്ഷിക്കാവുന്നതാണ് (2010-10-25 വരെ):

പ്ലാൻ 9, 9ബേസ്, GNU seq എന്നിവയുടെ seq:

# seq -f '%g\x41' 3
1\x41
2\x41
3\x41

FreeBSD, NetBSD എന്നിവയിലെ seq:

# seq -f '%g\x41' 1
1A
2A
3A

DragonFlyBSD-യിലെ seq:

# seq -f '%g\x41' 1
1A3
2A3
3A3

enum "\x41" മുതൽ "A" വരെ അൺഎസ്കേപ്പ് ചെയ്യുക:

# enum -f '%g\x41' 3
1A
2A
3A

ഒരു സൈഡ് നോട്ടിൽ, "\x25" ഒരു അക്ഷരാർത്ഥത്തിൽ "%" ഉണ്ടാക്കുന്നു; ഇത് ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ ഉണ്ടാക്കുന്നില്ല:

# enum -f '%g \x25g' 1
1 % ഗ്രാം

ഒഴിവാക്കുന്നു ഫൈനൽ പുതിയ വര
വ്യക്തമാക്കുന്നതിലൂടെ -n ഒരു പരാമീറ്ററായി, നിങ്ങൾക്ക് ഉണ്ടാക്കാം enum പിന്നിലുള്ള ന്യൂലൈൻ ഒഴിവാക്കുക.

വ്യത്യാസങ്ങൾ
GNU seq's --തുല്യ-വീതി കുറുക്കുവഴി -w ജോട്ടുകളുമായുള്ള വൈരുദ്ധ്യങ്ങൾ -w വാക്ക്. ഞങ്ങൾ ഉണ്ടാക്കാൻ തിരഞ്ഞെടുത്തു -e The
കുറുക്കുവഴി --തുല്യ-വീതി in enum, പകരം.

കൂടാതെ, GNU seq GPL v3 അല്ലെങ്കിൽ അതിനു ശേഷമുള്ള ലൈസൻസ് ഉള്ളപ്പോൾ, enum പുതിയ BSD പ്രകാരം ലൈസൻസ് നൽകിയിട്ടുണ്ട്
ലൈസൻസ്.

ശല്യമോന്നുമില്ല

ഏലിയാസ് പിപ്പിംഗ്, ആൻഡ്രിയാസ് ഗൺഷ്ൽ, ജസ്റ്റിൻ ബി. റൈ, ഡേവിഡ് പ്രെവോട്ട്, കാമിൽ ദുഡ്ക, മൈക്കൽ ബിയേനിയ

AUTHORS

ജാൻ ഹോക്ക് റഹ്ം[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>

സെബാസ്റ്റ്യൻ പിപ്പിംഗ്[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>

റിസോർസുകൾ

പ്രധാന വെബ് സൈറ്റ്: https://fedorahosted.org/enum/

Gitweb: http://git.fedorahosted.org/git/?p=enum.git

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് enum ഓൺലൈനായി ഉപയോഗിക്കുക