टर्मिनल से एक फाइल बनाने के लिए असीम रूप से शब्दों के एक सेट को कैसे दोहराएं?

19

टर्मिनल से एक फाइल बनाने के लिए असीम रूप से शब्दों के एक सेट को कैसे दोहराएं? मुझे इसकी आवश्यकता है कि आकार में 2-4GB जैसे पार्सिंग उद्देश्यों के लिए एक बड़ी फ़ाइल बनाई जाए। वर्तमान में मैं आकार बढ़ाने के लिए मैन्युअल रूप से एक ही फाइल में पेस्टिंग लाइनों की नकल कर रहा हूं।

command-line

— Nisheet
स्रोत

1

मैं विशेष यूनिक्स फ़ाइलों के साथ काम करने वाला उत्तर देखना चाहता हूं, इसलिए यह वास्तव में उस स्थान पर कब्जा नहीं करेगा। क्या यह संभव है?

— डेलेसन जूनियो

1

आप वास्तव में अनंत की तरह कुछ मतलब है mkfifo huge.tmp; while true; do yes "a dummy line" > huge.tmp; done?

— बोल्डवेन

50

कई बार एक पंक्ति दोहराने का एक आसान तरीका है:

yes we have no bananas | head -n 10000 > out.txt

परिणाम होगा। बाहर। 10,000 लाइनों में यह कहते हुए कि "हमारे पास केले नहीं हैं"।

बाइट्स, उपयोग की सटीक संख्या के उत्पादन को सीमित करने के headके -cबजाय विकल्प -n। उदाहरण के लिए, यह वास्तव में पाठ के 10 kB उत्पन्न करता है:

yes we have no bananas | head -c 10000 > out.txt

— हॉब्स
स्रोत

2

ओपी बाइट्स से निपटना चाहता है, लाइनों से नहीं।

— हेमायल सेप

4

बाइट्स में एक सीमा निर्दिष्ट करने के लिए, बस 10k लाइनों के head -c 10000बजाय 10 kB के लिए उपयोग करें head -n 10000।

— बाइट कमांडर

@ByteCommander हाँ, लेकिन यह एक लाइन के बीच में कट जाने से आउटपुट को नहीं रोकेगा। चूंकि आकार सटीक होना जरूरी नहीं है, मैं सही आकार प्राप्त करने के लिए लाइनों की संख्या का पता

— लगाऊंगा

1

मैं सहमत हूं, लेकिन मुझे यकीन नहीं है कि यह एक समस्या होगी या नहीं। ओपी ने निर्दिष्ट नहीं किया कि वह किस विधि को चाहता है, लेकिन आपके उत्तर में अभी भी दोनों शामिल हैं। ओह, और अपनी प्रतिष्ठा को दोगुना करने के लिए बधाई आज स्कोर :)

— बाइट कमांडर

@ बाइटकमांडर येप, मेला।

— hobbs

10

मैं असीम रूप से पाठ को दोहराने की सिफारिश नहीं कर सकता, लेकिन आप इस तरह से अजगर के साथ दोहराया पाठ की ~ 2GB फ़ाइल बना सकते हैं ...

python3 -c 'with open("bigfile", "w") as f: f.write(("hello world "*10+"\n")*2*10**7)'

वह "हेल्लो वर्ल्ड" को 10 बार प्रिंट करेगा और एक नई लाइन बनाएगा, और उस 20,000,000 बार दोहराएगा, जो फ़ाइल को परिणाम लिखेगा bigfile। यदि आपके सभी चार्ट ASCII हैं, तो प्रत्येक एक बाइट है, इसलिए जो आप लिखना चाहते हैं उसके आधार पर उचित गणना करें ...

आपका सीपीयू स्वामित्व में हो सकता है। अगर मैं 10,000,000 से अधिक लाइनें करने की कोशिश करता हूं तो मैं रैम से बाहर चला जाता हूं ...

_{मैं एक टोस्टर हालांकि चला रहा हूँ}

— Zanna
स्रोत

ओपी बाइट्स से निपटना चाहता है, लाइनों से नहीं।

— हेमायल सेप

@heemayl बेशक आपका उत्तर बेहतर है, लेकिन मैंने (अस्पष्ट रूप से) समझाया कि वांछित बाइट्स का उपयोग करने के लिए कितनी लाइनों की गणना करना है, इसलिए मुझे नहीं लगता कि मेरा उत्तर बिल्कुल बेकार है

— Zanna

4

@ हेमायल क्या आपको इतना यकीन है कि ओपी बाइट्स चाहते हैं? प्रश्न अनिवार्य रूप से बताता है कि ओपी एक बड़ी फाइल चाहता है। विशिष्ट आकार बहुत अस्पष्ट (2-4GB) है, इसलिए मुझे वास्तव में संदेह है कि मन में एक विशिष्ट बाइट सीमा है।

— टेराडॉन

1

