खोज…


टिप्पणियों

ActiveSupport रेल के बाकी ढांचे द्वारा उपयोग किए जाने वाले सामान्य प्रयोजन के उपकरण का एक उपयोगिता रत्न है।

इन साधनों को प्रदान करने वाले प्राथमिक तरीकों में से एक रूबी के मूल प्रकारों को बंद करना है। इन्हें कोर एक्सटेंशन्स के रूप में जाना जाता है।

कोर एक्सटेंशन्स: स्ट्रिंग एक्सेस

स्ट्रिंग # पर

किसी स्ट्रिंग ऑब्जेक्ट का एक विकल्प देता है। String#[] रूप में एक ही इंटरफ़ेस।

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)  # => ""

स्ट्रिंग # से

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

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

स्ट्रिंग # करने के लिए

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

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

from और to संगठनों ने मिलकर किया जा सकता है।

str = "hello"
str.from(0).to(-1) # => "hello"
str.from(1).to(-2) # => "ell"

स्ट्रिंग # पहले

स्ट्रिंग की लंबाई तक पहले वर्ण, या दिए गए वर्णों की संख्या लौटाता है।

str = "hello"
str.first    # => "h"
str.first(1) # => "h"
str.first(2) # => "he"
str.first(0) # => ""
str.first(6) # => "hello"

स्ट्रिंग # पिछले

स्ट्रिंग की गिनती के अंत से अंतिम वर्ण, या दिए गए वर्णों की संख्या को पीछे की ओर लौटाता है।

str = "hello"
str.last    # => "o"
str.last(1) # => "o"
str.last(2) # => "lo"
str.last(0) # => ""
str.last(6) # => "hello"

कोर एक्सटेंशन्स: स्ट्रिंग टू डेट / टाइम कन्वर्सेशन

स्ट्रिंग # TO_TIME

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

"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

स्ट्रिंग # TO_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

स्ट्रिंग # to_datetime

किसी स्ट्रिंग को 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

कोर एक्सटेंशन्स: स्ट्रिंग अपवर्जन

स्ट्रिंग # निकालें?

String#include? व्युत्क्रम में String#include?

"hello".exclude? "lo" # => false
"hello".exclude? "ol" # => true
"hello".exclude? ?h   # => false

कोर एक्सटेंशन्स: स्ट्रिंग फिल्टर

स्ट्रिंग # तोड़ो

व्हाट्सएप को अग्रणी या पीछे किए बिना दिए गए स्ट्रिंग के एक संस्करण को लौटाता है, और इंटीरियर में सभी निरंतर व्हाट्सएप को सिंगल स्पेस में जोड़ता है। विनाशकारी संस्करण squish! सीधे स्ट्रिंग उदाहरण पर कार्य करता है।

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

%{ Multi-line
   string }.squish                   # => "Multi-line string"
" foo   bar    \n   \t   boo".squish # => "foo bar boo"

स्ट्रिंग # निकालें

हटाए गए पैटर्न की सभी घटनाओं के साथ एक नया स्ट्रिंग लौटाता है। विनाशकारी संस्करण remove! सीधे दिए गए स्ट्रिंग पर काम करता है।

str = "foo bar test"
str.remove(" test")                 # => "foo bar"
str.remove(" test", /bar/)          # => "foo "

स्ट्रिंग # truncate

दी गई स्ट्रिंग की एक प्रति लौटा दी गई है यदि स्ट्रिंग लंबाई से अधिक लंबी है।

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

एक स्ट्रिंग या रेगेक्सप पास करें :separator एक प्राकृतिक ब्रेक पर अलग करने के लिए :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..."

स्ट्रिंग # truncate_words

दिए गए शब्दों की संख्या के बाद एक तार काट दिया जाता है।

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

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

'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)"

स्ट्रिंग # strip_heredoc

हेरेड्स में स्ट्रिप्स इंडेंटेशन। कम-से-कम गैर-खाली लाइन की तलाश करता है और प्रमुख व्हाट्सएप की मात्रा को हटा देता है।

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

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

उपयोगकर्ता देखेगा

This command does such and such.

Supported options are:
-h         This message
...

कोर एक्सटेंशन्स: स्ट्रिंग इन्फ्लेक्शन

स्ट्रिंग # pluralize

