класс String

Включить более предсказуемую типизацию по умолчанию для классов, похожих на строку. См. Object#acts_like?.

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

Если вы передаете одно целое число Fixnum, возвращает подстроку длиной в один символ в указанной позиции. Первый символ строки находится в позиции 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/string/access.rb, line 27
def at(position)
  self[position]
end

Строка считается пустой, если она пуста или содержит только пробелы:

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

Поддерживаются Unicode-пробелы:

"\u00a0".blank? # => true

@return [true, false]

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 115
def blank?
  BLANK_RE === self
end

По умолчанию, camelize преобразует строки в UpperCamelCase. Если аргумент для camelize установлен в :lower, camelize создаёт lowerCamelCase.

camelize также преобразует '/' в '::', что полезно для преобразования путей в пространства имён.

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

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 89
def camelize(first_letter = :upper)
  case first_letter
  when :upper
    ActiveSupport::Inflector.camelize(self, true)
  when :lower
    ActiveSupport::Inflector.camelize(self, false)
  end
end

Создаёт имя класса из множественного имени таблицы, как это делает Rails для имён таблиц и моделей. Обратите внимание, что это возвращает строку, а не класс. (Для преобразования в фактический класс следуйте classify с constantize.)

'egg_and_hams'.classify # => "EggAndHam"
'posts'.classify        # => "Post"

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 185
def classify
  ActiveSupport::Inflector.classify(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 65
def constantize
  ActiveSupport::Inflector.constantize(self)
end

Заменяет все символы подчёркивания на тире в строке.

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

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 125
def dasherize
  ActiveSupport::Inflector.dasherize(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 148
def deconstantize
  ActiveSupport::Inflector.deconstantize(self)
end

Удаляет часть модуля из выражения константы в строке.

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

См. также deconstantize.

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

Обратная функция String#include?. Возвращает true, если строка не содержит другую строку.

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

# File activesupport/lib/active_support/core_ext/string/exclude.rb, line 8
def exclude?(string)
  !include?(string)
end

Возвращает первый символ. Если передан лимит, возвращает подстроку с начала строки до достижения значения лимита. Если переданный лимит больше или равен длине строки, возвращает self.

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/access.rb, line 75
def first(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    to(limit - 1)
  end
end

Создаёт имя внешнего ключа из имени класса. separate_class_name_and_id_with_underscore определяет, следует ли методу вставлять '_' между именем и 'id'.

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

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 211
def foreign_key(separate_class_name_and_id_with_underscore = true)
  ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
end

Возвращает подстроку от заданной позиции до конца строки. Если позиция отрицательная, она считается с конца строки.

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

Можно комбинировать его с методом to и делать интересные вещи, такие как:

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

# File activesupport/lib/active_support/core_ext/string/access.rb, line 44
def from(position)
  self[position..-1]
end

Выводит первое слово с большой буквы, заменяет подчёркивания пробелами и удаляет заключительный '_id', если он есть. Как и titleize, это предназначено для создания красивого вывода.

Регистр первого слова можно отключить, установив необязательный параметр capitalize в false. По умолчанию этот параметр равен true.

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

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 200
def humanize(options = {})
  ActiveSupport::Inflector.humanize(self, options)
end

Преобразует String в TimeWithZone в текущей зоне, если Time.zone или Time.zone_default установлены, в противном случае преобразует String в Time через #to_time

# File activesupport/lib/active_support/core_ext/string/zones.rb, line 7
def in_time_zone(zone = ::Time.zone)
  if zone
    ::Time.find_zone!(zone).parse(self)
  else
    to_time
  end
end

Отступы строк в получателе:

"def some_method
  some_code
end
".indent(2)
# =>
  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, — это флаг, указывающий, нужно ли отступать пустые строки. По умолчанию — false.

"foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
"foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"

# File activesupport/lib/active_support/core_ext/string/indent.rb, line 40
def indent(amount, indent_string=nil, indent_empty_lines=false)
  dup.tap {|_| _.indent!(amount, indent_string, indent_empty_lines)}
end

Аналогично indent, но отступы применяются к получателю непосредственно.

Возвращает отформатированную строку или nil, если отступать нечего.

# File activesupport/lib/active_support/core_ext/string/indent.rb, line 5
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

Заворачивает текущую строку в класс ActiveSupport::StringInquirer, что дает вам более удобный способ проверки на равенство.

env = 'production'.inquiry
env.production?  # => true
env.development? # => false

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

Возвращает последний символ строки. Если указан limit, возвращает подстроку с конца строки до значения limit (считая назад). Если заданный limit больше или равен длине строки, возвращает self.

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/access.rb, line 95
def last(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    from(-limit)
  end
end

Прокси для многобайтовых строк

mb_chars — это безопасный прокси для методов работы со строками, учитывающий многобайтовые символы.

Он создает и возвращает экземпляр класса ActiveSupport::Multibyte::Chars, который инкапсулирует исходную строку. В этом прокси-классе определены безопасные для Unicode версии всех методов String. Если прокси-класс не отвечает на определенный метод, он передается инкапсулированной строке.

name = 'Claus Müller'
name.reverse # => "rell??M sualC"
name.length  # => 13

name.mb_chars.reverse.to_s # => "rellüM sualC"
name.mb_chars.length       # => 12

Цепочки методов

Все методы в прокси Chars, которые обычно возвращают строку, будут возвращать объект Chars. Это позволяет использовать цепочки методов для результата любого из этих методов.

name.mb_chars.reverse.length # => 12

Взаимодействие и конфигурация

Объект Chars старается быть максимально взаимозаменяемым с объектами String: сортировка и сравнение между String и Char работают как ожидается. Методы с ! изменяют внутреннее строковое представление в объекте Chars. Проблемы взаимодействия можно легко решить с помощью вызова to_s.

Для получения дополнительной информации о методах, определенных в прокси Chars, см. ActiveSupport::Multibyte::Chars. Для получения информации о том, как изменить поведение Multibyte по умолчанию, см. ActiveSupport::Multibyte.

# File activesupport/lib/active_support/core_ext/string/multibyte.rb, line 34
def mb_chars
  ActiveSupport::Multibyte.proxy_class.new(self)
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>

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 165
def parameterize(sep = '-')
  ActiveSupport::Inflector.parameterize(self, sep)
end

Возвращает форму множественного числа слова в строке.

Если указан необязательный параметр count, то если count == 1, будет возвращена единственная форма. Для любого другого значения count будет возвращена множественная форма.

Если указан необязательный параметр locale, слово будет поставлено во множественное число как слово этого языка. По умолчанию этот параметр установлен в :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/inflections.rb, line 31
def pluralize(count = nil, locale = :en)
  locale = count if count.is_a?(Symbol)
  if count == 1
    self
  else
    ActiveSupport::Inflector.pluralize(self, locale)
  end
end

Возвращает новую строку со всеми вхождениями шаблона, удаленными. Сокращение для String#gsub(pattern, '').

# File activesupport/lib/active_support/core_ext/string/filters.rb, line 24
def remove(pattern)
  gsub pattern, ''
end

Изменяет строку, удаляя все вхождения шаблона. Сокращение для String#gsub!(pattern, '').

# File activesupport/lib/active_support/core_ext/string/filters.rb, line 29
def remove!(pattern)
  gsub! pattern, ''
end

safe_constantize пытается найти объявленную константу с именем, указанным в строке. Возвращает nil, когда имя не в CamelCase или не инициализировано. См. ActiveSupport::Inflector#safe_constantize

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

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

Обратное к pluralize, возвращает единственную форму слова в строке.

Если указан необязательный параметр locale, слово будет переведено в единственное число как слово этого языка. По умолчанию этот параметр установлен в :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/inflections.rb, line 54
def singularize(locale = :en)
  ActiveSupport::Inflector.singularize(self, locale)
end

Возвращает строку, сначала удаляя все пробелы с обоих концов строки, а затем заменяя оставшиеся последовательные группы пробелов на один пробел.

Обратите внимание, что он обрабатывает как ASCII, так и Unicode-пробелы.

%Q{ 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 11
def squish
  dup.squish!
end

Выполняет деструктивное сжатие. См. #squish.

# File activesupport/lib/active_support/core_ext/string/filters.rb, line 16
def squish!
  gsub!(/\A[[:space:]]+/, '')
  gsub!(/[[:space:]]+\z/, '')
  gsub!(/[[:space:]]+/, ' ')
  self
end

Удаляет отступы в heredoc.

Например, в

if options[:usage]
  puts "    This command does such and such.

    Supported options are:
      -h         This message
      ...
".strip_heredoc
end

пользователь увидит сообщение об использовании, выровненное по левому краю.

Технически, он ищет строку с наименьшим отступом во всей строке и удаляет это количество ведущих пробелов.

# File activesupport/lib/active_support/core_ext/string/strip.rb, line 22
def strip_heredoc
  indent = scan(/^[ \t]*(?=\S)/).min.try(:size) || 0
  gsub(/^[ \t]{#{indent}}/, '')
end

Создает имя таблицы, как это делает Rails для моделей в именах таблиц. Этот метод использует метод pluralize для последнего слова в строке.

'RawScaledScorer'.tableize # => "raw_scaled_scorers"
'egg_and_ham'.tableize     # => "egg_and_hams"
'fancyCategory'.tableize   # => "fancy_categories"

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

Записывает все слова с большой буквы и заменяет некоторые символы в строке, чтобы создать более приятный заголовок. titleize предназначен для создания красивого вывода. Он не используется во внутренних компонентах Rails.

titleize также является псевдонимом для titlecase.

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

# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 107
def titleize
  ActiveSupport::Inflector.titleize(self)
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/access.rb, line 61
def to(position)
  self[0..position]
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 43
def to_date
  ::Date.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

# File activesupport/lib/active_support/core_ext/string/conversions.rb, line 53
def to_datetime
  ::DateTime.parse(self, false) unless blank?
end

Преобразует строку в значение Time. form может быть либо :utc, либо :local (по умолчанию :local).

Время анализируется с помощью метода Time.parse. Если form равно :local, то время находится в часовом поясе системы. Если часть даты отсутствует, используется текущая дата, а если часть времени отсутствует, то предполагается, что она равна 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 05:12:00 UTC
"12/13/2012".to_time               # => ArgumentError: argument out of range

# File activesupport/lib/active_support/core_ext/string/conversions.rb, line 19
def to_time(form = :local)
  parts = Date._parse(self, false)
  return if parts.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.getlocal
end

Усекает заданный text после заданной length, если text длиннее length:

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

Передайте строку или регулярное выражение :separator для усечения text на естественном разрыве:

'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 (по умолчанию «…») для общей длины, не превышающей length:

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

# File activesupport/lib/active_support/core_ext/string/filters.rb, line 51
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

Обратное преобразование к camelize. Преобразует выражение в строке к подчёркнутой, строчной форме.

underscore также изменит '::' на '/' для преобразования пространств имён в пути.

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

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