Ruby on Rails
ActiveSupport

Observaciones

Extensiones de núcleo: String Access

Cadena # en

Devuelve una subcadena de un objeto de cadena. La misma interfaz que 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)  # => ""

Cadena # de

Devuelve una subcadena desde la posición dada hasta el final de la cadena.

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

Cadena # a

Devuelve una subcadena desde el principio de la cadena a la posición dada.
Si la posición es negativa, se cuenta desde el final de la cadena.

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

from y to se puede utilizar en tándem.

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

Cadena # primero

Devuelve el primer carácter, o un número dado de caracteres hasta la longitud de la cadena.

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

Cadena # última

Devuelve el último carácter, o un número dado de caracteres desde el final de la cadena que cuenta hacia atrás.

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

Extensiones de núcleo: cadena a fecha / hora de conversión

Cadena # to_time

Convierte una cadena en un valor de tiempo. El parámetro de form puede ser :utc o :local , por defecto es :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

Cadena # to_date

Convierte una cadena en un valor de fecha.

"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

Cadena # to_datetime

Convierte una cadena a un valor 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

Extensiones de núcleo: Exclusión de cadenas

Cadena # ¿excluir?

La inversa de String#include?

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

Extensiones de núcleo: Filtros de cadena

Cuerda # squish

Devuelve una versión de la cadena dada sin espacios en blanco iniciales o finales, y combina todos los espacios en blanco consecutivos en el interior en espacios individuales. Squish versión destructiva squish! opera directamente en la instancia de cadena.

Maneja tanto los espacios en blanco ASCII como Unicode.

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

Cadena # eliminar

Devuelve una nueva cadena con todas las apariciones de los patrones eliminados. Versión destructiva remove! opera directamente en la cadena dada.

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

Cadena # truncar

Devuelve una copia de una cadena dada truncada en una longitud dada si la cadena es más larga que la longitud.

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

Pase una cadena o expresión regular :separator para truncar en un corte natural

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

Cadena # truncate_words

Devuelve una cadena truncada después de un número dado de palabras.

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

Pase una cadena o expresión regular para especificar un separador de palabras diferente

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

Los últimos caracteres se reemplazarán con la cadena de :omission (por defecto es "...")

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

Cadena # strip_heredoc

Tiras de sangrado en heredocs. Busca la línea no vacía menos sangrada y elimina esa cantidad de espacios en blanco iniciales.

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

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

el usuario vería

This command does such and such.

Supported options are:
-h         This message
...

Extensiones de núcleo: Inflexión de cuerdas

Cadena # pluralizar

Devoluciones de forma plural de la cadena. Opcionalmente toma un parámetro de count y devuelve una forma singular si count == 1 . También acepta un parámetro de locale para la pluralización específica del idioma.

'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

Devuelve la forma singular de la cadena. Acepta un parámetro de locale opcional.

'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

Intenta encontrar una constante declarada con el nombre especificado en la cadena. NameError un NameError nombre cuando el nombre no está en CamelCase o no está inicializado.

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

Cadena # safe_constantize

Realiza una constantize pero devuelve nil lugar de elevar NameError .

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

Cuerda # camelize

Convierte cadenas a UpperCamelCase de manera predeterminada, si :lower se da como param se convierte a lowerCamelCase en su lugar.

alias: camelcase

Nota: también convertirá / a :: que es útil para convertir rutas a espacios de nombres.

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

Cadena # título

Pone en mayúscula todas las palabras y reemplaza algunos caracteres en la cadena para crear un título de mejor apariencia.

alias: titlecase

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

Cadena # subrayado

Hace una forma subrayada, minúscula de la expresión en la cadena. El reverso de camelize .

Nota: el underscore también cambiará :: a / para convertir espacios de nombres en rutas.

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

Cadena # dasherizar

Reemplaza los guiones bajos con guiones en la cadena.

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

Cadena # demodulizar

Elimina la parte del módulo de la expresión constante en la cadena.

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

Cadena # desconstantizar

Elimina el segmento más a la derecha de la expresión constante en la cadena.

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

Cadena # parametrizar

Reemplaza los caracteres especiales en una cadena para que pueda usarse como parte de una URL "bonita".

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

Conserve el caso de los caracteres en una cadena con el argumento :preserve_case .

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

Un caso de uso muy común para la parameterize es anular el método to_param de un modelo ActiveRecord para admitir slugs de URL más descriptivos.

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

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

String # tableize

Crea el nombre de una tabla como lo hace Rails para modelos a nombres de tablas. Pluraliza la última palabra en la cadena.

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

Cadena # clasifica

Devuelve una cadena de nombre de clase de un nombre de tabla plural como lo hace Rails para los nombres de tabla a los modelos.

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

Cadena # humanizar

_id mayúscula la primera palabra, convierte los guiones bajos en espacios y _id un _id final si está presente.

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

Cadena # upcase_first

Convierte solo el primer carácter a mayúsculas.

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

Cadena # foreign_key

Crea un nombre de clave externa a partir de un nombre de clase. Pase false param para deshabilitar la adición de _ entre nombre e id .

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