स्ट्रिंग के बहुवचन रूप की वापसी। वैकल्पिक रूप से एक count पैरामीटर लेता है और यदि count == 1 एकवचन रूप देता है। भाषा-विशिष्ट बहुवचन के लिए एक locale पैरामीटर भी स्वीकार करता है।

'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"

स्ट्रिंग # singularize

स्ट्रिंग का एकवचन रूप देता है। एक वैकल्पिक locale पैरामीटर स्वीकार करता है।

'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"

स्ट्रिंग # constantize

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

'Module'.constantize  # => Module
'Class'.constantize   # => Class
'blargle'.constantize # => NameError: wrong constant name blargle

स्ट्रिंग # safe_constantize

एक constantize प्रदर्शन करता है, लेकिन NameError को बढ़ाने के बजाय nil लौटाता है।

'Module'.safe_constantize  # => Module
'Class'.safe_constantize   # => Class
'blargle'.safe_constantize # => nil

स्ट्रिंग # camelize

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

अन्य: camelcase

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

'active_record'.camelize                # => "ActiveRecord"
'active_record'.camelize(:lower)        # => "activeRecord"
'active_record/errors'.camelize         # => "ActiveRecord::Errors"
'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"

स्ट्रिंग # titleize

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

उपनाम: titlecase

'man from the boondocks'.titleize # => "Man From The Boondocks"
'x-men: the last stand'.titleize  # => "X Men: The Last Stand"

स्ट्रिंग # अंडरस्कोर

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

नोट: underscore भी बदल जाएगा :: करने के लिए / पथ नामस्थान कन्वर्ट करने के लिए।

'ActiveModel'.underscore         # => "active_model"
'ActiveModel::Errors'.underscore # => "active_model/errors"

स्ट्रिंग # dasherize

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

'puni_puni'.dasherize # => "puni-puni"

स्ट्रिंग # demodulize

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

'ActiveRecord::CoreExtensions::String::Inflections'.demodulize # => "Inflections"
'Inflections'.demodulize                                       # => "Inflections"
'::Inflections'.demodulize                                     # => "Inflections"
''.demodulize                                                  # => ''

स्ट्रिंग # deconstantize

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

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

स्ट्रिंग # parameterize

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

"Donald E. Knuth".parameterize # => "donald-e-knuth"

वर्णों के मामले को एक स्ट्रिंग में :preserve_case करें :preserve_case तर्क।

"Donald E. Knuth".parameterize(preserve_case: true) # => "Donald-E-Knuth"

parameterize करने के लिए एक बहुत ही सामान्य उपयोग केस अधिक वर्णनात्मक यूआरएल स्लग का समर्थन करने के लिए एक ActiveRecord मॉडल के to_param विधि को ओवरराइड करने के लिए है।

class Person < ActiveRecord::Base
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

Person.find(1).to_param # => "1-donald-e-knuth"

स्ट्रिंग # tableize

एक तालिका का नाम बनाता है जैसे मॉडल के नाम तालिका के लिए रेल करता है। स्ट्रिंग में अंतिम शब्द को बहुलता देता है।

'RawScaledScorer'.tableize # => "raw_scaled_scorers"
'ham_and_egg'.tableize     # => "ham_and_eggs"
'fancyCategory'.tableize   # => "fancy_categories"

स्ट्रिंग # वर्गीकृत

एक बहुवचन तालिका नाम से एक वर्ग नाम स्ट्रिंग लौटाता है जैसे रेल मॉडल के तालिका नामों के लिए करता है।

'ham_and_eggs'.classify # => "HamAndEgg"
'posts'.classify        # => "Post"

स्ट्रिंग # मानवीयकरण

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

'employee_salary'.humanize              # => "Employee salary"
'author_id'.humanize                    # => "Author"
'author_id'.humanize(capitalize: false) # => "author"
'_id'.humanize                          # => "Id"

स्ट्रिंग # upcase_first

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

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

स्ट्रिंग # foreign_key

एक वर्ग नाम से एक विदेशी कुंजी नाम बनाता है। नाम और id बीच _ जोड़ने को अक्षम करने के लिए false परम पास करें।

'Message'.foreign_key        # => "message_id"
'Message'.foreign_key(false) # => "messageid"
'Admin::Post'.foreign_key    # => "post_id"


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow