Nivel inicial7 min de lectura · Publicado el

Active Record Validations: validar campos en Rails

Validaciones de Active Record: la maleta con name John Doe pasa por la cinta a la base de datos y la de name nil se queda fuera con su error. Valida antes de guardarrubentejera.com base de datosname: "John Doe"name: nilName can't be blank
La validación es el mostrador de facturación: la maleta con nombre (name: "John Doe") pasa por la cinta a la bodega, que es la base de datos; la que no lo lleva se queda fuera con el aviso «Name can't be blank».

Las validaciones de Active Record (Active Record validations, también llamadas Rails validations) son las reglas que Rails comprueba en un modelo antes de guardarlo en la base de datos: que un campo no esté vacío, que un email tenga formato de email o que un nombre de usuario no esté repetido.

Funcionan como el mostrador de facturación de un aeropuerto: revisa cada maleta (cada registro) antes de mandarla a la bodega (la base de datos) y, si algo no cuadra, la para y dice por qué.

Casi todos los ejemplos se han ejecutado con Ruby 4.0.9 y Active Record 8.1.4.1, y las salidas que ves son las reales; la vista ERB sigue la guía oficial.

Tu primera validación con validates

class Person < ApplicationRecord
  validates :name, presence: true
end

Con esa línea, Rails no guarda una persona sin nombre:

Person.new(name: "John Doe").valid?  # => true
Person.new(name: nil).valid?         # => false
Person.new.save                      # => false
Person.create!(name: nil)            # lanza una excepción

La excepción de create! dice qué ha fallado:

ActiveRecord::RecordInvalid: Validation failed: Name can't be blank

Cuándo se lanzan las validaciones

Sin !: devuelven false si falla Con !: lanzan ActiveRecord::RecordInvalid
create create!
save save!
update update!

Para comprobar un objeto sin guardarlo:

  • valid? devuelve true si es válido.
  • invalid? devuelve true si no lo es.

Usa la versión con ! cuando un fallo sea un error de programación que no debería pasar (por ejemplo, en una tarea de datos), y la versión sin ! en los controladores, donde quieres volver a mostrar el formulario con los errores.

Leer los errores

Primero hay que lanzar las validaciones, con valid? o al guardar. Después, los errores están en errors:

person = Person.new(name: nil)
person.valid?
person.errors.full_messages   # mensajes completos, listos para mostrar
person.errors[:name]          # solo los de un campo
person.errors.details         # el tipo de cada error, útil en tests y APIs
["Name can't be blank"]
["can't be blank"]
{name: [{error: :blank}]}

errors.details devuelve el tipo de error (:blank) en lugar del texto, así que no cambia si traduces los mensajes.

validates_presence_of y validates: dos estilos para lo mismo

En código antiguo verás validates_presence_of. Es la forma clásica: un método por cada tipo de validación (validates_presence_of, validates_length_of, validates_uniqueness_of…). Sigue funcionando en Rails 8.1, pero la guía oficial indica que la sintaxis concisa con validates es la habitual hoy.

Estas tres versiones obligan a rellenar los mismos tres campos:

# 1. Estilo clásico
validates_presence_of :title, :user_request, :entity_name

# 2. Un validates por campo
validates :title, presence: true
validates :user_request, presence: true
validates :entity_name, presence: true

# 3. Varios campos en un solo validates
validates :title, :user_request, :entity_name, presence: true

Las tres dan exactamente los mismos errores con un registro vacío:

["Title can't be blank", "User request can't be blank", "Entity name can't be blank"]

La ventaja de validates es que junta todas las reglas de un campo en la misma línea:

validates :title, presence: true, length: { maximum: 100 }

Con el estilo clásico necesitarías dos líneas (validates_presence_of y validates_length_of), y las reglas de un mismo campo podrían acabar separadas. Si mantienes un proyecto que ya usa validates_presence_of, no hace falta cambiarlo todo: lo que más ayuda a quien lo lea es que el modelo use un solo estilo.

Los helpers de validación

Rails trae validadores para los casos habituales. Todos aceptan la opción message: para cambiar el texto del error.

presence y absence

presence comprueba que el campo no está vacío (ni nil, ni una cadena vacía, ni solo espacios). absence es lo contrario: que sí está vacío, útil para campos que solo deben rellenarse en ciertos casos.

