Descripción General de Action View

1 ¿Qué es Action View?

Action View es la V en MVC. Action Controller y Action View trabajan juntos para manejar solicitudes web. Action Controller se encarga de comunicarse con la capa del modelo (de MVC) y recuperar datos. Action View es entonces responsable de renderizar un cuerpo de respuesta a la solicitud web usando esos datos.

Por defecto, las plantillas de Action View (también referidas simplemente como "vistas") están escritas usando Ruby Embebido (ERB), lo que permite usar código Ruby dentro de documentos HTML.

Action View proporciona muchos métodos helper para generar dinámicamente etiquetas HTML para formularios, fechas y cadenas. También es posible agregar helpers personalizados a tu aplicación según sea necesario.

NOTA: Action View puede hacer uso de características de Active Model como to_param y to_partial_path para simplificar el código. Eso no significa que Action View dependa de Active Model. Action View es un paquete independiente que se puede usar con cualquier biblioteca Ruby.

2 Usando Action View con Rails

Las plantillas de Action View (también conocidas como "vistas") se almacenan en subdirectorios en el directorio app/views. Hay un subdirectorio que coincide con el nombre de cada controlador. Los archivos de vista dentro de ese subdirectorio se utilizan para renderizar vistas específicas como respuesta a acciones del controlador.

Por ejemplo, cuando usas scaffolding para generar un recurso article, Rails genera los siguientes archivos en app/views/articles:

$ bin/rails generate scaffold article
      [...]
      invoke  scaffold_controller
      create    app/controllers/articles_controller.rb
      invoke    erb
      create      app/views/articles
      create      app/views/articles/index.html.erb
      create      app/views/articles/edit.html.erb
      create      app/views/articles/show.html.erb
      create      app/views/articles/new.html.erb
      create      app/views/articles/_form.html.erb
      [...]

Los nombres de los archivos siguen una convención de nomenclatura de Rails. Comparten su nombre con la acción del controlador asociada. Por ejemplo, index.html.erb, edit.html.erb, etc.

Al seguir esta convención de nomenclatura, Rails encontrará automáticamente y renderizará la vista correspondiente al final de una acción del controlador, sin que tengas que especificarlo. Por ejemplo, la acción index en el articles_controller.rb renderizará automáticamente la vista index.html.erb dentro del directorio app/views/articles/. El nombre y la ubicación del archivo son importantes.

El HTML final devuelto al cliente se compone de una combinación del archivo ERB .html.erb, una plantilla de diseño que lo envuelve, y todos los parciales que el archivo ERB pueda referenciar. En el resto de esta guía, encontrarás más detalles sobre cada uno de los tres componentes: Plantillas, Parciales, Diseños.

3 Plantillas

Las plantillas de Action View pueden escribirse en diferentes formatos. Si el archivo de plantilla tiene una extensión .erb, utiliza Ruby embebido para construir una respuesta HTML. Si la plantilla tiene una extensión .jbuilder, utiliza la gema Jbuilder para construir una respuesta JSON. Y una plantilla con una extensión .builder utiliza la librería Builder::XmlMarkup para construir una respuesta XML.

Rails usa la extensión del archivo para distinguir entre múltiples sistemas de plantillas. Por ejemplo, un archivo HTML que usa el sistema de plantillas ERB tendrá .html.erb como extensión de archivo, y un archivo JSON que usa el sistema de plantillas Jbuilder tendrá la extensión de archivo .json.jbuilder. Otras bibliotecas pueden agregar otros tipos de plantillas y extensiones de archivo también.

3.1 ERB

Una plantilla ERB es una manera de esparcir código Ruby dentro de HTML estático usando etiquetas ERB especiales como <% %> y <%= %>.

Cuando Rails procesa las plantillas de vista ERB que terminan con .html.erb, evalúa el código Ruby embebido y reemplaza las etiquetas ERB con la salida dinámica. Ese contenido dinámico se combina con el marcado HTML estático para formar la respuesta HTML final.

