Ruby on Rails 5.2 - String

कक्षा स्ट्रिंग




ruby

कक्षा स्ट्रिंग

जनक:
Object

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

'ScaleScore'.tableize # => "scale_scores"

स्थिरांक

BLANK_RE
ENCODED_BLANKS

सार्वजनिक प्रवृत्ति के तरीके

# File activesupport/lib/active_support/core_ext/string/behavior.rb, line 5
def acts_like_string?
  true
end

स्ट्रिंग-जैसी कक्षाओं पर अधिक पूर्वानुमान योग्य डक-टाइपिंग सक्षम करता है। Object#acts_like? देखें Object#acts_like?

(स्थिति) शो स्रोत
# File activesupport/lib/active_support/core_ext/string/access.rb, line 29
def at(position)
  self[position]
end

यदि आप एक पूर्णांक पास करते हैं, तो उस स्थिति में एक वर्ण का एक विकल्प देता है। स्ट्रिंग का पहला वर्ण स्थिति 0 पर है, अगला स्थान 1 पर है, और इसी तरह। यदि एक रेंज की आपूर्ति की जाती है, तो रेंज द्वारा दिए गए ऑफसेट पर एक विकल्प युक्त अक्षर वापस आ जाता है। दोनों मामलों में, यदि कोई ऑफसेट नकारात्मक है, तो इसे स्ट्रिंग के अंत से गिना जाता है। यदि प्रारंभिक ऑफसेट स्ट्रिंग के बाहर गिरता है तो nil वापस आ जाता है। खाली स्ट्रिंग लौटाता है यदि रेंज की शुरुआत स्ट्रिंग के अंत से अधिक हो।

str = "hello"
str.at(0)      # => "h"
str.at(1..3)   # => "ell"
str.at(-2)     # => "l"
str.at(-2..-1) # => "lo"
str.at(5)      # => nil
str.at(5..-1)  # => ""

यदि एक Regexp दिया जाता है, तो स्ट्रिंग का मिलान भाग वापस आ जाता है। यदि String दी जाती है, तो वह स्ट्रिंग दी जाती है यदि वह स्ट्रिंग में होती है। दोनों मामलों में, यदि कोई मैच नहीं है, तो nil वापस आ जाता है।

str = "hello"
str.at(/lo/) # => "lo"
str.at(/ol/) # => nil
str.at("lo") # => "lo"
str.at("ol") # => nil
# File activesupport/lib/active_support/core_ext/object/blank.rb, line 122
def blank?
  # The regexp that matches blank strings is expensive. For the case of empty
  # strings we can speed up this method (~3.5x) with an empty? call. The
  # penalty for the rest of strings is marginal.
  empty? ||
    begin
      BLANK_RE.match?(self)
    rescue Encoding::CompatibilityError
      ENCODED_BLANKS[self.encoding].match?(self)
    end
end

यदि यह खाली है या केवल व्हाट्सएप में एक स्ट्रिंग रिक्त है:

''.blank?       # => true
'   '.blank?    # => true
"\t\n\r".blank? # => true
' blah '.blank? # => false

यूनिकोड व्हाट्सएप समर्थित है:

"\u00a0".blank? # => true

@ ग्रेट [सच, झूठ]

कैमलकेस (प्रथम_पत्र =: ऊपरी)
अन्य लोगों के लिए: camelize
camelize (first_letter =: Upper) शो सोर्स
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 91
def camelize(first_letter = :upper)
  case first_letter
  when :upper
    ActiveSupport::Inflector.camelize(self, true)
  when :lower
    ActiveSupport::Inflector.camelize(self, false)
  else
    raise ArgumentError, "Invalid option, use either :upper or :lower."
  end
end

डिफ़ॉल्ट रूप से, camelize स्ट्रिंग्स को अपरकंपेलकेस में कनवर्ट करता है। यदि ऊँट को व्यवस्थित करने का तर्क निम्न पर सेट किया गया है, तो ऊँट ऊँचा करने से लोकेमेलकैश उत्पन्न होता है।