class Person < ApplicationRecord
  validates :name, :login, :email, presence: true
  validates :legacy_code, absence: true
end

length

class Person < ApplicationRecord
  validates :name, length: { minimum: 2 }
  validates :bio, length: { maximum: 500 }
  validates :password, length: { in: 6..20 }
  validates :registration_number, length: { is: 6 }
end

format: validar un email en Rails

format comprueba el valor contra una expresión regular. Para un email, Ruby ya trae una: URI::MailTo::EMAIL_REGEXP, la misma que usa la guía oficial.

class User < ApplicationRecord
  validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
end

User.new(email: "[email protected]").valid?  # => true
User.new(email: "ana@").valid?             # => false
User.new(email: "ana.example.com").valid?  # => false

Un formato correcto no garantiza que el buzón exista; para eso hace falta enviar un correo de confirmación.

Otro ejemplo, un código que solo admite letras:

class Product < ApplicationRecord
  validates :legacy_code, format: { with: /\A[a-zA-Z]+\z/, message: "solo admite letras" }
end

Usa \A y \z (principio y final del texto), no ^ y $, que en Ruby marcan principio y final de línea: con ellos, un texto de dos líneas podría colar una línea maliciosa. Rails lo sabe y, si usas ^ o $ en format, falla al cargar el modelo con un ArgumentError que te sugiere \A y \z. Lo tienes explicado en expresiones regulares en Ruby.

inclusion y exclusion

class Coffee < ApplicationRecord
  validates :size, inclusion: { in: %w[small medium large],
    message: "%{value} no es un tamaño válido" }
end

class Account < ApplicationRecord
  validates :subdomain, exclusion: { in: %w[www us ca jp],
    message: "%{value} está reservado" }
end

in: acepta cualquier colección, como un array o un rango, y %{value} se sustituye por el valor rechazado.

numericality

class Player < ApplicationRecord
  validates :points, numericality: true
  validates :games_played, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
end

comparison

Compara un campo con otro o con un valor. Es útil con fechas:

class Event < ApplicationRecord
  validates :end_date, comparison: { greater_than: :start_date }
end

Con un evento que empieza el 10 de noviembre y acaba el 9:

["End date must be greater than 2026-11-10"]

acceptance

Para la casilla «Acepto las condiciones» de un formulario. No necesita columna en la tabla:

class Person < ApplicationRecord
  validates :terms_of_service, acceptance: true
end

confirmation

Para cuando el usuario escribe dos veces el mismo dato, como el email. Rails crea un atributo virtual con el sufijo _confirmation:

class Person < ApplicationRecord
  validates :email, confirmation: true
  validates :email_confirmation, presence: true
end
<%= form.text_field :email %>
<%= form.text_field :email_confirmation %>

Solo se compara si email_confirmation no es nil; por eso el ejemplo añade presence. Con dos emails distintos, el error es Email confirmation doesn't match Email.

uniqueness

class Account < ApplicationRecord
  validates :email, uniqueness: { case_sensitive: false }
end

Con [email protected] ya guardado, [email protected] da Email has already been taken.

validates_associated

Valida también los objetos asociados al guardar:

class Library < ApplicationRecord
  has_many :books
  validates_associated :books
end

Un matiz que conviene saber: has_many ya valida por defecto los libros nuevos que añades a la biblioteca (su opción validate es true). Lo que añade validates_associated es revalidar también los libros que ya estaban guardados y has modificado. Por eso, con un libro nuevo sin título y las dos cosas activas, el error sale dos veces:

["Books is invalid", "Books is invalid"]

No lo pongas en los dos lados de la asociación: según la guía, se llamarían el uno al otro en un bucle infinito. Si las asociaciones te suenan a chino, empieza por asociaciones en Rails.

Cuándo se aplica: on: :create y contextos propios

Por defecto, cada validación se aplica al crear y al actualizar. Con on: la limitas a uno de los dos:

class Person < ApplicationRecord
  validates :email, presence: true, on: :create   # solo al crear
  validates :age, numericality: true, on: :update  # solo al actualizar
  validates :login, presence: true, on: :signup    # contexto propio
end
  • Una persona nueva sin email da Email can't be blank; la de age no se comprueba.
  • Una vez guardada, puedes dejar el email vacío sin error, pero una edad "abc" da Age is not a number.
  • El contexto :signup solo se comprueba si lo pides: person.valid?(:signup) o person.save(context: :signup).

Los contextos propios sirven cuando un mismo modelo tiene reglas distintas según el formulario, como un registro en varios pasos.

Validaciones condicionales: if y unless

if: y unless: aplican una validación solo si se cumple (o no) una condición. Aceptan el nombre de un método o una lambda:

class Order < ApplicationRecord
  validates :card_number, presence: true, if: :paid_with_card?
  validates :password, length: { minimum: 8 }, unless: -> { password.blank? }

  def paid_with_card?
    payment_type == "card"
  end
end

Un pedido con tarjeta y sin número da Card number can't be blank; uno en efectivo pasa sin error.

Si varias validaciones comparten la misma condición, agrúpalas con with_options:

class User < ApplicationRecord
  with_options if: :admin? do
    validates :password, length: { minimum: 10 }
    validates :email, presence: true
  end

  def admin?
    role == "admin"
  end
end

allow_nil y allow_blank

Dos atajos para una condición frecuente, «valida solo si hay algo»:

  • allow_nil: true salta la validación si el valor es nil.
  • allow_blank: true la salta si el valor está vacío (nil, "" o solo espacios).
validates :payment_type, inclusion: { in: %w[cash card] }, allow_nil: true
validates :legacy_code, length: { is: 5 }, allow_blank: true

Validaciones propias

Cuando ningún helper encaja, escribes la regla tú.

validate: un método del modelo

Es la opción más sencilla. Fíjate en que es validate, en singular: recibe el nombre de un método que añade errores con errors.add.

class Event < ApplicationRecord
  validate :end_date_after_start_date

  private

  def end_date_after_start_date
    return if start_date.blank? || end_date.blank?

    if end_date <= start_date
      errors.add(:end_date, "debe ser posterior a la fecha de inicio")
    end
  end
end
["End date debe ser posterior a la fecha de inicio"]

validates (en plural) es para los helpers; validate (en singular), para tus métodos. Confundirlos es un error frecuente: validates :mi_metodo falla al cargar la clase porque espera al menos una opción de validación.

Para validar un archivo adjunto (por ejemplo, que sea una imagen), mira la guía de subida de archivos.

validates_with: una clase aparte

Si la regla es larga o la usan varios modelos, sácala a su propia clase:

class GoodnessValidator < ActiveModel::Validator
  def validate(record)
    if record.first_name == "Evil"
      record.errors.add(:base, "Esta persona es malvada")
    end
  end
end

class Person < ApplicationRecord
  validates_with GoodnessValidator
end

:base sirve para errores que no son de un campo concreto, sino del registro entero. No uses la forma antigua record.errors[:base] << "mensaje": en Rails 8.1.4.1 no da ningún error, pero el mensaje se pierde sin aviso y valid? devuelve true. Usa errors.add.

validates_each: un bloque para varios campos

El bloque recibe el registro, el nombre del atributo y su valor. En este ejemplo, nombre y apellido deben empezar por mayúscula:

class Person < ApplicationRecord
  validates_each :name, :surname do |record, attr, value|
    record.errors.add(attr, "debe empezar por mayúscula") if value =~ /\A[[:lower:]]/
  end
end

Validaciones estrictas

Con strict: true, un fallo no se guarda en errors: lanza una excepción en cuanto se valida. Sirve para datos que nunca deberían llegar mal, porque no los escribe el usuario.

class Person < ApplicationRecord
  validates :name, presence: { strict: true }
end

Person.new.valid?
ActiveModel::StrictValidationFailed: Name can't be blank

Métodos que se saltan las validaciones

Algunos métodos escriben directamente en la base de datos sin pasar por el mostrador. Según la guía oficial, entre otros:

  • update_column, update_columns, update_attribute y update_all;
  • insert_all, upsert_all y compañía;
  • increment!, decrement!, toggle! y touch;
  • save(validate: false).
person = Person.create!(name: "Ana")
person.update_column(:name, nil)  # guarda nil sin validar

Úsalos solo cuando sepas por qué. Si necesitas que un dato nunca sea inválido, aunque alguien use estos métodos, añade también una restricción en la base de datos.

Validar en el modelo, en la base de datos o en el navegador