Dentro de una plantilla ERB, se puede incluir código Ruby usando tanto las etiquetas <% %> como <%= %>. La etiqueta <% %> (sin el =) se usa cuando quieres ejecutar código Ruby pero no directamente mostrar el resultado, como condiciones o bucles. La etiqueta <%= %> se usa para código Ruby que genera una salida y quieres que esa salida se renderice dentro de la plantilla, como un atributo de modelo como person.name en este ejemplo:

<h1>Nombres</h1>
<% @people.each do |person| %>
  Nombre: <%= person.name %><br>
<% end %>

El bucle se configura usando etiquetas de incrustación regulares (<% %>) y el nombre se inserta usando las etiquetas de incrustación de salida (<%= %>).

Ten en cuenta que funciones como print y puts no se renderizarán en la vista con plantillas ERB. Así que algo como esto no funcionaría:

<%# INCORRECTO %>
Hola, Sr. <% puts "Frodo" %>

El ejemplo anterior muestra que se pueden agregar comentarios en ERB dentro de la etiqueta <%# %>.

Para suprimir espacios en blanco iniciales y finales, puedes usar <%- -%> intercambiablemente con <% y %>.

3.2 Jbuilder

Jbuilder es una gema mantenida por el equipo de Rails e incluida en el Gemfile por defecto de Rails. Se utiliza para construir respuestas JSON usando plantillas.

Si no lo tienes, puedes agregar lo siguiente a tu Gemfile:

gem "jbuilder"

Un objeto Jbuilder llamado json está disponible automáticamente para las plantillas con una extensión .jbuilder.

Aquí hay un ejemplo básico:

json.name("Alex")
json.email("alex@example.com")

produciría:

{
  "name": "Alex",
  "email": "alex@example.com"
}

Consulta la documentación de Jbuilder para más ejemplos.

3.3 Builder

Las plantillas Builder son una alternativa más programática a ERB. Es similar a JBuilder pero se utiliza para generar XML, en lugar de JSON.

Un objeto XmlMarkup llamado xml está disponible automáticamente para las plantillas con una extensión .builder.

Aquí hay un ejemplo básico:

xml.em("enfatizado")
xml.em { xml.b("énfasis y negrita") }
xml.a("Un Enlace", "href" => "https://rubyonrails.org")
xml.target("name" => "compilar", "option" => "rápido")

lo cual produciría:

<em>enfatizado</em>
<em><b>énfasis &amp; negrita</b></em>
<a href="https://rubyonrails.org">Un enlace</a>
<target option="rápido" name="compilar" />

Cualquier método con un bloque se tratará como una etiqueta de marcado XML con marcado anidado en el bloque. Por ejemplo, lo siguiente:

xml.div {
  xml.h1(@person.name)
  xml.p(@person.bio)
}

produciría algo como:

<div>
  <h1>David Heinemeier Hansson</h1>
  <p>Un producto del Diseño Danés durante el Invierno del '79...</p>
</div>

Consulta la documentación de Builder para más ejemplos.

3.4 Compilación de Plantillas

Por defecto, Rails compilará cada plantilla en un método para renderizarla. En el entorno de desarrollo, cuando alteras una plantilla, Rails verificará el tiempo de modificación del archivo y lo recompilará.

También hay almacenamiento en caché de fragmentos para cuando diferentes partes de la página necesitan ser almacenadas y caducadas por separado. Aprende más sobre esto en la guía de almacenamiento en caché.

4 Parciales

Las plantillas parciales, usualmente llamadas simplemente "parciales", son una manera de dividir las plantillas de vista en fragmentos más pequeños y reutilizables. Con parciales, puedes extraer un fragmento de código de tu plantilla principal a un archivo separado más pequeño, y renderizar ese archivo en la plantilla principal. También puedes pasar datos a los archivos parciales desde la plantilla principal.

Veamos esto en acción con algunos ejemplos:

4.1 Renderizando Parciales

Para renderizar un parcial como parte de una vista, usas el método render dentro de la vista:

<%= render "product" %>

Esto buscará un archivo llamado _product.html.erb en la misma carpeta para renderizar dentro de esa vista. Los nombres de archivo parciales comienzan con un carácter de guion bajo por convención. El nombre del archivo distingue los parciales de las vistas regulares. Sin embargo, no se usa guion bajo al referirse a parciales para renderizar dentro de una vista. Esto es cierto incluso cuando refieres un parcial de otro directorio:

<%= render "application/product" %>

Ese código buscará y mostrará un archivo parcial llamado _product.html.erb en app/views/application/.

4.2 Usando Parciales para Simplificar Vistas

Una manera de usar parciales es tratarlos como el equivalente de métodos. Una forma de mover detalles fuera de una vista para que puedas entender más fácilmente lo que está pasando. Por ejemplo, podrías tener una vista que se vea así:

<%= render "application/ad_banner" %>

<h1>Productos</h1>

<p>Aquí hay algunos de nuestros excelentes productos:</p>
<% @products.each do |product| %>
  <%= render partial: "product", locals: { product: product } %>
<% end %>

<%= render "application/footer" %>

Aquí, los parciales _ad_banner.html.erb y _footer.html.erb podrían contener contenido que se comparte entre muchas páginas en tu aplicación. No necesitas ver los detalles de estas secciones cuando estás enfocado en una página de Productos.

El ejemplo anterior también usa el parcial _product.html.erb. Este parcial contiene detalles para renderizar un producto individual y se usa para renderizar cada producto en la colección @products.

4.3 Pasando Datos a Parciales con la Opción `locals`

Al renderizar un parcial, puedes pasar datos al parcial desde la vista que lo renderiza. Usas la opción locals: hash para esto. Cada clave en la opción locals: está disponible como una variable local del parcial:

<%# app/views/products/show.html.erb %>

<%= render partial: "product", locals: { my_product: @product } %>

<%# app/views/products/_product.html.erb %>

<%= tag.div id: dom_id(my_product) do %>
  <h1><%= my_product.name %></h1>
<% end %>

Una "variable local de parcial" es una variable que es local a un parcial dado y solo está disponible dentro de ese parcial. En el ejemplo anterior, my_product es una variable local de parcial. Se le asignó el valor de @product cuando se pasó al parcial desde la vista original.

Ten en cuenta que normalmente simplemente llamaríamos a esta variable local product. Estamos usando my_product para distinguirlo del nombre de la variable de instancia y el nombre de la plantilla en este ejemplo.

Dado que locals es un hash, puedes pasar múltiples variables según sea necesario, como locals: { my_product: @product, my_reviews: @reviews }.

Sin embargo, si una plantilla se refiere a una variable que no se pasa a la vista como parte de la opción locals:, la plantilla generará un ActionView::Template::Error:

<%# app/views/products/_product.html.erb %>

<%= tag.div id: dom_id(my_product) do %>
  <h1><%= my_product.name %></h1>

  <%# => genera ActionView::Template::Error para `product_reviews` %>
  <% product_reviews.each do |review| %>
    <%# ... %>
  <% end %>
<% end %>

4.4 Usando `local_assigns`

Cada parcial tiene un método llamado local_assigns disponible. Puedes usar este método para acceder a claves pasadas a través de la opción locals:. Si un parcial no fue renderizado con :some_key establecido, el valor de local_assigns[:some_key] será nil dentro del parcial.

Por ejemplo, product_reviews es nil en el siguiente ejemplo ya que solo product está establecido en locals::

<%# app/views/products/show.html.erb %>

<%= render partial: "product", locals: { product: @product } %>

<%# app/views/products/_product.html.erb %>

<% local_assigns[:product]          # => "#<Product:0x0000000109ec5d10>" %>
<% local_assigns[:product_reviews]  # => nil %>

Un caso de uso para local_assigns es pasar opcionalmente una variable local y luego realizar condicionalmente una acción en el parcial basado en si la variable local está establecida. Por ejemplo:

<% if local_assigns[:redirect] %>
  <%= form.hidden_field :redirect, value: true %>
<% end %>

Otro ejemplo de _blob.html.erb de Active Storage. Este establece el tamaño basado en si la variable local in_gallery está establecida al renderizar el parcial que contiene esta línea:

<%= image_tag blob.representation(resize_to_limit: local_assigns[:in_gallery] ? [ 800, 600 ] : [ 1024, 768 ]) %>

4.5 `render` sin Opciones `partial` y `locals`

En los ejemplos anteriores, render toma 2 opciones: partial y locals. Pero si estas son las únicas opciones que necesitas usar, puedes omitir las claves, partial y locals, y especificar solo los valores.

Por ejemplo, en lugar de:

<%= render partial: "product", locals: { product: @product } %>

Puedes escribir:

<%= render "product", product: @product %>

También puedes usar esta forma abreviada basada en convenciones:

<%= render @product %>

Esto buscará un parcial llamado _product.html.erb en app/views/products/, así como pasar un local llamado product establecido en el valor @product.

4.6 Las Opciones `as` y `object`

Por defecto, los objetos pasados a la plantilla están en una variable local con el mismo nombre que la plantilla. Entonces, dado:

<%= render @product %>

dentro del parcial _product.html.erb obtendrás la variable de instancia @product en la variable local product, como si hubieras escrito:

<%= render partial: "product", locals: { product: @product } %>

La opción object se puede usar para especificar un nombre diferente. Esto es útil cuando el objeto de la plantilla está en otro lugar (por ejemplo, en una variable de instancia diferente o en una variable local).

Por ejemplo, en lugar de:

<%= render partial: "product", locals: { product: @item } %>

puedes escribir:

<%= render partial: "product", object: @item %>

Esto asigna la variable de instancia @item a una variable local de parcial llamada product. ¿Qué pasa si quisieras cambiar el nombre de la variable local del valor predeterminado product a algo más? Puedes usar la opción :as para eso.

Con la opción as, puedes especificar un nombre diferente para la variable local así:

<%= render partial: "product", object: @item, as: "item" %>

Esto es equivalente a

<%= render partial: "product", locals: { item: @item } %>

4.7 Renderizando Colecciones

Es común que una vista itere sobre una colección, como @products, y renderice una plantilla parcial para cada objeto en la colección. Este patrón ha sido implementado como un único método que acepta un array y renderiza un parcial para cada uno de los elementos en el array.

Así que este ejemplo para renderizar todos los productos:

<% @products.each do |product| %>
  <%= render partial: "product", locals: { product: product } %>
<% end %>

puede reescribirse en una sola línea:

<%= render partial: "product", collection: @products %>

Cuando un parcial se llama con una colección, las instancias individuales del parcial tienen acceso al miembro de la colección que se está renderizando a través de una variable nombrada después del parcial. En este caso, dado que el parcial es _product.html.erb, puedes usar product para referirte al miembro de la colección que se está renderizando.

También puedes usar la siguiente forma abreviada basada en convenciones para renderizar colecciones.

<%= render @products %>

Lo anterior asume que @products es una colección de instancias de Product. Rails utiliza convenciones de nomenclatura para determinar el nombre del parcial a usar buscando el nombre del modelo en la colección, Product en este caso. De hecho, incluso puedes renderizar una colección compuesta por instancias de diferentes modelos usando esta abreviatura, y Rails elegirá el parcial apropiado para cada miembro de la colección.

4.8 Plantillas de Espaciador

También puedes especificar un segundo parcial para ser renderizado entre instancias del parcial principal usando la opción :spacer_template:

<%= render partial: @products, spacer_template: "product_ruler" %>

Rails renderizará el parcial _product_ruler.html.erb (sin pasarle datos) entre cada par de parciales _product.html.erb.

4.9 Variables de Contador

