फ़ाइल नाम की एक उत्पन्न सूची का उपयोग तर्क सूची के रूप में - रिक्त स्थान के साथ

Question

मैं एक स्क्रिप्ट का संग्रह करने की कोशिश कर रहा हूं, जिसमें एकत्र किए गए फ़ाइलनामों की एक सूची है find। कुछ खास नहीं, बस कुछ इस तरह:

$ myscript `find . -name something.txt`

समस्या यह है कि कुछ मार्गों में रिक्त स्थान होते हैं, इसलिए वे तर्क विस्तार पर दो अमान्य नामों में टूट जाते हैं। आम तौर पर मैं नामों को उद्धरणों के साथ घेरता हूँ, लेकिन यहाँ वे बैकक्वाटर के विस्तार द्वारा डाले गए हैं। मैंने findउद्धरण के साथ प्रत्येक फ़ाइल नाम के आउटपुट को और उसके आसपास फ़िल्टर करने का प्रयास किया है , लेकिन जब तक बैश उन्हें देखता है, तब तक उन्हें पट्टी करने में बहुत देर हो जाती है और उन्हें फ़ाइल नाम के हिस्से के रूप में माना जाता है:

$ myscript `find . -name something.txt | sed 's/.*/"&"/'`
No such file or directory: '"./somedir/something.txt"'

हां, यह नियम है कि कमांड लाइन कैसे संसाधित की जाती है, लेकिन मैं इसके आसपास कैसे पहुंचूं?

यह शर्मनाक है लेकिन मैं सही दृष्टिकोण के साथ आने में विफल रहा हूं। मैंने आखिर यह पता लगा लिया कि यह कैसे करना है xargs -0 -n 10000... लेकिन यह इतनी बदसूरत हैक है कि मैं अभी भी पूछना चाहता हूं: मैं बैककौट विस्तार के परिणामों को कैसे उद्धृत करूं, या उसी तरह से एक ही प्रभाव प्राप्त करूं?

संपादित करें: मैं इस तथ्य के बारे में उलझन में था कि सभी तर्कों को एक एकल तर्क सूची में इकट्ठा xargs करता है , जब तक कि यह अन्यथा नहीं बताया जाता है या सिस्टम सीमाएं पार हो सकती हैं। मुझे सीधे सेट करने के लिए सभी को धन्यवाद! दूसरों, इसे ध्यान में रखें क्योंकि आप स्वीकृत उत्तर को पढ़ते हैं क्योंकि यह बहुत सीधे इंगित नहीं किया गया है।

मैंने उत्तर स्वीकार कर लिया है, लेकिन मेरा प्रश्न शेष है: क्या बैकटिक (या $(...)) के विस्तार में रिक्त स्थान की रक्षा करने का कोई तरीका नहीं है ? (ध्यान दें कि स्वीकृत समाधान एक गैर-बाश उत्तर है)।

Comments

मुझे लगता है कि आपको फ़ाइल सेपरेटर के रूप में शेल का उपयोग करने के लिए क्या बदलना होगा (उदाहरण के लिए, IFS के मूल्य के साथ खेलकर, एक संभव तरीका IFS=", न्यूलाइन है ")। लेकिन क्या सभी फाइलनाम पर स्क्रिप्ट को निष्पादित करने की आवश्यकता है ? यदि नहीं, तो प्रत्येक फ़ाइल के लिए स्क्रिप्ट निष्पादित करने के लिए स्वयं का उपयोग करने पर विचार करें।

— njsg

IFS को बदलना एक महान विचार है, इसके बारे में सोचा नहीं था! कमांडलाइन उपयोग के लिए व्यावहारिक नहीं है, लेकिन फिर भी। :-) और हां, लक्ष्य है कि मैं अपनी स्क्रिप्ट के एक ही आह्वान के लिए सभी तर्क पारित करूं।

— एलेक्सिस

Answer 1

आप निम्नलिखित के कुछ कार्यान्वयन का उपयोग कर सकते हैं find और xargsइस तरह।

$ find . -type f -print0 | xargs -r0 ./myscript

या, मानक रूप से, बस find :

$ find . -type f -exec ./myscript {} +

उदाहरण

कहो कि मेरे पास निम्नलिखित नमूना निर्देशिका है।

