Nivel inicial5 min de lectura · Publicado el

Diferencia entre text y string en Ruby on Rails

Diferencia entre string y text en Rails: :string es la línea corta del nombre (VARCHAR(255)) y :text, el recuadro grande (TEXT, 64 KB). string corto, text largorubentejera.com NombreObservaciones:stringVARCHAR(255):textTEXT · 64 KB
En un formulario en papel, :string es la línea corta del nombre y :text, el recuadro de observaciones. En MySQL, :string crea un VARCHAR(255) y :text, un TEXT de unos 64 KB; en PostgreSQL y SQLite no hay ese límite.

La diferencia es, sobre todo, cuánto texto cabe y cómo lo guarda la base de datos. En MySQL, es la diferencia entre VARCHAR y TEXT. Piensa en un campo de un formulario en papel: el «Nombre» es una línea corta; «Observaciones», un recuadro grande. :string es la línea; :text, el recuadro.

En una migración

class CreateArticulos < ActiveRecord::Migration[8.1]
  def change
    create_table :articulos do |t|
      t.string :titulo        # texto corto
      t.text   :cuerpo        # texto largo
      t.timestamps
    end
  end
end

Más sobre migraciones en Migraciones en Ruby on Rails.

Lo que ves en MySQL

Con esa migración aplicada en MySQL 9.7, DESCRIBE enseña los dos tipos reales:

+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| id         | bigint       | NO   | PRI | NULL    | auto_increment |
| titulo     | varchar(255) | YES  |     | NULL    |                |
| cuerpo     | text         | YES  |     | NULL    |                |
| created_at | datetime(6)  | NO   |     | NULL    |                |
| updated_at | datetime(6)  | NO   |     | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

¿Cómo se mira eso desde la terminal? Lo tienes en conexión a MySQL desde consola.

¿Y en Ruby? Los dos son un String

La diferencia solo existe en la base de datos. En tu código, los dos atributos son objetos String de Ruby, con los mismos métodos:

articulo = Articulo.new(titulo: "Hola", cuerpo: "Texto largo")
articulo.titulo.class  # => String
articulo.cuerpo.class  # => String

Así que si buscabas cómo trabajar con cadenas en Ruby (upcase, split, include?…), da igual cuál de los dos tipos tenga la columna.

Qué crea cada uno según la base de datos: VARCHAR o TEXT

Base de datos :string :text
MySQL / MariaDB VARCHAR(255): hasta 255 caracteres TEXT: hasta 65.535 bytes (unos 64 KB)
PostgreSQL character varying sin límite text sin límite práctico
SQLite varchar, sin límite real text

Un detalle de MySQL: en VARCHAR(255) el límite se cuenta en caracteres, pero en TEXT se cuenta en bytes. Con utf8mb4, la codificación que usa Rails por defecto, una letra como la «ñ» ocupa dos bytes, así que en un TEXT caben unas 32.000 «ñ», no 65.535.

En PostgreSQL, character varying sin límite y text se comportan casi igual. Aun así, conviene elegir bien: el tipo comunica la intención y decide el campo que generan los formularios de Rails.

Cambiar el límite

Con limit: fijas el máximo de un :string:

t.string :codigo_postal, limit: 5

En MySQL, limit: en un :text elige el tamaño del tipo:

limit: en un :text (MySQL) Tipo que crea Capacidad
hasta 255 TINYTEXT 255 bytes
sin límite o hasta 65.535 TEXT 64 KB
hasta 16.777.215 MEDIUMTEXT 16 MB
hasta 4.294.967.295 LONGTEXT 4 GB

En MySQL también puedes indicarlo con size:, por ejemplo t.text :cuerpo, size: :medium. Con esta migración:

add_column :articulos, :codigo_postal, :string, limit: 5
add_column :articulos, :resumen, :text, limit: 255
add_column :articulos, :libro, :text, size: :medium
add_column :articulos, :enciclopedia, :text, limit: 4_294_967_295

MySQL crea estos tipos:

| codigo_postal | varchar(5)   | YES  |     | NULL    |                |
| resumen       | tinytext     | YES  |     | NULL    |                |
| libro         | mediumtext   | YES  |     | NULL    |                |
| enciclopedia  | longtext     | YES  |     | NULL    |                |

Cuándo usar cada uno

:string

  • Una sola línea
  • Nombres, emails, títulos, códigos, URLs cortas
  • Formulario: text_field

