क्या यह चिंता है कि \x1e का प्रतिनिधित्व करने का कोई तरीका नहीं है? या आप वास्तु सुधार के बारे में सोच रहे हैं?

मुझे लगता है कि सरणी विभाजक मुख्य रूप से उन जगहों पर सरणियों को बनाए रखने में उपयोग किया जाता है जो केवल तार लेते हैं, जैसे सार्वभौमिक चर या पर्यावरण चर।

2012-12-12 2:09，"Ridiculousfish" [email protected]写道：

क्या यह चिंता है कि \x1e का प्रतिनिधित्व करने का कोई तरीका नहीं है? या आप सोच रहे हैं
वास्तु सुधार के बारे में?

मैं कहूंगा कि मेरे मन में दोनों चिंताएं हैं। पूर्व के लिए, बस a . के बारे में सोचें
एम्बेडेड \x1e के साथ फ़ाइल नाम। POSIX कुछ भी कहता है लेकिन \0 की अनुमति है
फ़ाइल नाम, इसलिए यह पूरी तरह से संभव है। \0 का उपयोग सरणी सीमांकक के रूप में हो सकता है
थोड़ा बेहतर विकल्प, लेकिन यह दूसरी चिंता की ओर ले जाता है - यह
नाजुक और स्पष्ट रूप से गलत।

मुझे लगता है कि सरणी विभाजक मुख्य रूप से स्थानों में सरणियों को बनाए रखने में उपयोग किया जाता है
जो केवल तार लेते हैं, जैसे सार्वभौमिक चर या पर्यावरण चर।

यदि बने रहने का अर्थ है "क्रमबद्ध", नहीं। Arrays को हमेशा स्टोर किया जाता है
\x1e-सीमांकित प्रपत्र। निर्यातित पर्यावरण सरणियाँ ":" से जुड़ती हैं। वे
हालांकि सार्वभौमिक चर में उपयोग किया जाता है - जिसे आईएमएचओ लागू किया जाना चाहिए
इसके बजाय उचित भागने के साथ।

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें।

निजी उपयोग क्षेत्र चरित्र को विभाजक के रूप में उपयोग करने के बारे में कैसे? मछली पहले से ही कुछ मामलों में उनमें से कुछ का उपयोग करती है।

@JanKanis यह बेहतर नहीं है; फ़ाइल नामों में यह पूरी तरह से संभव है (गैर-utf8, देशी एन्कोडिंग का उपयोग कर फाइल सिस्टम पर विचार करना) और अन्य तारों पर।

मैं कहूंगा कि दूसरों के बीच, "\0" दूसरों के बीच एक _slightly_ बेहतर विकल्प है, क्योंकि यह यूनिक्स फ़ाइल नामों में एकमात्र चरित्र है, लेकिन यह अभी भी मेरे लिए खराब गंध है। इसके अलावा, हम पहले से ही बहुत सारे बंटवारे और सरणियों के संयोजन कर रहे हैं, मैं बेहतर वास्तुकला और कम कोड दोनों के परिणामस्वरूप सच्चे सरणियों को लागू करने की अपेक्षा करता हूं।

मछली पहले से ही निजी उपयोग के पात्रों और अमान्य बाइट्स को संभालती है जब यह बाहरी तारों को wchars में एन्कोड करती है। इन विशेष मूल्यों को बाइट द्वारा बाइट को निजी उपयोग वर्णों के एक विशिष्ट सेट में एन्कोड किया जाता है जिसे मछली भी आउटपुट पर फिर से डीकोड करती है, इसलिए सिद्धांत रूप में एक और निजी उपयोग चार का उपयोग कर काम कर सकता है। हालाँकि मैं मानता हूँ कि सच्चे सरणियों का उपयोग करना बहुत बेहतर है। मछली और फिशड के बीच संचार में एक जटिलता utf8 स्ट्रिंग्स का उपयोग करके सॉकेट पर होती है, और वहां मछली सरणी वस्तुओं को अलग करने के लिए एस्केप अनुक्रम "\ x1e" (0x1e बाइट के बजाए) का उपयोग करती है (मुझे लगता है)। लेकिन शायद इसका उपयोग करके हल किया जा सकता है उदाहरण के लिए एक निजी अप्रयुक्त एस्केप अनुक्रम।

मैं xiaq की चिंताओं को साझा करता हूं, लेकिन (व्यावहारिक लोगों के लिए) मुझे \n रास्ते में निहित विभाजन अधिक आक्रामक लगता है:

a<strong i="6">@raspeball</strong> ~> count (printf 'a\x1eb')
1
a<strong i="7">@raspeball</strong> ~> count (printf 'a\nb')
2

सबप्रोसेस आउटपुट की (न्यूलाइन सीमांकित) सरणी व्याख्या स्पष्ट और वैकल्पिक होनी चाहिए!

लेकिन इसका शायद सरणियों के अंतर्निहित भंडारण से कोई लेना-देना नहीं है ...

@xiaq : \0 का उपयोग करने में क्या गलत है? xargs इसे अपने "विश्वसनीय" विकल्प के रूप में उपयोग करता प्रतीत होता है।

आप पर्यावरण चर में \0 का उपयोग नहीं कर सकते हैं, इसलिए यह बच्चे के गोले में सरणियों को निर्यात करना कठिन बना देगा।

मैं zsh से माइग्रेट कर रहा हूं, जहां मैं इस क्रम का उपयोग $LESS env var को इसके "बंधे" चर सुविधा का लाभ उठाकर एक समझदार फैशन में परिभाषित करने के लिए करता हूं:

typeset -xT LESS less ' '
less=(
    --HILITE-UNREAD
    --LONG-PROMPT
)

मैंने संक्षिप्तता के लिए विकल्पों की पूरी सूची को छोड़ दिया है। Zsh में जिसके परिणामस्वरूप $LESS env var $less सरणी में विकल्पों की एक स्थान से अलग सूची है। मछली में समतुल्य परिणाम तत्वों को रिकॉर्ड विभाजक (\x1e) वर्ण द्वारा अलग किया जा रहा है। दस्तावेज़ीकरण के बावजूद कि सरणी के तत्वों को रिक्त स्थान से अलग किया जाएगा (मॉड्यूलो विशेष सरणी जैसे पाथ)। मुझे स्पष्ट रूप से एक असाइनमेंट करना है जो अपेक्षित परिणाम प्राप्त करने के लिए मानों को एक स्ट्रिंग में इंटरपोलेट करता है:

set -x LESS --HILITE-UNREAD \
    --LONG-PROMPT
set LESS "$LESS"

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

पुनश्च, दस्तावेज़ीकरण में कहीं भी रिकॉर्ड विभाजक वर्ण (\x1e) का उल्लेख नहीं है। जो एक और समस्या है।

@ krader1961 इसे साझा करने के लिए धन्यवाद। सूची-जैसे पर्यावरण चर के लिए कोई मानक यूनिक्स सम्मेलन नहीं है - कुछ कोलन सीमांकित हैं, अन्य अंतरिक्ष सीमित हैं। मछली \x1e का उपयोग करती है ताकि यह अपने स्वयं के सरणी को अलग कर सके।

क्या आप कृपया हमें गलत दस्तावेज पर इंगित कर सकते हैं?

आपको क्या लगता है कि सरणियों का निर्यात कैसे किया जाता है - कोलन, स्पेस, न्यूलाइन, कुछ और? क्या मछली को इस चरित्र पर भी पर्यावरण चर को टोकन करना चाहिए?

ऐसा लगता है कि अंतरिक्ष-सीमांकित तर्कों की अपेक्षा कम है। संभवतः सबसे सरल उपाय है set -x LESS '--HILITE-UNREAD --LONG-PROMPT' , आदि।

पर्यावरण चर जैसी सूची के लिए कोई मानक नहीं है क्योंकि परिभाषा के अनुसार वे एक कुंजी और मान से बने बाइट्स का एक मनमाना अनुक्रम हैं जो एक समान चिह्न से अलग होते हैं और एक अशक्त बाइट द्वारा समाप्त होते हैं। उन्हें प्रिंट करने योग्य पात्र होने की भी आवश्यकता नहीं है। उच्च स्तर के अमूर्तता के लिए एकमात्र व्यापक रूप से स्वीकृत सम्मेलन PATH env var के लिए execlp() फ़ंक्शन द्वारा स्थापित किया गया है।

दस्तावेज़ीकरण त्रुटिपूर्ण है जहाँ तक यह \x1E, \036, 30, या "रिकॉर्ड विभाजक" वर्ण का उपयोग करने का कोई उल्लेख नहीं करता है जब एक से अधिक तत्वों के साथ एक var निर्यात करते समय एक सरणी के तत्वों को अलग करता है। दस्तावेज़ीकरण बताता है कि

..., and array variables will be concatenated using the space character.

यह http://fishshell.com/docs/current/index.html में "परिवर्तनीय विस्तार" अनुभाग से है। यह अनुमान लगाना उचित है कि यह कथन निर्यात किए गए वर्रों पर भी लागू होता है जो कि उसी दस्तावेज़ के "सरणी" और "विशेष चर" अनुभागों में प्रलेखित विशेष-आवरण नहीं हैं।

यह मेरी भावना है कि मछली को स्वचालित रूप से एनवी वर्र्स को कोलन-सीमांकित विशेष केस वर्र्स जैसे पीएटीएच के बाहर एक सूची में टोकननाइज़ नहीं करना चाहिए। हालांकि, एक मजबूत साधन होना चाहिए जिसके द्वारा एक उपयोगकर्ता एक मनमाना चरित्र पर एक सरणी में एक var को टोकन कर सकता है।

var आधार पर var पर उपयोग किए जाने वाले वर्ण को कॉन्फ़िगर करने के लिए एक तंत्र अनुपस्थित (ala zsh "टाइपसेट-टी" कमांड) सरणी के तत्वों को संयोजित करते समय एक स्थान का उपयोग किया जाना चाहिए (फिर से, कोलन से अलग विशेष-केस वर्र्स को छोड़कर ) जाहिर है कि यह निजी डेटा स्टोर पर लागू नहीं होता है जैसे कि यूनिवर्सल वेरिएबल्स का स्टोरेज।

अंत में, मुझे मानक मछली कार्यों में कोई उपयोग नहीं मिला जहां एक env var का उपयोग किसी अन्य फ़ंक्शन या स्क्रिप्ट में एक से अधिक तत्वों वाले सरणी को पास करने के लिए किया जाता है। इस तरह के उपयोग के मामले मौजूद हो सकते हैं, लेकिन इसके लिए स्क्रिप्ट की आवश्यकता होती है कि वे डेटा के क्रमांकन/deserialization में स्पष्ट रूप से सहयोग करें, न कि मछली पर भरोसा करने के लिए उन वार्स से सरणियों का पुनर्निर्माण करें जिनके तार में रिकॉर्ड विभाजक चरित्र होता है।

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

उपयोगकर्ता स्ट्रिंग को टोकननाइज़ कर सकते हैं जैसे set SOMEPATH (string split : $SOMEPATH) ।

निर्यातित चरों के अंतरिक्ष-संयोजन का नकारात्मक पक्ष यह है कि जब मछली को पुनरावर्ती रूप से चलाया जाता है तो वे बदल जाते हैं। आज यह काम करता है:

> set -x list 1 2 3
> count $list
3
> fish -c 'count $list'
3

लेकिन अगर हम रिक्त स्थान के साथ निर्यात करते हैं, तो यह रिकर्सिव कॉल के लिए 1 दिखाएगा। जैसा कि आप कहते हैं कि हम इस पर भरोसा नहीं करते हैं, लेकिन यह एक निरंतरता के दृष्टिकोण से अच्छा है।

आपकी विचारशील प्रतिक्रिया के लिए धन्यवाद।

मुझे वह दूसरा करना होगा! चीजों पर एक नया नजरिया रखना हमेशा अच्छा होता है।

इस चर्चा में नए लोगों के लिए, मुझे लगता है कि मुझे इससे संबंधित कुछ चीजों को लाना होगा।

सूची श्वेतसूची तुरंत दिमाग में आती है, जो #2090 जैसे मुद्दों में दिखाई देती है।

इसका मतलब है कि $PATH, $CDPATH और $MANPATH के लिए, वे मछली के लिए सूचियों/सरणी के रूप में दिखाई देंगे, लेकिन निर्यात होने पर, ":" के साथ फिर से जुड़ जाएंगे। फिर एक मछली के अंदर एक मछली उन्हें फिर से विभाजित कर देगी। यह कोलन पर काम करता है, न कि \x1e। कोड की मेरी समझ से ऐसा प्रतीत होता है कि यह प्रत्येक कोलन पर करता है, जिसमें बचने का कोई मौका नहीं होता है, इसलिए यह $PATH प्रविष्टियों को उनके अंदर एक कोलन के साथ तोड़ सकता है - जो यूनिक्स फ़ाइलपैथ के अंदर अनुमति देता है, हालांकि यह कम से कम $ PATH के लिए टूटा हुआ लगता है . इस योजना का उपयोग उदाहरण के लिए पायथनपाथ और गोपथ के लिए भी किया जाता है।

मुझे अंतर्निहित हमेशा-विभाजन-पर-\x1e-छोड़कर-इन-तीन-विभाजन-उन्हें-पर-कोलन की तुलना में पर्यावरण चर को विभाजित करने के लिए कुछ और अधिक स्पष्ट होना अच्छा लगेगा, क्योंकि यह वास्तव में दो अलग-अलग योजनाएं हैं one और वर्तमान में एक सूची निर्यात करना हमेशा मछली के अलावा सब कुछ भ्रमित करेगा।

मेरा पसंदीदा समाधान splitenv var1 var2 var3 जैसा फ़ंक्शन होगा:

function splitenv --no-scope-shadowing
    set -e IFS # string split doesn't have superpowers, so unset IFS lest we split on both : and \n
    for arg in $argv
        set -q $arg; and set $arg (string split ":" $$arg)
    end
end

(यदि string split में महाशक्तियां हों , तो यह थोड़ा आसान होगा)

निर्यात किए जाने पर सभी सूचियों को कॉलोन के साथ जोड़ दिया जाएगा, इसलिए एक उपयोगकर्ता स्पष्ट रूप से उन्हें splitenv के साथ जोड़ सकता है (हालांकि मैं एक सहायक फ़ंक्शन पर मृत-सेट नहीं हूं, मुझे विश्वास है कि यह तुच्छ बनाना एक अच्छा है बात करने के लिए)। पश्च-संगतता के लिए, स्टार्टअप पर splitenv PATH CDPATH MANPATH निष्पादित किया जाएगा। यदि कोई उपयोगकर्ता इसे अलग तरह से निर्यात करना चाहता है, तो string join उपलब्ध है।

इन सबका मतलब है कि हमें अब \x1e की आवश्यकता नहीं है, हमारे पास एक ऐसी योजना है जिसे कम से कम अन्य कार्यक्रमों द्वारा समझने का एक लड़ने का मौका है, लेकिन (बल्कि विदेशी आईएमएचओ) मछली-अंदर-मछली अब fish -c 'splitenv list; count $list' हो गई है .

समस्या यह है कि, जैसा कि उल्लेख किया गया है, सामान्य कोलन-सेपरेटेड-लिस्ट स्कीम में कोलन से बचने का कोई तरीका नहीं है, और यदि हम एक जोड़ना चाहते हैं, तो string split में "--unscaped" नहीं है। केवल अनछुए विभाजकों पर विभाजित करने का विकल्प।

क्या मैं कोई मतलब निकाल रहा हूँ?

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

बचने के संबंध में, पाथ में कोलन से बचने के लिए जानबूझकर आपके द्वारा प्राप्त लिंक के अनुसार नहीं है। मुझे संदेह है कि पायथनपैथ, क्लासस्पैट इत्यादि इस संबंध में और अधिक सुसंगत हैं। चूंकि आप इन पथों में कोलन का उपयोग नहीं कर सकते हैं, इसलिए हम चुन सकते हैं कि हम इससे बचेंगे या नहीं; लेकिन अगर हम एक कोलन से बचते हैं तो हमें बैकस्लाश से बचने की जरूरत है, और मैं शर्त लगा सकता हूं कि आपके पास पाथ में बैकस्लैश हो सकता है। हमें श्वेतसूची (उघ) "से बच नहीं" की आवश्यकता हो सकती है।

वैकल्पिक रूप से हम इसके बारे में चिंता नहीं करते हैं, और किसी भी बृहदान्त्र को सीमांकक के रूप में कार्य करने दें। मुझे लगता है कि मैं अन्य गोले के साथ सादगी और परिचितता के लिए इस ओर झुकता हूं।

हम अभी भी इस समस्या का सामना कर रहे हैं कि कुछ सूची-जैसे चर स्थान-सीमांकित हैं, और अन्य कोलन सीमांकित हैं। एक संभावना यह है कि splitenv एक सीमांकक स्वीकार करता है, इसे याद रखता है, और निर्यात पर मूल्य के पुनर्निर्माण के लिए इसका उपयोग करता है:

splitenv --on ' ' LESS
splitenv --on ':' PYTHONPATH

ये कॉल अब किसी भी मौजूदा चर को आयात करने की दोहरी भूमिका निभाते हैं, और यह चिह्नित करते हैं कि यह कैसे निर्यात किया जाता है। तुम क्या सोचते हो?

साथ ही, config.fish को संपादित किए बिना ऐसा करने का कोई तरीका है? शायद सार्वभौमिक चर के हिस्से के रूप में?

हम अभी भी इस समस्या का सामना कर रहे हैं कि कुछ सूची-जैसे चर स्थान-सीमांकित हैं, और अन्य कोलन सीमांकित हैं। एक संभावना यह है कि स्प्लिटेंव एक सीमांकक स्वीकार करता है, इसे याद रखता है, और निर्यात पर मूल्य के पुनर्निर्माण के लिए इसका उपयोग करता है:

सुनने में तो अच्छा लगता है। हालांकि उस समय स्प्लिटेंव को एक स्क्रिप्ट बनाने से शायद मदद नहीं मिलेगी, क्योंकि हमें वैसे भी सी ++ पक्ष से सहयोग की आवश्यकता होगी।

ये कॉल अब किसी भी मौजूदा चर को आयात करने की दोहरी भूमिका निभाते हैं, और यह चिह्नित करते हैं कि यह कैसे निर्यात किया जाता है।

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

हालांकि यह मुझे परेशान कर रहा है कि मुझे याद नहीं है कि हमने पहले कहां संबंधित चर्चा की है - मुझे लगता है कि मुझे आज रात फिर से मुद्दों को हल करना होगा।

उपयोगकर्ता स्ट्रिंग को टोकननाइज़ कर सकते हैं जैसे set SOMEPATH (string split : $SOMEPATH) ।

string कमांड कहीं भी दस्तावेज नहीं है जो मुझे मिल सकता है। साथ ही, man string स्ट्रिंग (3) मैन पेज दिखाता है जो बीएसडी (और मैक ओएस एक्स) पर स्ट्रिंग मैनिपुलेशन फ़ंक्शंस को दस्तावेज करता है।

लेकिन अगर हम रिक्त स्थान के साथ निर्यात करते हैं, तो यह रिकर्सिव कॉल के लिए 1 दिखाएगा। जैसा कि आप कहते हैं कि हम इस पर भरोसा नहीं करते हैं, लेकिन यह एक निरंतरता के दृष्टिकोण से अच्छा है।

हालांकि यह व्यवहार हैरान करने वाला है। मैं शर्त लगाने के लिए तैयार हूं कि यदि आप 100 लोगों से पूछते हैं कि क्या होता है जब एक से अधिक तत्वों के साथ एक var निर्यात किया जाता है तो उनमें से 90 कहेंगे कि मान एक विभाजक के रूप में अंतरिक्ष के साथ जुड़े हुए हैं। कुछ लोग कह सकते हैं कि अल्पविराम या अन्य चार का उपयोग विभाजक के रूप में किया जाता है। और env चलाने वाले दो व्यक्ति कहेंगे कि मान बिना विभाजक के संयोजित हैं क्योंकि जब तक आप cat -evt जैसी किसी चीज़ के माध्यम से आउटपुट को फ़िल्टर नहीं करते हैं, रिकॉर्ड विभाजक वर्ण अदृश्य है।

जो #2090 . जैसे मुद्दों में दिखाई देता है

मुझे खेद है, लेकिन मुझे उस उपयोगकर्ता की शिकायत में कोई दम नजर नहीं आता। MANPATH पहले से ही सेट है या नहीं, यह स्पष्ट रूप से परीक्षण करके समस्या को तुच्छ रूप से हल किया गया है। जो, मुझे लगता है, कुछ ऐसा है जो आपको किसी भी घटना में करना है जो कि अग्रणी बनाम अनुगामी कोलन के शब्दार्थ को देखते हुए है।

इसलिए यह $PATH प्रविष्टियों को उनके अंदर एक कोलन के साथ तोड़ सकता है

इसे ठीक करने में कम से कम तीस साल बहुत देर हो चुकी है। हमें कोलन से बचने (और विस्तार से बचने वाले चरित्र) को लागू नहीं करना चाहिए क्योंकि यह गैर-मानक व्यवहार होगा। कुछ समय पहले तक मैंने UNIX सपोर्ट स्पेशलिस्ट के रूप में 20+ साल बिताए थे। मैंने कभी किसी को शिकायत करते नहीं सुना है कि $PATH या इसी तरह के चर में एम्बेडेड निर्देशिका में एक कोलन की उपस्थिति एक मुद्दा था।

मेरा पसंदीदा समाधान एक समारोह होगा जैसे splitenv var1 var2 var3

यह ठीक है, हालांकि यह स्पष्ट नहीं है कि क्यों (अनियंत्रित) string split पर्याप्त नहीं है। भले ही हमें एक नए फ़ंक्शन की आवश्यकता हो, हमें निश्चित रूप से कोई नया ऑटो-स्प्लिट एनवी वर्र्स नहीं जोड़ना चाहिए। केवल दो ही सामान्य हैं जो उस व्यवहार को वारंट करने के लिए पर्याप्त हैं PATH और CDPATH (और MANPATH इसके पहले से ही विशेष-आवरण के बाद से)। अन्य संस्करण जैसे PYTHONPATH को उपयोगकर्ता द्वारा स्पष्ट रूप से विभाजित किया जा सकता है यदि उन्हें यह उपयोगी लगता है।

हालांकि, यह कहने के बाद कि निश्चित रूप से यह पंजीकृत करने का एक तरीका होना चाहिए कि किसी दिए गए संस्करण (उदाहरण के लिए, पायथनपैथ) के तत्वों को निर्यात होने पर एक विशिष्ट विभाजक चार के साथ संयोजित किया जाना चाहिए। ऐसा करने का सबसे स्वाभाविक तरीका set कमांड के लिए एक नया विकल्प है। उदाहरण के लिए,

set -x -S ':' PYTHONPATH dir1 dir2 dir3

यह प्रभावित नहीं करेगा कि var को सार्वभौमिक var डेटा स्टोर में कैसे संग्रहीत किया जाता है जहां रिकॉर्ड-विभाजक चार का अभी भी उपयोग किया जाएगा और उस डेटा स्टोर से लोड होने पर यह स्वतः-विभाजित हो जाएगा। यह निर्धारित किया जाना है कि निर्यात के लिए पंजीकृत विभाजक चार स्ट्रिंग इंटरपोलेशन को भी प्रभावित करना चाहिए या नहीं। मेरी भावना यह है कि चाहिए। यही है, यदि उपरोक्त "सेट" कमांड को निष्पादित किया जाता है, तो एक अनुवर्ती

echo "PYTHONPATH is $PYTHONPATH"

PYTHONPATH के मूल्यों को संयोजित करने के लिए स्थान के बजाय एक बृहदान्त्र का उपयोग करना चाहिए। डिफ़ॉल्ट विभाजक मौजूदा शब्दार्थ को संरक्षित करने और उपयोगकर्ता के लिए आश्चर्य को कम करने के लिए एक स्थान है। ध्यान दें कि PATH जैसे विशेष-आवरण वाले संस्करण भी उस उदाहरण में एक कोलन का उपयोग करेंगे। जो वर्तमान व्यवहार के साथ असंगत है लेकिन नए शब्दार्थ के अनुरूप है और कम आश्चर्यजनक है। दूसरे शब्दों में, निर्यात किए गए वातावरण में $PATH के तत्वों को कॉलन द्वारा अलग क्यों किया जाता है, लेकिन के आउटपुट में रिक्त स्थान होते हैं

echo "PATH is $PATH"

स्ट्रिंग कमांड कहीं भी दस्तावेज नहीं है जो मुझे मिल सकता है। साथ ही, मैन स्ट्रिंग स्ट्रिंग (3) मैन पेज दिखाता है जो स्ट्रिंग मैनिपुलेशन फ़ंक्शंस को बीएसडी (और मैक ओएस एक्स) पर दस्तावेज करता है।

आराम से बाघ। यह विकास संस्करणों में है - https://github.com/fish-shell/fish-shell/blob/master/doc_src/string.txt देखें

यह ठीक है, हालांकि यह स्पष्ट नहीं है कि क्यों (अनियंत्रित) स्ट्रिंग विभाजन पर्याप्त नहीं है।

मेरा मूल विचार यह था कि यह एक सुविधा कार्य है इसलिए यह ऑपरेशन पूरी तरह से छोटा हो जाता है। @ridiculousfish के प्रस्ताव के साथ यह कुछ और हो जाता है और किसी प्रकार के स्टोर को समायोजित करता है ताकि निर्यात किए जाने पर चर भी उस चरित्र में शामिल हो जाए। string split सिर्फ एक कमांड है जो एक स्ट्रिंग को विभाजित करता है - मूल रूप से cut का हमारा संस्करण।

ऐसा करने का सबसे स्वाभाविक तरीका सेट कमांड के लिए एक नया विकल्प है।

यह एक और विकल्प है, हालांकि मैं पूरी तरह से अर्थशास्त्र पर बेचा नहीं गया हूं। जैसे set -S ':' PYTHONPATH । क्या यह PYTHONPATH को खाली सूची में सेट करेगा या यह मौजूदा PYTHONPATH को विभाजित करेगा? अब तक सभी सेट विकल्पों ने पूर्व किया है, इसलिए आपको set -S ':' PYTHONPATH $PYTHONPATH करना होगा। या हम इसे _not_ कर देंगे और उसी टूल में असंगति होगी।

दूसरे शब्दों में, निर्यात किए गए वातावरण में $PATH के तत्वों को कोलन द्वारा अलग क्यों किया जाता है लेकिन echo "PATH is $PATH" के आउटपुट में रिक्त स्थान होते हैं

यह वास्तव में एक अच्छा सवाल है। बेशक आप विभाजक से for p in $PATH; echo $p; end कहने की अपेक्षा नहीं करेंगे, लेकिन प्रति-चर विभाजक चार के साथ इसमें शामिल होना सही काम हो सकता है। बेशक इसे मैन्युअल रूप से करने के लिए string join है।

हालांकि यह व्यवहार हैरान करने वाला है। मैं शर्त लगाने के लिए तैयार हूं कि यदि आप 100 लोगों से पूछते हैं कि क्या होता है जब एक से अधिक तत्वों के साथ एक var निर्यात किया जाता है तो उनमें से 90 कहेंगे कि मान एक विभाजक के रूप में अंतरिक्ष के साथ जुड़े हुए हैं।

डिज़ाइन-दर-सर्वेक्षण और मछली करने में एक सामान्य समस्या है। क्योंकि सर्वेक्षण किए गए लोगों को अक्सर बैश (और कुछ हद तक अन्य POSIXy गोले) का ज्ञान होता है, जबकि मछली का विचार कम से कम कुछ POSIX को छोड़कर कुछ _better_ करना है।

इसका मतलब यह नहीं है कि यह पूरी तरह से बेकार है, यह सिर्फ ध्यान में रखने वाली बात है - अगर हम इस तरह के विचारों से चिपके रहते हैं, तो हमारे पास बैश का शब्द-विभाजन व्यवहार और इफ-फाई होगा।

क्या set -S ':' PYTHONPATH PYTHONPATH को खाली सूची में सेट करेगा या यह मौजूदा PYTHONPATH को विभाजित करेगा?

यह इसे एक खाली सूची में सेट कर देगा। यदि उपयोगकर्ता मौजूदा मूल्य को बनाए रखना चाहता है तो उन्हें इसे स्पष्ट रूप से शामिल करना होगा (नीचे देखें)।

निर्यात या प्रक्षेप के लिए किसी दिए गए संस्करण के सरणी तत्वों को संयोजित करते समय उपयोग किए जाने वाले वर्ण (या खाली स्ट्रिंग) को कॉन्फ़िगर करने के साधन के अपवाद के साथ हमारे पास पहले से ही सभी आवश्यक क्षमताएं हैं। अगर कोई PYTHONPATH जैसे var में हेरफेर करना चाहता है तो वे इसे एक साधारण स्ट्रिंग के रूप में मान सकते हैं:

set PYTHONPATH "/a/new/dir:$PYTHONPATH"

या वे इसे एक सरणी के रूप में मान सकते हैं:

set -S ":" PYTHONPATH /a/new/dir (string split ":" $PYTHONPATH)

ध्यान दें कि स्ट्रिंग में इंटरपोलेट करते समय स्पेस के बजाय स्प्लिट/कॉन्सटेनेशन कैरेक्टर का उपयोग करने का मेरा प्रस्ताव लगातार व्यवहार प्रदान करता है चाहे उपयोगकर्ता var को सरणी में विभाजित करता हो या नहीं।

मैं निश्चित रूप से समिति द्वारा डिजाइन का सुझाव नहीं दे रहा हूं। इस तरह zsh की तरह पागलपन और फर्जीवाड़ा है। मैं केवल यह इंगित कर रहा हूं कि जब दो या दो से अधिक विकल्प दिए जाते हैं, तो एक दूसरे को चुनने का कोई अन्य कारण नहीं होता है, तो उस विकल्प को चुनना जो शेल के उपयोगकर्ता को कम से कम आश्चर्यचकित करेगा, सबसे अच्छा विकल्प है। यही कारण है कि मैं (फिलहाल) नए आदेशों या व्यवहारों जैसे ऑटो-स्प्लिटिंग वर्र्स (पाथ और सीडीपीएटीएच के अलावा, निश्चित रूप से) को पेश करने का विरोध कर रहा हूं। यह इस तरह की चीज है जो अक्सर और आमतौर पर केवल config.fish और एनाकोंडा की "सक्रिय" स्क्रिप्ट जैसे कुछ विशेष कार्यों में की जाती है। और बाद वाले को सही ढंग से व्यवहार करने का तरीका इस बात की परवाह किए बिना कि उपयोगकर्ता ने पहले से ही var को अपने config.fish में एक सरणी में विभाजित किया है या नहीं, इसे हमेशा एक स्ट्रिंग के रूप में माना जाता है जिसे विभाजित करने की आवश्यकता होती है। उदाहरण के लिए, यदि PYTHONPATH को संशोधित करने की आवश्यकता है तो यह ऐसा कुछ कर सकता है:

# Hypothetical snippet from the Anaconda activate script.
if test (count PYTHONPATH) -gt 1
    set -S ':' PYTHONPATH /activated/python/tree $PYTHONPATH
else
    set PYTHONPATH "/activated/python/tree:$PYTHONPATH"
end

या, अधिक सरलता से,

# Hypothetical snippet from the Anaconda activate script.
set -S ':' PYTHONPATH /activated/python/tree (string split ':' $PYTHONPATH)

हां, यह संभावित रूप से एक सरणी में एक साधारण स्ट्रिंग हो सकता है। लेकिन मेरे नियम के साथ कि -S स्विच द्वारा निर्दिष्ट वर्ण का उपयोग तब किया जाता है जब उस रूपांतरण को एक सरणी में निर्यात और इंटरपोल करना अभ्यास में कोई फर्क नहीं पड़ता। हालाँकि, एक कोने का मामला है। क्या होता है यदि उपयोगकर्ता ने स्पष्ट रूप से var को अपने config.fish में एक सरणी में परिवर्तित नहीं किया है और फिर वह उपरोक्त काल्पनिक स्क्रिप्ट की तरह कुछ चलाता है। वर संभावित रूप से एक बहु-तत्व सरणी बन जाता है जिसका अर्थ है कि यदि वे बाद में करते हैं

for elem in $PYTHONPATH
   echo $elem
end

यह कोलन से अलग निर्देशिकाओं के रूप में मूल्य के साथ केवल एक बार लूप के शरीर को निष्पादित नहीं करेगा क्योंकि उपयोगकर्ता उम्मीद कर सकता है क्योंकि वे काल्पनिक "सक्रिय" स्क्रिप्ट द्वारा किए गए विभाजन से अनजान थे। मुझे लगता है कि हम इसके साथ रह सकते हैं क्योंकि उपयोगकर्ता के लिए ऐसा कुछ करना प्रतिकूल होगा।

टीएल; डॉ मुझे लगता है कि सूचियों को उनके डिलीमीटर को "याद रखना" चाहिए और नीचे यही कारण है।

मैं उपरोक्त में से अधिकांश से सहमत हूं। एक बात जो अभी भी थकाऊ लगती है, वह यह है कि ऊपर दिए गए आदेश अभी भी अत्यधिक क्रियात्मक लगते हैं; यानी, कभी-कभी इनमें से कुछ कमांड को सादे अंग्रेजी में वर्णन करना आसान होता है।

एक उदाहरण के रूप में (और मैं लंबाई पर उतना ध्यान केंद्रित नहीं कर रहा हूं जितना कि बार-बार होने वाली चीजों की संख्या पर):

• मछली: set -S ':' PYTHONPATH /activated/python/tree (string split ':' $PYTHONPATH)
• अंग्रेज़ी: " /activated/python/tree से PYTHONPATH ( : -delimited`) जोड़ें"

यहां दो दोहराई गई चीजें हैं: PYTHONPATH और सीमांकक : । वह PYTHONPATH दोहराया जाना चाहिए, यकीनन दो कारणों से ठीक है, और इन दोनों में से कोई भी कारण सीमांकक पर लागू नहीं होता है।

1. जब कोई set PYTHONPATH /activated/python/tree $PYTHONPATH कहता है तो यह समझना मुश्किल नहीं है कि क्या हो रहा है, क्योंकि यह i = 2 + i जैसी चीजों के समान है, जो एक बहुत ही परिचित अवधारणा/मुहावरा है। (लेकिन हमारे पास अभी भी += जैसे शॉर्टकट हैं, इसलिए मैं नीचे --append ध्वज का प्रस्ताव करता हूं।) दूसरी ओर, जब लोग किसी सूची में शामिल होने के बारे में सोचते हैं, तो वे बंटवारे के बारे में नहीं सोचते हैं। और एक सीमांकक पर शामिल होना। वे पूरी सूची को किसी अन्य प्रारूप में बदलने, वास्तविक संचालन करने और इसे वापस रखने के बारे में नहीं सोचते हैं। उनके दिमाग में, वे स्वाभाविक रूप से इसे कुछ "आंतरिक" या "पसंदीदा" सीमांकक में बदलने के बजाय एक सीमांकक के रूप में पढ़ते हैं।
2. जोड़ने के लिए एक सादे set कमांड का उपयोग करना दो अलग-अलग सूचियों में शामिल होने के लिए एक और कमांड जोड़ने से बचाता है। दूसरी ओर, एक सीमांकक से दूसरे में परिवर्तित करना एक ऐसी चीज है जिसे हम आदर्श रूप से कभी नहीं चाहते कि उपयोगकर्ता मैन्युअल रूप से करे, ज्यादातर उपरोक्त कारणों से।

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

# Changes the delimiter for this list. This might be done in some global config file for common lists as this one.
set -S ':' --no-modify PYTHONPATH
# or, workaround if you don't want to add extra options to set:
set -S ':' PYTHONPATH $PYTHONPATH

# The actual append operation
set --prepend PYTHONPATH /activated/python/tree
# or, workaround if you don't want to add extra options to set:
set PYTHONPATH /activated/python/tree $PYTHONPATH

निहितार्थ/अनुवर्ती प्रश्न/आदि:

1. यह वर्तमान सुझाव के साथ काफी संगत है। यहां आवश्यक परिवर्तन हैं:
   
   
   
   • सीमांकक छड़ी बनाएं (संभवतः __fish_sep_PYTHONPATH के रूप में किसी अन्य चर का उपयोग करके)
   
   
   • (वैकल्पिक) एक ध्वज जोड़ें जिसे मैं वर्तमान में --no-modify पर कॉल कर रहा हूं, जो मछली को उसकी सामग्री को बदले बिना सूची के सीमांकक को बदलने के लिए कहता है। संभवतः उपरोक्त कारण (1) के कारण --append और --prepend झंडे भी जोड़ें। वैसे भी इसकी आवश्यकता नहीं है, जैसा कि ऊपर दिए गए समाधान से पता चलता है कि आज मछली में कैसे संलग्न और प्रीपेन्डिंग किया जाता है।
   
   
2. मछली में, सूचियों को कम से कम प्रथम श्रेणी के नागरिकों की तरह व्यवहार किया जाना चाहिए। इसका मतलब यह है कि सीमांकक को बदलने से स्ट्रिंग प्रतिनिधित्व बदलना चाहिए, न कि सूची प्रतिनिधित्व (जब तक कि सीमांकक तत्वों में से किसी एक में मौजूद न हो, जिस स्थिति में विभाजन अनिवार्य है)। उदाहरण के लिए, यदि आप सीमांकक को , से : में बदल रहे हैं, तो ["0:1", "2"] को ["0", "1", "2"] बनना चाहिए न कि ["0", "1,2"] (जो कि ऐसा तब होगा जब आप सूची का समर्थन करने वाली स्ट्रिंग को बदले बिना बस सीमांकक को बदल दें)। इस व्यवहार को वर्तमान व्यवहार और इस तथ्य के साथ अधिकतम संगतता होनी चाहिए कि वर्तमान में एक डिफ़ॉल्ट, अपरिवर्तनीय सीमांकक है।

यहाँ नीचे की रेखा है:

• इसमें बहुत कम टोकन शामिल हैं, और लगभग कुछ भी दोहराया नहीं जाता है।
• यह कई उपयोगकर्ताओं के मानसिक मॉडल के समानांतर है। उपयोगकर्ता इन शब्दों में सोचते हैं: "प्रीपेन्ड", "डिलीमीटर सेट करें", "संशोधित न करें"।
• यह इस कार्य को करने का एकमात्र सही तरीका प्रतीत होता है (पुराना तरीका अब अतिरिक्त अनाड़ी लगता है), और इसलिए ये जोड़ ऑर्थोगोनैलिटी को नष्ट नहीं करते हैं।

set --no-modify -S : PYTHONPATH
set --prepend PYTHONPATH /activated/python/tree

मेरे प्रस्ताव के बारे में विस्तृत टिप्पणी के लिए धन्यवाद, @szhu । हालाँकि, आपके प्रस्तावित समाधान में कई समस्याएं हैं। उदाहरण के लिए, --no-modify विकल्प का जोड़ वास्तव में चर को सूची में परिवर्तित करके संशोधित करता है और इस प्रकार चर को संशोधित करता है। जबकि मैंने आपके प्रस्ताव के लगभग सभी तत्वों को अस्वीकार कर दिया है, इसने मुझे एक अधिक सरल समाधान के बारे में सोचने पर मजबूर कर दिया, जो आपके सभी बिंदुओं पर, यदि सभी को नहीं, सबसे अधिक संबोधित करेगा। शायद मछली को यह बताने के लिए एक तंत्र होना चाहिए कि किसी दिए गए env var को हमेशा किसी दिए गए टोकन (उदाहरण के लिए, ":" या "") पर स्वचालित रूप से विभाजित और पुनर्गठित किया जाना चाहिए। इसे एक ऑटो-सरणी पदनाम कहा जा सकता है और जब किसी मौजूदा मान को निष्पादित किया जाता है तो वह पहले से ही एक सरणी नहीं होने पर तुरंत विभाजित हो जाएगा।

इस व्यवहार को सक्रिय करने के लिए सेट कमांड में एक नया विकल्प जोड़ा जा सकता है। हालांकि, मुझे चिंता है कि ऐसा करना अस्पष्ट है और बिना किसी मूल्य वाले चर को परिभाषित करने के रूप में व्याख्या की जा सकती है। क्या सेट कमांड में -ए टोकन विकल्प जोड़ना स्पष्ट होगा? उदाहरण के लिए:

set -x -A ':' PYTHONPATH

संभवतः यह किसी भी मौजूदा PYTHONPATH env var को एक कोलन पर विभाजित होने के बाद एक सरणी में परिवर्तित कर देगा। इसके विपरीत जब एक स्ट्रिंग में निर्यात या प्रक्षेपित किया जाता है तो मूल्यों को एक कोलन पर संयोजित किया जाता है। इसी तरह, भले ही उस समय कमांड निष्पादित होने के समय PYTHONPATH मौजूद नहीं था, ऑटो-सरणी विनिर्देश याद रखा जाएगा और बाद के उपयोग प्रभावित होंगे। उदाहरण के लिए, यह स्पष्ट रूप से एक सरणी बनाएगा:

set PYTHONPATH /a/path /b/path /c:/d/path

लेकिन उस आखिरी तर्क का क्या? क्या इसे स्वचालित रूप से दो टोकन में विभाजित किया जाना चाहिए?