$ tree
.
|-- dir1
|   `-- a\ file1.txt
|-- dir2
|   `-- a\ file2.txt
|-- dir3
|   `-- a\ file3.txt
`-- myscript

3 directories, 4 files

अब हम कहते हैं कि मेरे पास इसके लिए है ./myscript ।

#!/bin/bash

for i in "$@"; do
    echo "file: $i"
done

अब जब मैं निम्नलिखित कमांड चलाता हूं।

$ find . -type f -print0 | xargs -r0 ./myscript 
file: ./dir2/a file2.txt
file: ./dir3/a file3.txt
file: ./dir1/a file1.txt
file: ./myscript

या जब मैं इस तरह से 2 रूप का उपयोग करता हूं:

$ find . -type f -exec ./myscript {} +
file: ./dir2/a file2.txt
file: ./dir3/a file3.txt
file: ./dir1/a file1.txt
file: ./myscript

विवरण

ढूँढें + xargs

उपरोक्त 2 विधियां, हालांकि अलग-अलग दिख रही हैं, अनिवार्य रूप से समान हैं। पहले आउटपुट को खोजने से ले रहा है, इसे खोजने के \0लिए -print0स्विच के माध्यम से NULLs ( ) का उपयोग करके विभाजित करता है । xargs -0विशेष रूप से इनपुट लेने के लिए है कि के NULLs का उपयोग कर विभाजित बनाया गया है। यही कारण है कि गैर मानक वाक्य रचना जीएनयू द्वारा पेश किया गया था findऔर xargsलेकिन यह भी सबसे हाल ही में BSDs की तरह कुछ अन्य लोगों में आजकल पाया जाता है। -rविकल्प बुला से बचने के लिए आवश्यक है myscriptयदि findजीएनयू साथ पाता कुछ भी नहीं findलेकिन BSDs के साथ नहीं।

नोट: यह संपूर्ण दृष्टिकोण इस तथ्य पर टिका है कि आप कभी भी एक स्ट्रिंग को पारित नहीं करेंगे जो कि बहुत लंबा है। यदि यह है, तो ./myscriptखोज से बाद के शेष परिणामों के साथ एक दूसरा आह्वान किक जाएगा।

+ के साथ खोजें

यह मानक तरीका है (हालांकि यह केवल अपेक्षाकृत हाल ही में (2005) जीएनयू कार्यान्वयन के लिए जोड़ा गया था find)। हम जो कर रहे हैं वह करने की क्षमता xargsवस्तुतः निर्मित है find। तो findफाइलों की एक सूची मिल जाएगी और फिर उस सूची को उतने ही तर्कों के रूप में पारित कर सकते हैं जितना -execकि निर्दिष्ट कमांड के लिए फिट हो सकते हैं (ध्यान दें कि इस मामले में {}केवल कुछ समय पहले ही अंतिम हो सकता है +), यदि आवश्यक हो तो कई बार कमांड चलाएं।

क्यों नहीं बोली?

पहले उदाहरण में हम तर्कों को अलग करने के लिए NULLs का उपयोग करके पूरी तरह से उद्धरण के साथ मुद्दों से बचकर एक शॉर्टकट ले रहे हैं। जब xargsयह सूची दी जाती है तो यह हमारे व्यक्तिगत कमांड परमाणुओं की रक्षा करने वाले NULL पर प्रभावी रूप से विभाजित होने का निर्देश है।

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

कमांड लाइन का अधिकतम आकार?

यह प्रश्न समय-समय पर सामने आता है इसलिए एक बोनस के रूप में मैं इसे इस उत्तर के साथ जोड़ रहा हूं, मुख्य रूप से इसलिए मैं इसे भविष्य में पा सकता हूं। आप यह xargsदेखने के लिए उपयोग कर सकते हैं कि पर्यावरण की सीमा क्या है:

$ xargs --show-limits
Your environment variables take up 4791 bytes
POSIX upper limit on argument length (this system): 2090313
POSIX smallest allowable upper limit on argument length (all systems): 4096
Maximum length of command we could actually use: 2085522
Size of command buffer we are actually using: 131072

Comments

