यह जांचने के लिए कि रूबी में स्ट्रिंग का विकल्प है या नहीं

Question

मेरे पास सामग्री के साथ एक स्ट्रिंग चर है:

varMessage =   
            "hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n"


            "/my/name/is/balaji.so\n"
            "call::myFunction(int const&)\n"
            "void::secondFunction(char const&)\n"
             .
             .
             .
            "this/is/last/line/liobrary.so"

स्ट्रिंग में मुझे उप-स्ट्रिंग ढूंढनी होगी:

"hi/thsid/sdfhsjdf/dfjsd/sdjfsdn\n"

"/my/name/is/balaji.so\n"
"call::myFunction(int const&)\n"

मुझे ये कैसे मिल सकता है? मुझे यह निर्धारित करने की आवश्यकता है कि उप-स्ट्रिंग मौजूद है या नहीं।

Comments

संबंधित प्रश्न: stackoverflow.com/questions/3876246/…

— एंड्रयू ग्रिम

ऐसा करने के लिए विभिन्न तरीकों के टूटने के लिए stackoverflow.com/a/3878656/128421 देखें ।

— टीन मैन

Answer 1

आप include?विधि का उपयोग कर सकते हैं :

my_string = "abcdefg"
if my_string.include? "cde"
   puts "String includes 'cde'"
end

Comments

याद रखें कि include?मामला संवेदी है। तो अगर my_stringऊपर के उदाहरण में कुछ "abcDefg"(अपरकेस के साथ D) जैसा include?("cde")होगा , तो वापस आ जाएगा false। आप downcase()कॉल करने से पहले करना चाह सकते हैं include?()।

— फॉर्टेक्स