:text

  • Varias líneas o longitud imprevisible
  • Descripciones, comentarios, contenido de artículos
  • Formulario: textarea

Compruébalo con un test

La validación de la nota anterior es una regla, y una regla merece un test. Con el modelo así:

class Articulo < ApplicationRecord
  validates :titulo, length: { maximum: 255 }
end

Este test comprueba el límite justo y el primer valor que se pasa:

require "test_helper"

class ArticuloTest < ActiveSupport::TestCase
  test "un título de 255 caracteres es válido" do
    assert Articulo.new(titulo: "a" * 255).valid?
  end

  test "un título de 256 caracteres da un error claro, no un fallo de MySQL" do
    articulo = Articulo.new(titulo: "a" * 256)

    refute articulo.valid?
    assert_includes articulo.errors[:titulo], "is too long (maximum is 255 characters)"
  end
end
bin/rails test test/models/articulo_test.rb
2 runs, 4 assertions, 0 failures, 0 errors, 0 skips

Si alguien quita o cambia la validación, este test avisa antes de que el usuario vea el error de MySQL.

Errores frecuentes

1. Guardar más de 255 caracteres en un :string en MySQL. Sin validación, MySQL rechaza el valor y Rails lanza una excepción:

Articulo.create!(titulo: "a" * 256)
ActiveRecord::ValueTooLong: Mysql2::Error: Data too long for column 'titulo' at row 1

Con "a" * 255 se guarda sin problema. Lo mismo pasa con un :text que supera sus 65.535 bytes. En SQLite, en cambio, un :string de 1.000 caracteres se guarda sin rechistar, así que el error puede no aparecer en desarrollo y sí en producción, si allí usas MySQL.

2. Poner un índice a una columna :text en MySQL. Para buscar rápido por una columna se le añade un índice, pero en MySQL un TEXT no se puede indexar entero:

add_index :articulos, :cuerpo
Mysql2::Error: BLOB/TEXT column 'cuerpo' used in key specification without a key length

O le dices cuántos caracteres del principio indexar (add_index :articulos, :cuerpo, length: 100), o, si es un dato corto que vas a buscar, como un email, la columna debería ser :string.

3. Cambiar de :string a :text cuando ya hay datos. Se hace con una migración nueva y change_column, que Rails no sabe deshacer solo. Cómo escribirla para que tenga marcha atrás está en migraciones en Ruby on Rails.

Cuándo no usar cada uno

  • No uses :text para datos cortos que vayas a buscar, ordenar o hacer únicos (emails, códigos, slugs): en MySQL complica los índices y no comunica la intención.
  • No uses :string para lo que escribe el usuario sin límite claro (comentarios, descripciones): en MySQL, a partir de 256 caracteres el valor se rechaza con una excepción (porque Rails activa el modo estricto de MySQL, STRICT_ALL_TABLES, en cada conexión).
  • No subas a MEDIUMTEXT o LONGTEXT por si acaso. Si el contenido es un fichero (un PDF, una imagen), no va en la tabla: va como adjunto, con Active Storage.

Ejercicio de cinco minutos

  1. Crea un modelo con nombre:string y biografia:text, y escribe un test que espere un error de validación con un nombre de 256 caracteres. Comprueba que falla.
  2. Haz que pase con validates :nombre, length: { maximum: 255 }.
  3. Si tienes MySQL a mano, quita la validación y prueba a guardar el mismo nombre desde la consola de Rails: lee el error que da la base de datos.

Fuentes

Comprobado el 7 de noviembre de 2026 en Rails 8.1.4.1 (última versión publicada) y revisado el 11 de noviembre de 2026:

Ejecutado el 11 de noviembre de 2026 con Ruby 3.4.12, Rails 8.1.4.1 y la gema mysql2 0.5.7 contra MySQL 9.7.4 (imágenes oficiales ruby:3.4 y mysql:lts de Docker): la migración, los tipos que crean limit: y size:, la clase String de los dos atributos, ValueTooLong con 256 caracteres y con un TEXT de 80.000 bytes, el error del índice y el índice con length: 100, y el test. Lo de SQLite, con Rails 8.1.4.1 y SQLite (sqlite3 2.10.2). PostgreSQL y MariaDB no se han ejecutado: sus tipos se han comprobado en el código fuente de Rails.