Nivel inicial7 min de lectura · Publicado el

Diferencias entre link_to, redirect_to y render en Rails

Diferencias entre link_to, redirect_to y render en Rails: un cartel que indica la ventanilla 3, un funcionario que te manda allí y otro que te atiende. Redirigir no es renderizarrubentejera.com ventanilla 3→3link_totú decidesredirect_tovuelves a pedirrenderte atiende aquí
link_to es el cartel de la pared: tú decides si vas a la ventanilla 3. redirect_to es el funcionario que te manda allí, donde vuelves a pedir (una petición nueva). render te atiende en la misma ventanilla.

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_to es el cartel de la pared que dice «Empadronamiento, ventanilla 3». Está ahí; tú decides si vas.
  • redirect_to es el funcionario que te dice «esto no es aquí, vaya a la ventanilla 3». Te levantas y vuelves a preguntar allí.
  • render es 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í

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_to lleva al usuario a la página del post. Así, si recarga, no vuelve a enviar el formulario.
  • Si falla, render :new pinta otra vez el formulario con @post y sus errores, para que el usuario corrija sin perder lo que escribió. El estado 422 (: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 frente a render al guardar un formulario. Si se guarda, el controlador responde con redirect_to @post: un 302 con la nueva URL; el navegador hace una petición nueva, recibe la página del post y la URL cambia. Si falla, render :new responde en la misma petición con el formulario, @post, sus errores y el estado 422, y la URL no cambia.
Las flechas continuas son peticiones del navegador y las discontinuas, respuestas. Con 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_to cuando el formulario falla. Al hacer una petición nueva se pierden @post, sus errores y lo que había escrito el usuario.
  • No uses render después de guardar con éxito. La URL seguiría siendo la del POST, y si el usuario recarga, el navegador le ofrece reenviar el formulario: un post duplicado.
  • No uses link_to para acciones que cambian datos (borrar, publicar, votar). Un enlace es para navegar; para cambiar algo, button_to o un formulario.

Ejercicio de cinco minutos

  1. Copia el test del create en una aplicación con un scaffold de Post. Cambia el render :new por un redirect_to new_post_path y mira qué test falla y por qué.
  2. Vuelve a dejarlo como estaba y añade un test que compruebe que, tras guardar, la respuesta es una redirección (assert_response :redirect).
  3. Añade una acción que reciba params[:volver_a] y redirija con url_from. Escribe un test que le pase https://example.com y 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 de ActionController::Redirecting (allow_other_host, url_from y action_on_open_redirect). Que esta opción vale :raise desde load_defaults 7.0 está en Configuring Rails Applications y en el código de railties 8.1.4.1.
  • El aviso Form responses must redirect to another location se ha comprobado en el código de Turbo que incluye turbo-rails 2.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.4 de Docker): el HTML de link_to y button_to, el test del create, DoubleRenderError, OpenRedirectError, url_from con una URL externa y con una interna, y que :unprocessable_entity sigue devolviendo 422. El scaffold de esa versión usa :unprocessable_content y status: :see_other, y no incluye rails-ujs.