@ हेमायएल हाँ, लेकिन यह बहुत, बहुत अस्पष्ट है। मेरी समझ यह है कि ओपी केवल एक बड़ी फ़ाइल चाहता है और एक सटीक आकार की परवाह नहीं करता है। अन्यथा, उन्होंने इतने बड़े आकार के बजाय एक आकार दिया होता।

— टेराडॉन

1

@cat ikr! <3python <3

— Zanna

9

पर्ल का निफ्टी xऑपरेटर है:

$ perl -e 'print "foo\n" x 5'
foo
foo
foo
foo
foo

इसलिए, एक सरल समाधान के रूप में, आप अपनी रेखा को कुछ मिलियन बार लिख सकते हैं। उदाहरण के लिए, इस कमांड ने एक 3 जी फाइल बनाई:

perl -e 'print "This is my line\n" x 200000000' > file

यदि आपको एक सटीक आकार (इस मामले में 2 GiB) निर्दिष्ट करने की आवश्यकता है, तो आप कर सकते हैं:

perl -e 'use bytes; while(length($str)<2<<20){ $str.="This is my line\n"} print "$str\n"' > file

— terdon
स्रोत

यदि आप धीरज रखते हैं, तो आप कूल पर्ल 6 ऑपरेटर्स का उपयोग कर सकते हैं, जबकि पर्ल 6 को छोड़कर बहुत कुछ, बहुत, बहुत, बहुत धीमा है: D

— cat

@ क्या यह वास्तव में है? मैंने 6 को बिल्कुल भी नहीं छुआ है, लेकिन मैंने यह मान लिया था कि इसमें केवल सभी अच्छाई और ओओ एक्स्ट्रा कलाकार होंगे। किसी भी विचार क्यों यह धीमी है?

— टेराडन

1

मेरी टिप्पणी ज्यादातर शानदार थी, लेकिन मैंने इस साल की शुरुआत में पाया कि पर्ल 6 की तुलना में पर्ल 6 काफी धीमा है, जो पर्ल 5 (जो मैंने परीक्षण नहीं किया था) की तुलना में बहुत अधिक धीमा है। कार्य सुविधाओं और शुद्धता पर केंद्रित है, प्रदर्शन अभी तक नहीं है, लेकिन इसे 2015 के लिए एक लक्ष्य के रूप में सूचीबद्ध किया गया था। इसके अलावा, क्या पर्ल 6 मेरे लिए पर्याप्त तेज़ है? ।

— कैट

(दूसरी ओर, सुविधाओं की सूची कम से कम कहने के लिए प्रभावशाली है।)

— बिल्ली

7

किसी फ़ाइल में दोहराए जाने वाले शब्दों का सेट जैसे source.txt। का आकार प्राप्त करें source.txt, जैसे कि बाइट्स में:
```
 stat -c '%s' source.txt
```
गंतव्य फ़ाइल का आकार destination.txt, जैसे , 2 GB या 4 GB या जो भी तय करें। आकार को बाइट्स में बदलें।
गंतव्य फ़ाइल आकार को स्रोत फ़ाइल आकार से विभाजित करें। bashफ्लोटिंग पॉइंट अंकगणित नहीं कर सकते हैं, लेकिन इस मामले में इसकी आवश्यकता नहीं है।
विभाजन परिणाम समय में forएक cat source.txtऑपरेशन को दोहराने के लिए एक निर्माण का उपयोग करें । यह गंतव्य फ़ाइल आकार का निकटतम अनुमानित होगा जिसे आप पुनरावृत्ति द्वारा प्राप्त कर सकते हैं। ऑपरेशन के आउटपुट में सहेजा गया है destination.txt।

उदाहरण के लिए, source.txt30 बाइट्स का है, और हम एक 2 जीबी फ़ाइल बनाना चाहते हैं, हमें इसकी आवश्यकता है:

for ((i=0; i<=((16777216/30)); i++)); do cat source.txt; done >destination.txt

यहाँ मैं ((16777216/30))इनिशियलाइज़ेशन के समय ऊपरी सीमा तय कर रहा हूँ ; आप परिणाम प्राप्त कर सकते हैं और यहां भी डाल सकते हैं।

ऑपरेशन में कुछ समय लगेगा; जितना बड़ा होगा source.txt, उतना कम समय की जरूरत होगी।

— heemayl
स्रोत

1

क्या यह destination.txtलूप के प्रत्येक पुनरावृत्ति के लिए एक बार खुला और बंद नहीं होता है?

— मोनिका को बहाल करना - Sep-- 15

@ हेक्सफ़्रेक्शन डुह, निश्चित।

— हेमायल सेप

6

आप एक while-लूप का उपयोग भी कर सकते हैं ।

उदाहरण: इसकी सामग्री foo.txt(यह आपका स्रोत है):

foo
bar
foobar

bar.txtखाली है (यह आपकी लक्षित फ़ाइल है)। अब आप निम्न लूप को foo.txtकई बार की सामग्री में लिखने के लिए rn कर सकते हैं bar.txt:

