Active Record Validations: validar campos en Rails
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?devuelvetruesi es válido.invalid?devuelvetruesi 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 deageno se comprueba. - Una vez guardada, puedes dejar el email vacío sin error, pero una edad
"abc"daAge is not a number. - El contexto
:signupsolo se comprueba si lo pides:person.valid?(:signup)operson.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: truesalta la validación si el valor esnil.allow_blank: truela 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_attributeyupdate_all;insert_all,upsert_ally compañía;increment!,decrement!,toggle!ytouch;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 } |
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_blanky:strict,validate,validates_with, métodos que se saltan las validaciones, el aviso devalidates_associatedy la recomendación de la sintaxisvalidates. - API de Rails, ActiveRecord::Associations::ClassMethods (8.1.4.1): la opción
validatedehas_many,truepor defecto, y cuándo usarvalidates_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.