इसमें शामिल करें कि यह स्वयं आदर्श नहीं है क्योंकि यह NoMethodError को फेंक सकता है यदि nil test = nil testcclude? ("Test") NoMethodError: अपरिभाषित विधि `शामिल? ' शून्य के लिए: NilClass को हमेशा अपेक्षित मान में शामिल किए जाने वाले मान को परिवर्तित करना चाहिए: - test.to_s.include? ("test")

— Gary

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

— ल्यूक ग्रिफिथ्स

Answer 2

यदि मामला अप्रासंगिक है, तो केस-असंवेदनशील नियमित अभिव्यक्ति एक अच्छा समाधान है:

'aBcDe' =~ /bcd/i  # evaluates as true

यह मल्टी-लाइन स्ट्रिंग्स के लिए भी काम करेगा।

अधिक जानकारी के लिए रूबी का Regexp वर्ग देखें।

Comments

यदि आप उपयोगकर्ता इनपुट के खिलाफ मिलान कर रहे हैं और इस तकनीक का उपयोग कर रहे हैं, Regexp.escapeतो स्ट्रिंग पर उपयोग करना याद रखें । अधिकांश उपयोग के मामलों के लिए, some_str.include? substr.downcase()तेजी से काम करना चाहिए और अधिक पठनीय होना चाहिए।

— जैक

इस तरह से एक नियमित अभिव्यक्ति का उपयोग करना जरूरी नहीं है कि इसका उपयोग तेजी से हो 'aBcDe'.downcase.include?('bcd')। रेगेक्स का उद्देश्य है, लेकिन अंतर्निहित तरीकों के तेज होने पर उनका उपयोग न करें। वास्तविक डेटा के साथ बेंचमार्किंग का परीक्षण किया जा सकता है।

— द टिन मैन

यह सच के रूप में मूल्यांकन नहीं करता है। यह 1 का मूल्यांकन करता है जो सत्य नहीं है।

— slindsey3000

!! ('aBcDe' = ~ / bcd / i) सही या गलत का मूल्यांकन करेगा। उपयोग !! मुहावरा

— slindsey3000

वैकल्पिक रूप से, मैच का उपयोग करें? एक बूलियन लौटने के लिए:/bcd/i.match?('aBcDe')

— ferrell_io

Answer 3

आप भी ऐसा कर सकते हैं ...

my_string = "Hello world"

if my_string["Hello"]
  puts 'It has "Hello"'
else
  puts 'No "Hello" found'
end

# => 'It has "Hello"'

यह उदाहरण रूबी के स्ट्रिंग #[]विधि का उपयोग करता है ।

Comments

यह एक साफ-सुथरी चाल है जिसे मैंने पहले नहीं देखा है। लेकिन #include?अभी भी थोड़ी तेजी है।

— स्कॉट स्कूपबैच

#include?जब आप अंदर रिक्त स्थान के साथ वाक्यों के साथ काम कर रहे हों तो काम नहीं करता क्योंकि #includeवाक्य को शब्दों में विभाजित करता है और फिर शब्दों को अलग सरणी मान के रूप में उपयोग करता है। यह वाक्यों के लिए पूरी तरह से काम करता है। +1

— ल्यूसिमो

[]अधिक जानकारी के लिए रूबी की स्ट्रिंग विधि देखें।

— टिन मैन

Answer 4

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

रूबी रिटर्न में रेगेक्स मिलान nilजब अभिव्यक्ति मैच नहीं करता है। जब यह होता है, तो यह उस चरित्र के सूचकांक को वापस कर देता है जहां मैच होता है। उदाहरण के लिए:

"foobar" =~ /bar/  # returns 3
"foobar" =~ /foo/  # returns 0
"foobar" =~ /zzz/  # returns nil

यह ध्यान रखना महत्वपूर्ण है कि केवल रूबी में nilऔर बूलियन अभिव्यक्ति falseझूठी का मूल्यांकन करती है। एक खाली एरे, खाली हैश, या इंटेगर 0 सहित, बाकी सब कुछ, सच का मूल्यांकन करता है।

इसीलिए /foo/उपरोक्त उदाहरण काम करता है, और क्यों।

if "string" =~ /regex/

अपेक्षा के अनुसार काम करता है, ifअगर मैच हुआ तो केवल ब्लॉक के 'सही' हिस्से में प्रवेश करना ।

Answer 5

ऊपर दिए गए स्वीकृत उत्तर की तुलना में अधिक रसीला मुहावरे रेल में उपलब्ध हैं (3.1.0 और उससे अधिक) .in?:

my_string = "abcdefg"
if "cde".in? my_string
  puts "'cde' is in the String."
  puts "i.e. String includes 'cde'"
end

मुझे भी लगता है कि यह अधिक पठनीय है।

in?अधिक जानकारी के लिए दस्तावेज़ देखें ।

ध्यान दें कि यह केवल रेल में उपलब्ध है , और शुद्ध रूबी नहीं।

Comments

यह रेल पर निर्भर करता है, ओपी ने माणिक समाधान के लिए कहा

— dft

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

— stwr667

Stackoverflow.com/a/4239625/128421 देखें । यह रेल में है, लेकिन रेल के सक्रिय समर्थन कोर एक्सटेंशन का उपयोग करके नियमित रूप से रूबी से आसानी से पहुँचा जा सकता है, जो केवल तरीकों जैसे छोटे समूहों के आसान चेरी-पिकिंग की अनुमति देता है in?।

— टिन मैन

सही @theTinMan। "cde".in? my_stringशुद्ध रूबी की पैदावार में NoMethodError। लेकिन इसके साथ require 'active_support/core_ext/object/inclusion'काम करता है, जिसे या तो रेल से या फिर कट-डाउन एक्टिव सपोर्ट कोर एक्सटेंशन्स से लोड किया जा सकता है ।

— stwr667

Answer 6

टेर्नरी तरीका

my_string.include?('ahr') ? (puts 'String includes ahr') : (puts 'String does not include ahr')

या

puts (my_string.include?('ahr') ? 'String includes ahr' : 'String not includes ahr')

Answer 7

आप स्ट्रिंग तत्व संदर्भ विधि का उपयोग कर सकते हैं जो है[]

अंदर []या तो एक शाब्दिक सबस्ट्रिंग, एक इंडेक्स, या एक रेगीक्स हो सकता है:

> s='abcdefg'
=> "abcdefg"
> s['a']
=> "a"
> s['z']
=> nil

चूँकि nilकार्यात्मक रूप से समान है falseऔर किसी भी प्रतिस्थापन से लौटा है [], trueतो आप तर्क का उपयोग कर सकते हैं जैसे कि आप विधि का उपयोग करते हैं .include?:

0> if s[sub_s]
1>    puts "\"#{s}\" has \"#{sub_s}\""
1> else 
1*    puts "\"#{s}\" does not have \"#{sub_s}\""
1> end
"abcdefg" has "abc"

0> if s[sub_s]
1>    puts "\"#{s}\" has \"#{sub_s}\""
1> else 
1*    puts "\"#{s}\" does not have \"#{sub_s}\""
1> end
"abcdefg" does not have "xyz" 

बस सुनिश्चित करें कि आप एक उप स्ट्रिंग के साथ एक सूचकांक को भ्रमित नहीं करते हैं:

> '123456790'[8]    # integer is eighth element, or '0'
=> "0"              # would test as 'true' in Ruby
> '123456790'['8']  
=> nil              # correct

तुम भी एक regex का उपयोग कर सकते हैं:

> s[/A/i]
=> "a"
> s[/A/]
=> nil

Comments

यह अभूतपूर्व है

— क्रेग

Answer 8

कैसे जांचें कि क्या एक स्ट्रिंग में रूबी में एक विकल्प है?

जब आप 'चेक' कहते हैं, तो मुझे लगता है कि आप एक बूलियन वापस चाहते हैं जिस स्थिति में आप उपयोग कर सकते हैं String#match?। match?स्ट्रिंग्स या रेगेक्स को इसके पहले पैरामीटर के रूप में स्वीकार करता है, अगर यह पूर्व है तो यह स्वचालित रूप से रेगेक्स में बदल जाता है। तो आपका उपयोग मामला होगा:

str = 'string'
str.match? 'strings' #=> false
str.match? 'string'  #=> true
str.match? 'strin'   #=> true
str.match? 'trin'    #=> true
str.match? 'tri'     #=> true

String#match?एक वैकल्पिक दूसरे तर्क का अतिरिक्त लाभ है जो एक सूचकांक को निर्दिष्ट करता है जिसमें से स्ट्रिंग को खोजना है। डिफ़ॉल्ट रूप से यह करने के लिए सेट है 0।

str.match? 'tri',0   #=> true
str.match? 'tri',1   #=> true
str.match? 'tri',2   #=> false

Answer 9

user_input = gets.chomp
user_input.downcase!

if user_input.include?('substring')
  # Do something
end

यह जांचने में आपकी मदद करेगा कि स्ट्रिंग में सबस्ट्रिंग है या नहीं

puts "Enter a string"
user_input = gets.chomp  # Ex: Tommy
user_input.downcase!    #  tommy


if user_input.include?('s')
    puts "Found"
else
    puts "Not found"
end