Rails también hace disponible una variable de contador dentro de un parcial llamado por la colección. La variable se nombra después del título del parcial seguido de _counter. Por ejemplo, al renderizar una colección @products el parcial _product.html.erb puede acceder a la variable product_counter. La variable indexa el número de veces que el parcial ha sido renderizado dentro de la vista envolvente, comenzando con un valor de 0 en la primera renderización.

<%# index.html.erb %>
<%= render partial: "product", collection: @products %>

<%# _product.html.erb %>
<%= product_counter %> # 0 para el primer producto, 1 para el segundo producto...

Esto también funciona cuando el nombre de la variable local se cambia usando la opción as:. Así que si hiciste as: :item, la variable del contador sería item_counter.

Nota: Las siguientes dos secciones, Locales Estrictos y Asignaciones Locales con Coincidencia de Patrones son características más avanzadas de usar parciales, incluidas aquí por completitud.

4.10 `local_assigns` con Coincidencia de Patrones

Dado que local_assigns es un Hash, es compatible con el operador de asignación de coincidencia de patrones de Ruby 3.1:

local_assigns => { product:, **options }
product # => "#<Product:0x0000000109ec5d10>"
options # => {}

Cuando claves distintas de :product se asignan a una variable Hash local del parcial, pueden ser expandidas en llamadas a métodos helper:

<%# app/views/products/_product.html.erb %>

<% local_assigns => { product:, **options } %>

<%= tag.div id: dom_id(product), **options do %>
  <h1><%= product.name %></h1>
<% end %>

<%# app/views/products/show.html.erb %>

<%= render "products/product", product: @product, class: "card" %>
<%# => <div id="product_1" class="card">
  #      <h1>Un widget</h1>
  #    </div>
%>

La asignación de coincidencia de patrones también admite el cambio de nombre de variables:

local_assigns => { product: record }
product             # => "#<Product:0x0000000109ec5d10>"
record              # => "#<Product:0x0000000109ec5d10>"
product == record   # => true

También puedes leer condicionalmente una variable y luego recurrir a un valor predeterminado cuando la clave no es parte de las opciones locals:, usando fetch:

<%# app/views/products/_product.html.erb %>

<% local_assigns.fetch(:related_products, []).each do |related_product| %>
  <%# ... %>
<% end %>

Combinar la asignación de coincidencia de patrones de Ruby 3.1 con llamadas a Hash#with_defaults habilita asignaciones de variables locales de parcial predeterminadas compactas:

<%# app/views/products/_product.html.erb %>

<% local_assigns.with_defaults(related_products: []) => { product:, related_products: } %>

<%= tag.div id: dom_id(product) do %>
  <h1><%= product.name %></h1>

  <% related_products.each do |related_product| %>
    <%# ... %>
  <% end %>
<% end %>

Por defecto, los parciales aceptarán cualquier locals como argumentos de palabra clave. Para definir qué locals acepta un parcial, usa un comentario mágico locals:. Para aprender más, lee sobre Locales Estrictos.

4.11 Locales Estrictos

Los parciales de Action View aceptarán cualquier número de locals como argumentos de palabra clave. Puedes hacer cumplir cuántos y cuáles locals acepta una plantilla, establecer valores predeterminados y más con un comentario mágico locals:.

Aquí hay algunos ejemplos del comentario mágico locals::

<%# app/views/messages/_message.html.erb %>

<%# locals: (message:) -%>
<%= message %>

Lo anterior hace que message sea una variable local requerida. Renderizar el parcial sin un argumento de variable local :message generará una excepción:

render "messages/message"
# => ActionView::Template::Error: falta local: :message para app/views/messages/_message.html.erb

Si se establece un valor predeterminado, entonces se puede usar si message no se pasa en locals::

<%# app/views/messages/_message.html.erb %>

<%# locals: (message: "¡Hola, mundo!") -%>
<%= message %>

Renderizar el parcial sin una variable local :message usa el valor predeterminado establecido en el comentario mágico locals::

render "messages/message"
# => "¡Hola, mundo!"

Renderizar el parcial con variables locales no especificadas en el comentario mágico local: también generará una excepción:

render "messages/message", unknown_local: "generará una excepción"
# => ActionView::Template::Error: local desconocido: :unknown_local para app/views/messages/_message.html.erb

Puedes permitir argumentos de variables locales opcionales con el operador de doble asterisco **:


<%# app/views/messages/_message.html.erb %>

<%# locals: (message: "¡Hola, mundo!", **attributes) -%>
<%= tag.p(message, **attributes) %>

O puedes desactivar locals completamente estableciendo locals: en vacío ():

<%# app/views/messages/_message.html.erb %>

<%# locals: () %>

Renderizar el parcial con cualquier argumento de variable local generará una excepción:

render "messages/message", unknown_local: "generará una excepción"
# => ActionView::Template::Error: no se aceptan locales para app/views/messages/_message.html.erb

Action View procesará el comentario mágico locals: en cualquier motor de plantillas que soporte comentarios prefijados con #, y leerá el comentario mágico de cualquier línea en el parcial.

PRECAUCIÓN: Solo se admiten argumentos de palabra clave. Definir argumentos posicionales o de bloque generará un Error de Action View en el momento de la renderización.

El método local_assigns no contiene valores predeterminados especificados en el comentario mágico local:. Para acceder a una variable local con un valor predeterminado que tiene el mismo nombre que una palabra clave reservada de Ruby, como class o if, los valores se pueden acceder a través de binding.local_variable_get:

<%# locals: (class: "message") %>
<div class="<%= binding.local_variable_get(:class) %>">...</div>

5 Diseños

Los diseños se pueden usar para renderizar una plantilla de vista común alrededor de los resultados de las acciones del controlador de Rails. Una aplicación Rails puede tener múltiples diseños en los que se pueden renderizar las páginas.

Por ejemplo, una aplicación podría tener un diseño para un usuario que ha iniciado sesión y otro para la parte de marketing del sitio. El diseño del usuario que ha iniciado sesión podría incluir navegación de nivel superior que debería estar presente en muchas acciones del controlador. El diseño de ventas para una aplicación SaaS podría incluir navegación de nivel superior para cosas como páginas de "Precios" y "Contáctenos". Los diferentes diseños pueden tener un contenido de encabezado y pie de página diferente.

Para encontrar el diseño para la acción del controlador actual, Rails primero busca un archivo en app/views/layouts con el mismo nombre base que el controlador. Por ejemplo, renderizar acciones desde la clase ProductsController usará app/views/layouts/products.html.erb.

Rails usará app/views/layouts/application.html.erb si no existe un diseño específico para el controlador.

Aquí hay un ejemplo de un diseño simple en el archivo application.html.erb:

<!DOCTYPE html>
<html>
<head>
  <title><%= "Tu Aplicación Rails" %></title>
  <%= csrf_meta_tags %>
  <%= csp_meta_tag %>
  <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
  <%= javascript_importmap_tags %>
</head>
<body>

<nav>
  <ul>
    <li><%= link_to "Inicio", root_path %></li>
    <li><%= link_to "Productos", products_path %></li>
    <!-- Enlaces de navegación adicionales aquí -->
  </ul>
</nav>

<%= yield %>

<footer>
  <p>&copy; <%= Date.current.year %> Tu Empresa</p>
</footer>

En el ejemplo de diseño anterior, el contenido de la vista se renderizará en lugar de <%= yield %>, y estará rodeado por el mismo contenido de <head>, <nav> y <footer>.

Rails proporciona más formas de asignar diseños específicos a controladores y acciones individuales. Puedes aprender más sobre los diseños en general en la guía Layouts y Renderizado en Rails.

5.1 Diseños Parciales

Los parciales pueden tener sus propios diseños aplicados a ellos. Estos diseños son diferentes de los aplicados a una acción del controlador, pero funcionan de manera similar.