धन्यवाद, लेकिन मुझे अपनी स्क्रिप्ट के एक ही आह्वान पर सभी तर्क पारित करने की आवश्यकता है । यह समस्या वर्णन में है, लेकिन मुझे लगता है कि मैंने यह स्पष्ट नहीं किया कि यह आकस्मिक नहीं है।

— एलेक्सिस

@alexis - उत्तरों को फिर से पढ़ें, वे आपकी स्क्रिप्ट के एक कॉल पर सभी तर्क पारित कर रहे हैं।

— स्लम

मैं शापित हो जाऊँगा! मैं +तर्क के बारे में नहीं जानता था find(और आप +गद्य में भी प्रयोग करते हैं, इसलिए मैंने पहली बार आपका स्पष्टीकरण याद किया)। लेकिन इस बिंदु पर अधिक, मैं गलत समझा हूँ क्या xargsडिफ़ॉल्ट रूप से करता है !!! यूनिक्स का उपयोग करने के तीन दशकों में मैंने अब तक इसके लिए कोई उपयोग नहीं किया है, लेकिन मुझे लगा कि मुझे अपना टूलबॉक्स पता है ...

— एलेक्सिस

@alexis - मुझे लगा कि आप जो कह रहे थे वह आपको याद होगा। हाँ xargsएक कमांड का शैतान है। आपको इसे पढ़ना होगा और findआदमी के पेज को कई बार टटोलना होगा कि वे क्या कर सकते हैं। स्विच के मई एक-दूसरे के गर्भ-पॉज़िटिव हैं, जिससे भ्रम पैदा होता है।

— स्लम

@alexis - टूल बॉक्स में जोड़ने के लिए एक और बात, नेस्टेड कमांड चलाने के लिए बैकक्वाट्स / बैकटिक्स का उपयोग न करें, $(..)अब इसके बजाय उपयोग करें । यह स्वचालित रूप से उद्धरण आदि के घोंसले के शिकार को संभालता है।

— स्लम

Answer 2

find . -name something.txt -exec myscript {} +

उपरोक्त में, findसभी मिलान फ़ाइल नाम पाता है और उन्हें तर्क के रूप में प्रदान करता है myscript। यह रिक्त स्थान या किसी अन्य विषम वर्णों की परवाह किए बिना फ़ाइल नामों के साथ काम करता है।

यदि सभी फ़ाइल नाम एक पंक्ति में फिट होते हैं, तो myscript को एक बार निष्पादित किया जाता है। यदि शेल को संभालने के लिए सूची बहुत लंबी है, तो आवश्यकतानुसार कई बार myscript चलाएंगे।

अधिक: एक कमांड लाइन पर कितनी फाइलें फिट होती हैं? man findकहता है कि findयह कमांड लाइन बनाता है "उसी तरह जिस तरह से xargs इसका निर्माण करता है"। और, man xargsकि सीमाएं प्रणाली पर निर्भर हैं और आप उन्हें चलाकर निर्धारित कर सकते हैं xargs --show-limits। ( getconf ARG_MAXयह भी एक संभावना है)। लिनक्स पर, सीमा आमतौर पर (लेकिन हमेशा नहीं) लगभग 2 मिलियन अक्षर प्रति कमांड लाइन होती है।

Answer 3

@ एसएलएम के ठीक जवाब के लिए कुछ अतिरिक्त।

तर्कों के आकार पर सीमा execve(2)सिस्टम कॉल पर है (वास्तव में, यह तर्क और पर्यावरण के तार और बिंदुओं के संचयी आकार पर है)। यदि myscriptऐसी भाषा में लिखा जाता है कि आपका शेल व्याख्या कर सकता है, तो हो सकता है कि आपको इसे निष्पादित करने की आवश्यकता न हो, आप अपना शेल केवल दूसरे व्याख्याकार को निष्पादित किए बिना इसकी व्याख्या कर सकते हैं।

यदि आप स्क्रिप्ट को इस रूप में चलाते हैं:

(. myscript x y)

यह पसंद है:

myscript x y

