{"id":59124,"date":"2022-11-07T12:07:16","date_gmt":"2022-11-07T11:07:16","guid":{"rendered":"https:\/\/kinsta.com\/es\/?p=59124&post_type=knowledgebase&preview_id=59124"},"modified":"2025-10-01T21:31:01","modified_gmt":"2025-10-01T19:31:01","slug":"inertia-js","status":"publish","type":"post","link":"https:\/\/kinsta.com\/es\/blog\/inertia-js\/","title":{"rendered":"La Gu\u00eda Definitiva de Inertia.js"},"content":{"rendered":"

Las aplicaciones de una sola p\u00e1gina (SPA) se han convertido en la forma moderna de crear aplicaciones web, e Inertia.js es una herramienta l\u00edder que permite a los desarrolladores crear SPA con renderizaci\u00f3n tanto del lado del cliente como del lado del servidor.<\/p>\n

En este art\u00edculo, veremos c\u00f3mo Inertia hace que construir SPAs sea un juego de ni\u00f1os y c\u00f3mo resuelve muchos otros problemas para los desarrolladores. Tambi\u00e9n cubriremos las principales caracter\u00edsticas de la herramienta.<\/p>\n

Pero antes de empezar, vamos a asegurarnos de que entendemos c\u00f3mo funcionan las aplicaciones del lado del servidor y del lado del cliente.<\/p>\n

<\/div><\/kinsta-auto-toc>\n

\u00bfQu\u00e9 Es la Renderizaci\u00f3n del Lado del Servidor?<\/h2>\n

La renderizaci\u00f3n del lado del servidor (SSR) es cuando una aplicaci\u00f3n puede renderizar o mostrar el contenido de la p\u00e1gina web en el servidor en lugar de en el navegador. Cuando un usuario intenta visitar ejemplo.com<\/strong>, el navegador hace una petici\u00f3n al servidor solicitando toda la informaci\u00f3n necesaria para mostrar esta p\u00e1gina web espec\u00edfica, y el servidor responde instant\u00e1neamente proporcionando al navegador una p\u00e1gina completamente renderizada.<\/p>\n

Los motores de b\u00fasqueda intervienen e indexan la informaci\u00f3n suministrada por el servidor antes de que llegue al navegador; esto se conoce como optimizaci\u00f3n de motores de b\u00fasqueda (SEO). A continuaci\u00f3n, el navegador resuelve el contenido de JavaScript, y la p\u00e1gina web se muestra al usuario.<\/p>\n

\"Mostrando
Mostrando contenido renderizado en el lado del servidor.<\/figcaption><\/figure>\n

El problema del enfoque SSR es que se tarda mucho en cargar una p\u00e1gina completamente renderizada desde el servidor, lo que no ofrece una experiencia agradable al usuario. Por ello, los desarrolladores consideran las SPA y el renderizado del lado del cliente.<\/p>\n\n

\u00bfQu\u00e9 Es la Renderizaci\u00f3n del Lado del Cliente?<\/h2>\n

La renderizaci\u00f3n del lado del cliente permite que el navegador tenga todo lo que necesita para renderizar la p\u00e1gina web desde el lado del cliente, en lugar de recibir una p\u00e1gina completamente renderizada desde el servidor. Cuando se carga la p\u00e1gina, el navegador no env\u00eda ninguna otra petici\u00f3n al servidor, lo que hace que la experiencia de navegaci\u00f3n sea extremadamente r\u00e1pida.<\/p>\n

\"Visualizando
Visualizando el contenido renderizado en el lado del cliente.<\/figcaption><\/figure>\n

El renderizado del lado del cliente ayud\u00f3 a la creaci\u00f3n de las SPA, revolucionando la web. Se puede crear un sitio web que no requiera recargar la p\u00e1gina, independientemente de cu\u00e1ntos enlaces se pulsen. Esto facilita al usuario la navegaci\u00f3n por el sitio web.<\/p>\n

Aunque las SPA son fant\u00e1sticas, este enfoque tiene mucha complejidad y problemas que vamos a tratar hoy. Inertia aborda la mayor\u00eda de estos problemas utilizando eficazmente los frameworks del lado del servidor. Combina las mejores caracter\u00edsticas de las aplicaciones del lado del servidor y del lado del cliente.<\/p>\n

\u00bfQu\u00e9 es Inertia.js?<\/h2>\n

Inertia no es un framework de JavaScript<\/a>. En su lugar, es una estrategia o t\u00e9cnica para desarrollar SPAs. Permite al desarrollador utilizar los marcos actuales del lado del servidor para construir una SPA moderna sin la complejidad que conlleva.<\/p>\n

Inercia se ha dise\u00f1ado para acompa\u00f1ar, no para sustituir, a los frameworks que ya utilizas. Consid\u00e9ralo un \u00fatil aliado que te ayuda a completar las tareas de forma m\u00e1s r\u00e1pida y eficiente. Actualmente es compatible con tres frameworks de frontend (Vue, React y Svelte) para la renderizaci\u00f3n del lado del cliente y con dos frameworks de backend (Laravel y Rails) para la renderizaci\u00f3n del lado del servidor.<\/p>\n

Para la mayor\u00eda de los desarrolladores de Lar<\/a>avel<\/a>, Inertia es una de las t\u00e9cnicas m\u00e1s fiables para construir SPAs, ya que les permite conectar tanto los frameworks de frontend como de backend.<\/p>\n

\u00bfC\u00f3mo Funciona Inertia.js?<\/h2>\n

Inertia es similar a Vue Router, en el sentido de que te permite moverte entre p\u00e1ginas sin tener que recargar toda la p\u00e1gina. Sin embargo, Inertia funciona en sincronizaci\u00f3n con tu framework del lado del servidor. Esto es posible con Link<\/code>, una envoltura para la etiqueta de anclaje est\u00e1ndar. Cuando se hace clic en un Link<\/code>, Inercia intercepta el evento de clic y env\u00eda una petici\u00f3n XHR al servidor, haciendo que \u00e9ste reconozca que se trata de una petici\u00f3n de Inertia y devuelva una respuesta JSON. Esa respuesta incluye el nombre y los datos del componente JavaScript, tras lo cual Inertia elimina m\u00e1gicamente los componentes innecesarios y los sustituye por los necesarios para visitar la nueva p\u00e1gina y actualiza el estado del historial.<\/p>\n

Una inmersi\u00f3n profunda en la funcionalidad de Inertia.js<\/h3>\n

Cuando un visitante visita inicialmente example.com<\/strong>, el navegador realiza una petici\u00f3n est\u00e1ndar de p\u00e1gina completa, y el servidor devuelve una respuesta HTML completa como si no existiera Inercia. Esta respuesta HTML tiene todos los activos del sitio (CSS, JavaScript), pero tambi\u00e9n contiene un activo extra para Inertia, que es la ra\u00edz div<\/code> con el atributo data-page<\/code> que contiene datos JSON para la p\u00e1gina inicial. Inertia utiliza entonces estos datos JSON para poner en marcha el marco del frontend y mostrar la p\u00e1gina inicial.<\/p>\n

\"Inertia.js:
Inertia.js: Respuesta de la visita a la p\u00e1gina inicial.<\/figcaption><\/figure>\n

Una vez iniciada la aplicaci\u00f3n, cada ruta que el usuario visite dentro del mismo dominio utilizando Link<\/code> ser\u00e1 una petici\u00f3n XHR con la cabecera X-Inertia<\/code>. Esto indica al servidor que se trata de una petici\u00f3n de Inercia.<\/p>\n

La respuesta vendr\u00e1 como una respuesta JSON con el contenido de la p\u00e1gina, en lugar de una respuesta HTML completa como en la visita inicial.<\/p>\n

\"Inertia.js:
Inertia.js: Respuesta de la visita de la ruta posterior.<\/figcaption><\/figure>\n

\u00bfQu\u00e9 Problemas Resuelve Inertia.js?<\/h2>\n

Inertia resuelve un gran n\u00famero de problemas para los desarrolladores web. El objetivo de crear Inertia era dar soluciones r\u00e1pidas y eficaces a toda la complejidad que conlleva el dise\u00f1o de una SPA.<\/p>\n

Complejidades de las SPA<\/h3>\n

Si los desarrolladores construyeran una SPA sin Inertia, tendr\u00edan que crear APIs REST o GraphQL y protegerlas con alg\u00fan tipo de m\u00e9todo de autenticaci\u00f3n, lo que requerir\u00eda la creaci\u00f3n de un sistema de gesti\u00f3n de estados en el front-end, entre otras muchas cosas.<\/p>\n

Inertia se dise\u00f1\u00f3 para ayudar a los desarrolladores a transformar sus aplicaciones del lado del servidor, que se ejecutan completamente en el servidor backend, en una aplicaci\u00f3n JavaScript de una sola p\u00e1gina sin tener que pasar por todas las complejidades que conlleva la construcci\u00f3n de SPA.<\/p>\n

Crear una SPA con Inertia es similar a crear una aplicaci\u00f3n renderizada del lado del servidor. Creas controladores, haces consultas a la base de datos para obtener los datos necesarios y luego devuelves los resultados a las vistas.<\/p>\n

La clave aqu\u00ed es que las vistas son componentes de JavaScript. Esto significa que obtienes los datos de tu servidor, y luego Inertia trabaja con el marco del frontend para mostrar la p\u00e1gina que contiene los datos como un archivo JavaScript, eliminando la necesidad de crear APIs.<\/p>\n

Autenticaci\u00f3n<\/h3>\n

Como Inertia alimenta la aplicaci\u00f3n con datos y respuestas del backend, simplemente utilizar\u00e1 cualquier sistema de autenticaci\u00f3n que tengas en el lado del servidor. Esto significa que no tendr\u00e1s que preocuparte por la autenticaci\u00f3n del lado del cliente, sino que tendr\u00e1s un sistema de autenticaci\u00f3n basado en la sesi\u00f3n que se sincroniza con tu sistema de autenticaci\u00f3n del lado del servidor.<\/p>\n

Problemas de SEO<\/h3>\n

Como se ha explicado anteriormente para la renderizaci\u00f3n del lado del servidor, los motores de b\u00fasqueda interceptan la respuesta del servidor al navegador para indexar el contenido HTML de la p\u00e1gina web. En el caso de una SPA, los motores de b\u00fasqueda tendr\u00e1n dificultades para identificar el contenido de la p\u00e1gina, ya que el servidor responder\u00e1 con componentes JavaScript y datos JSON.<\/p>\n

Pero Inertia ha resuelto este problema introduciendo la funci\u00f3n de renderizaci\u00f3n del lado del servidor (SSR)<\/a> que puedes a\u00f1adir a tu aplicaci\u00f3n. Inertia utiliza el entorno Node.js como disparador para convertir la respuesta de datos JSON en HTML.<\/p>\n

Para ilustrar mejor esto, imagina a Inertia sentada entre el servidor y el navegador, observando. Cuando el servidor recibe una petici\u00f3n de Inertia y devuelve una respuesta JSON, Inertia detecta la existencia de un servidor Node.js, transforma la respuesta JSON en HTML y la devuelve, permitiendo a los motores de b\u00fasqueda indexar la p\u00e1gina como si la aplicaci\u00f3n no fuera una SPA.<\/p>\n

Inertia tambi\u00e9n proporciona un componente Head<\/code>, que te permite a\u00f1adir un t\u00edtulo y metadatos a tu p\u00e1gina:<\/p>\n

\n<script setup>\nimport { Head } from '@inertiajs\/inertia-vue3'\n<\/script>\n\n<template>\n  <Head>\n    <title>Page Title<\/title>\n    <meta name=\"description\" content=\"Page Description" \/>\n  <\/Head>\n<\/template>\n<\/code><\/pre>\n
Aqu\u00ed tienes otro ejemplo de la documentaci\u00f3n online de<\/a> Inertia:<\/p>\n
\n\/\/ Layout.vue\n\nimport { Head } from '@inertiajs\/inertia-vue3'\n\n<Head>\n  <title>My app<\/title>\n  <meta head-key=\"description\" name=\"description\" content=\"This is the default description\" \/>\n  <link rel=\"icon\" type=\"image\/svg+xml\" href=\"\/favicon.svg\" \/>\n<\/Head>\n\n\/\/ About.vue\n\nimport { Head } from '@inertiajs\/inertia-vue3'\n\n<Head>\n  <title>About - My app<\/title>\n  <meta head-key=\"description\" name=\"description\" content=\"This is a page specific description\" \/>\n<\/Head>\n<\/code><\/pre>\n
Formularios y ayudante de formularios<\/h3>\n
Es posible enviar una solicitud de formulario est\u00e1ndar mientras se utiliza Inertia. Sin embargo, al hacerlo, se actualizar\u00e1 toda la p\u00e1gina.<\/p>\n
Inertia permite a los usuarios realizar solicitudes de formularios utilizando Inertia, lo que elimina la posibilidad de refrescar la p\u00e1gina. Una vez que el formulario se env\u00eda con Inercia, se gestiona en el lado del servidor, lo que te permite redirigir al usuario a la misma p\u00e1gina (o a una p\u00e1gina completamente diferente).<\/p>\n
Inercia nos facilita la vida a la hora de crear y enviar formularios. Aqu\u00ed tienes un ejemplo de c\u00f3mo puedes usarlo con la API de composici\u00f3n de Vue.js 3:<\/p>\n
\n<script setup>\n  import { useForm } from \"@inertiajs\/inertia-vue3\";\n\n  const form = useForm({\n    email: null,\n    password: null,\n  });\n<\/script>\n\n<template>\n  <form @submit.prevent=\"form.post('kinsta\/login')\">\n    \n    <input type=\"text\" v-model=\"form.email\" \/>\n    \n    <input type=\"password\" v-model=\"form.password\" \/>\n    \n    <button type=\"submit\">Login<\/button>\n  <\/form>\n<\/template>\n<\/code><\/pre>\n
Puedes enviar el formulario con GET<\/code>, POST<\/code>, PUT<\/code>, PATCH<\/code> y DELETE<\/code>.<\/p>\n
\n<script setup>\n  import { useForm } from \"@inertiajs\/inertia-vue3\";\n\n  const form = useForm({\n    email: null,\n    password: null,\n  });\n\n  const submit = () => {\n    form.post(\"kinsta\/login\");\n  };\n<\/script>\n\n<template>\n  <form @submit.prevent=\"submit()\">\n    \n    <input type=\"text\" v-model=\"form.email\" \/>\n    \n    <input type=\"password\" v-model=\"form.password\" \/>\n    \n    <button type=\"submit\">Login<\/button>\n  <\/form>\n<\/template>\n<\/code><\/pre>\n
El ayudante de formulario de Inertia tambi\u00e9n ofrece algunas propiedades \u00fatiles como la propiedad processing<\/code> que se convierte en true<\/code> una vez que el formulario comienza a procesarse. Esto puede usarse para desactivar los botones de env\u00edo mientras el formulario se est\u00e1 procesando para evitar m\u00faltiples env\u00edos:<\/p>\n
\n<button type=\"submit\" :disabled=\"form.processing\">Submit<\/button>\n<\/code><\/pre>\n
Tambi\u00e9n puedes utilizar preserveState<\/code>, preserveScroll<\/code> y devoluciones de llamada de eventos con el formulario, lo que ser\u00e1 \u00fatil cuando a\u00f1adas opciones adicionales al formulario:<\/p>\n
\nform.post('kinsta\/login, {\n  preserveScroll: true,\n  onSuccess: () => form.reset('password'),\n})\n<\/code><\/pre>\n
Recordar el estado con Inertia.js<\/h3>\n
Supongamos que un usuario est\u00e1 rellenando un formulario en tu sitio web y decide navegar a otra p\u00e1gina antes de enviarlo. Cuando regrese a la p\u00e1gina del formulario, se restablecer\u00e1 la entrada del formulario del usuario.<\/p>\n
Afortunadamente, Inertia proporciona la funci\u00f3n useRemember<\/code>, que te permite guardar las entradas del formulario del usuario en el estado de historia y restaurarlas en la navegaci\u00f3n de historia.<\/p>\n
Puedes utilizar esta funci\u00f3n import\u00e1ndola de Inertia y aplic\u00e1ndola a tu formulario:<\/p>\n
\nimport { useRemember } from '@inertiajs\/inertia-vue3'\n\nexport default {\n  setup() {\n    const form = useRemember({\n        first_name: null,\n        last_name: null,\n    })\n\n    return { form }\n  },\n}\n<\/code><\/pre>\n
Si tienes una p\u00e1gina con muchos formularios que utilizan la funci\u00f3n useRemember<\/code>, cada componente debe tener una clave \u00fanica para que Inertia sepa qu\u00e9 datos debe restaurar en cada componente:<\/p>\n
\nconst form = useRemember({\n        first_name: null,\n        last_name: null,\n    }, 'Users\/Create')\n<\/code><\/pre>\n
No es necesario utilizar la funci\u00f3n useRemember<\/code> cuando se utiliza el ayudante de formularios de Inertia. Inertia recordar\u00e1 el estado de la entrada del formulario de forma autom\u00e1tica, por lo que s\u00f3lo tenemos que darle un identificador \u00fanico:<\/p>\n
\nimport { useForm } from '@inertiajs\/inertia-vue3'\n\nconst form = useForm('CreateUser', data)\n<\/code><\/pre>\n
Lo bueno de esta funcionalidad es que puedes recordar manualmente cualquier dato de tu aplicaci\u00f3n. Esto tambi\u00e9n puede ser \u00fatil para pasar datos de un componente profundamente anidado al componente principal:<\/p>\n
\nimport { Inertia } from '@inertiajs\/inertia'\n\n\/\/ DeeplyNestedComponent.vue\nInertia.remember(data, 'my-key')\n\n\/\/ MainComponent.vue\nlet data = Inertia.restore('my-key')\n<\/code><\/pre>\n
Carga de archivos<\/h3>\n
Inercia detecta si el formulario incluye archivos y, si es as\u00ed, transforma los datos de la solicitud en el objeto formData<\/code>, que siempre es necesario. As\u00ed que si tienes un formulario que incluye un nombre y un avatar, Inertia tratar\u00e1 el formulario como multipart\/form-data<\/code>.<\/p>\n
Validaci\u00f3n y errores<\/h3>\n
Cuando un usuario env\u00eda un formulario con valores incorrectos y se env\u00eda al servidor para su validaci\u00f3n, devuelve al usuario a la p\u00e1gina del formulario con un flash de errores de validaci\u00f3n en la sesi\u00f3n. Inercia captura los errores de la sesi\u00f3n y los guarda como accesorios de la p\u00e1gina.<\/p>\n
Como los props son reactivos, aparecen cuando se completa el env\u00edo del formulario. Para que Inercia detecte la existencia de errores, vigila page.props.errors<\/code>.<\/p>\n
Una vez que ha encontrado errores, proporciona una llamada de retorno a onError()<\/code> en lugar de onSuccess()<\/code>.<\/p>\n
Aqu\u00ed tienes un ejemplo con Vue 3 para ayudarte a entender el concepto:<\/p>\n
\nconst submit = () => {\n    form.post(\"kinsta\/login\", {\n        onError: () => {\n            return \"Hi! , the server returned an error and Inertia saved it as a prop. Do as you like with me\"\n        },\n        onSuccess: () => {\n            return \"Wohoo!!\"\n        }\n    }\n    );\n  };\n<\/code><\/pre>\n
Mostrar los errores es tan f\u00e1cil como definirlos como props y mostrarlos condicionalmente en tu HTML:<\/p>\n
\n<script setup>\n  defineProps({\n    errors: Object,\n  });\n\n\/\/\n<\/script>\n\n<template>\n  <form @submit.prevent=\"submit()\">\n    \/\/\n    <div v-if=\"errors.email\">{{ errors.email }}<\/div>\n  <\/form>\n<\/template>\n<\/code><\/pre>\n
Al utilizar Inercia, no tienes que preocuparte por los datos de entrada antiguos en caso de errores. Una vez que Inercia detecta que el usuario ha sido redirigido a la p\u00e1gina con errores, conserva autom\u00e1ticamente el estado antiguo del componente para POST<\/code>, PUT<\/code>, PATCH<\/code> y DELETE<\/code>.<\/p>\n
Recargas parciales con Inertia.js<\/h3>\n
La funcionalidad de recarga parcial de Inertia es simplemente excelente, ya que s\u00f3lo recarga un componente seleccionado en la p\u00e1gina, en lugar de volver a obtener todo el conjunto de datos del servidor. Esto lleva la optimizaci\u00f3n de tu aplicaci\u00f3n al siguiente nivel. Tambi\u00e9n puedes visitar el siguiente enlace para saber m\u00e1s sobre c\u00f3mo optimizar el rendimiento de tu aplicaci\u00f3n Laravel<\/a>.<\/p>\n
Se pueden realizar recargas parciales utilizando la propiedad only<\/code> de Inertia:<\/p>\n
\nimport { Inertia } from '@inertiajs\/inertia'\n\nInertia.visit(url, {\n  only: ['users'],\n})\n<\/code><\/pre>\n
Redirecciones externas con Inertia.js<\/h3>\n
El enrutamiento de subdominios, o redireccionamiento externo, es uno de los retos m\u00e1s frustrantes de las SPA. Es irracional esperar que tu aplicaci\u00f3n siga siendo una aplicaci\u00f3n de una sola p\u00e1gina mientras visita un dominio diferente.<\/p>\n
Puede ser necesario redirigir una petici\u00f3n de Inertia a un sitio web externo o incluso a otro punto final no perteneciente a Inertia en tu aplicaci\u00f3n. Esto es posible mediante una visita iniciada por el servidor window.location<\/code>:<\/p>\n
\nreturn Inertia::location($url);\n<\/code><\/pre>\n
Si abres la consola mientras pruebas esto, ver\u00e1s que devuelve 409 conflict<\/code>. Esta respuesta contiene la URL en la cabecera X-Inertia-Location<\/code>, que Inertia detectar\u00e1 en el lado del cliente y realizar\u00e1 autom\u00e1ticamente la visita.<\/p>\n
C\u00f3mo Trabajar con Inertia.js<\/h2>\n
Trabajar con Inertia es similar a trabajar en una aplicaci\u00f3n del lado del servidor, con la excepci\u00f3n de que es una aplicaci\u00f3n de una sola p\u00e1gina totalmente reactiva. Deber\u00edas ser capaz de definir tus rutas, personalizar los controladores y devolver una vista para que Inertia la env\u00ede a tu framework de frontend.<\/p>\n
Rutas de Laravel e Inertia.js<\/h3>\n
El enrutamiento de Laravel no es algo a lo que quieras renunciar cuando desarrolles tu aplicaci\u00f3n; te permite construir r\u00e1pidamente las rutas m\u00e1s complejas, y hay un mont\u00f3n de recursos de Laravel gratuitos y de pago<\/a> que pueden ayudarte a aprender m\u00e1s sobre Laravel y c\u00f3mo funciona el enrutamiento.<\/p>\n
Lo bueno aqu\u00ed es que no necesitas Vue Router o React Router para llevar a cabo un enrutamiento simple del lado del cliente, porque Inertia tiene su propio sistema de enrutamiento que funciona con el de Laravel. Si el trabajo no requiere ning\u00fan dato del backend, puedes utilizar el ayudante del enrutador para enrutar directamente a un componente.<\/p>\n
\nRoute::inertia('\/home', 'HomeComponent');\n<\/code><\/pre>\n
\npublic function index()\n    {\n    return Inertia::render('Users\/Index', [\n        'users' => User::all();\n        'create_url' => URL::route('users.create'),\n    ]);\n}\n<\/code><\/pre>\n
Antes de continuar, nos gustar\u00eda presentarte DevKinsta<\/a>, una potente herramienta para desarrolladores, dise\u00f1adores y agencias que les permite construir aplicaciones web de WordPress de una o varias p\u00e1ginas. Afortunadamente, WordPress puede integrarse con Laravel utilizando el paquete Corcel<\/a>. Si construyes una aplicaci\u00f3n Laravel con integraci\u00f3n de WordPress, echa un vistazo a la herramienta Kinsta APM<\/a> para una extraordinaria monitorizaci\u00f3n del rendimiento.<\/p>\n
Redirecciones<\/h3>\n
Siempre debes redirigir al usuario a la ruta correcta que corresponde a la solicitud inicial. Por ejemplo, si un usuario est\u00e1 enviando a store<\/code> endpoint para enviar un post, aseg\u00farate de redirigir al cliente a GET<\/code> endpoint quiz\u00e1s a la ruta del post.<\/p>\n
\npublic function store()\n{\n    Post::create(\n        Request::validate([\n            'title' => ['required'],\n            'body' => ['required'],\n        ])\n    );\n\n    \/\/ redirect the user to the posts show page\n    return Redirect::route('posts.show');\n}\n<\/code><\/pre>\n
Desventajas del Uso de Inertia.js<\/h2>\n
Hasta ahora, nos hemos centrado en las diversas ventajas de utilizar Inertia. Sin embargo, como cualquier herramienta, Inertia tambi\u00e9n tiene desventajas.<\/p>\n