ध्यान दें कि यह व्यवहार केवल निर्यात किए गए वर्रों पर लागू होना चाहिए और अन्यथा एक त्रुटि उठाई जाएगी। कुछ कोने के मामले भी हैं जिन्हें वर्तनी की आवश्यकता है। उदाहरण के लिए, क्या होगा यदि मूल ऑटो-विभाजन घोषणा में इस उदाहरण में मान शामिल हैं:

set -x -A ':' PYTHONPATH 'hello:goodbye' $PYTHONPATH

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

@ krader1961 , आपकी प्रतिक्रिया के लिए धन्यवाद। हालाँकि, आपको लगता है कि मैं चर को स्ट्रिंग से सूचियों में परिवर्तित कर रहा हूँ। मुझे लगता है कि आप मछली में एक महत्वपूर्ण अवधारणा को गलत समझ रहे हैं: प्रत्येक चर स्ट्रिंग्स की एक सूची है । स्ट्रिंग्स प्रतीत होने वाले चर वास्तव में लंबाई 1 की सूचियां हैं। मछली उन्हें लंबाई 0 या 2 या किसी अन्य लंबाई की सूचियों से अलग नहीं मानती है।

साथ ही, ध्यान दें कि जब आप सीमांकक बदलते हैं तो पर्यावरण चरों को पार करने के लिए उपयोग की जाने वाली अंतर्निहित स्ट्रिंग बदल सकती है, मछली के गुणों में से एक यह है कि उपयोगकर्ता को आम तौर पर डिलीमीटर के बारे में सोचने की आवश्यकता नहीं होती है। यही कारण है कि मैं अनुशंसा करता हूं कि सभी -S विकल्प यह निर्दिष्ट करता है कि इस सूची को स्ट्रिंग में कैसे परिवर्तित किया जाना चाहिए जब यह _exported बाहरी_ मछली हो। -S इन-फिश सूची प्रतिनिधित्व को नहीं बदलना चाहिए (उन मामलों को छोड़कर जहां लक्ष्य सीमांकक का उपयोग करके उस सूची का प्रतिनिधित्व करना असंभव है)।

वैसे, यहां एक उदाहरण है जो दिखाता है कि मेरा प्रस्ताव कितना साफ है। यहाँ एक चर $L को \x1e के डिफ़ॉल्ट सीमांकक में बदलने के लिए कोड दिया गया है। इसका किसी भी चर (किसी भी दायरे, किसी भी वस्तु की संख्या) पर बिल्कुल कोई प्रभाव नहीं पड़ेगा जो आज मछली में बनाया जा सकता है।

set -S \x1e L $L

एक और बात: --no-modify तर्कों का परिवार सिर्फ शॉर्टकट हैं। यहाँ उनके समकक्ष हैं:

| शॉर्टकट | समकक्ष |
| --- | --- |
| set [other args] --no-modify L | set [other args] L $L |
| set [other args] --prepend L $TOADD... | set [other args] L $TOADD... $L |
| set [other args] --append L $TOADD... | set [other args] L $L $TOADD... |

(मैंने पहले निम्नलिखित कहा है, लेकिन मुझे लगता है कि मैं अब इसे समझाते हुए एक बेहतर काम कर सकता हूं।) इस बात पर जोर देकर कि ये तीन तर्क कितने "गूंगा" हैं, कुछ सवाल कर सकते हैं कि क्या उनकी बिल्कुल भी आवश्यकता है। कोई यह बता सकता है कि मछली में ऑर्थोगोनैलिटी का एक डिजाइन सिद्धांत है । जब सभी चीजें ओर्थोगोनल होती हैं, तो इसका मतलब है कि किसी भी बड़े कार्य के लिए जो आप करना चाहते हैं, यह स्पष्ट होना चाहिए कि उस कार्य को करने के लिए कौन सी विशेषताओं को चुनना है - इसे करने का केवल एक ही सही तरीका होना चाहिए। यहां, मैं वास्तव में एक सूची में संशोधन को जोड़ने/जोड़ने/रोकने के लिए एक और तरीका जोड़ता हूं, लेकिन यह केवल इसलिए है क्योंकि मुझे लगता है कि समकक्षों को प्रतिस्थापित किया जा रहा है जो अनावश्यक रूप से वर्बोज़ हैं; वे संशोधित सूचियों को जोड़ने के सही तरीके नहीं होने चाहिए। इस बारे में स्वयं को समझाने का एक तरीका यह है कि आप इस बारे में सोचें कि आप किसी सूची में शामिल होने के बारे में कैसे सोचते हैं। आपको शायद लगता है कि " $TOADD को $L में जोड़ें" के बजाय " $L से $L $TOADD " पर सेट करें।

मुझे बताएं कि आप क्या सोचते हैं, और यदि यह मेरे प्रस्ताव के लिए अधिक ठोस मामला बनाता है। (इसके अलावा मेरे लिए चीजों को गलत समझना बहुत आम है इसलिए मुझे सही करने के लिए स्वतंत्र महसूस करें।)

@szhu मुझे इस बात की पूरी जानकारी है कि मछली के सभी संस्करण शून्य, एक या अधिक मानों की सूचियाँ हैं। आपने स्पष्ट रूप से मेरी पिछली टिप्पणियों को नहीं पढ़ा, जहां मैं स्पष्ट रूप से कहता हूं कि संबंधित सीमांकक को आंतरिक प्रतिनिधित्व को प्रभावित नहीं करना चाहिए या कैसे मूल्यों को सार्वभौमिक डेटा स्टोर (सीमांकक को संग्रहीत करने के अलावा) पर कायम रखा जाना चाहिए। आपने मेरे पिछले बिंदुओं को भी संबोधित नहीं किया। अपने अंतिम उदाहरण पर विचार करें:

set -S \x1e L $L

यदि L में पहले से ही दो या अधिक मान हैं तो उसे क्या करना चाहिए? संभवतः संबंधित सीमांकक को बदलने के अलावा और कुछ नहीं। क्या उस मामले में $L तर्क वैकल्पिक होगा? या इसे पहले मौजूदा सरणी को एक साधारण स्ट्रिंग में परिवर्तित करना चाहिए (संभावित रूप से मौजूदा डिलीमीटर का उपयोग करके संयोजित) फिर उस स्ट्रिंग को नए डिलीमीटर पर विभाजित करें? जैसा कि मैंने पहले कहा, शैतान विवरण में है।

अंततः स्थापित डिजाइनर और अनुरक्षक यह तय करेंगे कि आपके --no-modify कार्यों के परिवार को जोड़ा जाना चाहिए या नहीं, लेकिन मैं वोट नहीं देता क्योंकि वे अपनी लागत के सापेक्ष मेरी राय में पर्याप्त मूल्य नहीं जोड़ते हैं।

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

1. क्या $L में set -S \x1e L $L $ वैकल्पिक है?

set का मौजूदा व्यवहार नहीं बदलेगा। वर्तमान व्यवहार के तहत, set L $L L नहीं बदलता है और set L L को एक खाली सूची बनाता है। set -S \x1e L $L और set -S \x1e L के साथ भी।

1.1 क्या केवल सीमांकक बदलने के लिए set -S \x1e L $L अत्यधिक क्रियात्मक प्रतीत नहीं होता है?

थोड़ा। इसलिए मैं इसके लिए शॉर्टकट के रूप में --no-modify विकल्प का प्रस्ताव करता हूं।

लेकिन अगर यह शॉर्टकट मौजूद नहीं है तो मेरी योजना विफल नहीं होगी। हम पहले से ही हर दिन इस मुद्दे से निपटते हैं जब हम सूचियों को जोड़ते हैं: set PATH ~/.bin $PATH । इसलिए, इसी कारण से, मैं --prepend और --append का भी प्रस्ताव करता हूं।

2. रूपांतरण प्रक्रिया कैसे होगी?

मान लें कि हमारा पुराना सीमांकक \x1e है और हमारा नया है : , और हमारे पास एक मछली सूची है ["hello", "world"] ( hello\x1eworld के रूप में निर्यात किया गया)। रूपांतरण करने के दो बुनियादी तरीके हैं (" रूपांतरण विकल्प "):

1. ["hello", "world"] का उपयोग करें और इसे ["hello", "world"] में बदलें ( hello,world के रूप में निर्यात किया गया)
   लाभ: सूची प्रतिनिधित्व नहीं बदलता है।
2. hello\x1eworld का उपयोग करें और इसे ["hello\x1eworld"] में बदलें ( hello\x1eworld के रूप में निर्यात किया गया)
   लाभ: निर्यात किया गया मूल्य प्रतिनिधित्व नहीं बदलता है।

ध्यान दें कि यह UI परिप्रेक्ष्य से है, कार्यान्वयन परिप्रेक्ष्य से नहीं; हम इस बारे में बात कर रहे हैं कि यह उपयोगकर्ता को कैसा दिखता है। मैं अगले प्रश्न में कार्यान्वयन को कवर करूंगा। _नोट: यह शेष उत्तर नई सामग्री है जिसे मैंने ऊपर संबोधित नहीं किया है, जो आपके प्रश्नों से प्रेरित है। धन्यवाद!_

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

Vars का निर्यात स्वरूप बदलना। इस प्रकार, एक उपयोगकर्ता को सीमांकक बदलने की आवश्यकता होने का एकमात्र कारण उन प्रोग्रामों के लिए निर्यातित स्ट्रिंग को बदलना है जो पर्यावरण चर पढ़ते हैं। मछली में बनाई गई सूचियों के लिए, हम निश्चित रूप से रूपांतरण विकल्प 1 का उपयोग करेंगे, क्योंकि सूची के रूप में चर का अर्थ महत्वपूर्ण और अच्छी तरह से परिभाषित है, इसलिए हमें सूची प्रतिनिधित्व को संरक्षित करने की आवश्यकता है।

वर्रों का आयात प्रारूप बदलना। हालांकि, पर्यावरण चर जैसे PATH के लिए जो शुरू में मछली के बाहर बनाए गए हैं, हमें एक सूची के लिए, जिसमें पहले से ही एक सीमांकक है, हमें मछली को यह बताना होगा कि वह सीमांकक क्या है। इसके लिए हम रूपांतरण विकल्प 2 का उपयोग कर सकते हैं।

2.1 इसे कैसे लागू किया जाएगा?

मछली भले ही उपयोगकर्ता को यह जानने की आवश्यकता न हो, मछली वास्तव में सूचियों को तार के रूप में संग्रहीत करती है। चर x को hello\x1eworld के रूप में संग्रहीत किया जाता है। मेरे प्रस्ताव के तहत, एक और चर होगा, __fish_delimiter_x , जो चर के सीमांकक को निर्दिष्ट करता है x । यह अभी मौजूद नहीं है और इसलिए हम डिफ़ॉल्ट सीमांकक का उपयोग करते हैं, \x1e ।

