Ruby on Rails
ActiveSupport

Opmerkingen

Core Extensions: String Access

String # bij

Retourneert een substring van een stringobject. Dezelfde interface als 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)  # => ""

String # uit

Retourneert een substring van de gegeven positie naar het einde van de string.

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

String # om

Retourneert een substring vanaf het begin van de tekenreeks naar de opgegeven positie.
Als de positie negatief is, wordt deze geteld vanaf het einde van de string.

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

from en to kunnen gelijktijdig worden gebruikt.

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

String # eerste

Retourneert het eerste teken of een bepaald aantal tekens tot de lengte van de tekenreeks.

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

String # laatste

Retourneert het laatste teken, of een bepaald aantal tekens vanaf het einde van de reeks die achteruit telt.

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

Core Extensions: String naar datum / tijd conversie

String # TO_TIME

Converteert een tekenreeks naar een tijdwaarde. De form kan zijn :utc of :local , standaard ingesteld op :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

String # TO_DATE

Converteert een tekenreeks naar een datumwaarde.

"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

String # to_datetime

Converteert een tekenreeks naar een DateTime-waarde.

"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

Core Extensions: String Exclusion

String # uitsluiten?

Het omgekeerde van String#include?

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

Core Extensions: Stringfilters

String # squish

Retourneert een versie van de opgegeven tekenreeks zonder voorloop- of volgspaties en combineert alle opeenvolgende witruimten in het interieur tot enkele spaties. Destructieve versie squish! werkt rechtstreeks op de stringinstantie.

Verwerkt zowel ASCII als Unicode witruimte.

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

String # verwijderen

Retourneert een nieuwe string met alle exemplaren van de patronen verwijderd. Destructieve versie remove! werkt direct op de gegeven string.

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

String # truncate

Retourneert een kopie van een gegeven tekenreeks die op een bepaalde lengte is afgekapt als de tekenreeks langer is dan de lengte.

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

Geef een string of regexp :separator om af te kappen bij een natuurlijke pauze

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

String # truncate_words

Retourneert een afgekorte tekenreeks na een bepaald aantal woorden.

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

Geef een tekenreeks of regexp door om een ander scheidingsteken voor woorden op te geven

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

De laatste tekens worden vervangen door de :omission string (standaard ingesteld op "...")

'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)')
# => "And they found that many... (continued)"

String # strip_heredoc

Strips inspringen in heredocs. Zoekt naar de minst ingesprongen niet-lege regel en verwijdert die hoeveelheid voorloopruimte.

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

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

de gebruiker zou het zien

This command does such and such.

Supported options are:
-h         This message
...

Core Extensions: String-verbuiging

String # meervoudig maken

Retourneert de meervoudsvorm van de tekenreeks. Neemt optioneel een count en retourneert een enkelvoud als count == 1 . Accepteert ook een locale parameter voor taalspecifieke pluralisatie.

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

String # singularize

Retourneert de enkelvoudige vorm van de tekenreeks. Accepteert een optionele locale parameter.

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

String # constantize

Probeert een aangegeven constante te vinden met de naam die is opgegeven in de tekenreeks. Het roept een NameError als de naam niet in CamelCase staat of niet is geïnitialiseerd.

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

String # safe_constantize

Voert een constantize maar retourneert nil plaats van NameError verhogen.

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

String # kameleren

Converteert standaard strings naar UpperCamelCase, als :lower wordt gegeven als param in plaats daarvan wordt geconverteerd naar lowerCamelCase.

alias: camelcase

Opmerking: converteert ook / naar :: wat handig is voor het converteren van paden naar naamruimten.

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

String # titleize

Hoofdletters in alle woorden en vervangt enkele tekens in de tekenreeks om een mooiere titel te maken.

alias: titlecase

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

String # underscore

Maakt een onderstreepte, kleine vorm van de uitdrukking in de tekenreeks. Het omgekeerde van camelize .

Opmerking: underscore verandert ook :: in / om naamruimten naar paden te converteren.

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

String # dasherize

Vervangt onderstrepingstekens door streepjes in de tekenreeks.

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

String # demodulize

Hiermee verwijdert u het modulegedeelte uit de constante uitdrukking in de tekenreeks.

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

String # deconstantize

Hiermee verwijdert u het meest rechtse segment uit de constante uitdrukking in de tekenreeks.

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

String # parametriseren

Vervangt speciale tekens in een tekenreeks zodat deze kan worden gebruikt als onderdeel van een 'mooie' URL.

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

Behoud het hoofdlettergebruik van de tekens in een tekenreeks met het argument :preserve_case .

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

Een veel voorkomende use-case voor parameterize is het overschrijven van de to_param methode van een ActiveRecord-model om meer beschrijvende url-naaktslakken te ondersteunen.

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

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

String # tableize

Creëert de naam van een tabel zoals Rails doet voor modellen naar tabelnamen. Pluraliseert het laatste woord in de string.

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

String # classificeren

Retourneert een klassennaamreeks uit een meervoudige tabelnaam zoals Rails doet voor tabelnamen naar modellen.

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

String # Humanize

Hoofdlettergebruik het eerste woord, verandert onderstrepingstekens in spaties en verwijdert een achterblijvende _id indien aanwezig.

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

String # upcase_first

Converteert alleen het eerste teken naar hoofdletters.

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

String # foreign_key

Creëert een buitenlandse sleutelnaam uit een klassennaam. Geef false parameter door om het toevoegen van _ tussen naam en id te schakelen.

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