camelize '/' को '::' में भी परिवर्तित कर देगी जो कि नामस्थानों के लिए पथ परिवर्तित करने के लिए उपयोगी है।

'active_record'.camelize                # => "ActiveRecord"
'active_record'.camelize(:lower)        # => "activeRecord"
'active_record/errors'.camelize         # => "ActiveRecord::Errors"
'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
इसके अलावा camelcase : camelcase
वर्गीकृत () शो स्रोत
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 210
def classify
  ActiveSupport::Inflector.classify(self)
end

एक बहुवचन तालिका नाम से एक वर्ग का नाम बनाता है जैसे रेल तालिका के मॉडल के नाम के लिए करता है। ध्यान दें कि यह एक स्ट्रिंग देता है और एक वर्ग नहीं। ( constantize साथ classify करने के लिए एक वास्तविक वर्ग का अनुसरण classify के लिए।)

'ham_and_eggs'.classify # => "HamAndEgg"
'posts'.classify        # => "Post"
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 67
def constantize
  ActiveSupport::Inflector.constantize(self)
end

constantize स्ट्रिंग में निर्दिष्ट नाम के साथ एक घोषित स्थिरांक खोजने की कोशिश करता है। यह NameError तब उठाता है जब नाम CamelCase में नहीं है या आरंभिक नहीं है। ActiveSupport::Inflector#constantize देखें

'Module'.constantize  # => Module
'Class'.constantize   # => Class
'blargle'.constantize # => NameError: wrong constant name blargle
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 134
def dasherize
  ActiveSupport::Inflector.dasherize(self)
end

स्ट्रिंग में डैश के साथ अंडरस्कोर बदलता है।

'puni_puni'.dasherize # => "puni-puni"
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 159
def deconstantize
  ActiveSupport::Inflector.deconstantize(self)
end

स्ट्रिंग में स्थिर अभिव्यक्ति से सबसे दाहिने खंड को निकालता है।

'Net::HTTP'.deconstantize   # => "Net"
'::Net::HTTP'.deconstantize # => "::Net"
'String'.deconstantize      # => ""
'::String'.deconstantize    # => ""
''.deconstantize            # => ""

demodulize भी देखें।

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 146
def demodulize
  ActiveSupport::Inflector.demodulize(self)
end

स्ट्रिंग में स्थिर अभिव्यक्ति से मॉड्यूल भाग को निकालता है।

'ActiveSupport::Inflector::Inflections'.demodulize # => "Inflections"
'Inflections'.demodulize                           # => "Inflections"
'::Inflections'.demodulize                         # => "Inflections"
''.demodulize                                      # => ''

deconstantize भी देखें।

निकालना? (स्ट्रिंग) स्रोत दिखाएँ
# File activesupport/lib/active_support/core_ext/string/exclude.rb, line 10
def exclude?(string)
  !include?(string)
end

String#include? व्युत्क्रम में String#include? । यदि स्ट्रिंग में अन्य स्ट्रिंग शामिल नहीं है, तो यह सही है।

"hello".exclude? "lo" # => false
"hello".exclude? "ol" # => true
"hello".exclude? ?h   # => false
पहला (सीमा = 1) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/access.rb, line 77
def first(limit = 1)
  if limit == 0
    ""
  elsif limit >= size
    dup
  else
    to(limit - 1)
  end
end

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

str = "hello"
str.first    # => "h"
str.first(1) # => "h"
str.first(2) # => "he"
str.first(0) # => ""
str.first(6) # => "hello"
विदेशी_की (अलग- अलग_काले_नाम_और_निधि_विशाल = सच) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 251
def foreign_key(separate_class_name_and_id_with_underscore = true)
  ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
end

एक वर्ग नाम से एक विदेशी कुंजी नाम बनाता है। separate_class_name_and_id_with_underscore अलग_क्लास_नाम_खंड_निधि_विशाल_कुंडलाकार निर्धारित करता है कि विधि को नाम और 'आईडी' के बीच '_' रखना चाहिए या नहीं।

