Ruby on Rails
ActiveSupport
खोज…
टिप्पणियों
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"
