निर्देशिका ट्री बनाने का स्वचालित तरीका

Question

मैं A से Z तक एक डाइरेक्टरी ट्री बनाने की कोशिश कर रहा हूँ जहाँ अगली डाइरेक्टरी वर्तमान डाइरेक्टरी के भीतर है।

उदाहरण के लिए: बी ए के भीतर है और सी बी के भीतर और इसी तरह ।।

-A
--B
---C
----...Z

कैसे स्वचालित तरीके से इसे प्राप्त करने के बारे में कोई सुराग?

Comments

मुझे आश्चर्य है कि ऐसी निर्देशिकाओं का व्यावहारिक उद्देश्य क्या है। IMHO यह कोड गोल्फ के लिए एक प्रश्न की तरह दिखता है ।

— मेलेबियस

@Melebius एक संभावित उद्देश्य परीक्षण के मामले के रूप में एक निर्देशिका संरचना बनाना है, ताकि यह सत्यापित करने में मदद मिल सके कि कुछ अन्य कमांड, स्क्रिप्ट या एप्लिकेशन संपत्ति का काम करती है। यहाँ एक हालिया उदाहरण है जहाँ प्रश्न स्वयं विशिष्ट निर्देशिका संरचनाएँ बनाने के बारे में नहीं था, लेकिन यह जानना कि ऐसा करने के लिए कमांड लिखना कैसे परीक्षण उद्देश्यों के लिए उपयोगी था, इसके बावजूद कि विशिष्ट संरचना कैसे और अजीब थी, लेकिन इसके कारण नहीं। (विशिष्ट निर्देशिका संरचना बनाने के बारे में भी हमारे पास कई प्रश्न हैं, जिन्हें " mkdir -p" के लिए खोजकर पाया जा सकता है ।)

— एलियाह कगन

Answer 1

साथ mkdir, printfऔर पार्टी की ब्रेस विस्तार:

$ mkdir -p "$(printf "%s/" {A..Z})"
$ tree A
A
└── B
    └── C
        └── D
            └── E
                └── F
                    └── G
                        └── H
                            └── I
                                └── J
                                    └── K
                                        └── L
                                            └── M
                                                └── N
                                                    └── O
                                                        └── P
                                                            └── Q
                                                                └── R
                                                                    └── S
                                                                        └── T
                                                                            └── U
                                                                                └── V
                                                                                    └── W
                                                                                        └── X
                                                                                            └── Y
                                                                                                └── Z

25 directories, 0 files

• {A..Z}करने के लिए फैलता है A B ... Z,
• printf "%s/"/उनके साथ तर्कों को छापता है, इसलिए मुझे मिलता हैA/B/...Z/
• और किसी भी मूल निर्देशिका के साथ निर्देशिका mkdir -pबनाता है जिसे A/B/.../Zबनाने की आवश्यकता होती है।

Comments

उसके लिए धन्यवाद। मैंने सोचा कि मुझे यह त्रुटि मिली। मैं कमांड mkdir का उपयोग करता हूं: ए / बी / सी / डी / ई / एफ / जी / एच / आई / जे / के / एल / एम / एन / ओ / पी / क्यू / आर / एस / टी / यू / वी / W / X / Y: ऐसी कोई फ़ाइल या निर्देशिका नहीं

— Nish

@Nish वहाँ एक है -pमें mkdirआदेश।

— मूरू

मेरा बुरा, मैंने कोशिश की कि मेरे मैक पर ubuntu के बजाय। और एक अनुवर्ती प्रश्न यह है -> मान लें कि मैं ए (एक ही संरचना AtoZ में) के भीतर A1..A100 निर्देशिका चाहता था। तब B1..B100 बी के भीतर। तो यह कुछ इस तरह दिखता है -> imgur.com/jfuKEdf

— Nish

मान लीजिए कि आप टिप्पणियों के बजाय एक वास्तविक प्रश्न के रूप में अनुवर्ती पोस्ट करते हैं, और छवियों का उपयोग नहीं करते थे लेकिन पाठ। यह बेहतर होगा, नहीं?

— मूरू

मैं यहां आपकी बात समझता हूं। यह एक कोड के रूप में इसे पोस्ट करने के लिए मुश्किल है और उस पर एक hugeass आउटपुट है। तो बस स्क्रीनशॉट को देखने से समझने में आसानी होती है।

— निस

Answer 2

बहुत ही सरल स्तर पर, आप {A..Z}सभी पत्र बनाने के लिए विस्तार का उपयोग कर सकते हैं , फिर पुनरावृति से प्रत्येक को बना सकते हैं और दर्ज कर सकते हैं:

~/test_directory$ for d in {A..Z}; do mkdir "$d"; cd "$d"; done
~/test_directory/A/B/C/D/E/F/G/H/I/J/K/L/M/N/O/P/Q/R/S/T/U/V/W/X/Y/Z$ 

जैसा कि आप मेरे शीघ्र आउटपुट में देख सकते हैं, अब आपके पास पूरी तरह से जंजीर निर्देशिका है।

हालाँकि, यदि वास्तविक निर्देशिका नाम केवल वर्णमाला से भिन्न हैं, तो आपको किसी तरह निर्देशिका के नामों की सूची प्रदान करनी होगी, शायद एक फ़ाइल के माध्यम से, जिस पर आप पुनरावृति करते हैं और उसी प्रक्रिया को फिर से करते हैं। मूल रूप से, यह

while IFS= read -r dir_name;do mkdir "$dir_name"; cd "$dir_name" ;done < directory_list.txt

Comments

यह बहुत मजेदार है। यहाँ एक अनुवर्ती प्रश्न है। मान लीजिए कि मैं A (उसी संरचना AtoZ में) के भीतर A1..A100 निर्देशिका चाहता था। तब B1..B100 बी के भीतर। तो यह कुछ इस तरह दिखता है -> imgur.com/jfuKEdf

— Nish

@ निश आह, कि एक आंतरिक लूप की आवश्यकता होगीfor d in {A..Z}; do mkdir "$d"; cd "$d"; for i in {1..100}; do mkdir "${d}${i}" ;done ; done

— Sergiy Kolodyazhnyy

या यहां तक ​​कि आंतरिक लूप के बिना,for d in {A..Z}; do mkdir "$d"; cd "$d"; mkdir "$d"{1..100}; done

— सर्जियो कोलोडियाज़नी

उसके लिए धन्यवाद। यह काम करने लगता है, लेकिन निर्देशिका का क्रम खराब लग रहा है इसलिए 2 के बाद नहीं है। इसकी क्रमबद्ध रूप से छंटनी की जाती है। वैसे भी उसे ठीक करने के लिए? यहाँ एक स्क्रीनशॉट है -> imgur.com/a/Zqj1c

— Nish

@ नीश क्रमबद्धता पाठ आधारित है, संख्यात्मक नहीं है जैसा कि मुझे लगता है कि आप अपेक्षा करते हैं। जहाँ तक tree, मुझे यकीन नहीं है कि इसे कैसे ठीक किया जाए, लेकिन मुझे लगता है कि यह treeसमस्या भी नहीं हो सकती है, बल्कि शेल का क्रमबद्ध क्रम है। मैं सुझाव देता हूं कि इस बारे में वास्तविक सवाल पूछें या यहाँ अभी तक unix.stackexchange.com पर

— Sergiy Kolodyazhnyy

Answer 3

भले ही मूरू के printfतरीके को हराया नहीं जा सकता है, मैं व्यक्तिगत रूप jotसे इस तरह की चीज के लिए पसंद करता हूं । jotउबंटू में डिफ़ॉल्ट रूप से स्थापित नहीं है। athena-jotपैकेज यह प्रदान करता है। इनमें से कोई भी आदेश काम करता है:

mkdir -p "$(jot -s/ -c 26 A)"

jot -s/ -c 26 A | xargs mkdir -p

वास्तव में कोई भी कमांड जो अक्षरों के अनुक्रम को उत्पन्न करता है और उन्हें स्लैश के साथ जोड़ता है, इससे सुविधा होगी, क्योंकि इसके आउटपुट को mkdir -pया तो कमांड प्रतिस्थापन ( muru के उत्तर में ) या उपयोग के माध्यम से पारित किया जा सकता है xargs। यहां कुछ टूल का उपयोग करके कुछ उदाहरण दिए गए हैं और xargsइसके लिए आपको सॉफ़्टवेयर स्थापित करने की आवश्यकता नहीं है, सिवाय शायद बहुत कम सिस्टम या उबंटू कोर पर:

perl -we 'print join "/", A..Z' | xargs mkdir -p

ruby -we 'print (?A..?Z).to_a * ?/' | xargs mkdir -p

python3 -c 'print("/".join(__import__("string").ascii_uppercase))' | xargs mkdir -p

ओल्ड उबंटू रिलीज़ पायथन 3 के बजाय पायथन 2 के साथ आते हैं। इसके लिए, बस उस अंतिम कमांड को बनाने के लिए बदलाव python3करें python, यदि आप वास्तव में पायथन के साथ ऐसा करना चाहते हैं।

इसी तरह, मौरू का संक्षिप्त और सरल तरीका वैकल्पिक रूप से लिखा जा सकता है:

printf '%s/' {A..Z} | xargs mkdir -p

/निर्देशिका पथ में अनुगामी mkdir -pबनाने के लिए कहा जाता है, कोई समस्या नहीं है और यकीनन शैलीगत रूप से बेहतर है। लेकिन इसे छोड़ना ठीक है, जैसा कि इस उत्तर में अन्य उदाहरण हैं।