Digamos que estás mostrando un artículo en una página que debería estar envuelto en un div para fines de presentación. Primero, crearás un nuevo Article:

Article.create(body: '¡Los Diseños Parciales son geniales!')

En la plantilla show, renderizarás el parcial _article envuelto en el diseño box:

<%# app/views/articles/show.html.erb %>
<%= render partial: 'article', layout: 'box', locals: { article: @article } %>

El diseño box simplemente envuelve el parcial _article en un div:

<%# app/views/articles/_box.html.erb %>
<div class="box">
  <%= yield %>
</div>

Ten en cuenta que el diseño parcial tiene acceso a la variable local article que fue pasada en la llamada a render, aunque no se está utilizando dentro de _box.html.erb en este caso.

A diferencia de los diseños a nivel de aplicación, los diseños parciales aún tienen el prefijo de guion bajo en su nombre.

También puedes renderizar un bloque de código dentro de un diseño parcial en lugar de llamar a yield. Por ejemplo, si no tuvieras el parcial _article, podrías hacer esto en su lugar:

<%# app/views/articles/show.html.erb %>
<%= render(layout: 'box', locals: { article: @article }) do %>
  <div>
    <p><%= article.body %></p>
  </div>
<% end %>

Suponiendo que uses el mismo parcial _box de arriba, esto produciría la misma salida que el ejemplo anterior.

5.2 Colección con Diseños Parciales

Al renderizar colecciones también es posible usar la opción :layout:

<%= render partial: "article", collection: @articles, layout: "special_layout" %>

El diseño se renderizará junto con el parcial para cada elemento en la colección. Las variables del objeto actual y del contador del objeto, article y article_counter en el ejemplo anterior, estarán disponibles en el diseño también, de la misma manera que están dentro del parcial.

6 Helpers

Rails proporciona muchos métodos helper para usar con Action View. Estos incluyen métodos para:

Formatear fechas, cadenas y números
Crear enlaces HTML a imágenes, videos, hojas de estilo, etc.
Sanitizar contenido
Crear formularios
Localizar contenido

Puedes aprender más sobre los helpers en la Guía de Helpers de Action View y la Guía de Helpers de Formularios de Action View.

7 Vistas Localizadas

Action View tiene la capacidad de renderizar diferentes plantillas dependiendo del idioma actual.

Por ejemplo, supongamos que tienes un ArticlesController con una acción show. Por defecto, llamar a esta acción renderizará app/views/articles/show.html.erb. Pero si estableces I18n.locale = :de, entonces Action View intentará renderizar la plantilla app/views/articles/show.de.html.erb primero. Si la plantilla localizada no está presente, se usará la versión no decorada. Esto significa que no estás obligado a proporcionar vistas localizadas para todos los casos, pero serán preferidas y usadas si están disponibles.

Puedes usar la misma técnica para localizar los archivos de rescate en tu directorio público. Por ejemplo, estableciendo I18n.locale = :de y creando public/500.de.html y public/404.de.html te permitiría tener páginas de rescate localizadas.

Consulta la documentación de la API de Internacionalización (I18n) de Rails para más detalles.

Comentarios

Se te anima a ayudar a mejorar la calidad de esta guía.

Por favor contribuye si ves algún error tipográfico o errores fácticos. Para comenzar, puedes leer nuestra sección de contribuciones a la documentación.

También puedes encontrar contenido incompleto o cosas que no están actualizadas. Por favor agrega cualquier documentación faltante para main. Asegúrate de revisar Guías Edge primero para verificar si los problemas ya están resueltos o no en la rama principal. Revisa las Guías de Ruby on Rails para estilo y convenciones.

Si por alguna razón detectas algo que corregir pero no puedes hacerlo tú mismo, por favor abre un issue.

Y por último, pero no menos importante, cualquier tipo de discusión sobre la documentación de Ruby on Rails es muy bienvenida en el Foro oficial de Ruby on Rails.