Diferencias entre link_to, redirect_to y render en Rails
Cuando empiezas con Rails es fácil confundir estos tres, porque los tres «te llevan a otra página». La diferencia está en quién se mueve y cuándo.
Imagina que preguntas en el mostrador de un ayuntamiento:
link_toes el cartel de la pared que dice «Empadronamiento, ventanilla 3». Está ahí; tú decides si vas.redirect_toes el funcionario que te dice «esto no es aquí, vaya a la ventanilla 3». Te levantas y vuelves a preguntar allí.renderes el funcionario que te atiende en el momento, sin moverte de la ventanilla.
Resumen
link_to |
redirect_to |
render |
|
|---|---|---|---|
| Dónde se usa | Vista | Controlador | Controlador (y vistas, para parciales) |
| Qué devuelve | Un enlace HTML | Una respuesta 302 con la nueva URL | El HTML de una vista |
| ¿Cambia la URL del navegador? | Solo si el usuario pulsa | Sí | No |
| ¿Hay una petición nueva? | Sí, al pulsar | Sí, automática | No |
¿Se conservan las variables @? |
No | No | Sí |
link_to en Rails: un enlace en la vista
Genera el HTML de un enlace:
<%= link_to "Google", "https://google.com" %>
Resultado:
<a href="https://google.com">Google</a>
Lo habitual es enlazar a rutas de tu aplicación con sus helpers (métodos auxiliares que Rails genera para cada ruta):
<%= link_to "Volver", posts_path %>
<%= link_to post.title, post %>
<%= link_to "Docs", "https://guides.rubyonrails.org", target: "_blank", rel: "noopener" %>
<%= link_to post do %><strong><%= post.title %></strong><% end %>
Con un post de id 1 y título «Hola», Rails 8.1 genera esto:
<a href="/posts">Volver</a>
<a href="/posts/1">Hola</a>
<a target="_blank" rel="noopener" href="https://guides.rubyonrails.org">Docs</a>
<a href="/posts/1"><strong>Hola</strong></a>
Pasarle el objeto (post) en lugar de la ruta es un atajo: Rails deduce post_path(post). Las opciones que no conoce, como target o class, pasan tal cual al HTML. Y con un bloque, el contenido del enlace puede ser cualquier HTML.
redirect_to en Rails: manda al navegador a otra URL
Responde a la petición diciéndole al navegador que vaya a otra dirección. El navegador hace una petición nueva, así que la URL cambia y se pierde todo lo que tenías en la petición anterior:
redirect_to posts_path
redirect_to @post, notice: "Post creado"
redirect_to posts_path, status: :see_other
redirect_to "https://google.com", allow_other_host: true
Por defecto responde con un 302. Tras borrar o actualizar con Turbo, el scaffold de Rails 8.1 usa status: :see_other (303), que le dice al navegador que pida la nueva página con un GET. Y para mandar al usuario a otra web hace falta allow_other_host: true: en una aplicación nueva (con load_defaults 7.0 o posterior), Rails no redirige fuera de tu dominio si no se lo pides expresamente. El porqué está en los errores frecuentes.
render: pinta una vista sin cambiar de URL
Se usa sobre todo para mostrar una plantilla. La URL no cambia y las variables de instancia (@post) siguen disponibles en la vista:
render "posts/show" # pinta app/views/posts/show.html.erb
render :new # la plantilla new de este controlador
Si no llamas a ninguno de los dos, Rails hace render de la plantilla con el nombre de la acción.
El caso típico: guardar un formulario
Aquí se ve por qué existen los dos en el controlador:
def create
@post = Post.new(post_params)
if @post.save
redirect_to @post, notice: "Post creado" # todo bien: vete a verlo
else
render :new, status: :unprocessable_content # hay errores: vuelve a pintar el formulario
end
end
- Si se guarda,
redirect_tolleva al usuario a la página del post. Así, si recarga, no vuelve a enviar el formulario. - Si falla,
render :newpinta otra vez el formulario con@posty sus errores, para que el usuario corrija sin perder lo que escribió. El estado422(:unprocessable_content) es necesario para que Turbo muestre la respuesta. Antes se llamaba:unprocessable_entity; Rails 8.1 genera ya el nombre nuevo, y el antiguo sigue devolviendo 422.
redirect_to hay dos viajes de ida y vuelta; con render, uno solo.post_params filtra los datos del formulario; se explica en Strong params en Ruby on Rails.
Si todo va bien, redirige. Si hay errores, renderiza.
Compruébalo con un test
Los dos caminos del create se prueban con un test de integración, que hace la petición como lo haría el navegador. El modelo Post valida que tenga título (validates :title, presence: true):
require "test_helper"
class CrearPostTest < ActionDispatch::IntegrationTest
test "si se guarda, redirige a la página del post" do
post posts_url, params: { post: { title: "Hola", body: "Primer post" } }
assert_redirected_to post_url(Post.last)
follow_redirect!
assert_dom "p", text: "Post creado"
end
test "si falla, vuelve a pintar el formulario con sus errores" do
post posts_url, params: { post: { title: "", body: "Sin título" } }
assert_response :unprocessable_content
assert_dom "li", text: "Title can't be blank"
assert_dom "textarea", text: "Sin título"
end
end
bin/rails test test/controllers/crear_post_test.rb
2 runs, 8 assertions, 0 failures, 0 errors, 0 skips
El primero comprueba la redirección y que, al seguirla, aparece el aviso. El segundo, que render devuelve el 422 con el formulario, el error y lo que el usuario había escrito: justo lo que se perdería con un redirect_to.
Errores frecuentes
1. Llamar a render y a redirect_to en la misma acción. Ninguno de los dos termina la acción: el código de debajo sigue ejecutándose. Si después hay otro render o redirect_to, Rails se queja:
def doble
redirect_to courses_path
render plain: "hola"
end
AbstractController::DoubleRenderError: Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like "redirect_to(...); return".
Usa if/else como en el create, o return justo después del primero.
2. Redirigir a una URL que llega en la petición (?redirect_to=). Es tentador escribir redirect_to params[:redirect_to] para «volver a donde estaba el usuario». Pero cualquiera puede crear un enlace a tu web con ?redirect_to=https://web-falsa.example y usar tu dominio de cebo: es una redirección abierta (open redirect). En una aplicación nueva de Rails 8.1, la redirección se bloquea:
def vuelta
redirect_to params[:redirect_to]
end
ActionController::Redirecting::OpenRedirectError: Unsafe redirect to "https://example.com/phishing", pass allow_other_host: true to redirect anyway.
No lo arregles con allow_other_host: true, que vuelve a abrir el agujero. Usa url_from, que devuelve la URL solo si es de tu propia web, y una ruta de reserva si no:
redirect_to url_from(params[:redirect_to]) || courses_path
Con https://example.com/phishing redirige a /courses; con /courses/1, a /courses/1. Este bloqueo depende de la opción action_on_open_redirect, que vale :raise en las aplicaciones creadas con Rails 7.0 o posterior. En una aplicación más antigua que no la tenga activada, solo se apunta en el log.
3. render sin el estado 422 en un formulario con Turbo. Si el formulario falla y respondes con render :new a secas (estado 200), Turbo no pinta la respuesta y el usuario no ve los errores. En la consola del navegador aparece el aviso Form responses must redirect to another location. Ponle status: :unprocessable_content.
4. link_to con method: :delete en una aplicación nueva. Sigue generando HTML, pero con un atributo que solo entendía la antigua librería rails-ujs:
<a rel="nofollow" data-method="delete" href="/posts/1">Borrar</a>
Turbo no lee data-method, así que el navegador sigue el enlace con un GET normal: en lugar de borrar, muestra el post. Las dos formas que sí funcionan:
<a data-turbo-method="delete" data-turbo-confirm="¿Seguro?" href="/posts/1">Borrar</a>
<form class="button_to" method="post" action="/posts/1"><input type="hidden" name="_method" value="delete" /><button type="submit">Borrar</button><input type="hidden" name="authenticity_token" value="…" /></form>
En una petición real, el formulario de button_to lleva también el campo oculto authenticity_token, la protección de Rails contra peticiones falsificadas (CSRF); aquí se acorta su valor.
La primera sale de link_to "Borrar", post, data: { turbo_method: :delete, turbo_confirm: "¿Seguro?" } y la segunda, de button_to "Borrar", post, method: :delete. button_to funciona incluso sin JavaScript, porque es un formulario de verdad.
Cuándo no usar cada uno
- No uses
redirect_tocuando el formulario falla. Al hacer una petición nueva se pierden@post, sus errores y lo que había escrito el usuario. - No uses
renderdespués de guardar con éxito. La URL seguiría siendo la delPOST, y si el usuario recarga, el navegador le ofrece reenviar el formulario: un post duplicado. - No uses
link_topara acciones que cambian datos (borrar, publicar, votar). Un enlace es para navegar; para cambiar algo,button_too un formulario.
Ejercicio de cinco minutos
- Copia el test del
createen una aplicación con un scaffold dePost. Cambia elrender :newpor unredirect_to new_post_pathy mira qué test falla y por qué. - Vuelve a dejarlo como estaba y añade un test que compruebe que, tras guardar, la respuesta es una redirección (
assert_response :redirect). - Añade una acción que reciba
params[:volver_a]y redirija conurl_from. Escribe un test que le pasehttps://example.comy espere la ruta de reserva.
Sigue leyendo
Fuentes
- Layouts and Rendering in Rails (
render,redirect_to, 302 por defecto y que ninguno de los dos termina la acción) y Action View Helpers, guías oficiales de Rails 8.1.4.1. - Securing Rails Applications: Redirection, sobre el riesgo de pasar datos del usuario a
redirect_to, y la API deActionController::Redirecting(allow_other_host,url_fromyaction_on_open_redirect). Que esta opción vale:raisedesdeload_defaults 7.0está en Configuring Rails Applications y en el código derailties8.1.4.1. - El aviso
Form responses must redirect to another locationse ha comprobado en el código de Turbo que incluyeturbo-rails2.0.23, no en un navegador. - Ejecutado el 11 de noviembre de 2026 con Ruby 3.4.12 y Rails 8.1.4.1 en una aplicación nueva (imagen oficial
ruby:3.4de Docker): el HTML delink_toybutton_to, el test delcreate,DoubleRenderError,OpenRedirectError,url_fromcon una URL externa y con una interna, y que:unprocessable_entitysigue devolviendo 422. El scaffold de esa versión usa:unprocessable_contentystatus: :see_other, y no incluyerails-ujs.