रूबी में एक स्ट्रिंग को ट्रिम करने के लिए एक नया स्ट्रिंग बनाने के बिना विहित तरीका क्या है?

Question

यह वही है जो अब मेरे पास है - जो काम कर रहा है उसके लिए बहुत अधिक क्रियात्मक दिखता है।

@title        = tokens[Title].strip! || tokens[Title] if !tokens[Title].nil?

मान लें कि एक CSV लाइन को विभाजित करके प्राप्त एक सरणी है। अब पट्टी की तरह कार्य! chomp! एट। यदि स्ट्रिंग को संशोधित नहीं किया गया था तो सभी रिटर्न एनआईएल

"abc".strip!    # => nil
" abc ".strip!  # => "abc"

अगर इसे कॉपी बनाने के बिना अतिरिक्त अग्रणी या अनुगामी रिक्त स्थान होता है, तो इसे ट्रिम करने का रूबी तरीका क्या है?

अगर मैं करना चाहता हूँ तो बदसूरत हो जाता है tokens[Title].chomp!.strip!

Comments

यदि आप बार-बार टोकनों से चीजों को पढ़ते जा रहे हैं, तो इसे पूर्व-प्रक्रिया के लिए अधिक समझ में आ सकता है। यानी, "tokens.each {| t | t.strip!}"। तो आप बस "@ title = tokens [शीर्षक] || ''" कर सकते हैं

— glenn mcdonald

Answer 1

मुझे लगता है कि तुम क्या चाहते हो:

@title = tokens[Title]
@title.strip!

#strip!विधि वापस आ जाएगी nilअगर यह कुछ भी पट्टी नहीं था, और चर ही अगर यह हाथ धोना पड़ा।

रूबी मानकों के अनुसार, विस्मयादिबोधक चिह्न के साथ प्रत्यय वाली एक विधि जगह में परिवर्तनशील परिवर्तन करती है।

उम्मीद है की यह मदद करेगा।

अद्यतन: यह उत्पादन से irbप्रदर्शित करने के लिए है:

>> @title = "abc"
=> "abc"
>> @title.strip!
=> nil
>> @title
=> "abc"
>> @title = " abc "
=> " abc "
>> @title.strip!
=> "abc"
>> @title
=> "abc"

Comments

हम्म .. अभी भी मुझे लगता है कि @title = टोकन [शीर्षक] .strip! साफ दिखता है - इसकी एक दया यह unmodified स्ट्रिंग के बजाय शून्य देता है। जब तक कोई बेहतर उत्तर नहीं देता है .. आप स्वीकृत बिट प्राप्त कर रहे हैं।

— गिशु

ठीक है, @title = tokens [शीर्षक] .strip चाल करेगा, लेकिन आपके पास एक प्रति होगी, जो ठीक है यदि आप टोकन [शीर्षक] चर को अछूता रखते हैं।

— इगोर

रूबी 1.9 में नल है, जो वास्तव में आप क्या चाहते हैं: @ title.tap {| x | x.strip!}

— timkay

@timkay क्या ऐसा करना संभव होगा @title.tap &:strip!? जो किसी भी चीज से ज्यादा साफ लगता है।

— जॉन एगलैंड

nilजब तक वह कुछ नहीं छोड़ेगा तो दुनिया में क्यों लौटेगा ? इसमें कोई संदेह नहीं है कि एक टन लोगों को भ्रमित किया गया है (क्योंकि यह कोई मतलब नहीं है)।

— जोश एम।

Answer 2

Btw, अब माणिक पहले से ही बिना पट्टी का समर्थन करता है "!"।

की तुलना करें:

p "abc".strip! == " abc ".strip!  # false, because "abc".strip! will return nil
p "abc".strip == " abc ".strip    # true

इसके अलावा stripडुप्लिकेट के बिना यह असंभव है । String.c में सूत्रों को देखें:

static VALUE
rb_str_strip(VALUE str)
{
    str = rb_str_dup(str);
    rb_str_strip_bang(str);
    return str;
}

रूबी 1.9.3p0 (2011-10-30) [i386-mingw32]

अद्यतन 1: जैसा कि मैंने अभी देखा - यह 1999 वर्ष में बनाया गया था ( एसवीएन में # 372 देखें ):

Update2: strip!डुप्लिकेट नहीं बनाएंगे - दोनों में 1.9.x, 2.x और ट्रंक संस्करण।

Comments

"डुप्लिकेट के बिना स्ट्रिपिंग करना असंभव है" - बेशक यह संभव है, यही strip!है।

— कारोली होर्वाथ

@KarolyHorvath न 'आप सी में लिखा स्रोत कोड देखते हैं? Pls ध्यान से पढ़ें, मैंने डुप्लिकेट के बारे में यहां क्या लिखा है।

— ९

बेशक मैं इसे देखता हूं। लेकिन वह स्रोत कोड है strip। क्या मैं कुछ गलत समझ रहा हूं? मैं और कैसे "नकल के बिना अलग करना असंभव" की व्याख्या कर सकता था?

— कारोली होर्वाथ

@KarolyHorvath आंतरिक रूप से डुप्लिकेट हमेशा बनाया जाता है। यह स्ट्रिंग के बारे में `str = rb_str_dup (str);`

— gaRex

और यदि आप डुप्लिकेट नहीं चाहते हैं, तो आप strip!उर्फ का उपयोग करते हैं rb_str_strip_bang।

— कारोली होरवाथ

Answer 3

स्ट्रिप और चॉम्प दोनों की कोई आवश्यकता नहीं है क्योंकि स्ट्रिप भी कैरिज रिटर्न को हटा देगी - जब तक कि आपने डिफॉल्ट रिकॉर्ड सेपरेटर को नहीं बदला है और यही आप चूम रहे हैं।

ओली के जवाब में पहले से ही रूबी में ऐसा करने का विहित तरीका है, हालांकि यदि आप खुद को ऐसा करते हुए पाते हैं तो आप हमेशा इसके लिए एक तरीका परिभाषित कर सकते हैं:

def strip_or_self!(str)
  str.strip! || str
end

देते हुए:

@title = strip_or_self!(tokens[Title]) if tokens[Title]

यह भी ध्यान रखें कि यदि @titleटोकन शून्य है, तो स्टेटमेंट को असाइन किए जाने से रोका जाएगा , जिसके परिणामस्वरूप वह अपने पिछले मूल्य को बनाए रखेगा। यदि आप चाहते हैं या आपको @titleहमेशा सौंपा नहीं जा रहा है, तो आप चेक को विधि में स्थानांतरित कर सकते हैं और दोहराव को कम कर सकते हैं:

def strip_or_self!(str)
  str.strip! || str if str
end

एक विकल्प के रूप में, यदि आप रोमांच महसूस कर रहे हैं, तो आप स्ट्रिंग पर एक विधि को परिभाषित कर सकते हैं:

class String
  def strip_or_self!
    strip! || self
  end
end

इनमें से एक देना:

@title = tokens[Title].strip_or_self! if tokens[Title]

@title = tokens[Title] && tokens[Title].strip_or_self!

Answer 4

यदि आप रूबी का उपयोग रेल पर कर रहे हैं तो एक स्क्विश है

> @title = " abc "
 => " abc " 

> @title.squish
 => "abc"
> @title
 => " abc "

> @title.squish!
 => "abc"
> @title
 => "abc" 

यदि आप सिर्फ रूबी का उपयोग कर रहे हैं तो आप पट्टी का उपयोग करना चाहते हैं

इस के साथ साथ मिल गया है .. आपके मामले में आप बैंग के बिना पट्टी का उपयोग करना चाहते हैं!

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

पट्टी! मल्टी लाइन दृष्टिकोण का उपयोग करना

> tokens["Title"] = " abc "
 => " abc "
> tokens["Title"].strip!
 => "abc"
> @title = tokens["Title"]
 => "abc"

स्ट्रिप सिंगल लाइन अप्रोच ... आपका जवाब

> tokens["Title"] = " abc "
 => " abc "
> @title = tokens["Title"].strip if tokens["Title"].present?
 => "abc"

Answer 5

मुझे लगता है कि आपका उदाहरण एक समझदार दृष्टिकोण है, हालांकि आप इसे थोड़ा सरल कर सकते हैं:

@title = tokens[Title].strip! || tokens[Title] if tokens[Title]

वैकल्पिक आप इसे दो लाइनों पर रख सकते हैं:

@title = tokens[Title] || ''
@title.strip!

Answer 6

यदि आप कुछ इस तरह की आवश्यकता के बाद एक और विधि का उपयोग करना चाहते हैं:

( str.strip || str ).split(',')

इस तरह आप पट्टी कर सकते हैं और फिर भी कुछ कर सकते हैं :)

Answer 7

मरे तरीके:

> (@title = " abc ").strip!
 => "abc" 
> @title
 => "abc" 

Answer 8

यदि आपके पास माणिक 1.9 या एक्टिविस्पोर्ट है, तो आप बस कर सकते हैं

@title = tokens[Title].try :tap, &:strip!

यह वास्तव में अच्छा है, क्योंकि यह विधि :tryऔर :tapविधि का लाभ उठाता है , जो माणिक में सबसे शक्तिशाली कार्यात्मक निर्माण हैं, मेरी राय में।

एक समान रूप से, प्रतीक के रूप में पूरी तरह से कार्य करना:

@title = tokens[Title].send :try, :tap, &:strip!

Answer 9

@title = tokens[Title].strip! || tokens[Title]

यह पूरी तरह से संभव है कि मैं इस विषय को नहीं समझ पा रहा हूं, लेकिन क्या यह ऐसा नहीं है जो आपको चाहिए?

" success ".strip! || "rescue" #=> "success"
"failure".strip! || "rescue" #=> "rescue"