रूपांतरण विकल्प 1 के लिए:

1. पुराने सीमांकक पर चर को विभाजित करें, जिसके परिणामस्वरूप कार्यान्वयन भाषा (C++) में एक सच्ची सूची है।
2. नए डिलीमीटर का उपयोग करके सूची में शामिल हों, जिसके परिणामस्वरूप एक नई स्ट्रिंग होगी।
3. नए सीमांकक को __fish_delimiter_x में सहेजें।

रूपांतरण विकल्प 1 के लिए, एक समान कार्यान्वयन:

1. चर में, पुराने सीमांकक की सभी घटनाओं को नए के साथ बदलें।
2. नए सीमांकक को __fish_delimiter_x में सहेजें।

रूपांतरण विकल्प 2 के लिए:

1. नए सीमांकक को __fish_delimiter_x में सहेजें।

2.2 यदि हमें दोनों रूपांतरण विकल्पों की आवश्यकता है, तो उपयोगकर्ता कैसे निर्दिष्ट करेगा कि किसका उपयोग करना है?

शायद हमारे पास दो विकल्प हो सकते हैं: विकल्प 1 के -D या --convert-delimiter और विकल्प 2 के लिए -d या --set-delimiter ।

2.3 क्या हमें वास्तव में दोनों विकल्पों की आवश्यकता है?

वर्तमान मछली के तहत हम यह मान लेना चुनते हैं कि हम मछली के बाहर जंगली में \x1e नहीं देखेंगे। यदि हम इसे डिफ़ॉल्ट सीमांकक के रूप में रखते हैं और यह धारणा रखते हैं, तो रूपांतरण विकल्प 1 सीमांकक को बदलने और सेट करने दोनों के लिए पर्याप्त है और हमें रूपांतरण विकल्प 2 की आवश्यकता नहीं होगी । (इस बारे में आश्वस्त होने का एक आसान तरीका यह महसूस करना है कि यदि धारणा सत्य है, तो बाहरी रूप से बनाई गई सूचियों को परिवर्तित करते समय, रूपांतरण विकल्प 1 का चरण "पुराने सीमांकक की सभी घटनाओं को नए के साथ बदलें" कुछ भी नहीं करेगा, संपूर्ण रूपांतरण को कम करेगा रूपांतरण विकल्प 2.)

@ridiculousfish , मैं इस पर भी आपकी प्रतिक्रिया की सराहना करता हूं, विशेष रूप से UI और कार्यान्वयन विवरण के संबंध में। धन्यवाद!

ऐसा लगता है कि यहां दो मुद्दे हैं। आइए पहले के बारे में बात करते हैं?

सही सरणी के लिए +1

क्या वह विभाजक चाल वास्तव में मछली के लिए आवश्यक है? पिंग #627

समस्या # 2106 के लिए मेरे फिक्स के प्रकाश में इसे फिर से देखना, जिसमें मैंने देखा कि चर मानों के लिए स्ट्रिंग प्रतिनिधित्व को सरणियों में बदलने के दो असंगत तरीके थे। जिनमें से एक ने गलत तरीके से खाली तत्वों को हटा दिया। मुख्य मुद्दा यह है कि class env_var_t wcstring के वेक्टर के बजाय wcstring पर आधारित है। प्रयास के लायक है या नहीं, यह बहस के लिए खुला है।

यदि आप इस मुद्दे का अनुसरण कर रहे हैं तो मैं आपको पीआर #4082 पर एक नज़र डालने और शायद परीक्षण करने के लिए प्रोत्साहित करता हूं। मैंने इसे संबोधित करने का सबसे अच्छा तरीका तय किया है कि zsh में समान नाम से सुविधा के समान "बंधे" चर हैं।

ऐसा लगता है कि इन कॉलोन-निर्यात सूचियों के आस-पास के प्रश्न और इस श्वेतसूची में कौन से envvars शामिल किए जाने चाहिए, यह अभी तक अनिश्चित है। इस मामले में वर्तमान स्थिति क्या है? क्या हम इस विषय के अंतिम समाधान की आशा कर सकते हैं? आज ही, मैं फिर से इस जाल में फंस गया कि LD_LIBRARY_PATH श्वेतसूची में नहीं है...

संक्षेप में: यूनिक्स पर्यावरण चर तार हैं, इसलिए सरणी-जैसे एनवी वर्र्स को एक डिलीमीटर का उपयोग करना चाहिए। अधिकांश कॉलन ($PATH) का उपयोग करते हैं; हालांकि सभी ($ कम) नहीं करते हैं। हम आयात/निर्यात (और वास्तव में इस तरह से काम करने के लिए उपयोग की जाने वाली मछली) पर सभी सरणी को सीमित करने के लिए कोलन का उपयोग करना चाहते हैं; समस्या यह है कि कुछ फ्लैट चर में कोलन होते हैं ($DISPLAY, $SSH_CONNECTION)।

लक्ष्य मछली के सरणी समर्थन के साथ सीमांकित चर को स्वाभाविक रूप से काम करना है। @szhu ने एक सीमांकक को ट्रैक करने के लिए set बढ़ाने का सुझाव दिया, लेकिन IMO set को बढ़ाना इसे संलग्न करने के लिए गलत जगह है:

• वेरिएबल को सेट करने और उसके डिलीमीटर को सेट करने के बीच कष्टप्रद बातचीत ( --no-modify प्रेरित करना)।
• परिसीमनकर्ता चर दायरे के साथ कैसे इंटरैक्ट करते हैं, इसके बारे में मुश्किल सवाल।
• सार्वभौमिक चर के आसपास की समस्याएं। हमें uvars को सीमांकक को याद रखना सिखाना होगा, और साथ ही लगभग --no-modify क्योंकि uvars के साथ इसके वर्तमान मान पर एक चर सेट करने का कोई तरीका नहीं है।

समीक्षा करने पर मैं @faho के splitenv विचार का समर्थन करता हूं। splitenv name मौजूदा चर को कोलन पर विभाजित करेगा, बस। यह आश्चर्यजनक रूप से सरल है। वे वेरिएबल्स जो कोलन का उपयोग नहीं करते हैं वे इतने दुर्लभ हैं कि हमें उनके लिए विशेष समर्थन की आवश्यकता नहीं है।

नकारात्मक पक्ष यह है कि मछली निर्यात की गई सरणियों को कोलन-सीमांकित स्ट्रिंग के रूप में फिर से आयात किया जाएगा; व्यवहार में मुझे लगता है कि यह दुर्लभ होगा।

यदि हम इससे बच सकते हैं तो हमें उपयोगकर्ताओं पर यह splitenv जटिलता नहीं डालनी चाहिए। इसलिए मैं एक कदम आगे जाना चाहता हूं, और सभी पर्यावरण चरों के लिए बृहदान्त्र श्वेतसूची का विस्तार करना चाहता हूं, जिनका नाम PATH में समाप्त होता है , जैसे LD_LIBRARY_PATH, PYTHONPATH, आदि। व्यवहार में यह लगभग हर समय सही काम करना चाहिए; इसके द्वारा काटे जाने वाला कोई भी व्यक्ति मूल्य को ठीक करने के लिए string join का उपयोग कर सकता है।

तो मैं क्या प्रस्तावित करता हूं (वास्तव में फाहो का प्रस्ताव):

• कोलन का उपयोग करके सभी सरणियों को निर्यात करें; कोई और ASCII रिकॉर्ड विभाजक नहीं।
• एक splitenv फ़ंक्शन लागू करें जो कोलन पर एक चर को विभाजित करता है। इसे मछली लिपि में लिखा जा सकता है।
• कोलन से अलग की गई श्वेतसूची को PATH में समाप्त होने वाले सभी चरों तक बढ़ाएं।

मेरा मानना ​​​​है कि यह कम से कम और संगत तरीके से कोलन-सीमांकित सरणी से जुड़े अधिकांश दर्द को संबोधित करेगा।

स्प्लिटेंव विचार के बारे में:

मान लें कि मैं चाहता हूं कि मछली एक ऐसी सूची का निर्यात करे जिसके आइटम में कोलन हों, उदाहरण के लिए: ["item1", "item:2"] । (मुझे नहीं लगता कि यह एक दुर्लभ घटना है, खासकर जब उपयोगकर्ता इनपुट को स्टोर करने के लिए सरणी का उपयोग किया जाता है।)

क्या सूची को item1:item:2 के रूप में निर्यात किया जाएगा? यदि ऐसा है, तो निर्यात के बाद मूल सूची को फिर से बनाना असंभव होगा।

साथ ही, चरों के लिए अपरिवर्तनीय श्वेतसूची का होना गलत लगता है, हालांकि श्वेतसूची का *?PATH होना कम गलत लगता है। (यह एक चर के रूप में सीमांकक को संग्रहीत करने के मेरे प्रस्ताव का एक और कारण था - श्वेतसूची को एक चर सेट करके बदला जा सकता है।)

@szhu तुम सही हो। Exported-lists-can't-contain-colons एक ऐसी समस्या है जिससे यूनिक्स पहले से ही पीड़ित है :

तब से \

इसलिए मुझे मछली के लिए समान सीमा (केवल निर्यात किए गए चर के लिए) शुरू करने के बारे में बहुत बुरा नहीं लगता।

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

मैं मानता हूं कि किनारे का मामला जहां प्रस्ताव अच्छी तरह से काम नहीं करता है, वह बहुत आम नहीं है, लेकिन मुझे डर है कि अगर लोग इसमें भाग लेते हैं तो यह वास्तव में बुरा होगा।

यहां एक उदाहरण दिया गया है जो केवल आंशिक रूप से तैयार किया गया है:

set -x TEST color:red 
set -x TEST2 color:red font:serif
set -x TEST_PATH color:red 
set -x TEST2_PATH color:red font:serif
exec fish
echo $TEST #=> color:red
echo $TEST2 #=> color:red:font:serif
echo $TEST_PATH #=> color red 
echo $TEST2_PATH #=> color red font serif

मैं कल्पना कर सकता हूं कि उपरोक्त को देखने के बाद बहुत से नए उपयोगकर्ता भ्रमित हो रहे हैं।

मुझे लगता है कि निम्नलिखित व्यवहार काफी अधिक सुखद होगा:

set -x TEST color:red 
set -x TEST2 color:red font:serif
set -x TEST_PATH color:red 
set -x TEST2_PATH color:red font:serif
exec fish
echo $TEST # color:red
echo $TEST2 # color:red font:serif
echo $TEST_PATH #=> color:red 
echo $TEST2_PATH #=> color:red font:serif

मुझे इस पर आपके और समुदाय के विचार चाहिए।

मौजूदा कोलन से क्यों नहीं बचते? यह भेद को बनाए रखेगा।

भागना मेरे लिए समझ में आता है।

क्या यह अभी भी भ्रमित हो सकता है कि एक चर एक सरणी है या नहीं, याद नहीं किया जाएगा?

set -x TEST2 color:red font:serif
set -x TEST2_PATH color:red font:serif
exec fish
echo $TEST2 # color\:red:font\:serif
echo $TEST2_PATH #=> color:red font:serif

हां। मेरी परिकल्पना यह है कि पथ सूचियों के बाहर निर्यात सरणियाँ आम नहीं हैं।

MANPATH का डबल कोलन (::) के लिए एक विशेष अर्थ है - #2090 देखें - क्या यह काम में एक स्पैनर फेंकता है?

मैं यह भी तर्क दूंगा कि किसी भी मामले में साइडकार वैरिएबल FISH_ARRAY_VARIABLES=FOO\t:\nBAR\t;\nBAZ\t-\n होने से मछली के उदाहरणों के लिए अन्य प्रक्रियाओं को परेशान किए बिना और "हम कर रहे हैं" की आवश्यकता के बिना सरणी चर को फिर से लेने के लिए एक अच्छा संकेत होगा मछली को शामिल करना अब" चेकर ..

पुन: https://github.com/fish-shell/fish-shell/issues/436#issuecomment -392409659 @zanchey
मैंने विस्तार से #2090 नहीं पढ़ा है, लेकिन मेरा मानना ​​है कि कोलन-सीमांकित-स्ट्रिंग और सरणी रूपों के बीच कनवर्ट करना पूरी तरह से निर्बाध है (सिवाय जब कोलन ~ प्रकट नहीं होता है ~ सरणी आइटम में दिखाई देता है)।

MANPATH में डबल-कोलन शामिल करने के लिए, बस एक खाली स्ट्रिंग जोड़ें जहां डबल कोलन दिखाई दे:

$ set -x MANPATH 1 2 '' 3
# Check if it's set
$ bash -c 'echo $MANPATH'
1:2::3

एक कोलन के साथ MANPATH शुरू करने के लिए, शुरुआत में बस एक खाली स्ट्रिंग आइटम जोड़ें:

$ set -x MANPATH '' 1 2 3
# Check if it's set
$ bash -c 'echo $MANPATH'
:1:2:3

मैंने यहां सब कुछ का पालन नहीं किया है, लेकिन एक उपयोगकर्ता के रूप में मैं "कोई कॉन्फ़िगरेशन नहीं" की वकालत करना चाहता हूं।
मुझे लगता है कि set -S और splitenv विन्यास के रूप हैं। कुछ उपयोगकर्ता उन्हें fish.config में करते हैं और PYTHONPATH को सरणी के रूप में संभालते हैं। अन्य लोग PYTHONPATH को सिंगल कोलन-सीमांकित शब्द के रूप में नहीं संभालेंगे। कॉपी-पेस्ट स्टैकओवरफ्लो सलाह और एक उपयोगकर्ता से दूसरे उपयोगकर्ता के लिए PYTHONPATH में हेरफेर करने वाली स्क्रिप्ट चलाना हमेशा काम नहीं करेगा ...

एक निश्चित "यदि यह PATH के साथ समाप्त होता है " नियम कॉन्फ़िगरेशन-मुक्त है और जितना आप प्राप्त कर सकते हैं उतना सही लगता है: +1:
(इस पर मेरी कोई राय नहीं है कि क्या यह पिछड़ी असंगति के लायक है)
हां, set -x TEST2_PATH color:red font:serif को color red font serif सरणी के रूप में आयात किया जाएगा लेकिन निर्यात चर के साथ यह सौदा है। आप यह समझे बिना कि यह कैसे काम करता है, आप वास्तव में एक निर्यात किए गए संस्करण को एक सरणी में सेट नहीं कर सकते।

हां। मेरी परिकल्पना यह है कि पथ सूचियों के बाहर निर्यात सरणियाँ आम नहीं हैं।

@ridiculousfish जो वर्तमान गोले में सच हो सकता है, लेकिन मुझे लगता है कि जैसे-जैसे मछली अधिक कर्षण प्राप्त करती है, उपयोगकर्ता मछली की मछली के गोले को सूची भेजने की क्षमता का लाभ उठाना चाह सकते हैं। मैं कल्पना कर सकता हूं कि अंततः ऐसे प्रोग्राम/प्लगइन्स हो सकते हैं जो मछली सत्र की स्थिति का प्रबंधन करते हैं (मैं कुछ वर्षों में इस टिप्पणी पर वापस जांच करूंगा कि यह सच है या नहीं), और सार्वभौमिक रूप से ऑटो-डी/क्रमबद्ध सूचियों में सक्षम होने के नाते उस कोड को और अधिक साफ और कम वर्कअराउंड-वाई बना देगा।

समान लेकिन थोड़ा अलग विचार: PATH को विशेष मामले के रूप में मानना ​​एक कालानुक्रमिक बढ़त का मामला है जिसे उपयोगकर्ता शायद तभी समझते हैं जब उनके पास गोले के विशिष्ट उपयोग के मामलों का इतिहास हो। यह मछली की सामान्य स्क्रिप्टिंग भाषा के रूप में उपयोग करने की क्षमता को सीमित करता है, और कुछ संभावित भविष्य के उपयोग के मामलों को सीमित करता है।

@ridiculousfish मुझे लगता है कि एक संभावित समाधान प्रत्येक पर्यावरण चर/सरणी को अपने विभाजक के साथ जोड़ना है (और आप '\x1e' या ' ' या ':' को डिफ़ॉल्ट के रूप में रख सकते हैं), और पर्यावरण चर बनाने वाला उपयोगकर्ता संघर्षों से बचने के लिए उपयुक्त विभाजक चुनने के लिए जिम्मेदार है। आदेश इस तरह हो सकता है: set --separator ':' TMP 1 2 3 । इस प्रकार उन प्रसिद्ध पर्यावरण चर के लिए, उपयोगकर्ता केवल संबंधित प्रसिद्ध विभाजक चुन सकते हैं जिन्हें अन्य कार्यक्रमों द्वारा भी पहचाना जा सकता है और मछली को अधिक कार्यक्रमों (जैसे पायथन) के साथ अधिक संगत बना सकते हैं।

उन लोगों के लिए जो केवल हाल की टिप्पणियों को पढ़ रहे हैं, बस एक नोट है कि @thuzf की set --separator अनुशंसा वही है जो set -S अनुशंसा इस पूरे थ्रेड में बार-बार उल्लिखित है। उस चर्चा पर अधिक संदर्भ प्राप्त करने के लिए, आप इस पृष्ठ को set -S के लिए grep कर सकते हैं।

@szhu पिछले set -S पर ध्यान न देने के लिए क्षमा करें। मूल रूप से मैं भी यही चाहता हूं। मैंने यह भी देखा कि इस नए विकल्प पर अन्य लोगों की कई चिंताएँ थीं। मैं नीचे इन चिंताओं पर अपने विचार दे सकता हूं (चूंकि मछली के सेट ने एक विकल्प के रूप में -s उपयोग नहीं किया है, मैं इसके बाद --separator -s का उपयोग करूंगा):

1. --no-modify कुछ संशोधित करता है। हां, और आपको नाम को स्पष्ट होने के लिए बदलना चाहिए, उदाहरण के लिए, --change-separator ।
2. कुछ कोने/मुश्किल मामले हैं। यह मूल रूप से अच्छी तरह से परिभाषित सिंटैक्स के कारण नहीं है, और अगर हम सिंटैक्स की सख्त परिभाषा देते हैं तो इसे स्वाभाविक रूप से टाला जा सकता है। उदाहरण के लिए:
   
   
   
   1. मूल विचार: परिभाषित होने पर प्रत्येक var (सूची) अपने स्वयं के विभाजक से जुड़ा होता है (डिफ़ॉल्ट ' ' है)। इस विभाजक का उपयोग तब किया जाएगा जब यह var स्ट्रिंग से बनाया गया है और जब इसे स्ट्रिंग में परिवर्तित किया जाता है (यह कुछ भाषाओं में एक सामान्य विचार है जैसे कि पायथन का join() फ़ंक्शन)। निर्यात किए जाने पर या जब उपयोगकर्ता ऐसा करना चाहता है तो एक var स्ट्रिंग में परिवर्तित हो जाता है।
   
   
   2. एनवी वर्र्स कैसे बनाएं
      
      
      
      
      
      1. set ENV_VAR a b c । बिना -s , हम डिफ़ॉल्ट विभाजक के रूप में ' ' चुनते हैं।
      
      
      
      2. set -s ':' ENV_VAR । इस मामले में, ENV_VAR एक खाली सूची के रूप में सेट है।
      
      
      
      3. set -s ':' ENV_VAR a b:c d e:f । इस मामले में, इस कोड को लिखने वाले उपयोगकर्ताओं को स्पष्ट रूप से समझना चाहिए कि ':' विभाजक है और समझते हैं कि ENV_VAR ['a b', 'c d e', 'f'] की तरह एक सरणी होगी और इसे 'a b:c d e:f' के रूप में निर्यात किया जाएगा। क्या होगा यदि आप चाहते हैं कि निर्यात किया गया ENV_VAR रिक्त स्थान से शुरू हो और रिक्त स्थान के साथ समाप्त हो? आपको एस्केप का उपयोग करना चाहिए जैसे: set -s ':' ENV_VAR \ a b:c d e:f\ । फिर ENV_VAR [' a b', 'c d e', 'f '] होगा और इसे ' a b:c d e:f ' के रूप में निर्यात किया जाएगा।
      
      
      
      4. set -s ':' ENV_VAR a b:c d e:f $ENV_VAR । इस मामले में, यह इस बात पर निर्भर करता है कि $ कैसे काम करता है। यदि इसे सूची के बजाय ENV_VAR के स्ट्रिंग मान को निकालने के रूप में परिभाषित किया गया है, तो यह कमांड $ENV_VAR को नीचे की सूची से परिवर्तित स्ट्रिंग मान के साथ बदलने जैसा ही होगा, और इस मामले में, set -s ':' ENV_VAR a b:c d e:f:$ENV_VAR है शायद आप वास्तव में क्या चाहते हैं (f के बाद f : नोटिस करें); यदि इसे ENV_VAR (जो स्ट्रिंग के बजाय एक सूची है) के चर को निकालने के रूप में परिभाषित किया गया है, तो यह पाइथन की तरह ही एक सूची विस्तार ऑपरेशन बन जाना चाहिए। उदाहरण के लिए, बाद के मामले में, यदि ENV_VAR ['x', 'y'] है, तो इस ऑपरेशन के बाद ENV_VAR ['a b', 'c d e', 'f', 'x', 'y'] बन जाएगा। क्या होगा यदि ENV_VAR का पिछला विभाजक ':' नहीं है? पहले वाले मामले में, यह सुनिश्चित करना आपकी ज़िम्मेदारी है कि आप सही काम कर रहे हैं, उदाहरण के लिए, आपको मूल विभाजक को ':' में बदलकर या वर्तमान विभाजक को मूल विभाजक में बदलकर संगत विभाजक का उपयोग करना चाहिए। बाद के मामले में, यह इस सरणी के विभाजक को मूल एक (कोई फर्क नहीं पड़ता) से ':' पर सेट कर देगा।
      
      
      
   
   
   3. विभाजक कैसे बदलें
      
      
      
      
      
      1. set --change-separator ':' ENV_VAR । यदि ENV_VAR मौजूद नहीं है, तो प्रोग्राम को 0 के अलावा त्रुटि कोड के साथ बाहर निकलना चाहिए। काफी आसान और स्पष्ट।
      
      
      
   
   
   4. विभाजक कैसे देखें
      
      
      
      
      
      1. set --view-separator ENV_VAR ।
      
      
      
   
   

इसके अलावा, मुझे वास्तव में लगता है कि यह समस्या स्पष्ट और जरूरी है और उपयोगकर्ताओं के लिए एक बड़ा दर्द बिंदु है और आशा है कि इस समस्या को जल्द से जल्द हल किया जा सकता है क्योंकि यह वास्तव में उपयोगकर्ता के अनुभव को बहुत प्रभावित करता है। वास्तव में मुझे अब मछली का उपयोग करने के लिए अन्य (यहां तक ​​​​कि बहुत छोटी) समस्याओं का सामना नहीं करना पड़ा है, सिवाय इसके कि यह इतना बड़ा है।

मुझे सच में लगता है कि यह समस्या स्पष्ट और जरूरी है

@thuzhf : मैं कहूंगा कि आप इसे कम करके आंक रहे हैं।

एक कारण यह है कि #5169 में आपकी समस्या $LD_LIBRARY_PATH के साथ थी, लेकिन यह वास्तव में मछली की सूची नहीं है! आपको इसे अन्य गोले की तरह ही सेट करना चाहिए set LD_LIBRARY_PATH "$LD_LIBRARY_PATH:/some/path" ।

मछली स्वचालित रूप से तीन विरासत/निर्यात चर को सूचियों में बदल देती है:

$PATH, $MANPATH और $CDPATH। और वास्तव में इस सूची में निर्यात होने पर ":" विभाजक होगा।

अन्य "मानकीकृत" चर जैसे $LD_LIBRARY_PATH को फिशस्क्रिप्ट में सूचियों के रूप में नियंत्रित नहीं किया जाना चाहिए, इसलिए आपके पास यह समस्या नहीं है। वेरिएबल जो मानकीकृत नहीं हैं, आप अपनी इच्छानुसार संभाल सकते हैं, क्योंकि अन्य प्रोग्राम उनके साथ वैसे भी कुछ नहीं करेंगे, इसलिए विभाजक गैर-महत्वपूर्ण है।

@faho आपके स्पष्ट स्पष्टीकरण के लिए धन्यवाद। यह वास्तव में मेरे लिए बहुत मायने रखता है। ठीक है, मैं कह सकता हूँ कि यह समस्या मेरे लिए हल हो गई है।

मैंने #2090 में वर्णित MANPATH मुद्दे पर एक नज़र डाली। परिदृश्य को मैनपथ से जोड़ना है जैसे कि यह सिस्टम पथ का उपयोग करना जारी रखता है।

बैश में इसे export MANPATH="$MANPATH:/new/path" के रूप में लिखा जाएगा। यदि MANPATH सेट है, तो यह इसके साथ जुड़ जाएगा। यदि सेट नहीं किया जाता है, तो यह एक कोलन को जोड़ देगा, जो सिस्टम निर्देशिकाओं का उपयोग करने के लिए एक मानव-विशिष्ट संकेत है। यह सिंटैक्स मछली में काम नहीं करता है; समस्या यह है कि MANPATH एक सरणी है और इसलिए "$MANPATH" में कोलन के बजाय रिक्त स्थान होंगे।

एक "बंधे हुए चर" दृष्टिकोण हमें उदाहरण के लिए fish_manpath को एक सरणी के रूप में रखने की अनुमति देगा जो MANPATH को कोलन से अलग स्ट्रिंग के रूप में प्रतिबिंबित करता है। यह पूरी तरह से मछली लिपि में बनाया जा सकता है। हालांकि हम इसे सभी पथ-समान चरों के लिए करना चाहते हैं, न कि केवल MANPATH, और यह एक महत्वपूर्ण संगतता विराम होगा जिसे प्रबंधित करना स्पष्ट नहीं है। इसके अलावा इसमें भी वही समस्याएं हैं, उदाहरण के लिए manpath सरणी-चर zsh में संलग्न करने के लिए अजीब है, इसलिए यह स्पष्ट नहीं है कि यह क्यों मौजूद है।

यहाँ मेरा प्रस्ताव MANPATH की स्थिति को बेहतर या बदतर नहीं बनाता है; मुझे लगता है कि करने की बात पंट है और MANPATH से जुड़ने के लिए बस एक आसान कहानी है, जो यह है:

set -q MANPATH || set MANPATH ''
set -x MANPATH $MANPATH /new/path

config.fish में पेस्ट करने के लिए यह बहुत दर्दनाक नहीं है।

यहाँ मेरा प्रस्ताव MANPATH की स्थिति को बेहतर या बदतर नहीं बनाता है; मुझे लगता है कि करने की बात पंट है और MANPATH से जुड़ने के लिए बस एक आसान कहानी है, जो यह है:

@ridiculousfish : मैं एक कदम आगे जाने की सोच रहा हूं, वास्तव में: इन विशेष चर को ":" पर भी असाइनमेंट पर विभाजित करें, और उद्धृत विस्तार में स्थान के बजाय ":" के साथ जुड़ें।

इसका मतलब है कि जब आप set -gx MANPATH "$MANPATH:/new/path" करते हैं, तो मछली जाती है और स्वचालित रूप से विभाजन करती है, जिसके परिणामस्वरूप set -gx MANPATH "" /new/path के बराबर होता है।

अब, इसका मतलब है कि ":" $MANPATH (और $PATH, और $CDPATH) में पथ में प्रकट नहीं हो सकता है, लेकिन वे वैसे भी ऐसा नहीं कर सकते क्योंकि यह गैर-मछली उपयोगिताओं को तोड़ देगा!

यह हमें शायद एक दिन विशेष हैंडलिंग को हटाने की अनुमति देगा, क्योंकि यह इसे संभालने का एक क्रॉस-संगत तरीका जोड़ता है - आपको बस : के साथ असाइन करना होगा, और इसे (string split : -- $MANPATH) के साथ उपयोग करना होगा

@faho मैं इस विचार को गर्म कर रहा हूं - उपयोगकर्ता इस विशेष उपचार को प्राप्त करने के रूप में एक चर को कैसे चिह्नित करेगा? क्या splitenv ऐसा करेंगे?

उपयोगकर्ता इस विशेष उपचार को प्राप्त करने के रूप में एक चर को कैसे चिह्नित करेगा?

मेरा विचार वास्तव में अंकन की अनुमति नहीं देना था - बस इसे $PATH et al के लिए विशेष व्यवहार के रूप में छोड़ दें। जो हमें भविष्य में किसी बिंदु पर सूचीबद्ध करने से दूर कर देगा।

हालाँकि, मुझे तब से यह समझ में आया है कि अन्य चरों के लिए इसे अनुमति देने से हमें अन्य चरों के साथ भी मदद मिलती है - उदाहरण के लिए मैंने पहले कहा है कि मेरा $EDITOR बाहरी के साथ संगतता के लिए एक तत्व ( set EDITOR "emacs -nw" ) के रूप में सेट है उपकरण, लेकिन मछली इसे बेहतर पसंद करेगी यदि यह एक सूची थी।

तो मैं शायद _space_ को एक डिलीमीटर के रूप में डिफ़ॉल्ट कर दूंगा, जब तक कि यह एक पथ-जैसा न हो (और यह मानते हुए कि यदि पाथ में नाम समाप्त होता है तो शायद ठीक है)।

क्या स्प्लिटेंव इसे करेगा?

मैं वास्तव में इसके लिए एक और बिल्टिन पेश करना पसंद नहीं करता, इसलिए शायद मैं तर्क-से-सेट विकल्प के साथ जाऊंगा।

मैं सहमत हूं कि "विशेष-आवरण पथ/मैनपाथ/सीडीपीएटीएच अजीब है; हमें एक और सामान्य समाधान की आवश्यकता है"।

मेरा प्रस्ताव है कि हम स्पेशल-केसिंग पाथ/मैनपाथ/सीडीपीएटीएच बंद कर दें। उनका इलाज किया जाएगा (मछली के अंत-उपयोगकर्ता द्वारा) जिस तरह से वे अन्य गोले में हैं। $PATH (और अन्य) एक एकल स्ट्रिंग (या मछली शब्दजाल में 1 की लंबाई वाली एक सूची) होगी जिसमें कोलन होंगे। ध्यान दें कि मैं मछली उपयोगकर्ता अनुभव का जिक्र कर रहा हूं, न कि इन चीजों को आंतरिक रूप से कैसे संभाला जाता है; मुझे नहीं पता कि मछली के अंदर का कार्यान्वयन कैसा दिखेगा--मैं वहां किसी भी समस्या को इंगित करने के लिए दूसरों पर भरोसा करता हूं।

दी, इसमें पिछड़ी असंगति का नुकसान होगा, लेकिन मुझे लगता है कि यह सादगी और लालित्य में एक बड़े लाभ के रूप में इसके लायक होगा। मुझे लगता है कि यह #2090 को भी संबोधित करेगा।

सब क्या सोचते हैं?

5245 विलय कर दिया गया है, इसलिए यह हल हो गया लगता है।