while [ $(stat --format "%s" bar.txt) -lt 150 ] 
do 
    cat foo.txt >> bar.txt
done

स्पष्टीकरण:

stat --format "%s" bar.txtbar.txtबाइट्स के आकार को प्रदर्शित करता है ।
while [ $(stat --format "%s" bar.txt) -lt 150 ] लक्ष्य आकार (इस मामले में 150 बाइट्स) तक पहुंचने तक निम्नलिखित क्रियाएं दोहराई जाएंगी।
cat foo.txt >> bar.txtकी सामग्री के संलग्न foo.txtकरने के लिएbar.txt

— Wayne_Yux
स्रोत

4

पहले आग की कमान:

dd if=/dev/urandom of=file.txt bs=2048 count=10

हमारे आकार 2027 * 10 = 20Kb में, यादृच्छिक बाइट्स की गिनती के आकार के पथ पर एक फ़ाइल बनाएगा। जिसे आवश्यकता के अनुसार बदला जा सकता है।

cat - > file.txt

यह STDIN को एक फ़ाइल पर पुनर्निर्देशित करता है, इसलिए आपको दो लाइनें दर्ज करनी होंगी और फिर Ctrl + D दबाना होगा। फिर आपको निम्नलिखित कमांड चलाने की आवश्यकता होगी:

for i in {1..n}; do cat file.txt file.txt > file2.txt && mv file2.txt file.txt; done

जहाँ n एक पूर्णांक है। यह आपकी मूल दो पंक्तियों को डुप्लिकेट करके, इसमें 2 ^ (n + 1) लाइनों के साथ एक फ़ाइल बनाएगा। तो 16 लाइनों के साथ एक फ़ाइल बनाने के लिए आप क्या करेंगे:

for i in {1..3}; do cat file.txt file.txt > file2.txt && mv file2.txt file.txt; done

आरंभ करने के लिए यहां कुछ और नंबर दिए गए हैं:

n=15 will give you 65536 lines (if the original two lines were 'hello' and 'world' the file will be 384Kb)
n=20 will give you 2097152 lines (12Mb file with 'hello' and 'world' as the two starting lines)
n=25 will give you 67108864 lines (384Mb file with 'hello' and 'world' as the two starting lines)

— अवनि बधेका
स्रोत

2

ओपी बाइट्स से निपटना चाहता है, लाइनों से नहीं।

— हेमायल सेप

ओपी फाइल भरने के लिए नकल की लाइन भी रखते हैं। और मेरी पहली कमांड ने पहले से ही मेमोरी के आवश्यक बाइट्स के अनुसार फाइल बनाई।

— अवनी बधेका

@heemayl newline चरित्र अभी भी एक बाइट रखता है, मेरी पहले की टिप्पणी के समान। यह एक वैध चरित्र है। हालाँकि, ओपी ने शब्दों को निर्दिष्ट किया , अवनि, इसलिए मुझे नहीं लगता कि आपके / dev / urandom तकनीक उनके प्रश्न का उत्तर देती है।

— माइक एस

यह निर्भर करता है कि आप कुछ यादृच्छिक बाइट्स की कोशिश कर रहे हैं या नहीं। यहां तक कि आप अपनी खुद की कुछ फाइलें चुन सकते हैं जिनमें डेटा का बहुत अधिक बाइट होता है।

— अवनी बधेका

4

FIFOs शायद वही हैं जो आप खोज रहे हैं। किसी दिए गए फ़ाइल के साथ अपने कार्यक्रम को कॉल करने के बजाय, आप प्रक्रिया कमांड सबस्टेशन के माध्यम से एक शेल कमांड के परिणाम को टाई कर सकते हैं और प्रोग्राम अपने आउटपुट को एक सादे फ़ाइल के रूप में देखेगा। यहां लाभ यह है कि अब आप अपने डिस्क स्थान तक सीमित नहीं हैं, इसलिए आप उन फ़ाइलों तक पहुंच सकते हैं जो अन्यथा असंभव होगा, इसलिए जब तक आपके प्रोग्राम को पहले पूरी फ़ाइल को बफर करने की आवश्यकता नहीं होती है और बस इसे लाइन द्वारा पार्स कर सकते हैं। उदाहरण के लिए, सामग्री उत्पन्न करने के लिए @hobbs के उत्तर का उपयोग करना:

wc -c <(yes we have no bananas | head -n 5000000000)

यह मुझे 95 गीगाबाइट फ़ाइल (wc के अनुसार) को HDD स्पेस में बिना किसी खर्च के और बमुश्किल किसी भी रैम को उधार देता है, बस यह पढ़ने के लिए कमांड रिटर्न क्या करता है, बफर करने के लिए पर्याप्त है। यह "असीम" के करीब है जैसा कि आप प्राप्त करने जा रहे हैं।

— संतो ग्वेरा
स्रोत