Esta guía cubre la instalación y ejecución de Ruby on Rails.

Después de leerlo, sabrás:

• Cómo instalar Rails, crear una nueva aplicación Rails y conectar su aplicación a una base de datos.
• La estructura general de una aplicación Rails.
• Principios básicos de MVC (Model, View Controller - "Model-View-Controller") y diseño basado en RESTful.
• Cómo generar rápidamente el código inicial de la aplicación Rails.

Supuestos en esta guía

Esta guía es para principiantes que quieren iniciar una aplicación Rails desde cero. No se asume que haya trabajado con Rails antes.

Rails es un marco de desarrollo web escrito en el lenguaje de programación Ruby. Si no tiene experiencia en Ruby, puede que le resulte difícil comenzar a aprender Rails de inmediato. Hay varios buenos recursos en inglés dedicados al aprendizaje de Ruby, por ejemplo:

Tenga en cuenta que algunos de los recursos, aunque siguen siendo excelentes, aún cubren versiones anteriores de Ruby como 1.6 y 1.8 en particular, y no incluyen parte de la sintaxis que verá en el desarrollo diario de Rails.

¿Qué es Rails?

Rails es un marco de desarrollo web escrito en el lenguaje de programación Ruby. Está diseñado para facilitar la programación de aplicaciones web al hacer una serie de suposiciones sobre lo que cada desarrollador necesita para crear un nuevo proyecto. Le permite escribir menos código mientras programa en comparación con otros lenguajes y marcos. Los desarrolladores profesionales en Rails también notan que hace que el desarrollo de aplicaciones web sea más divertido =)

Rails es una pieza maestra de software. Hace la suposición de que hay una "mejor" manera de hacer algo, y está diseñado para alentar esa manera y, en algunos casos, incluso desalentar las alternativas. Si estudia "The Rails Way", puede descubrir un aumento significativo en la productividad en usted mismo. Si persiste y trae viejos hábitos de otros lenguajes al desarrollo de Rails e intenta usar patrones aprendidos en otros lugares, su experiencia de desarrollo será menos que feliz.

La filosofía de Rails incluye dos importantes principios rectores:

• No te repitas: DRY es un principio de ingeniería de software que establece que "Cada pieza de información debe tener una única representación autorizada, no redundante, en el sistema". No escriba la misma información una y otra vez, el código será más fácil de mantener y más extensible y con menos errores.
• Convención sobre configuración: Rails tiene opiniones sobre la mejor manera de hacer muchas cosas en una aplicación web, y utiliza estas convenciones de forma predeterminada en lugar de obligarlo a ajustar varios archivos de configuración.

Creación de un nuevo proyecto de rieles

La mejor manera de usar esta guía es repasarla paso a paso. Todos los pasos son esenciales para ejecutar la aplicación de ejemplo y no se requiere código ni pasos adicionales.

Siguiendo este tutorial, creará un proyecto Rails llamado blog, un blog web muy simple. Antes de comenzar a construir la aplicación, debemos asegurarnos de que Rails esté instalado.

Los siguientes ejemplos usan $ para indicar una línea de entrada de terminal en estilo UNIX sistemas operativos ah, aunque se podría configurar de otra forma. Si usa Windows, la línea se verá como c:\source_code>

3.1. Instalación de rieles

Antes de instalar Rails, debe asegurarse de tener los requisitos previos necesarios instalados en su sistema. Estos incluyen Ruby y SQLite3.

Abrir aplicaciones para línea de comando. En macOS abra Terminal.app, en Windows seleccione "Ejecutar" en el menú Inicio y escriba "cmd.exe". Cualquier comando que comience con un signo de dólar $ debe ejecutarse en la línea de comando. Asegúrese de tener instalada la versión actual de Ruby:

$ rubí -v rubí 2.5.0

Rails requiere la instalación de Ruby versión 2.5.0 o posterior. Si el número de versión es inferior a este, deberá instalar una copia nueva de Ruby.

Para instalar rápidamente Ruby y Ruby on Rails en su sistema, Usuarios de Windows puede usar Rails Installer. Se pueden ver métodos de instalación adicionales para la mayoría de los sistemas operativos en ruby-lang.org.

Si está en Windows, deberá instalar el kit de desarrollo del instalador de Ruby.

También necesitará instalar la base de datos SQLite3.

Muchos sistemas operativos similares a UNIX populares vienen con una versión aceptable de SQLite3. En Windows, si instaló Rails usando Rails Installer, ya tiene instalado SQLite. Otros usuarios pueden consultar las instrucciones de instalación en el sitio de SQLite3. Comprueba que esté correctamente instalado y en tu PATH:

$ sqlite3 --versión

El programa debe informar su versión.

Para instalar Rails, use el comando de instalación de gemas proporcionado por RubyGems:

$ joya instalar rieles

Para verificar que todo esté instalado correctamente, debe hacer lo siguiente:

$ rieles --versión

Si se muestra algo como "Rails 6.0.0", puede continuar.

3.2. Creación de una aplicación de blog

Rails viene con una serie de scripts, llamados generadores, diseñados para hacer la vida de un desarrollador más fácil al crear todo lo que necesitan para comenzar una tarea en particular. Uno de ellos es el nuevo generador de aplicaciones, que le proporciona la base de una aplicación Rails para que no tenga que escribirla usted mismo.

Para usar este generador, abra una terminal, navegue a una carpeta donde tenga permiso para crear archivos y escriba:

$ carriles nuevo blog

Esto creará una aplicación de Rails llamada Blog en el directorio del blog e instalará las gemas cuyas dependencias se mencionan en el Gemfile cuando se usa la instalación del paquete.

A usando Windows Subsistema para Linux, existen algunas restricciones en los mensajes. sistema de archivos para deshabilitar las gemas spring y listen, lo que se puede hacer ejecutando rails new blog --skip-spring --skip-listen .

Puede ver todas las posibles opciones de línea de comandos que acepta el generador de aplicaciones de Rails ejecutando rails new -h .

Una vez que haya creado la aplicación de blog, vaya a su carpeta:

El directorio del blog contiene varios archivos y carpetas generados automáticamente que definen la estructura de la aplicación Rails. La mayor parte del trabajo en este tutorial se llevará a cabo en la carpeta de la aplicación, pero por ahora, repasemos las funciones de cada carpeta que Rails crea en la nueva aplicación predeterminada:

Archivo/Carpeta	Propósito
aplicación/	Contiene los controladores, modelos, vistas, asistentes, programas de correo, canales, trabajos y activos de su aplicación. Veremos esta carpeta con más detalle más adelante.
compartimiento/	Contiene los scripts de Rails que inician su aplicación y el directorio también puede contener otros scripts que use para configurar, actualizar, implementar o ejecutar.
configuración/	Configuraciones de rutas, bases de datos de tu aplicación, etc. Esto se trata con más detalle en Configuración de aplicaciones Rails.
config.ru	Configuración de rack para servidores basados ​​en rack utilizados para ejecutar la aplicación. Para obtener más información sobre Rack, consulte el sitio web de Rack.
db/	Contiene el esquema actual de su base de datos, así como las migraciones de bases de datos.
archivo de gemas Gemfile.lock	Estos archivos le permiten especificar qué dependencias de gemas necesita su aplicación Rails. Estos archivos son utilizados por la gema Bundler. Para obtener más información sobre Bundler, consulte el sitio de Bundler.
libre/	Módulos externos para su aplicación.
Iniciar sesión/	Archivos de registro de la aplicación.
paquete.json	Este archivo le permite especificar qué dependencias npm son necesarias para su aplicación Rails. Este archivo es utilizado por Yarn. Para obtener más información sobre Yarn, consulte el sitio web de Yarn.
público/	La única carpeta a la que se puede acceder externamente tal cual. Contiene archivos estáticos y activos compilados.
Rakefile	Este archivo busca y carga tareas que se pueden ejecutar en la línea de comandos. La tarea definida está disponible en todos los componentes de Rails. En lugar de cambiar Rakefile, puede agregar sus propias tareas agregando archivos al directorio lib/tasks de la aplicación.
LÉAME.md	Este es un manual introductorio para su aplicación. Debe editarse para decirles a los demás qué hace su aplicación, cómo configurarla, etc.
almacenamiento/	Archivos de almacenamiento activo para el servicio de disco. Esto se trata en la guía de descripción general de almacenamiento activo.
prueba/	Pruebas unitarias, accesorios y otros aparatos de prueba. Esto se cubre en la guía Prueba de aplicaciones de rieles.
tmp/	Archivos temporales (como archivos de caché y pid)
vendedor/	Lugar para el código de terceros. En una aplicación Rails típica, incluye gemas externas.
.gitignore	Este archivo le dice a git qué archivos (explícitos o comodines) debe ignorar. Consulte GitHub - Ignorar archivos para obtener más información sobre cómo ignorar archivos.
versión .ruby	Este archivo contiene la versión predeterminada de Ruby.

¡Hola Rieles!

Primero, mostremos algo de texto en la pantalla. Esto requiere un servidor en ejecución para su aplicación Rails.

4.1. Iniciar el servidor web

De hecho, ya tienes una aplicación Rails funcional. Para estar seguro, necesita ejecutar un servidor web en su máquina. Esto se puede hacer ejecutando el siguiente comando desde el directorio del blog:

Si está utilizando Windows, debe pasar los scripts de la carpeta bin directamente al intérprete de Ruby, es decir, al servidor ruby ​​​​bin\rails.

La compresión de activos de JavaScript requiere un entorno de tiempo de ejecución de JavaScript en su sistema, y ​​su ausencia dará como resultado un error execjs durante la compresión de activos. Por lo general, macOS y Windows vienen con un tiempo de ejecución de JavaScript instalado. therubyrhino es el tiempo de ejecución recomendado para los usuarios de JRuby y se agrega a Gemfile si la aplicación se genera para JRuby. Puede aprender todo sobre los tiempos de ejecución admitidos en ExecJS

Esto iniciará Puma, el servidor web distribuido con Rails por defecto. Para ver la aplicación en acción, abra una ventana del navegador y vaya a http://localhost:3000. Debería ver la página de información predeterminada de Rails:

Para detener el servidor web, presione Ctrl+C en la terminal donde se está ejecutando. Para verificar que el servidor se ha detenido, debería volver a ver el cursor de la línea de comandos. Para la mayoría de los sistemas similares a UNIX, incluido macOS, este será el signo de dólar $ . En el modo de desarrollo, Rails generalmente no requiere que detenga el servidor; todos los cambios que realice en los archivos son recogidos automáticamente por el servidor.

La página "Bienvenido a bordo" es como una prueba para una nueva aplicación de Rails: muestra que sus programas están configurados correctamente para mostrar la página.

4.2. Di hola, Rieles

Para que Rails diga "Hola", debe crear al menos controlador y vista(representación).

El propósito de un controlador es recibir solicitudes específicas a una aplicación. Enrutamiento decide qué controlador recibirá qué solicitudes. A menudo hay más de una ruta a cada controlador y las diferentes rutas se pueden manejar de manera diferente. juegos de acción. El propósito de cada acción es recopilar información para proporcionarla a la vista.

El propósito de una vista es mostrar esta información en un formato legible por humanos. Una distinción importante que debe hacerse es que el lugar donde se recopila la información es controlador, no una vista. La vista solo debe mostrar esta información. De forma predeterminada, las plantillas de vista están escritas en un lenguaje llamado eRuby (Embedded Ruby), que se convierte mediante el ciclo de solicitud en Rails antes de enviarlo al usuario.

Para crear un nuevo controlador, debe ejecutar el generador de "controlador" y decirle que desea un controlador llamado "Bienvenido" con una acción llamada "índice", como esta:

$ rieles generan controlador Índice de bienvenida

Rails creará algunos archivos y una ruta.

Crear aplicación/controladores/welcome_controller.rb ruta obtener "bienvenida/índice" invocar erb crear aplicación/vistas/bienvenida crear aplicación/vistas/bienvenida/index.html.erb invocar test_unit crear prueba/controladores/bienvenida_controlador_prueba.rb invocar asistente crear aplicación/ helpers/welcome_helper.rb invocar test_unit invocar activos invocar scss crear app/assets/stylesheets/welcome.scss

Los más importantes son, por supuesto, el controlador, ubicado en app/controllers/welcome_controller.rb, y la vista, ubicada en app/views/welcome/index.html.erb.

Abra el archivo app/views/welcome/index.html.erb en un editor de texto. Elimine todo el código existente en el archivo y reemplácelo con la siguiente línea de código:

Si vuelve a enviar el formulario, verá algo como lo siguiente:

"¡Primer artículo!", "texto"=>"Este es mi primer artículo") permitido: false>

Esta acción ahora muestra las opciones para el artículo que vino del formulario. Sin embargo, sigue siendo inútil. Sí, ves los parámetros, pero en realidad no haces nada con ellos.

5.4. Creación del modelo de artículo

Los modelos en Rails usan el nombre en singular y su tabla correspondiente en la base de datos usa el nombre en plural. Rails proporciona un generador de modelos que la mayoría de los desarrolladores de Rails utilizan para crear nuevos modelos. Para crear un nuevo modelo, ejecute este comando en su terminal:

$ rieles generar modelo Título del artículo:cadena de texto:texto

Con este comando, le decimos a Rails que queremos un modelo Article con el atributo título tipo de cadena y atributo texto tipo de texto. Estos atributos se agregan automáticamente a la tabla de artículos y se vinculan al modelo de artículo.

Rails creará una serie de archivos en respuesta. En este momento solo estamos interesados ​​en app/models/article.rb y db/migrate/20140120191729_create_articles.rb (su nombre puede ser ligeramente diferente). Este último es responsable de crear la estructura de la base de datos, por lo que lo analizaremos más a fondo.

Active Record es lo suficientemente inteligente como para asociar automáticamente los nombres de las columnas con los atributos del modelo, lo que significa que no tiene que declarar los atributos dentro de los modelos de Rails, Active Record lo hace automáticamente.

5.5. Ejecutando la migración

Como has visto, Rails generar modelo creó el archivo migraciones de base de datos en el directorio db/migrate. Las migraciones son una clase de Ruby diseñada para facilitar la creación y modificación de tablas de bases de datos. Rails usa comandos de rake para ejecutar migraciones, y es posible deshacer una migración después de que se haya aplicado a su base de datos. El nombre del archivo de migración incluye una marca de tiempo para asegurarse de que se ejecutan en el orden en que se crearon.

Si busca en el archivo db/migrate/YYYYMMDDHHMMSS_create_articles.rb (recuerde, su archivo tiene un nombre ligeramente diferente), esto es lo que encontrará:

Crear artículos de clase< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Esta migración crea un método de cambio que se llama cuando se ejecuta esta migración. La acción definida en esta migración también es reversible, lo que significa que Rails sabe cómo deshacer los cambios realizados por esta migración en caso de que decidas deshacerlos más adelante. Cuando ejecute esta migración, creará una tabla de artículos con una columna de cadena y una columna de texto. También creará dos campos de marca de tiempo para realizar un seguimiento de cuándo se creó y actualizó el artículo.

Ahora necesitamos usar el comando Rails para ejecutar la migración:

$ raíles db:migrar

Rails ejecutará este comando de migración e informará que ha creado la tabla Artículos.

CreateArticles: migrando =============================================== = -- create_table(:articles) -> 0.0019s == CreateArticles: migrado (0.0020s) ============================= ============

Dado que está ejecutando en el entorno de desarrollo de forma predeterminada, este comando se aplicará a la base de datos definida en la sección de desarrollo de su archivo config/database.yml. Si desea ejecutar migraciones en otro entorno, como producción, debe pasarlas explícitamente cuando llame al comando: rails db:migrate RAILS_ENV=production .

5.6. Guardar datos en el controlador

Volviendo a ArticlesController, necesitamos modificar la acción de creación para usar el nuevo modelo de artículo para guardar datos en la base de datos. Abra app/controllers/articles_controller.rb y modifique la acción de creación de la siguiente manera:

Def create @article = Article.new(params[:article]) @article.save redirect_to @article end

Esto es lo que sucede aquí: cada modelo de Rails se puede inicializar con los atributos apropiados, que se vincularán automáticamente a las columnas de la base de datos correspondientes. En la primera línea, hacemos precisamente eso (recuerde que params[:article] contiene los atributos que nos interesan). Entonces @article.save es responsable de guardar el modelo en la base de datos. Finalmente, redirigimos al usuario a la acción mostrar, que definiremos más adelante.

Quizás se pregunte por qué la A en Article.new está en mayúscula cuando todos los demás enlaces de artículos en esta guía usan minúsculas. En este contexto, nos referimos a una clase denominada Article , que se define en app/models/article.rb . Los nombres de las clases en Ruby deben comenzar con una letra mayúscula.

Ahora que hay validaciones, llamar a @article.save en un artículo no válido devolverá false . Si vuelve a abrir app/controllers/articles_controller.rb, verá que no verificamos el resultado de llamar a @article.save en la acción de creación. Si @article.save falla en esta situación, debemos volver a mostrar el formulario al usuario. Para hacer esto, reemplace las acciones new y create en app/controllers/articles_controller.rb con estas:

Def new @article = Article.new end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end private def article_params params.require(:article).permit(:title , :texto) fin

Ahora, la nueva acción crea una nueva variable de instancia llamada @article y verá por qué en un par de párrafos.

Tenga en cuenta que en la acción de creación usamos render en lugar de redirect_to cuando save devuelve false . El método de procesamiento se usa para que el objeto @article se devuelva a la nueva plantilla cuando se procesa. Esta representación se realiza dentro de la misma solicitud que el envío del formulario, mientras que redirect_to le dice al navegador que realice otra solicitud.

5.11. Actualizaciones de artículos

Hemos revelado la parte "CR" de CRUD. Ahora centrémonos en la parte "U", actualizando artículos.

El primer paso es agregar una acción de edición a ArticlesController, generalmente entre las acciones new y create, como se muestra.

Def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end fin

La vista contendrá un formulario similar al que usamos al crear nuevos artículos. Cree un archivo llamado app/views/articles/edit.html.erb y agréguele lo siguiente:

Edición de artículo

<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %> <% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %> <%= link_to "Back", articles_path %>

En este momento, estamos dirigiendo el formulario a una acción de actualización, que aún no está definida, pero lo haremos pronto.

Pasar el objeto del artículo al método form_with establecerá automáticamente la URL para enviar el formulario del artículo editado. Esta opción le dice a Rails que queremos que este formulario se envíe con PATCH , un método HTTP que se espera que se use para actualizaciones recursos de acuerdo con el protocolo REST.

A continuación, debe crear una acción de actualización en app/controllers/articles_controller.rb. Agréguelo entre la acción de creación y el método privado:

Def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "editar" end end privado def article_params params.require(:article).permit(:title, :text) end

El nuevo método, update , se utiliza cuando desea actualizar una entrada que ya existe y toma un hash que contiene los atributos que desea actualizar. Como antes, si hay un error al actualizar el artículo, queremos volver a mostrar el formulario al usuario.

Hemos reutilizado el método article_params que definimos anteriormente para la acción de creación.

No es necesario pasar todos los atributos para actualizar. Por ejemplo, si se llamara a @article.update(title: "Un nuevo título"), Rails solo actualizaría el atributo de título, dejando intactos todos los demás atributos.

<% @articles.each do |article| %> <% end %>

Título	Texto
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

Y también agregue app/views/articles/show.html.erb a la plantilla para que el enlace "Editar" también esté en la página del artículo. Agregue lo siguiente al final de la plantilla:

... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Y así es como se ve nuestra aplicación ahora:

5.12. Uso de parciales para limpiar la repetición en las vistas

Nuestra página de edición es muy similar a la página nueva, de hecho, usan el mismo código para mostrar el formulario. Eliminemos esta duplicación usando una vista parcial. Por convención, los archivos parciales comienzan con un guión bajo.

Cree un nuevo archivo app/views/articles/_form.html.erb con el siguiente contenido:

<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>

<% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %>

Ahora actualicemos la vista app/views/articles/new.html.erb para usar este nuevo parcial, reescribiéndolo completamente:

articulo nuevo

<%= render "form" %> <%= link_to "Back", articles_path %>

Y lo mismo para la vista app/views/articles/edit.html.erb:

Editar artículo

<%= render "form" %> <%= link_to "Back", articles_path %>

5.13. Eliminación de artículos

Ahora estamos listos para cubrir la parte "D" de CRUD, eliminando de una base de datos. Siguiendo la convención REST, la ruta para eliminar artículos en la salida de rutas de rieles es la siguiente:

ELIMINAR /artículos/:id(.:formato) artículos#destruir

El método de enrutamiento de eliminación debe usarse para rutas que destruyen recursos. Si se deja como una ruta de obtención normal, sería posible generar las siguientes URL maliciosas:

mira este gato!

Usamos el método de eliminación para destruir los recursos, y esta ruta está asociada con la acción de destrucción en app/controllers/articles_controller.rb , que aún no existe. El método destroy suele ser la última acción CRUD en el controlador y, como todas las acciones CRUD públicas, debe colocarse antes que cualquier método privado o protegido. Vamos a agregarlo:

Def destroy @article = Article.find(params[:id]) @article.destroy redirect_toarticles_path end

El ArticlesController completo en app/controllers/articles_controller.rb ahora debería verse así:

Artículos de claseController< ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end

Puede llamar a destroy en objetos Active Record cuando desee eliminarlos de la base de datos. Tenga en cuenta que no necesitamos agregar una vista para esta acción ya que estamos redirigiendo a la acción de índice.

Listado de artículos

<%= link_to "New article", new_article_path %> <% @articles.each do |article| %> <% end %>

Título	Texto
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>	<%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %>

Aquí usamos link_to de una manera diferente. Pasamos la ruta nombrada como el segundo argumento y las opciones como el otro argumento. El método: :eliminar y datos: (confirmar: "¿Está seguro?") Las opciones se utilizan como atributos html5, por lo que cuando se hace clic en un enlace, Rails primero mostrará al usuario un cuadro de diálogo de confirmación y luego enviará el enlace utilizando el método de eliminación. . Esto se hace usando el archivo JavaScript rails-ujs, que se incluye automáticamente en el diseño de la aplicación (app/views/layouts/application.html.erb) cuando se genera la aplicación. Sin este archivo, no se mostrará el cuadro de diálogo de confirmación.

Felicitaciones, ahora puede crear, ver todos e individualmente, actualizar y eliminar artículos.

Agregar un segundo modelo

Es hora de agregar el segundo modelo a la aplicación. El segundo modelo manejará los comentarios sobre los artículos.

6.1. Generación de un modelo

Tenemos la intención de usar el mismo generador que usamos anteriormente al crear el modelo Article. Esta vez crearemos un modelo de comentario que contiene un enlace al artículo. Ejecute el siguiente comando en una terminal:

$ rieles generar modelo Comentar comentarista:cuerpo de cadena:artículo de texto:referencias

Este comando genera cuatro archivos:

Primero, echemos un vistazo a app/models/comment.rb:

comentario de clase< ApplicationRecord belongs_to:article end

Esto es muy similar al modelo Article que vimos anteriormente. La diferencia está en la línea pertenece_a:artículo , que establece conexión registro activo. Aprenderá sobre las conexiones en la siguiente sección de la guía.

La palabra clave (:references) utilizada en el comando bash es un tipo de datos especial para modelos. Crea una nueva columna en su base de datos con el nombre del modelo renderizado con _id adjunto, que puede contener valores numéricos. Para comprenderlo mejor, analice el archivo db/schema.rb después de realizar la migración.

Además del modelo, Rails también realizó una migración para crear la tabla de base de datos correspondiente:

Clase CreateComments< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, null: false, foreign_key: true t.timestamps end end end

La línea t.references crea una columna numérica denominada article_id , un índice en ella y una restricción de clave externa que apunta a la columna id de la tabla de artículos. A continuación, ejecutamos la migración:

$ raíles db:migrar

Rails es lo suficientemente inteligente como para ejecutar solo aquellas migraciones que aún no se han ejecutado en la base de datos actual, en nuestro caso verá:

CreateComments: migrando ============================================== = -- create_table(:comments) -> 0.0115s == CreateComments: migrado (0.0119s) ============================= ==========

6.2. Vinculación de modelos

Los enlaces de Active Record le permiten declarar fácilmente las relaciones entre dos modelos. En el caso de comentarios y artículos, puede describir la relación de la siguiente manera:

• Cada comentario pertenece a un artículo.
• Un artículo puede tener muchos comentarios.

De hecho, se parece mucho a la sintaxis que usa Rails para declarar esta relación. Ya has visto la línea de código en el modelo Comentario (app/models/comment.rb) que hace que cada comentario pertenezca a un artículo:

comentario de clase< ApplicationRecord belongs_to:article end

Debe editar app/models/article.rb para agregar el otro lado del enlace:

articulo de clase< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

Estos dos anuncios están automáticamente disponibles. un gran número de oportunidades. Por ejemplo, si tiene una variable de instancia @article que contiene un artículo, puede obtener todos los comentarios que pertenecen a ese artículo en una matriz llamando a @article.comments .

6.3. Agregar una ruta para comentarios

Al igual que con el controlador de bienvenida, debemos agregar una ruta para que Rails sepa a qué dirección queremos ir para ver los comentarios. Abra el archivo config/routes.rb nuevamente y edítelo de la siguiente manera:

Recursos:los artículos hacen recursos:los comentarios terminan

Esto creará comentarios como recurso anidado en artículos. Esta es la otra cara de capturar la relación jerárquica que existe entre artículos y comentarios.

6.4. Generar un controlador

Con el modelo en su lugar, centremos nuestra atención en crear el controlador apropiado. Nuevamente usaremos el mismo generador que usamos antes:

$ rieles generan controlador

Se crearán cuatro archivos y un directorio vacío:

Al igual que con cualquier otro blog, nuestros lectores crearán sus comentarios inmediatamente después de leer el artículo y, después de agregar un comentario, serán redirigidos a la página de visualización del artículo y verán que su comentario ya se ha reflejado. En este sentido, nuestro CommentsController sirve como un medio para crear comentarios y eliminar el spam, si lo hubiera.

Primero, extenderemos la plantilla de presentación de artículos (app/views/articles/show.html.erb) para permitirnos agregar un nuevo comentario:

Título: <%= @article.title %>

texto: <%= @article.text %>

Añadir un comentario:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Esto agregará un formulario a la página de visualización del artículo que crea un nuevo comentario cuando se llama a la acción de creación en CommentsController. Aquí, la llamada form_with usa una matriz, que creará una ruta anidada como /articles/1/comments .

Escribamos create en app/controllers/comments_controller.rb:

Clase ComentariosControlador< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

Esto es un poco más complicado que lo que viste en el artículo controlador. Este es un efecto secundario del archivo adjunto que configuró. Cada solicitud de un comentario realiza un seguimiento del artículo al que se adjunta el comentario, por lo que primero resolvemos la recuperación del artículo llamando a find en el modelo Article.

Además, el código aprovecha algunos de los métodos disponibles para las relaciones. Usamos el método de creación en @article.comments para crear y guardar un comentario. Esto vincula automáticamente el comentario para que pertenezca a un artículo en particular.

Una vez que hemos creado un nuevo comentario, llevamos al usuario de regreso al artículo original usando el ayudante article_path(@article). Como hemos visto, llama a la acción show en ArticlesController , que a su vez representa la plantilla show.html.erb. Aquí es donde queremos mostrar los comentarios, así que agreguemos lo siguiente a app/views/articles/show.html.erb .

Título: <%= @article.title %>

texto: <%= @article.text %>

Comentarios

<% @article.comments.each do |comment| %>

comentarista: <%= comment.commenter %>

Comentario: <%= comment.body %>

<% end %>

Añadir un comentario:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Ahora puede agregar artículos y comentarios a su blog y mostrarlos en los lugares correctos.

refactorización

Ahora que tenemos artículos y comentarios funcionando, echemos un vistazo a la plantilla app/views/articles/show.html.erb. Se hizo largo e incómodo. Usemos parciales para descargarlo.

7.1. Representación de colecciones de parciales

Primero, hagamos un comentario parcial que muestre todos los comentarios del artículo. Cree un archivo app/views/comments/_comment.html.erb y coloque lo siguiente en él:

comentarista: <%= comment.commenter %>

Comentario: <%= comment.body %>

Luego puede cambiar app/views/articles/show.html.erb así:

Título: <%= @article.title %>

texto: <%= @article.text %>

Comentarios

<%= render @article.comments %>

Añadir un comentario:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Esto ahora hará que app/views/comments/_comment.html.erb sea parcial una vez por cada comentario en la colección @article.comments. Dado que el método de render itera sobre la colección @article.comments, asigna cada comentario a una variable local denominada como parcial, en nuestro caso comment , que está disponible en el parcial para renderizar.

7.2. Representación de un formulario en un parcial

Movamos también la nueva sección de comentarios a nuestro parcial. Nuevamente, cree un archivo app/views/comments/_form.html.erb que contenga:

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %>

Luego cambie app/views/articles/show.html.erb así:

Título: <%= @article.title %>

texto: <%= @article.text %>

Comentarios

<%= render @article.comments %>

Añadir un comentario:

<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

El segundo render solo define la plantilla para el parcial que queremos renderizar, comments/form . Rails es lo suficientemente inteligente como para sustituir un guión bajo en esta línea y comprender que quería representar el archivo _form.html.erb en el directorio app/views/comments.

El objeto @article está disponible en cualquier parcial representado en la vista porque lo hemos definido como una variable de instancia.

Eliminación de comentarios

Otra característica importante del blog es la capacidad de eliminar el spam. Para hacer esto, necesitamos insertar algún enlace en la vista y una acción de destrucción en el CommentsController.

comentarista: <%= comment.commenter %>

Comentario: <%= comment.body %>

<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>

Presionando esto nuevo enlace"Destruir comentario" activará un DELETE /articles/:article_id/comments/:id en nuestro CommentsController que luego se usará para encontrar el comentario que queremos eliminar, así que agreguemos una acción de destrucción a nuestro controlador (app/controllers/comments_controller .rb):

Clase ComentariosControlador< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

La acción de destrucción encontrará el artículo que estamos viendo, encontrará el comentario en la colección @article.comments y luego lo eliminará de la base de datos y nos llevará de vuelta a la vista del artículo.

8.1. Eliminación de objetos relacionados

Si elimina un artículo, los comentarios asociados con él también deben eliminarse, de lo contrario, solo ocuparán espacio en la base de datos. Rails le permite usar la opción dependiente en el enlace para lograr esto. Modifique el modelo de artículo, app/models/article.rb , de la siguiente manera:

articulo de clase< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Seguridad

9.1. Autenticación básica

Si publica su blog en línea, cualquiera puede agregar, editar y eliminar artículos o eliminar comentarios.

Rails proporciona un sistema de autenticación HTTP básico que funciona bien en esta situación.

En ArticlesController necesitamos una forma de bloquear el acceso a varias acciones si el usuario no está autenticado. Aquí podemos usar el método Rails http_basic_authenticate_with para permitir el acceso a las acciones requeridas si el método lo permite.

Para usar el sistema de autenticación, lo definiremos en la parte superior de nuestro ArticlesController en app/controllers/articles_controller.rb. En nuestro caso, queremos que el usuario se autentique para cada acción, excepto para indexar y mostrar, por lo que lo escribiremos así:

Artículos de claseController< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

También queremos permitir que solo los usuarios autenticados eliminen comentarios, por lo que en CommentsController (app/controllers/comments_controller.rb) escribiremos:

Clase ComentariosControlador< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

Ahora, si intenta crear un nuevo artículo, encontrará un desafío de autenticación básica HTTP:

Otros métodos de autenticación también están disponibles para aplicaciones Rails. Dos complementos populares de Rails son Devise y Authlogic, entre otros.

9.2. Otros pensamientos de seguridad

La seguridad, especialmente en las aplicaciones web, es un área amplia y detallada. La seguridad de su aplicación Rails se cubre con más detalle en la guía de seguridad de la aplicación Rails.La forma más fácil de trabajar con Rails es almacenar todos los datos externos en UTF-8. De lo contrario, las bibliotecas de Ruby y Rails a menudo podrán convertir sus datos nativos a UTF-8, pero esto no siempre funciona de manera confiable, por lo que es mejor asegurarse de que todos los datos externos sean UTF-8.

Si comete un error en esta área, el síntoma más común es un diamante negro con un signo de interrogación dentro que aparece en el navegador. Otro síntoma común es que aparecen caracteres como "ü" en lugar de "ü". Rails toma una serie de pasos internos para mitigar casos comunes de problemas que pueden detectarse y solucionarse automáticamente. Sin embargo, si hay datos externos que no están almacenados en UTF-8, esto puede generar este tipo de problemas que Rails no puede detectar ni solucionar automáticamente.

Las dos fuentes de datos más comunes que no están en UTF-8 son:

• Su editor de texto: La mayoría de los editores de texto (como TextMate) guardan los archivos como UTF-8 de forma predeterminada. Si su editor de texto no hace esto, es posible que los caracteres especiales escritos en sus plantillas (como é) aparezcan como un signo de interrogación en forma de diamante en el navegador. Esto también se aplica a los archivos de traducción de su i18N. La mayoría de los editores que no utilizan UTF-8 de forma predeterminada (como algunas versiones de Dreamweaver) ofrecen una forma de cambiar los valores predeterminados a UTF-8. hazlo
• Su base de datos: Rails convertirá de forma predeterminada los datos de su base de datos a UTF-8 en el límite. Sin embargo, si su base de datos no usa UTF-8 internamente, es posible que no pueda almacenar todos los caracteres que escribe su usuario. Por ejemplo, si su base de datos usa internamente Latin-1 y su usuario ingresa caracteres rusos, hebreos o japoneses, los datos se perderán tan pronto como ingresen a la base de datos. Si es posible, use UTF-8 como almacenamiento interno en su base de datos.

El autor se animó a escribir este texto estudiando una serie de materiales que se encuentran en la Web Global, que bien podrían designarse con el mismo encabezado/etiqueta: Cómo aprendí rubí(o Ruby on Rails, PHP, JS, C++, etc.) por tres días.

Bueno, o algo así. El autor, a su vez, recordó de inmediato (asociaciones incontrolables) una serie de anécdotas, unidas nuevamente por un tema común, que consiste en evaluar acciones que se pueden realizar tontamente ... el idioma ruso es poderoso e increíblemente aforístico, pero, desafortunadamente, no parece posible citar aquí estas obras maestras; en consecuencia, no queda más que ofrecer a la atención del lector una versión del doki escrito por él mismo del ciclo Cómo disfrutar y aprender a trabajar relativamente rápido en Ruby on Rails.

Siempre se puede encontrar un ejemplo práctico del código descrito en el artículo, entre otros ejemplos de Rails, en el blog de prueba del autor en herokuapp.com, bienvenido.

La técnica es sencilla, y el autor no pretende en absoluto ser pionero aquí: es necesario que sea interesante, y los resultados no tardarían en llegar. No está de más tratar de jugar con tus propias debilidades, a veces incluso la vanidad puede ser beneficiosa para la causa; los resultados del desarrollo deben ser tales que puedan presentarse con orgullo a los lectores, amigos y colegas en la Web, desplegarse en algún lugar de Heroku o Amazonas, también, para que pueda volver a ellos una y otra vez, reconstruir y mejorar, foros y StackOwerflow para ayudarnos a todos. Así que digo, ¿por qué no escribir, para empezar, tu blog en Ruby on Rails?

Sugiero comenzar con los excelentes muelles Getting Started with Rails o su adaptación al idioma ruso de Rails para principiantes, también Build a Blog with Ruby on Rails, también para ayudar a los materiales de este blog, cuyos enlaces se encuentran fácilmente en la barra lateral izquierda. . Y luego, todo, luego magia, al principio todo está pintado como un reloj, abre la consola, y adelante ... el autor considera que es su deber hacer solo algunas explicaciones y recomendaciones técnicas diseñadas para que sea más fácil para el adepto. busque y obtenga el Lado Luminoso de la Fuerza, y no más Togo. Esta es solo tu pelea, sigue adelante y regresa con una victoria.

Asi que. El paso a paso del primer manual está bien calibrado y no te causará, espero, ninguna molestia; solo se requiere que estés atento, repitiendo meticulosamente los pasos detallados comentados... y en una hora tu primer blog está listo, puedes tomarte un descanso y pasar al segundo, algo más interesante. Y es aquí donde, puede resultar, necesitará algunas palabras de despedida, a las que ahora procederemos.

Comencemos con la declaración de que estos métodos son bastante capaces (alternativamente) de parecerse a lo siguiente, pero de ninguna manera como el original:

app/controladores/posts_controller.rb

# Actualizar acción actualiza la publicación con la nueva información def update if @post.update_attributes(post_params) flash[:notice] = "¡Publicación actualizada con éxito!" redirect_to posts_path else flash[:alert] = "¡Error al actualizar la publicación!" render:edit end end # La acción show presenta la publicación individual después de recuperar la identificación def show end # La acción destroy elimina la publicación permanentemente de la base de datos def destroy @post = Post.find(params[:id]) if @post .destroy flash[:notice] = "¡Publicación eliminada con éxito!" redirect_to posts_path else flash[:alert] = "¡Error al actualizar la publicación!" final final

Y, sin embargo, intente de esta manera y de aquella, por qué no. Vamos más allá.

El segundo blog, aunque más complejo (editor de artículos añadido CKEditor y dispositivo, una herramienta de autenticación flexible para aplicaciones de rieles), por alguna razón no permite comentarios en el original. Tendrá que compensar esta deficiencia usted mismo: proceda por analogía con la descripción de la creación del primer blog, solo se requerirán cambios muy pequeños: en pocas palabras, en lugar de artículo y artículos el primer blog que tendrás publicar y publicaciones en el segundo blog, eso es todo, de hecho, la diferencia. Ten cuidado y todo saldrá bien.

Recaptcha también tendrás que vincularte a los comentarios tú mismo: sí, sí, esto no es Joomla para ti, acostúmbrate. Sin embargo, no se requieren esfuerzos titánicos, el proceso de conexión Recaptcha descrito en detalle en el artículo Incluyendo Recaptcha en la aplicación Rails. Además, no es superfluo ajustar dispositivo de tal forma que el blog funciona (¡al menos al principio!) en modo monousuario, permitiendo a muchos de sus lectores el modo SÓLO LECTURA, es decir, prohibiremos el registro de nuevos usuarios para empezar. Hay muchas recetas diferentes en la Web sobre cómo hacer esto, pero, en mi opinión, el truco más competente de este tipo está en el dispositivo Wiki, en un material llamado Cómo: configurar el dispositivo como un sistema de usuario único. . Es decir, creamos un nuevo controlador:

app/controladores/registrations_controller.rb:

Controlador de registros de clase< Devise::RegistrationsController before_action:one_admin_registered?, only: [:new, :create] protected def one_admin_registered? if ((Admin.count == 1) & (admin_signed_in?)) redirect_to root_path elsif Admin.count == 1 redirect_to new_admin_session_path end end end

luego lo anulamos en rutas.rb y eso es todo:

#devise_for:admins devise_for:admins, controllers: (registros: "registros")

CKEDITOR.editorConfig = function(config) ( // config.enterMode = 2; //deshabilitado

Completamente config.enterMode = CKEDITOR.ENTER_BR // presionando la tecla ENTER de entrada
config.shiftEnterMode = CKEDITOR.ENTER_P; //presionando la entrada SHIFT + ENTER KEYS

Config.autoParagraph = falso; // detiene la inserción automática de

enfocado);

Quizás, para empezar, eso es realmente todo... joder, casi se me olvida lo más importante. Si va a implementar su nuevo blog en Heroku- añadir estas tres líneas a

config/aplicación.rb

Config.assets.precompile += Ckeditor.assets config.assets.precompile += %w(ckeditor/*) config.autoload_paths += %W(#(config.root)/app/models/ckeditor)

De lo contrario CKEditor se niega a trabajar para usted en un lugar nuevo.

Ruby es un lenguaje de programación poderoso y popular. Además de su popularidad, se basa en un marco conocido que le permite crear sitios web geniales y dinámicos de varios temas. Si observa el ranking TIOBE, entonces el idioma se encuentra entre los veinte idiomas más populares del mundo.

El lenguaje apareció en 1995 y se considera un lenguaje joven en comparación con C o C++, que aparecieron en 1972 y 1983, respectivamente. El lenguaje tiene una serie de ventajas y características específicas que se implementan exclusivamente en él, si comparamos otros lenguajes de programación populares.

Plan del curso

Durante el curso en video, aprenderá el lenguaje Ruby sin usar marcos adicionales. Cursos adicionales sobre rubí puedes encontrar en .

Durante el curso, aprenderemos cómo instalar y trabajar con el lenguaje, aprenderemos la sintaxis Rubí(variables, bucles, declaraciones condicionales), así como cosas más complejas: programación orientada a objetos, trabajar con archivos, excepciones, métodos y muchos otros temas.

Instalación de Ruby en Windows

Para instalar Ruby en Windows, use RubyInstaller, que se puede descargar desde el sitio web oficial en este enlace. Descarga la última versión e instálala como un programa normal. Una vez completada la instalación, verá una ventana similar:

En esta ventana, asegúrese de que la casilla de verificación esté marcada, luego se abrirá otra aplicación para la instalación rubí en el sistema.

En la ventana que se abre, ingrese 1 a su vez y presione Enter, después de esperar el final de la instalación, presione 2 y Enter y al final ejecute el tercer comando presionando 3 y Enter.

Instalar Ruby en una Mac

En una Mac, Ruby está instalado de manera predeterminada, por lo que no necesita hacer nada adicional. Puede verificar la versión de idioma en la terminal con el siguiente comando:

Si la versión está desactualizada, puede descargar una nueva. Primero debe descargar el administrador de versiones de Ruby. Esto se hace a través de la terminal con el comando:

Rizo -L https://get.rvm.io | bash -s estable

Después de instalar el administrador, reinicie la terminal. Ejecute el siguiente comando:

lista RVM conocida

Después de reiniciar, puede instalar la versión que desee. En nuestro caso se instaló la versión 2.4.2:

rvm instalar ruby-2.4.2

Al final, puede verificar la versión nuevamente y, si aún es antigua, simplemente configure la nueva versión como predeterminada.

Uno de los primeros y más completos tutoriales de Rails en la web. La principal ventaja es una cobertura detallada de los temas más necesarios, actualizaciones periódicas y contenido gratuito.

Es cierto que el recurso está completamente en inglés. Y es importante comprender que esto está construido en forma de libro: debe resolver todos los problemas usted mismo. Debido a esto, no se puede predecir la duración y la complejidad del entrenamiento.

2. Retransmisiones

Otro recurso de formación muy conocido en Internet. Más de una generación de desarrolladores de Rails creció con él. También en inglés.

No está diseñado como un curso de capacitación holístico, sino como una serie de screencasts: lecciones breves sobre un tema específico. Hay muchas lecciones, puedes encontrar casi cualquier tema.

Desafortunadamente, el proyecto dejó de actualizarse en 2013.

3. Rieles para zombis

Una excelente introducción a los raíles para principiantes en un juego estilo búsqueda con un toque de zombi. Es muy popular entre los principiantes completos.

Es conveniente que no necesites instalar nada en tu computadora. Todos los rompecabezas se resuelven en el navegador. Paso a paso, recorre el juego y comienza a comprender los conceptos básicos de Ruby on Rails.

Si no entiendes nada de programación, esta es tu elección. No hay temas complejos en el curso, nada distrae de lo básico. En Inglés.

3.Udemy

Gran colección de cursos de vídeo. Entre ellos hay muchos sobre rubí y rubí sobre rieles. No tiene sentido dar enlaces específicos: elija según su gusto por precio o popularidad.

El formato de Udemy implica cursos bastante cortos con énfasis en lecciones en video. No espere tareas serias o apoyo inmediato de los maestros.

4. Bursa rubí

Un poderoso curso corto sobre los conceptos básicos del desarrollo de Rails. Profesores experimentados, buen programa.

En el curso, la presencia personal del estudiante es deseable y se lleva a cabo solo en las grandes ciudades de Ucrania.

5. Desarrollo en Ruby on Rails de Evil Martians

Un intensivo de tres días de uno de los equipos de Ruby on Rails más experimentados de Rusia.

Raramente hecho. Es caro (a juzgar por las críticas, merece la pena). Requiere presencia personal. Adecuado solo para programadores avanzados, no hay nada que hacer para principiantes allí.

6. Ruby on Rails Online Intensivo de Good Programmer

Un nuevo proyecto de un equipo conocido en Youtube por sus cursos de Ruby para principiantes.

El programa intensivo de 3 meses está diseñado para principiantes completos y promete convertirlo en un programador junior con una cartera de nada más que 12 aplicaciones inteligentes.

El curso consta de lecciones en video, tareas prácticas, apoyo del maestro, seminarios web regulares.

A juzgar por canal de Youtube y comentarios de los usuarios: estos chicos saben lo que están haciendo y no se aburrirán con ellos.

La principal ventaja de cualquier diseñador web es poder comprender, e incluso organizar, lo que sucede "detrás de escena".

Como mínimo, deberías tomar algunas lecciones de programación. No estoy hablando de lenguajes front-end como HTML y CSS; probablemente ya sepa mucho de esto. Estoy hablando de cosas de back-end.

Si sabe cómo sentar las bases, podrá comprender mejor cómo diseñar el resto del sitio. El hecho es que aprender a codificar te hará un diseñador más erudito. Además, ¿quién no querría contratar a un diseñador que sabe todo, desde diseño hasta desarrollo de sitios web?

El truco es elegir un lugar para empezar. Aprender a programar puede ser un proceso difícil, especialmente si elige uno de los más lenguajes complejos como C++ o PHP.

Entonces, ¿cuál es el mejor lugar para empezar? Solo hay una respuesta: Ruby on Rails es uno de los mejores lenguajes de programación y marcos para aprender los conceptos básicos del diseño.

¿Por qué Ruby es la mejor opción?

Para los principiantes, Ruby es uno de los lenguajes más fáciles de aprender, especialmente si tiene experiencia en HTML o CSS como la mayoría de los diseñadores.

Uno de los primeros programas que harás cuando empieces a aprender un idioma es el infame "¡Hola mundo!", que consiste en imprimir esas palabras en la pantalla.

Con lenguajes como C++, puede haber entre cinco y siete líneas de código solo para mostrar esas dos palabras. Pero si usa Ruby, solo habrá una línea y un comando.

Pone "hola, mundo!"

¡Eso es todo! Eso es todo lo que necesitas para imprimir las palabras "¡Hola mundo!" en la pantalla. Bastante fácil, ¿verdad?

Ruby on Rails también es un lenguaje muy seco. Siendo uno de los principios del desarrollo, DRY (seco) significa "Don't Repeat Yourself" (¡No te repitas!) - es decir, no vuelvas a programar un elemento cuando puedes usar uno que ya has creado. Esto convierte a Ruby en un lenguaje de programación muy ligero y de uso común para el desarrollo, ya que tiene como objetivo realizar un proyecto de manera rápida y eficiente.

¿Rubí o Rails?

Ruby es un lenguaje de programación. Rails es un marco que usa Ruby para hacer el trabajo. El marco Ruby on Rails es una colección de código prefabricado o preescrito que ayuda a acelerar el proceso de creación de nuevos proyectos. Inicialmente, se creó para desarrollar la herramienta de gestión de proyectos Basecamp. Además de Basecamp, existen otras aplicaciones web populares creadas con Rails, como 500px, ThemeForest y MyFitnessPal.

Una vez que comprenda cómo trabajar con el lenguaje Ruby y hacer que las cosas funcionen en el marco Ruby On Rails, puede comenzar a crear aplicaciones web.

Ruby: ¡en la cima de la popularidad!

Gracias a la explosión de popularidad. dispositivos móviles y tecnología que siempre está en contacto, Ruby es increíblemente popular en este momento. Y probablemente seguirá siendo así. El índice TIOBE clasifica a Ruby como el decimotercer lenguaje de programación más popular. De acuerdo con las nuevas tendencias, según Indeed.com, Ruby también está experimentando una demanda sorprendentemente alta.

Índice TIOBE

De cualquier manera, ya sea que elija demanda o popularidad, Ruby es bastante popular. Esto lo convierte en uno de los mejores lugares para empezar, porque una vez que dominas el idioma, puedes conseguir un trabajo bastante rápido. Y eso es antes de que empieces a aprender otro idioma para ampliar tus habilidades.

¡Ruby tiene un punto de apoyo fuerte!

Algunos de los otros lenguajes han estado más a nuestro lado, es cierto, pero aun así, el soporte y la documentación palidecen en comparación con lo que está disponible para Ruby. Otros idiomas también carecen de cohesión comunitaria en torno a un marco de gran soporte.

Gracias al marco de Ruby On Rails, ya hay toneladas de código preexistente que puede usar en sus propios proyectos. Ruby Gems, la biblioteca del marco de Ruby, tiene más de 600 000 bibliotecas para elegir.

Cada vez que aprende algo nuevo, necesita mucha documentación y apoyo. Hay un montón de lugares para encontrar tutoriales, tutoriales, guías e incluso foros de preguntas y respuestas. Si se encuentra con un problema específico, es probable que una simple búsqueda en la web lo solucione. Es importante.

La documentación simple y el fácil acceso al soporte son esenciales cuando estás aprendiendo un nuevo idioma, cuando en realidad estás aprendiendo algo nuevo.

Ruby "permite" más control sobre el diseño

Si solo es un diseñador web, crear un sitio web puede ser un proceso largo y complicado. Cuando se sienta a trabajar con un programador y discute el back-end necesario para su sitio, a menudo tiene que sacrificar el front-end para que todo funcione correctamente.

En última instancia, esto puede conducir a un producto que se ve completamente diferente a su visión original. Puede que al programador no le importe, pero probablemente será problemático para ti.

No te encontrarás con problemas de este tipo si te programas a ti mismo. No tiene que depender de otros para obtener un proyecto terminado y comprenderá mucho mejor lo que se puede lograr en términos de desarrollo. Seguramente hubo un momento o dos en los que los objetivos de su proyecto eran demasiado altos para un programador o equipo de desarrollo. Cuando aprende un lenguaje como Ruby, puede disfrutar de la facilidad de comprender las necesidades y las posibilidades, por otro lado.

Esencialmente, Ruby está diseñado para usarse en aplicaciones web y desarrollo web, por lo que es el lugar perfecto para los aspirantes a diseñadores web. Una vez que comprenda el lenguaje y aprenda a usar el marco Ruby on Rails, tendrá mucho más control sobre sus proyectos.

¿Dónde aprender Rubí?

Mayoría La mejor manera aprender un idioma es sumergirse en él y trabajar con él. También hay muchas guías y tutoriales que puede consultar. Si tiene una memoria visual desarrollada y comprende mejor a través de presentaciones visuales, vaya a YouTube: hay una gran selección de videos educativos.

Si desea una experiencia de aprendizaje similar a la de un salón de clases tradicional, puede aprender programando sitios web de aprendizaje. No tienes que ir a la universidad o colegio para obtener una educación laboral.

Uno de mis recursos favoritos, y completamente gratuito, para aprender Rails es Rails Tutorial de Michael Hartle. Lo llevará de un proyecto simple a uno complejo a su propio ritmo y puede comenzar desde el principio sin ningún conocimiento de Ruby on Rails.

Independientemente del camino de aprendizaje que elija, recuerde que solo la práctica hace al maestro. Establezca metas personales para pasar una cierta cantidad de tiempo cada día trabajando con Ruby. Cíñete a esos objetivos y sé persistente. Antes de conocer este lenguaje hasta el final, ya serás un experto que puede crear algunos proyectos fantásticos.