सिवाय इसके कि इसे लागू करने के बजाय वर्तमान शेल के एक बच्चे द्वारा व्याख्या की जा रही है, (जिसमें अंततः निष्पादन भी शामिल है sh(या जो भी हो, वह और भी अधिक तर्कों के साथ शी-बैंग लाइन निर्दिष्ट करता है)।

अब स्पष्ट रूप से, आप कमांड के find -exec {} +साथ उपयोग नहीं कर सकते हैं ., .शेल के बिलिन कमांड के रूप में, इसे शेल द्वारा निष्पादित किया जाना है, द्वारा नहीं find।

इसके साथ zsh, यह आसान है:

IFS=$'\0'
(. myscript $(find ... -print0))

या:

(. myscript ${(ps:\0:)"$(find ... -print0)"}

हालाँकि zsh, आपको findपहले स्थान की आवश्यकता नहीं होगी क्योंकि इसकी अधिकांश सुविधाएँ zshग्लोबिंग में निर्मित हैं ।

bashचरों में NUL वर्ण नहीं हो सकते, इसलिए आपको दूसरा रास्ता खोजना होगा। एक तरीका हो सकता है:

files=()
while IFS= read -rd '' -u3 file; do
  files+=("$file")
done 3< <(find ... -print0)
(. myscript "${files[@]}")

आप 4.0 में और बाद globstarमें विकल्प के साथ zsh- शैली पुनरावर्ती ग्लोबिंग का उपयोग कर सकते हैं bash:

shopt -s globstar failglob dotglob
(. myscript ./**/something.txt)

ध्यान दें कि 4.3 **में तय होने तक निर्देशिकाओं में सहानुभूति का पालन किया गया था bash। यह भी ध्यान दें कि ग्लोबिंग क्वालिफायर को bashलागू नहीं किया जाता है zshताकि आपको findवहां की सभी सुविधाएँ न मिलें ।

एक अन्य विकल्प GNU का उपयोग करना होगा ls:

eval "files=(find ... -exec ls -d --quoting-style=shell-always {} +)"
(. myscript "${files[@]}")

आप यह सुनिश्चित करना चाहते हैं तो ऊपर तरीकों में भी इस्तेमाल किया जा सकता myscriptहै निष्पादित (यदि तर्क सूची बहुत बड़ी है में नाकाम रहने के) केवल एक बार। लिनक्स के हालिया संस्करणों पर, आप उस सीमा को तर्क सूची पर उठा सकते हैं और उठा भी सकते हैं:

ulimit -s 1048576

(1GiB स्टैक आकार, जिसका एक चौथाई का उपयोग arg + env सूची के लिए किया जा सकता है)।

ulimit -s unlimited

(कोई सीमा नहीं)

Answer 4

अधिकांश प्रणालियों में, कमांड लाइन की लंबाई की सीमा होती है, जो किसी भी कार्यक्रम में, उपयोग xargsया करने के लिए पारित की जाती है -exec command {} +। से man find:

-exec command {} +
      This  variant  of the -exec action runs the specified command on
      the selected files, but the command line is built  by  appending
      each  selected file name at the end; the total number of invoca‐
      tions of the command will  be  much  less  than  the  number  of
      matched  files.   The command line is built in much the same way
      that xargs builds its command lines.  Only one instance of  `{}'
      is  allowed  within the command.  The command is executed in the
      starting directory.

चालान बहुत कम होंगे, लेकिन एक होने की गारंटी नहीं। कमांड लाइन के तर्क के आधार पर, आपको स्टन से स्क्रिप्ट में NUL से अलग किए गए फ़ाइल नाम को पढ़ना चाहिए -o -। मैं कुछ ऐसा करूंगा:

$ find . -name something.txt -print0 | myscript -0 -o -

और उसके myscriptअनुसार विकल्प तर्कों को लागू करें ।

Comments

हां, ओएस तर्कों की संख्या / आकार में एक सीमा लगाता है जिसे पारित किया जा सकता है। आधुनिक लिनक्स सिस्टम पर यह (विशाल) ( linux.die.net/man/2/execve ) (स्टैक आकार का 1/4, 0x7FFFFFFF तर्क) है। AFAIK बैश अपने आप में कोई सीमा नहीं है। मेरी सूचियां बहुत छोटी हैं, और मेरी समस्या गलतफहमी या गलत-याद करने के कारण थी कि कैसे xargsकाम करता है। आपका समाधान वास्तव में सबसे मजबूत है, लेकिन यह इस मामले में ओवरकिल है।

— एलेक्सिस

Answer 5

बैकटिक (या $ (...)) के विस्तार में रिक्त स्थान की रक्षा करने का कोई तरीका नहीं है?

नहीं, वहाँ नहीं है। ऐसा क्यों है?

बैश को यह जानने का कोई तरीका नहीं है कि क्या संरक्षित किया जाना चाहिए और क्या नहीं।

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

तो आपको क्या करना है यदि आप चाहते हैं कि एक सरणी एक बाइट प्रारूप को परिभाषित करे जिसमें एक सरणी हो, और यही उपकरण है जैसे xargsऔर findक्या करें: यदि आप उन्हें -0तर्क के साथ चलाते हैं , तो वे एक बाइनरी सरणी प्रारूप के अनुसार काम करते हैं जो तत्वों को समाप्त करता है अशक्त बाइट, अन्यथा अपारदर्शी बाइट स्ट्रीम के लिए शब्दार्थ जोड़ना।

दुर्भाग्य से, bashनल बाइट पर स्ट्रिंग्स को विभाजित करने के लिए कॉन्फ़िगर नहीं किया जा सकता है। हमें दिखाने के लिए /unix//a/110108/17980 का धन्यवाद zsh।

xargs

आप चाहते हैं कि आपकी आज्ञा एक बार चले, और आपने कहा कि xargs -0 -n 10000आपकी समस्या का हल है। ऐसा नहीं है, यह सुनिश्चित करता है कि यदि आपके पास 10000 से अधिक पैरामीटर हैं, तो आपकी कमांड एक से अधिक बार चलेगी।

यदि आप इसे सख्ती से या तो एक बार चलाना चाहते हैं या विफल रहते हैं, तो आपको -xतर्क और -nतर्क को तर्क से बड़ा प्रदान करना होगा -s(वास्तव में: इतना बड़ा कि शून्य-लंबाई वाले तर्कों का एक पूरा गुच्छा और साथ ही कमांड का नाम इसमें फिट नहीं होता है) -sआकार)। ( आदमी xargs , नीचे अंश देखें)

वर्तमान में मैं जिस सिस्टम पर हूं, वह लगभग 8M तक सीमित है, इसलिए यहां मेरी सीमा है:

$ printf '%s\0' -- {1..1302582} | xargs -x0n 2076858 -s 2076858 /bin/true
xargs: argument list too long
$ printf '%s\0' -- {1..1302581} | xargs -x0n 2076858 -s 2076858 /bin/true
(no output)

दे घुमा के

यदि आप किसी बाहरी कमांड को शामिल नहीं करना चाहते हैं, तो पढ़ा गया लूप एक सरणी खिलाता है, जैसा कि /unix//a/110108/17980 में दिखाया गया है , चीजों को विभाजित करने के लिए बैश का एकमात्र तरीका है नल बाइट।

( . ... "$@" )स्टैक के आकार की सीमा से बचने के लिए स्क्रिप्ट को स्रोत बनाने का विचार अच्छा है (मैंने यह कोशिश की, यह काम करता है!), लेकिन शायद सामान्य परिस्थितियों के लिए महत्वपूर्ण नहीं है।

यदि आप स्टड से कुछ और पढ़ना चाहते हैं, तो प्रक्रिया पाइप के लिए एक विशेष एफडी का उपयोग करना महत्वपूर्ण है, लेकिन अन्यथा आपको इसकी आवश्यकता नहीं होगी।

इसलिए, रोजमर्रा की घरेलू जरूरतों के लिए सबसे सरल "देशी" तरीका:

files=()
while IFS= read -rd '' file; do
    files+=("$file")
done <(find ... -print0)

myscriptornonscript "${files[@]}"

यदि आपको अपनी प्रक्रिया पेड़ की तरह साफ और देखने में अच्छी लगती है, तो यह विधि आपको करने की अनुमति देती है exec mynonscript "${files[@]}", जो मेमोरी से बैश प्रक्रिया को हटा देती है, इसे तथाकथित कमांड से बदल दिया जाता है। xargsहमेशा याद में रहेगा जब तक कि कमांड चलता है, भले ही कमांड केवल एक बार चलने वाला हो।

---

देशी बैश विधि के खिलाफ क्या बोलता है:

$ time { printf '%s\0' -- {1..1302581} | xargs -x0n 2076858 -s 2076858 /bin/true; }

real    0m2.014s
user    0m2.008s
sys     0m0.172s

$ time {
  args=()
  while IFS= read -rd '' arg; do
    args+=( "$arg" )
  done < <(printf '%s\0' -- $(echo {1..1302581}))
  /bin/true "${args[@]}"
}
bash: /bin/true: Argument list too long

real    107m51.876s
user    107m38.532s
sys     0m7.940s

ऐश हैंडलिंग के लिए बैश को अनुकूलित नहीं किया गया है।

---

आदमी xargs :

-एन मैक्स-आर्ग्स

प्रति कमांड लाइन में अधिकतम अधिकतम-आर्ग्यूमेंट तर्क का उपयोग करें। अधिकतम-आर्ग्यूमेंट तर्क से कम का उपयोग किया जाएगा यदि आकार (-s विकल्प देखें) को पार कर जाता है, जब तक कि -x विकल्प नहीं दिया जाता है, जिस स्थिति में xargs बाहर निकल जाएगा।

-s अधिकतम-वर्ण

प्रति पंक्ति में अधिकतम-वर्ण वर्णों का उपयोग करें, जिसमें कमांड और प्रारंभिक-तर्क और तर्क तार के सिरों पर समाप्ति नल शामिल हैं। सबसे बड़ी अनुमत मूल्य प्रणाली-निर्भर है, और निष्पादन के लिए तर्क लंबाई सीमा के रूप में गणना की जाती है, आपके वातावरण का आकार कम, हेडरूम के 2048 बाइट्स। यदि यह मान 128KiB से अधिक है, तो डिफ़ॉल्ट मान के रूप में 128Kib का उपयोग किया जाता है; अन्यथा, डिफ़ॉल्ट मान अधिकतम है। 1KiB 1024 बाइट्स है।

-एक्स

यदि आकार (-s विकल्प देखें) से अधिक हो तो बाहर निकलें।

Comments

सभी परेशानी के लिए धन्यवाद, लेकिन आपका मूल आधार इस तथ्य को नजरअंदाज करता है कि बैश सामान्य रूप से उद्धरण प्रसंस्करण की एक विस्तृत प्रणाली का उपयोग करता है। लेकिन बैकॉक विस्तार में नहीं। निम्नलिखित की तुलना करें (जो दोनों त्रुटियां देते हैं, लेकिन अंतर दिखाते हैं): ls "what is this"बनाम ls `echo '"what is this"'` । किसी ने backquotes के परिणाम के लिए उद्धरण प्रसंस्करण को लागू करने की उपेक्षा की।

— एलेक्सिस

मुझे खुशी है कि बैकक्वाटर बोली प्रसंस्करण नहीं करते हैं। तथ्य यह है कि वे शब्द विभाजन भी करते हैं, आधुनिक कंप्यूटिंग इतिहास में पर्याप्त उलझन में लग रहा है, सिर खरोंच और सुरक्षा दोष है।

— क्लैके

सवाल यह है कि "बैकटिक (या $(...)) विस्तार में रिक्त स्थान की सुरक्षा के लिए कोई रास्ता नहीं है ?", इसलिए प्रसंस्करण को अनदेखा करना उचित लगता है जो उस स्थिति में नहीं किया जाता है।

— क्लैके

अशक्त-तत्व तत्व सरणी प्रारूप किसी सरणी को व्यक्त करने का सबसे सरल और सबसे सुरक्षित तरीका है। यह सिर्फ एक शर्म की बात है कि bashयह मूल रूप से समर्थन नहीं करता है जैसे कि जाहिरा तौर पर zshकरता है।

— क्लैकी

वास्तव में, बस इस हफ्ते मैंने इस्तेमाल किया printf "%s\0"और xargs -0एक उद्धृत स्थिति के आसपास मार्ग करने के लिए जहां एक मध्यवर्ती उपकरण एक शेल द्वारा पार्स स्ट्रिंग के माध्यम से मापदंडों को पारित करेगा। उद्धरण हमेशा आपको काटने के लिए वापस आता है।

— क्लैके