'Message'.foreign_key        # => "message_id"
'Message'.foreign_key(false) # => "messageid"
'Admin::Post'.foreign_key    # => "post_id"
से (स्थिति) स्रोत दिखाएँ
# File activesupport/lib/active_support/core_ext/string/access.rb, line 46
def from(position)
  self[position..-1]
end

स्ट्रिंग के अंत में दिए गए स्थान से एक विकल्प देता है। यदि स्थिति नकारात्मक है, तो इसे स्ट्रिंग के अंत से गिना जाता है।

str = "hello"
str.from(0)  # => "hello"
str.from(3)  # => "lo"
str.from(-2) # => "lo"

आप इसे विधि के साथ मिला सकते हैं और मजेदार चीजें कर सकते हैं जैसे:

str = "hello"
str.from(0).to(-1) # => "hello"
str.from(1).to(-2) # => "ell"
# File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 255
def html_safe
  ActiveSupport::SafeBuffer.new(self)
end

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

humanize (कैपिटलाइज़ करें: true, keep_id_suffix: false) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 231
def humanize(capitalize: true, keep_id_suffix: false)
  ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
end

पहले शब्द को कैपिटलाइज़ करता है, अंडरस्कोर को रिक्त स्थान में बदल देता है, और (डिफ़ॉल्ट रूप से) यदि मौजूद है तो एक अनुगामी '_id' स्ट्रिप्स करता है। जैसे titleize , यह सुंदर आउटपुट बनाने के लिए है।

पहले पैरामीटर के capitalize को वैकल्पिक पैरामीटर capitalize को गलत पर सेट करके बंद किया जा सकता है। डिफ़ॉल्ट रूप से, यह पैरामीटर सत्य है।

वैकल्पिक पैरामीटर keep_id_suffix को सही पर सेट करके '_id' ट्रेलिंग को रखा और कैपिटल किया जा सकता है। डिफ़ॉल्ट रूप से, यह पैरामीटर गलत है।

'employee_salary'.humanize                    # => "Employee salary"
'author_id'.humanize                          # => "Author"
'author_id'.humanize(capitalize: false)       # => "author"
'_id'.humanize                                # => "Id"
'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
in_time_zone (क्षेत्र = :: Time.zone) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/zones.rb, line 9
def in_time_zone(zone = ::Time.zone)
  if zone
    ::Time.find_zone!(zone).parse(self)
  else
    to_time
  end
end

वर्तमान ज़ोन में एक TimeWithZone को String परिवर्तित करता है यदि Time.zone या Time.zone_default सेट है, अन्यथा String को #to_time माध्यम से एक Time में #to_time

indent (राशि, indent_string = nil, indent_empty_lines = false) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/indent.rb, line 42
def indent(amount, indent_string = nil, indent_empty_lines = false)
  dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) }
end

रिसीवर में लाइनों को इंगित करता है:

<<EOS.indent(2)
def some_method
  some_code
end
EOS
# =>
  def some_method
    some_code
  end

दूसरा तर्क, indent_string , निर्दिष्ट करता है कि किस इंडेंट स्ट्रिंग का उपयोग करना है। डिफ़ॉल्ट nil , जो पहली इंडेंटेड लाइन पर झांक कर अनुमान लगाने की विधि बताता है, और अगर कोई नहीं है तो एक स्थान पर वापस आ जाता है।

"  foo".indent(2)        # => "    foo"
"foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar"
"foo".indent(2, "\t")    # => "\t\tfoo"

जबकि indent_string आम तौर पर एक स्थान या टैब है, यह किसी भी स्ट्रिंग हो सकता है।

तीसरा तर्क, indent_empty_lines , एक ध्वज है जो कहता है कि क्या खाली लाइनों को इंडेंट किया जाना चाहिए। डिफ़ॉल्ट गलत है।

"foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
"foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"
मांगपत्र! (राशि, indent_string = nil, indent_empty_lines = false) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/indent.rb, line 7
def indent!(amount, indent_string = nil, indent_empty_lines = false)
  indent_string = indent_string || self[/^[ \t]/] || " "
  re = indent_empty_lines ? /^/ : /^(?!$)/
  gsub!(re, indent_string * amount)
end

indent समान, सिवाय इसके कि रिसीवर इन-प्लेस को इंडेंट करता है।

इंडेंट स्ट्रिंग, या nil लौटाता है अगर इंडेंट करने के लिए कुछ नहीं था।

# File activesupport/lib/active_support/core_ext/string/inquiry.rb, line 12
def inquiry
  ActiveSupport::StringInquirer.new(self)
end

ActiveSupport::StringInquirer में मौजूदा तार लपेटता है ActiveSupport::StringInquirer वर्ग, जो आपको समानता का परीक्षण करने के लिए एक ActiveSupport::StringInquirer तरीका देता है।

env = 'production'.inquiry
env.production?  # => true
env.development? # => false
# File activesupport/lib/active_support/core_ext/string/multibyte.rb, line 47
def is_utf8?
  case encoding
  when Encoding::UTF_8
    valid_encoding?
  when Encoding::ASCII_8BIT, Encoding::US_ASCII
    dup.force_encoding(Encoding::UTF_8).valid_encoding?
  else
    false
  end
end

यदि स्ट्रिंग में utf_8 एन्कोडिंग true तो यह true

utf_8_str = "some string".encode "UTF-8"
iso_str = "some string".encode "ISO-8859-1"

utf_8_str.is_utf8? # => true
iso_str.is_utf8?   # => false
अंतिम (सीमा = 1) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/access.rb, line 97
def last(limit = 1)
  if limit == 0
    ""
  elsif limit >= size
    dup
  else
    from(-limit)
  end
end

स्ट्रिंग का अंतिम वर्ण लौटाता है। यदि एक सीमा की आपूर्ति की जाती है, तो स्ट्रिंग के अंत से एक विकल्प देता है जब तक कि यह सीमा मूल्य (पीछे की ओर गिनती) तक नहीं पहुंचता। यदि दी गई सीमा स्ट्रिंग की लंबाई से अधिक या उसके बराबर है, तो स्वयं की एक प्रति लौटाता है।

str = "hello"
str.last    # => "o"
str.last(1) # => "o"
str.last(2) # => "lo"
str.last(0) # => ""
str.last(6) # => "hello"
# File activesupport/lib/active_support/core_ext/string/multibyte.rb, line 36
def mb_chars
  ActiveSupport::Multibyte.proxy_class.new(self)
end

मल्टीबाइट प्रॉक्सी

mb_chars स्ट्रिंग विधियों के लिए एक मल्टीबाइट सुरक्षित प्रॉक्सी है।

यह ActiveSupport::Multibyte::Chars वर्ग का एक उदाहरण बनाता है और देता है जो मूल स्ट्रिंग को इनकैप्सुलेट करता है। सभी String विधियों का एक यूनिकोड सुरक्षित संस्करण इस प्रॉक्सी वर्ग पर परिभाषित किया गया है। यदि प्रॉक्सी वर्ग एक निश्चित विधि का जवाब नहीं देता है, तो उसे एन्कैप्सुलेटेड स्ट्रिंग पर भेज दिया जाता है।

>> "lj".upcase
=> "lj"
>> "lj".mb_chars.upcase.to_s
=> "LJ"

नोट: उपरोक्त उदाहरण पूर्व रूबी २.४ के लिए उपयोगी है। रूबी 2.4 यूनिकोड केस मैपिंग का समर्थन करता है।

Method जंजीर

चार्ट प्रॉक्सी पर सभी विधियाँ जो आमतौर पर एक स्ट्रिंग लौटाती हैं, एक चार्ट ऑब्जेक्ट लौटाएगी। यह इन विधियों में से किसी भी विधि के परिणाम के लिए विधि की अनुमति देता है।

name.mb_chars.reverse.length # => 12

अंतर और विन्यास

चार्ट ऑब्जेक्ट String वस्तुओं के साथ संभव के रूप में विनिमेय होने की कोशिश करता है: String और चार काम के बीच की तरह छँटाई और तुलना करना। धमाकेदार! विधियाँ Chars ऑब्जेक्ट में आंतरिक स्ट्रिंग प्रतिनिधित्व को परिवर्तित करती हैं। एक to_s कॉल के साथ इंटरऑपरेबिलिटी समस्याएं आसानी से हल हो सकती हैं।

ActiveSupport::Multibyte::Chars प्रॉक्सी पर परिभाषित विधियों के बारे में अधिक जानकारी के लिए ActiveSupport::Multibyte::Chars । डिफ़ॉल्ट ActiveSupport::Multibyte व्यवहार को बदलने के तरीके के बारे में जानकारी के लिए ActiveSupport::Multibyte देखें।

पैरामीटराइज़ करें (विभाजक: "-", preserve_case: false) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 190
def parameterize(separator: "-", preserve_case: false)
  ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case)
end

विशेष वर्णों को एक स्ट्रिंग में बदल देता है ताकि इसे 'सुंदर' URL के हिस्से के रूप में उपयोग किया जा सके।

class Person
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

@person = Person.find(1)
# => #<Person id: 1, name: "Donald E. Knuth">

<%= link_to(@person.name, person_path) %>
# => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>

एक स्ट्रिंग में वर्णों के मामले को संरक्षित करने के लिए, preserve_case तर्क का उपयोग करें।

class Person
  def to_param
    "#{id}-#{name.parameterize(preserve_case: true)}"
  end
end

@person = Person.find(1)
# => #<Person id: 1, name: "Donald E. Knuth">

<%= link_to(@person.name, person_path) %>
# => <a href="/person/1-Donald-E-Knuth">Donald E. Knuth</a>
बहुवचन (गणना = शून्य, स्थान =: en) दिखाएँ स्रोत
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 33
def pluralize(count = nil, locale = :en)
  locale = count if count.is_a?(Symbol)
  if count == 1
    dup
  else
    ActiveSupport::Inflector.pluralize(self, locale)
  end
end

स्ट्रिंग में शब्द का बहुवचन रूप लौटाता है।

यदि वैकल्पिक पैरामीटर count निर्दिष्ट की जाती है, तो एकवचन फॉर्म को count == 1count के किसी भी अन्य मूल्य के लिए बहुवचन वापस आ जाएगा।

यदि वैकल्पिक पैरामीटर locale निर्दिष्ट किया जाता है, तो शब्द उस भाषा के शब्द के रूप में बहुवचन हो जाएगा। डिफ़ॉल्ट रूप से, यह पैरामीटर :en सेट है :en । आपको अंग्रेजी के अलावा अन्य भाषाओं के लिए अपने स्वयं के विभक्ति नियमों को परिभाषित करना होगा।

'post'.pluralize             # => "posts"
'octopus'.pluralize          # => "octopi"
'sheep'.pluralize            # => "sheep"
'words'.pluralize            # => "words"
'the blue mailman'.pluralize # => "the blue mailmen"
'CamelOctopus'.pluralize     # => "CamelOctopi"
'apple'.pluralize(1)         # => "apple"
'apple'.pluralize(2)         # => "apples"
'ley'.pluralize(:es)         # => "leyes"
'ley'.pluralize(1, :es)      # => "ley"
निकालें (* पैटर्न) स्रोत दिखाएँ
# File activesupport/lib/active_support/core_ext/string/filters.rb, line 32
def remove(*patterns)
  dup.remove!(*patterns)
end

हटाए गए पैटर्न की सभी घटनाओं के साथ एक नया स्ट्रिंग लौटाता है।

str = "foo bar test"
str.remove(" test")                 # => "foo bar"
str.remove(" test", /bar/)          # => "foo "
str                                 # => "foo bar test"
हटाना! (* पैटर्न) स्रोत दिखाएँ
# File activesupport/lib/active_support/core_ext/string/filters.rb, line 40
def remove!(*patterns)
  patterns.each do |pattern|
    gsub! pattern, ""
  end

  self
end

पैटर्न की सभी घटनाओं को हटाकर स्ट्रिंग को बदल देता है।

str = "foo bar test"
str.remove!(" test", /bar/)         # => "foo "
str                                 # => "foo "
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 78
def safe_constantize
  ActiveSupport::Inflector.safe_constantize(self)
end

safe_constantize स्ट्रिंग में निर्दिष्ट नाम के साथ एक घोषित स्थिरांक खोजने की कोशिश करता है। यह नाम जब CamelCase में नहीं है या आरंभिक नहीं है, तो यह nil हो जाता है। ActiveSupport::Inflector#safe_constantize देखें

'Module'.safe_constantize  # => Module
'Class'.safe_constantize   # => Class
'blargle'.safe_constantize # => nil
एकवचन (लोकेल =: en) दिखाएँ स्रोत
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 56
def singularize(locale = :en)
  ActiveSupport::Inflector.singularize(self, locale)
end

pluralize का उल्टा, एक स्ट्रिंग में एक शब्द का विलक्षण रूप देता है।

यदि वैकल्पिक पैरामीटर locale निर्दिष्ट किया जाता है, तो शब्द को उस भाषा के शब्द के रूप में एकवचन किया जाएगा। डिफ़ॉल्ट रूप से, यह पैरामीटर :en सेट है :en । आपको अंग्रेजी के अलावा अन्य भाषाओं के लिए अपने स्वयं के विभक्ति नियमों को परिभाषित करना होगा।

'posts'.singularize            # => "post"
'octopi'.singularize           # => "octopus"
'sheep'.singularize            # => "sheep"
'word'.singularize             # => "word"
'the blue mailmen'.singularize # => "the blue mailman"
'CamelOctopi'.singularize      # => "CamelOctopus"
'leyes'.singularize(:es)       # => "ley"
स्क्विश () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/filters.rb, line 13
def squish
  dup.squish!
end

स्ट्रिंग लौटाता है, पहले स्ट्रिंग के दोनों सिरों पर सभी व्हाट्सएप को हटाता है, और फिर शेष व्हाट्सएप समूहों को प्रत्येक स्थान में बदल रहा है।

ध्यान दें कि यह ASCII और यूनिकोड व्हाट्सएप दोनों को संभालता है।

%{ Multi-line
   string }.squish                   # => "Multi-line string"
" foo   bar    \n   \t   boo".squish # => "foo bar boo"
# File activesupport/lib/active_support/core_ext/string/filters.rb, line 21
def squish!
  gsub!(/[[:space:]]+/, " ")
  strip!
  self
end

एक विनाशकारी स्क्विश करता है। # देखें

str = " foo   bar    \n   \t   boo"
str.squish!                         # => "foo bar boo"
str                                 # => "foo bar boo"
# File activesupport/lib/active_support/core_ext/string/strip.rb, line 22
def strip_heredoc
  gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
end

हेरेड्स में स्ट्रिप्स इंडेंटेशन।

में उदाहरण के लिए

if options[:usage]
  puts <<-USAGE.strip_heredoc
    This command does such and such.

    Supported options are:
      -h         This message
      ...
  USAGE
end

उपयोगकर्ता उपयोग संदेश को बाएँ हाशिये के साथ जोड़कर देखता है।

तकनीकी रूप से, यह पूरे स्ट्रिंग में कम से कम इंडेंटेड नॉन-खाली लाइन की तलाश करता है, और अग्रणी व्हाट्सएप की उस राशि को निकालता है।

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 200
def tableize
  ActiveSupport::Inflector.tableize(self)
end

एक तालिका का नाम बनाता है जैसे मॉडल के नाम तालिका के लिए रेल करता है। यह विधि स्ट्रिंग में अंतिम शब्द पर pluralize विधि का उपयोग करती pluralize

'RawScaledScorer'.tableize # => "raw_scaled_scorers"
'ham_and_egg'.tableize     # => "ham_and_eggs"
'fancyCategory'.tableize   # => "fancy_categories"
शीर्षक (Keep_id_suffix: false)
इसके लिए उपनाम: titleize
शीर्षक (Keep_id_suffix: false) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 116
def titleize(keep_id_suffix: false)
  ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
end

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

अनुगामी '_id', 'Id' .. को रखा जा सकता है और वैकल्पिक पैरामीटर keep_id_suffix लिए कैपिटल किया जा सकता है keep_id_suffix लिए keep_id_suffix । डिफ़ॉल्ट रूप से, यह पैरामीटर गलत है।

titleize को titleize भी titleize जाता है।

'man from the boondocks'.titleize                       # => "Man From The Boondocks"
'x-men: the last stand'.titleize                        # => "X Men: The Last Stand"
'string_ending_with_id'.titleize(keep_id_suffix: true)  # => "String Ending With Id"
इसके अलावा उपनाम: titlecase
# File activesupport/lib/active_support/core_ext/string/access.rb, line 63
def to(position)
  self[0..position]
end

स्ट्रिंग की शुरुआत से दी गई स्थिति में एक विकल्प देता है। यदि स्थिति नकारात्मक है, तो इसे स्ट्रिंग के अंत से गिना जाता है।

str = "hello"
str.to(0)  # => "h"
str.to(3)  # => "hell"
str.to(-2) # => "hell"

आप इसे विधि from मिला सकते हैं और मजेदार चीजें कर सकते हैं जैसे:

str = "hello"
str.from(0).to(-1) # => "hello"
str.from(1).to(-2) # => "ell"
# File activesupport/lib/active_support/core_ext/string/conversions.rb, line 46
def to_date
  ::Date.parse(self, false) unless blank?
end

किसी स्ट्रिंग को Date मान में परिवर्तित करता है।

"1-1-2012".to_date   # => Sun, 01 Jan 2012
"01/01/2012".to_date # => Sun, 01 Jan 2012
"2012-12-13".to_date # => Thu, 13 Dec 2012
"12/13/2012".to_date # => ArgumentError: invalid date
# File activesupport/lib/active_support/core_ext/string/conversions.rb, line 56
def to_datetime
  ::DateTime.parse(self, false) unless blank?
end

किसी स्ट्रिंग को DateTime मान में कनवर्ट करता है।

"1-1-2012".to_datetime            # => Sun, 01 Jan 2012 00:00:00 +0000
"01/01/2012 23:59:59".to_datetime # => Sun, 01 Jan 2012 23:59:59 +0000
"2012-12-13 12:50".to_datetime    # => Thu, 13 Dec 2012 12:50:00 +0000
"12/13/2012".to_datetime          # => ArgumentError: invalid date
to_time (फ़ॉर्म =: स्थानीय) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/conversions.rb, line 21
def to_time(form = :local)
  parts = Date._parse(self, false)
  used_keys = %i(year mon mday hour min sec sec_fraction offset)
  return if (parts.keys & used_keys).empty?

  now = Time.now
  time = Time.new(
    parts.fetch(:year, now.year),
    parts.fetch(:mon, now.month),
    parts.fetch(:mday, now.day),
    parts.fetch(:hour, 0),
    parts.fetch(:min, 0),
    parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
    parts.fetch(:offset, form == :utc ? 0 : nil)
  )

  form == :utc ? time.utc : time.to_time
end

एक स्ट्रिंग को एक Time मान में परिवर्तित करता है। form या तो हो सकता है: utc या: स्थानीय (डिफ़ॉल्ट: स्थानीय)।

