Ruby Language
स्ट्रिंग्स

वाक्य - विन्यास

• 'ए स्ट्रिंग' // एकल-उद्धृत शाब्दिक के माध्यम से एक स्ट्रिंग बनाता है
• "एक स्ट्रिंग" // दोहरे-उद्धृत शाब्दिक के माध्यम से एक स्ट्रिंग बनाता है
• String.new ("एक स्ट्रिंग")
• सिंगल क्यू स्ट्रिंग्स बनाने के लिए% q (ए स्ट्रिंग) // वैकल्पिक सिंटैक्स
• % Q (A string) // वैकल्पिक वाक्य रचना दोहरे उद्धृत तार बनाने के लिए

एकल-उद्धृत और दोहरे-उद्धृत स्ट्रिंग शाब्दिक के बीच अंतर

मुख्य अंतर यह है कि डबल-उद्धृत String शाब्दिक स्ट्रिंग प्रक्षेपों और भागने के दृश्यों के पूर्ण सेट का समर्थन करते हैं।

उदाहरण के लिए, वे प्रक्षेप के माध्यम से मनमानी रूबी अभिव्यक्तियों को शामिल कर सकते हैं:

# Single-quoted strings don't support interpolation
puts 'Now is #{Time.now}'
# Now is #{Time.now}

# Double-quoted strings support interpolation
puts "Now is #{Time.now}"
# Now is 2016-07-21 12:43:04 +0200

डबल-उद्धृत स्ट्रिंग्स "\n" , "\t" सहित भागने के दृश्यों के पूरे सेट का समर्थन करते हैं ...

puts 'Hello\nWorld'
# Hello\nWorld

puts "Hello\nWorld"
# Hello
# World

... जबकि एकल-उद्धृत स्ट्रिंग्स नो एस्केप अनुक्रमों का समर्थन करते हैं, एकल-उद्धृत स्ट्रिंग्स के उपयोगी होने के लिए आवश्यक न्यूनतम सेट को छोड़कर: शाब्दिक एकल उद्धरण और बैकस्लैश, क्रमशः '\'' और '\\' ।

एक स्ट्रिंग बनाना

रूबी एक String ऑब्जेक्ट बनाने के कई तरीके प्रदान करता है। " स्ट्रिंग शाब्दिक " बनाने के लिए सबसे आम तरीका एकल या दोहरे उद्धरण चिह्नों का उपयोग कर रहा है:

s1 = 'Hello'
s2 = "Hello"

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

मनमाने स्ट्रिंग सीमांकक का उपयोग करके स्ट्रिंग शाब्दिक बनाने के कई अन्य संभावित तरीके भी हैं। एक मनमाना स्ट्रिंग सीमांकक एक % है जो कि सीमांकित जोड़े के सीमांकक के साथ है:

%(A string)
%{A string}
%<A string>
%|A string|
%!A string!

अंत में, आप %q और %Q अनुक्रम का उपयोग कर सकते हैं, जो ' और " " के बराबर हैं:

puts %q(A string)
# A string
puts %q(Now is #{Time.now})
# Now is #{Time.now}

puts %Q(A string)
# A string
puts %Q(Now is #{Time.now})
# Now is 2016-07-21 12:47:45 +0200

%q और %Q क्रम उपयोगी होते हैं जब स्ट्रिंग में एकल उद्धरण, दोहरे उद्धरण या दोनों का मिश्रण होता है। इस तरह, आपको सामग्री से बचने की आवश्यकता नहीं है:

%Q(<a href="/profile">User's profile<a>)

जब तक एक मेल जोड़ी है, तब तक आप कई अलग-अलग सीमांकक का उपयोग कर सकते हैं:

%q(A string)
%q{A string}
%q<A string>
%q|A string|
%q!A string!

स्ट्रिंग संगति

कॉन्टैनेटेट स्ट्रिंग्स + ऑपरेटर के साथ:

s1 = "Hello"
s2 = " "
s3 = "World"

puts s1 + s2 + s3
# => Hello World

s = s1 + s2 + s3
puts s
# => Hello World

या << ऑपरेटर के साथ:

s = 'Hello'
s << ' '
s << 'World'
puts s
# => Hello World

ध्यान दें कि << ऑपरेटर बाईं ओर ऑब्जेक्ट को संशोधित करता है।

आप भी तार को गुणा कर सकते हैं, जैसे

"wow" * 3
# => "wowwowwow"

स्ट्रिंग इंटरपोलेशन

दोहरे-उद्धृत परिसीमन " और %Q अनुक्रम #{ruby_expression} का उपयोग करके स्ट्रिंग प्रक्षेप का समर्थन करता है:

puts "Now is #{Time.now}"
# Now is Now is 2016-07-21 12:47:45 +0200

puts %Q(Now is #{Time.now})
# Now is Now is 2016-07-21 12:47:45 +0200

केस में हेरफेर

"string".upcase     # => "STRING"
"STRING".downcase   # => "string"
"String".swapcase   # => "sTRING"
"string".capitalize # => "String"

ये चार विधियाँ मूल रिसीवर को संशोधित नहीं करती हैं। उदाहरण के लिए,

str = "Hello"
str.upcase # => "HELLO"
puts str   # => "Hello"

चार समान विधियां हैं जो समान कार्य करती हैं लेकिन मूल रिसीवर को संशोधित करती हैं।

"string".upcase!     # => "STRING"
"STRING".downcase!   # => "string"
"String".swapcase!   # => "sTRING"
"string".capitalize! # => "String"

उदाहरण के लिए,

str = "Hello"
str.upcase!  # => "HELLO"
puts str     # => "HELLO"

टिप्पणियाँ:

• रूबी 2.4 से पहले ये तरीके यूनिकोड को नहीं संभालते हैं।

एक बंटवारे का विभाजन

String#split विभाजन एक String को एक सीमांकक के आधार पर एक Array में String#split करता है।

"alpha,beta".split(",")
# => ["alpha", "beta"]

एक खाली Array में रिक्त String परिणाम:

"".split(",")
# => []

एक में परिणाम सीमांकक एक मेल नहीं खाने वाले Array एक आइटम युक्त

"alpha,beta".split(".")
# => ["alpha,beta"]

आप नियमित अभिव्यक्ति का उपयोग करके एक स्ट्रिंग भी विभाजित कर सकते हैं:

"alpha, beta,gamma".split(/, ?/)
# => ["alpha", "beta", "gamma"]

सीमांकक वैकल्पिक है, डिफ़ॉल्ट रूप से एक स्ट्रिंग व्हाट्सएप पर विभाजित है:

"alpha beta".split
# => ["alpha", "beta"] 

तार जुड़ना

Array#join a Array a String , एक सीमांकक के आधार पर:

["alpha", "beta"].join(",")
# => "alpha,beta"

सीमांकक वैकल्पिक है, और खाली String लिए डिफ़ॉल्ट है।

["alpha", "beta"].join
# => "alphabeta"

एक खाली Array परिणाम एक रिक्त String , कोई फर्क नहीं पड़ता जो कि सीमांकक का उपयोग किया जाता है।

[].join(",")
# => ""

मल्टीलिन स्ट्रिंग्स

बहुस्तरीय स्ट्रिंग बनाने का सबसे आसान तरीका सिर्फ उद्धरण चिह्नों के बीच कई लाइनों का उपयोग करना है:

address = "Four score and seven years ago our fathers brought forth on this
continent, a new nation, conceived in Liberty, and dedicated to the
proposition that all men are created equal."

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

puts <<-RAVEN
  Once upon a midnight dreary, while I pondered, weak and weary, 
  Over many a quaint and curious volume of forgotten lore— 
      While I nodded, nearly napping, suddenly there came a tapping, 
  As of some one gently rapping, rapping at my chamber door. 
  "'Tis some visitor," I muttered, "tapping at my chamber door— 
              Only this and nothing more." 
  RAVEN

रूबी <<EOT साथ यहां शैल-शैली के दस्तावेज़ों का समर्थन करती है, लेकिन समाप्ति पाठ को पंक्ति को प्रारंभ करना चाहिए। यह कोड इंडेंटेशन को बढ़ाता है, इसलिए उस शैली का उपयोग करने का कोई कारण नहीं है। दुर्भाग्य से, स्ट्रिंग में इंडेंटेशन होंगे, यह इस बात पर निर्भर करता है कि कोड खुद कैसे इंडेंट करता है।

रूबी 2.3 ने समस्या को हल करके <<~ जो अतिरिक्त अग्रणी स्थानों को स्ट्रिप्स करता है:

def build_email(address)
  return (<<~EMAIL)
    TO: #{address}

    To Whom It May Concern:

    Please stop playing the bagpipes at sunrise!
                     
    Regards,
    Your neighbor               
  EMAIL
end

प्रतिशत स्ट्रिंग्स मल्टीलाइन स्ट्रिंग्स बनाने के लिए भी काम करते हैं:

%q(
HAMLET        Do you see yonder cloud that's almost in shape of a camel?
POLONIUS        By the mass, and 'tis like a camel, indeed.
HAMLET        Methinks it is like a weasel.
POLONIUS        It is backed like a weasel.
HAMLET        Or like a whale?
POLONIUS        Very like a whale
)

प्रक्षेप से बचने और क्रम से बचने के कुछ तरीके हैं:

• दोहरे उद्धरण के बजाय एकल उद्धरण: '\n is a carriage return.'

• लोअर केस q एक प्रतिशत स्ट्रिंग में: %q[#{not-a-variable}]

• एक हेरेडोक में टर्मिनल स्ट्रिंग का एकल उद्धरण:

  <<-'CODE'
     puts 'Hello world!'
  CODE
  

स्वरूपित तार

रूबी आपूर्ति सरणी से मूल्यों के साथ किसी भी प्लेसहोल्डर्स को प्रतिस्थापित करके स्ट्रिंग के मानों को एक स्ट्रिंग में इंजेक्ट कर सकता है।

"Hello %s, my name is %s!" % ['World', 'br3nt']
# => Hello World, my name is br3nt!

स्थान धारकों को दो %s द्वारा दर्शाया गया है और मान सरणी ['Hello', 'br3nt'] द्वारा दिए गए हैं। % ऑपरेटर सरणी के मानों को इंजेक्ट करने के लिए स्ट्रिंग को निर्देश देता है।

स्ट्रिंग चरित्र प्रतिस्थापन

tr पद्धति एक स्ट्रिंग की एक प्रति लौटाती है जहां पहले तर्क के पात्रों को दूसरे तर्क के पात्रों द्वारा प्रतिस्थापित किया जाता है।

"string".tr('r', 'l') # => "stling"

पैटर्न की केवल पहली घटना को बदलने के लिए एक अन्य अभिव्यक्ति के साथ sub विधि का उपयोग करें

"string ring".sub('r', 'l') # => "stling ring"

यदि आप किसी पैटर्न की सभी घटनाओं को उस अभिव्यक्ति के साथ बदलना चाहते हैं तो gsub उपयोग gsub

"string ring".gsub('r','l') # => "stling ling" 

वर्णों को हटाने के लिए, दूसरे पैरामीटर के लिए एक रिक्त स्ट्रिंग में पास करें

आप इन सभी तरीकों में नियमित अभिव्यक्ति का भी उपयोग कर सकते हैं।

यह ध्यान रखना महत्वपूर्ण है कि ये विधियाँ केवल एक स्ट्रिंग की नई प्रति लौटाएंगी और स्ट्रिंग को जगह में संशोधित नहीं करेंगी। ऐसा करने के लिए, आपको tr! का उपयोग करने की आवश्यकता है tr! , sub! और gsub! क्रमशः विधियाँ।

एक स्ट्रिंग में डेटा को समझना

रूबी में, एक स्ट्रिंग एक एन्कोडिंग के नाम के साथ ही बाइट्स का एक क्रम है (जैसे कि UTF-8 , US-ASCII , ASCII-8BIT ) जो निर्दिष्ट करता है कि आप वर्णों के रूप में उन बाइट्स की व्याख्या कैसे कर सकते हैं।

रूबी स्ट्रिंग्स का उपयोग टेक्स्ट (मूल रूप से वर्णों का एक क्रम) रखने के लिए किया जा सकता है, जिस स्थिति में आमतौर पर UTF-8 एन्कोडिंग का उपयोग किया जाता है।

"abc".bytes  # => [97, 98, 99]
"abc".encoding.name  # => "UTF-8"

रूबी स्ट्रिंग्स का उपयोग बाइनरी डेटा (बाइट्स का एक क्रम) रखने के लिए भी किया जा सकता है, जिस स्थिति में आमतौर पर ASCII-8BIT एन्कोडिंग का उपयोग किया जाता है।

[42].pack("i").encoding  # => "ASCII-8BIT"

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

"\xFF \xFF".valid_encoding? # => false
"\xFF \xFF".split(' ')      # ArgumentError: invalid byte sequence in UTF-8

स्ट्रिंग प्रतिस्थापन

p "This is %s" % "foo"
# => "This is foo"

p "%s %s %s" % ["foo", "bar", "baz"]
# => "foo bar baz"

p "%{foo} == %{foo}" % {:foo => "foo" }
# => "foo == foo"

देखें स्ट्रिंग % डॉक्स और कर्नेल :: sprintf अधिक जानकारी के लिए।

स्ट्रिंग के साथ शुरू होता है

यह जानने के लिए कि क्या एक स्ट्रिंग एक पैटर्न के साथ शुरू होती है, start_with? तरीका काम आता है

str = "zebras are cool"
str.start_with?("zebras")      => true

आप index साथ पैटर्न की स्थिति भी जांच सकते हैं

str = "zebras are cool"
str.index("zebras").zero?      => true

स्ट्रिंग के साथ समाप्त होता है

यह जानने के लिए कि क्या एक स्ट्रिंग एक पैटर्न के साथ समाप्त होती है, end_with? तरीका काम आता है

str = "I like pineapples"
str.end_with?("pineaaples")      => false

पोजिशनिंग स्ट्रिंग्स

रूबी में, तार को बाएं-उचित, दाएं-उचित या केंद्रित किया जा सकता है

स्ट्रिंग को बाएं-औचित्य देने के लिए, ljust विधि का उपयोग करें। यह दो मापदंडों में लेता है, एक पूर्णांक नए स्ट्रिंग और एक स्ट्रिंग के वर्णों की संख्या का प्रतिनिधित्व करता है, जो पैटर्न को भरने का प्रतिनिधित्व करता है।

यदि पूर्णांक मूल स्ट्रिंग की लंबाई से अधिक है, तो नया स्ट्रिंग शेष स्थान लेने वाले वैकल्पिक स्ट्रिंग पैरामीटर के साथ छोड़ दिया जाएगा। यदि स्ट्रिंग पैरामीटर नहीं दिया गया है, तो स्ट्रिंग को रिक्त स्थान के साथ गद्देदार किया जाएगा।

str ="abcd"
str.ljust(4)          => "abcd"
str.ljust(10)         => "abcd      "

एक स्ट्रिंग को सही-सही ठहराने के लिए, rjust विधि का उपयोग करें। यह दो मापदंडों में लेता है, एक पूर्णांक नए स्ट्रिंग और एक स्ट्रिंग के वर्णों की संख्या का प्रतिनिधित्व करता है, जो पैटर्न को भरने का प्रतिनिधित्व करता है।

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

str = "abcd"
str.rjust(4)          => "abcd"
str.rjust(10)         => "      abcd"

एक स्ट्रिंग को केंद्र में करने के लिए, center विधि का उपयोग करें। यह दो मापदंडों में लेता है, नया स्ट्रिंग और एक स्ट्रिंग की चौड़ाई का प्रतिनिधित्व करने वाला पूर्णांक, जिसे मूल स्ट्रिंग के साथ गद्देदार किया जाएगा। स्ट्रिंग को केंद्र में संरेखित किया जाएगा।

str = "abcd"
str.center(4)          => "abcd"
str.center(10)         => "   abcd   "