Dónde Ventaja Límite
Modelo (Active Record validations) Mensajes claros, fáciles de probar Se pueden saltar con los métodos anteriores
Base de datos (NOT NULL, índices únicos) Nadie se las salta Mensajes de error poco amigables
Navegador (HTML o JavaScript) Respuesta inmediata El usuario puede desactivarlas
Controlador Rápidas de escribir Según la guía de Rails, se vuelven difíciles de probar y mantener

La tabla es un resumen nuestro de la guía. Lo habitual es combinar las del modelo con restricciones en la base de datos para lo crítico, y añadir las del navegador solo como comodidad para el usuario.

Si necesitas cambiar un dato antes de validarlo (por ejemplo, quitar espacios), eso no es una validación sino un callback; tienes before_validation en callbacks en Rails.

Probar una validación con un test

Una validación es una regla de negocio: si alguien la borra sin querer, un test debería avisar. Con Minitest, que viene con Rails:

require "test_helper"

class PersonTest < ActiveSupport::TestCase
  test "requiere nombre" do
    person = Person.new(name: nil)

    assert_not person.valid?
    assert person.errors.added?(:name, :blank)
  end

  test "es válida con nombre" do
    assert Person.new(name: "Ana").valid?
  end
end

Prueba siempre los dos lados: el caso que debe fallar y el que debe pasar. Un test que solo comprueba el fallo seguiría en verde si la validación rechazara también los datos buenos. Si empiezas con tests, lee la introducción al testing en Ruby y el ciclo rojo, verde, refactor de TDD.

Escribir primero el test también ayuda cuando un asistente de IA genera el modelo: el test fija la regla y comprueba que el código generado la cumple. Es la idea de IA Limpia aplicada a algo pequeño (interpretación nuestra).

Pruébalo sin crear una app

Para experimentar con validaciones no necesitas un proyecto Rails: basta con Active Record y SQLite en memoria. Con Docker:

docker run --rm -it ruby:4.0 bash -c 'gem install activerecord:8.1.4.1 sqlite3 && irb'

Dentro de irb, pega esto:

require "active_record"
require "sqlite3"

ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
ActiveRecord::Schema.define { create_table(:people) { |t| t.string :name } }

class Person < ActiveRecord::Base
  validates :name, presence: true
end

person = Person.new
person.valid?
person.errors.full_messages

Las dos últimas líneas devuelven:

false
["Name can't be blank"]

Dentro de una app Rails, los modelos heredan de ApplicationRecord en lugar de ActiveRecord::Base, y la tabla la crea una migración.

Tu chuleta

Quieres… Escribe
Campo obligatorio validates :name, presence: true
Longitud length: { minimum: 2, maximum: 50 }
Email format: { with: URI::MailTo::EMAIL_REGEXP }
Valor de una lista inclusion: { in: %w[a b c] }
Sin repetidos uniqueness: true + índice único
Solo al crear on: :create
Solo si se cumple algo if: :metodo? o unless: -> { ... }
Saltar si está vacío allow_nil: true o allow_blank: true
Regla propia validate :metodo + errors.add
Comprobar sin guardar valid? y errors.full_messages

Fuentes

Documentación oficial consultada el 9 de noviembre de 2026:

  • Guía de Rails, Active Record Validations (Rails 8.1.4.1): helpers, opciones :on, :if, :unless, :allow_nil, :allow_blank y :strict, validate, validates_with, métodos que se saltan las validaciones, el aviso de validates_associated y la recomendación de la sintaxis validates.
  • API de Rails, ActiveRecord::Associations::ClassMethods (8.1.4.1): la opción validate de has_many, true por defecto, y cuándo usar validates_associated.

Ejecutado en Docker con ruby:4.0 (Ruby 4.0.9), Active Record 8.1.4.1 y sqlite3 2.10.2, con SQLite en memoria: todos los ejemplos de modelo del artículo y sus salidas, que errors[:base] << no añade ningún error, las tres formas de validar presencia, el script de «Pruébalo sin crear una app» y los dos tests con ActiveSupport::TestCase (sin require "test_helper", que solo existe dentro de una app Rails). También se ha comprobado que presence rechaza un texto de solo espacios, que validates sin opciones da ArgumentError y que format con ^ o $ también. La vista ERB de confirmation no se ha ejecutado; sigue la guía oficial. Fuera de una app Rails, with_options necesita require "active_support/core_ext/object/with_options", que Rails ya carga.

Este artículo reúne también el contenido de «Formatos para validar campos en Ruby on Rails» (2018), sobre validates_presence_of.