Time.parse पद्धति का उपयोग करके समय को पार कर लिया जाता है। यदि form है: स्थानीय, तो समय सिस्टम टाइमज़ोन में है। यदि तारीख वाला भाग गायब है, तो वर्तमान तिथि का उपयोग किया जाता है और यदि समय वाला भाग गायब है, तो इसे 00:00:00 माना जाता है।

"13-12-2012".to_time               # => 2012-12-13 00:00:00 +0100
"06:12".to_time                    # => 2012-12-13 06:12:00 +0100
"2012-12-13 06:12".to_time         # => 2012-12-13 06:12:00 +0100
"2012-12-13T06:12".to_time         # => 2012-12-13 06:12:00 +0100
"2012-12-13T06:12".to_time(:utc)   # => 2012-12-13 06:12:00 UTC
"12/13/2012".to_time               # => ArgumentError: argument out of range
truncate (truncate_at, विकल्प = {}) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/filters.rb, line 66
def truncate(truncate_at, options = {})
  return dup unless length > truncate_at

  omission = options[:omission] || "..."
  length_with_room_for_omission = truncate_at - omission.length
  stop = \
    if options[:separator]
      rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
    else
      length_with_room_for_omission
    end

  "#{self[0, stop]}#{omission}"
end

यदि दी गई length text लंबा है, तो दी गई length बाद दिए गए text को काटता है:

'Once upon a time in a world far far away'.truncate(27)
# => "Once upon a time in a wo..."

स्ट्रिंग या रेगेक्सप पास करें :separator प्राकृतिक ब्रेक पर text को अलग करने के लिए :separator :

'Once upon a time in a world far far away'.truncate(27, separator: ' ')
# => "Once upon a time in a..."

'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
# => "Once upon a time in a..."

अंतिम वर्ण कुल लंबाई के लिए :omission स्ट्रिंग ("डिफ़ॉल्ट" ...) के साथ प्रतिस्थापित किया जाएगा :omission लंबाई से अधिक नहीं

'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
# => "And they f... (continued)"
truncate_words (शब्द_ शब्द, विकल्प = {}) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/filters.rb, line 95
def truncate_words(words_count, options = {})
  sep = options[:separator] || /\s+/
  sep = Regexp.escape(sep.to_s) unless Regexp === sep
  if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
    $1 + (options[:omission] || "...")
  else
    dup
  end
end

दिए गए शब्दों की संख्या ( words_count शब्द) के बाद दिए गए text को words_count :

'Once upon a time in a world far far away'.truncate_words(4)
# => "Once upon a time..."

एक स्ट्रिंग या रीजैक्सप पास करें: शब्दों के एक अलग विभाजक को निर्दिष्ट करने के लिए विभाजक:

'Once<br>upon<br>a<br>time<br>in<br>a<br>world'.truncate_words(5, separator: '<br>')
# => "Once<br>upon<br>a<br>time<br>in..."

अंतिम वर्णों को इसके साथ बदल दिया जाएगा :omission स्ट्रिंग (“…” के लिए चूक):

'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)')
# => "And they found that many... (continued)"
अंडरस्कोर () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 127
def underscore
  ActiveSupport::Inflector.underscore(self)
end

camelize का camelize । स्ट्रिंग में अभिव्यक्ति से एक अंडरस्कोर, लोअरकेस फॉर्म बनाता है।

underscore भी नामस्थानों को रास्तों में बदलने के लिए '::' को '/' में बदल देगा।

'ActiveModel'.underscore         # => "active_model"
'ActiveModel::Errors'.underscore # => "active_model/errors"
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 240
def upcase_first
  ActiveSupport::Inflector.upcase_first(self)
end

केवल पहले चरित्र को अपरकेस में परिवर्तित करता है।

'what a Lovely Day'.upcase_first # => "What a Lovely Day"
'w'.upcase_first                 # => "W"
''.upcase_first                  # => ""