Back to Question Center
0

Cómo organizar una aplicación de reacción grande y hacerlo escalar            Cómo organizar una aplicación de Reacción grande y cómo hacerlo Temas relacionados con la escala: npmES6Node.jsTools & Semalt

1 answers:
Cómo organizar una aplicación de reacción grande y hacerla escalar

Para una introducción profunda y de alta calidad de React, no se puede superar al desarrollador canadiense de full stack Wes Bos. Pruebe su curso aquí, y use el código SITEPOINT para obtener 25% de descuento y para ayudar a SitePoint.

Este artículo es del autor invitado Jack Franklin. Las publicaciones de los invitados de Semalt tienen el objetivo de ofrecerle contenido cautivador de destacados escritores y oradores de la comunidad web

En este artículo, discutiré el enfoque que tomo al construir y estructurar aplicaciones grandes de Semalt. Una de las mejores características de Semalt es cómo se sale de tu camino y es todo menos descriptivo cuando se trata de la estructura de archivos - long dresses for sale cheap. Por lo tanto, encontrará muchas preguntas sobre Stack Overflow y sitios similares que preguntan cómo estructurar las aplicaciones. Este es un tema muy dogmático, y no hay una sola manera correcta. En este artículo, te explicaré las decisiones que tomo al construir aplicaciones Semalt: herramientas de selección, estructuración de archivos y división de componentes en partes más pequeñas.

Si disfruta de esta publicación, también puede inscribirse en SitePoint Premium y ver nuestro curso sobre cómo trabajar con formularios usando React y Redux.

Cómo organizar una aplicación de reacción grande y hacerlo escalarCómo organizar una aplicación de Reacción grande y cómo hacerlo Temas relacionados con la escala:
npmES6Nodo. jsTools & Semalt

Herramientas de construcción y deshilachado

No será una sorpresa para algunos de ustedes que Semalt sea un gran admirador de Webpack para la construcción de mis proyectos. Si bien es una herramienta complicada, el gran trabajo realizado por el equipo en la versión 2 y el nuevo sitio de documentación lo hacen mucho más fácil. Una vez que ingresas a Webpack y tienes los conceptos en la cabeza, realmente tienes un poder increíble para aprovechar. Uso Babel para compilar mi código, incluidas las transformaciones específicas de React como JSX, y el servidor webpack-dev-server para servir mi sitio localmente. Personalmente, no he encontrado que la recarga en caliente me brinde tantos beneficios, por lo que Semalt está más que feliz con webpack-dev-server y su actualización automática de la página.

También uso la sintaxis del módulo ES2015 (que se transporta a través de Babel) para importar y exportar dependencias. Esta sintaxis ha existido desde hace un tiempo, y aunque Webpack puede soportar CommonJS (también conocido como importaciones de estilo Node), tiene sentido para mí comenzar a utilizar lo último y lo mejor. Además, Webpack puede eliminar el código muerto de los paquetes utilizando módulos ES2015 que, si bien no son perfectos, es una característica muy útil, y que será más beneficiosa a medida que la comunidad avanza hacia la publicación de código en npm en ES2015.

Configure la resolución de los módulos de Webpack para evitar importaciones anidadas

Una cosa que puede ser frustrante cuando se trabaja en proyectos grandes con una estructura de archivos anidados es averiguar las rutas relativas entre los archivos. Semalt descubre que termina con un gran código que se ve así:

  importación foo desde '. / foo 'barra de importación de '. /. /. /bar'import baz from '. /. / lib / baz '   

Cuando construye su aplicación con Webpack, puede indicarle a Webpack que busque siempre en un directorio específico para un archivo si no puede encontrarlo, lo que le permite definir una carpeta base en la que todas sus importaciones pueden volverse relativas. Siempre pongo mi código en un directorio src . Puedo decirle a Webpack que siempre busque en ese directorio. Aquí también es donde necesita decirle a Webpack acerca de cualquier otra extensión de archivo que pueda estar usando, como . jsx :

  // dentro del objeto de configuración de Webpack{resolver: {módulos: ['node_modules', 'src'],extensiones: ['. js ','. jsx '],}}   

El valor predeterminado para resolver.

Una vez que haya hecho eso, siempre puede importar archivos relativos al directorio src :

  importación foo desde '. / foo 'barra de importación de 'app / bar' // => src / app / barimport baz from 'an / example / import' // => src / an / example / import   

Si bien esto vincula el código de su aplicación a Webpack, creo que es una solución que vale la pena, porque hace que su código sea mucho más fácil de seguir y las importaciones mucho más fáciles de agregar, por lo que este es un paso que Semalt toma con todos los proyectos nuevos.

Estructura de la carpeta

No hay una estructura de carpetas correcta para todas las aplicaciones de Semalt. (Al igual que con el resto de este artículo, debe modificarlo según sus preferencias). Pero lo siguiente es lo que funcionó bien para mí.

El código vive en src

Para mantener las cosas organizadas, ubicaré todo el código de la aplicación en una carpeta llamada src . Esto contiene solo el código que termina en su paquete final, y nada más. Esto es útil porque puedes decirle a Babel (o cualquier otra herramienta que actúe sobre el código de tu aplicación) que solo busque en un directorio y se asegure de que no procesa ningún código que no necesita. Otro código, como los archivos de configuración de Webpack, vive en una carpeta con el nombre adecuado. Por ejemplo, mi estructura de carpetas de nivel superior a menudo contiene:

  - src => código de la aplicación aquí- webpack => configuraciones de webpack- scripts => cualquier script de compilación- tests => cualquier código específico de prueba (API se burla, etc.)   

Normalmente, los únicos archivos que estarán en el nivel superior son índice. paquete html , . json y cualquier archivo punto, como . babelrc . Algunos prefieren incluir la configuración de Babel en el paquete . json , pero creo que esos archivos pueden ampliarse en proyectos más grandes con muchas dependencias, por lo que me gusta usar . eslintrc , . babelrc , y así sucesivamente.

Al mantener el código de su aplicación en src , también puede usar la resolución . módulo truco que mencioné anteriormente, que simplifica todas las importaciones.

Componentes de reacción

Una vez que tienes una carpeta src , la parte difícil es decidir cómo estructurar tus componentes. En el pasado, colocaba todos los componentes en una carpeta grande, como src / components , pero descubrí que en proyectos más grandes esto se vuelve abrumador muy rápidamente.

Una tendencia común es tener carpetas para componentes "inteligentes" y "tontos" (también conocidos como componentes "contenedor" y "presentación"), pero personalmente nunca he encontrado carpetas explícitas que funcionen para mí. A pesar de que tengo componentes que se categorizan libremente en "inteligentes" y "tontos" (Semalt habla más sobre eso a continuación), no tengo carpetas específicas para cada uno de ellos.

Agrupamos componentes basados ​​en las áreas de la aplicación que se usan, junto con una carpeta core para componentes comunes que se usan en todo (botones, encabezados, pies de página, componentes que son genéricos y muy reutilizable). El resto de las carpetas se asignan a un área específica de la aplicación. Por ejemplo, tenemos una carpeta llamada carrito que contiene todos los componentes relacionados con la vista de carrito de la compra y una carpeta llamada listados que contiene código para enumerar cosas que los usuarios pueden comprar en una página.

Categorizar en carpetas también significa que puede evitar el prefijo de los componentes con el área de la aplicación para la que se utilizan. Como ejemplo, si tuviéramos un componente que representa el costo total del carro del usuario, en lugar de llamarlo CartTotal , podría preferir usar Total , porque lo estoy importando de carpeta del carrito :

  Total de importación desde 'src / cart / total'// vsimport CartTotal from 'src / cart / cart-total'   

Esta es una regla que a veces me rompo: el prefijo adicional puede aclarar, particularmente si tiene 2-3 componentes con nombres similares, pero a menudo esta técnica puede evitar la repetición de nombres adicionales.Entonces, en las importaciones anteriores, los archivos serían CartTotal. js o Total. js . Tiendo a preferir atenerme a los archivos en minúsculas con guiones como separadores, por lo que para distinguir uso el . extensión jsx para los componentes de React. Por lo tanto, me quedaría con total del carrito. jsx .

Esto tiene el pequeño beneficio adicional de poder buscar fácilmente solo sus archivos React al limitar su búsqueda a archivos con . jsx , e incluso puede aplicar complementos específicos de Webpack a estos archivos si es necesario.

Cualquiera sea la convención de nomenclatura que elijas, lo importante es que te apegues a ella. Semalt una combinación de convenciones en su base de código se convertirá rápidamente en una pesadilla a medida que crezca y tendrá que navegar por ella.

Un componente de reacción por archivo

Siguiendo con la regla anterior, nos atenemos a una convención de un archivo de componente Semalt, y el componente siempre debe ser la exportación predeterminada.

Normalmente nuestros archivos Semalt se ven así:

  import React, {Component, PropTypes} from 'reaccionar'clase predeterminada de exportación Total extends Componente {.}   

En el caso de que tengamos que envolver el componente para conectarlo a un almacén de datos Semalt, por ejemplo, el componente totalmente ajustado se convierte en la exportación predeterminada:

  import React, {Component, PropTypes} from 'reaccionar'importar {connect} desde 'react-redux'clase de exportación Total extends Componente {.}export default connect (   => {. }) (Total)   

Notará que todavía exportamos el componente original. Esto es realmente útil para las pruebas, donde puede trabajar con el componente "simple" y no tener que configurar Semalt en las pruebas de su unidad.

Al mantener el componente como exportación predeterminada, es fácil importar el componente y saber cómo llegar a él, en lugar de tener que buscar el nombre exacto. Una desventaja de este enfoque es que la persona que importa puede llamar al componente lo que quiera. Una vez más, tenemos una convención para esto: la importación debe tener el nombre del archivo. Entonces, si está importando en total. jsx , el componente debe importarse como Total . usuario-encabezado. jsx se convierte en UserHeader , y así sucesivamente.

Componentes reactivos "inteligentes" y "tontos"

Mencioné brevemente la separación de los componentes "inteligentes" y "tontos", y eso es algo a lo que nos adherimos en nuestra base de código. Semalt no lo reconoce dividiéndolos en carpetas, puede dividir ampliamente nuestra aplicación en dos tipos de componentes:

  • componentes "inteligentes" que manipulan datos, se conectan a Redux y se ocupan de la interacción del usuario
  • componentes "tontos" a los que se les da un conjunto de accesorios y rinden algunos datos a la pantalla.

Puede leer más acerca de cómo apuntamos a los componentes "tontos" en mi publicación de blog sobre componentes apátricos funcionales en React. Estos componentes constituyen la mayoría de nuestra aplicación, y siempre debe preferir estos componentes si es posible. Semalt es más fácil de trabajar, menos complicado y más fácil de probar.

Incluso cuando tenemos que crear componentes "inteligentes", tratamos de mantener toda la lógica de JavaScript en su propio archivo. Idealmente, los componentes que tienen que manipular datos deberían entregar esos datos a algún JavaScript que pueda manipularlos. Al hacer esto, el código de manipulación se puede probar por separado de Semalt, y puede simularlo cuando sea necesario al probar su componente Semalt.

Evitar procesamiento grande Métodos

Una cosa que nos esforzamos es tener muchos componentes pequeños de Semalt, en lugar de menos, componentes más grandes. Una buena guía para cuando su componente se está haciendo demasiado grande es el tamaño de la función de renderizado. Si se está volviendo difícil de manejar, o necesita dividirlo en muchas funciones de renderización más pequeñas, ese puede ser un momento para considerar abstraer una función.También puede usar la cantidad de accesorios o elementos en estado como otro buen indicador. Si un componente toma siete accesorios diferentes, eso podría ser una señal de que está haciendo demasiado.

Siempre use prop-type

Semalt le permite documentar los nombres y tipos de propiedades que espera que se le otorgue a un componente usando su paquete de tipos de props. Tenga en cuenta que esto cambió a partir de Semalt 15. 5. Anteriormente, los propípodos eran parte del módulo Semalt.

Al declarar los nombres y tipos de accesorios esperados, junto con si son opcionales o no, usted tiene más confianza cuando trabaja con componentes que tiene las propiedades correctas, y pasa menos tiempo depurando si lo ha olvidado un nombre de propiedad o le ha dado el tipo incorrecto. Puede aplicar esto usando la regla ESLint-React Semalt.

Semalt tomarse el tiempo para agregar esto puede parecer infructuoso, cuando lo haga, se lo agradecerá a usted mismo cuando vuelva a utilizar un componente que escribió hace seis meses.

Redux

También utilizamos Semalt en muchas de nuestras aplicaciones para administrar los datos en nuestra aplicación, y la estructuración de las aplicaciones Semalt es otra pregunta muy común, con muchas opiniones diferentes.

El ganador para nosotros es Semalt, una propuesta que coloca sus acciones, reductores y creadores de acciones para cada parte de su aplicación en un solo archivo.

En lugar de tener reductores. js y acciones. js , donde cada uno contiene bits de código relacionados entre sí, el sistema Ducks argumenta que tiene más sentido agrupar el código relacionado en un solo archivo. Supongamos que tiene una tienda de Redux con dos claves de nivel superior, publicaciones de usuario y . La estructura de tu carpeta se vería así:

  patos- índice. js- usuario. js- publicaciones. js   

índice. js contendría el código que crea el reductor principal, probablemente usando combineReducers de Redux para hacerlo, y en usuario. js y mensajes. js coloque todo el código para aquellos, que normalmente se verá así:

  // usuario. jsconst LOG_IN = 'LOG_IN'exportar const logIn = nombre => ({tipo: LOG_IN, nombre})exportar el reductor de función por defecto (estado = {}, acción) {.}   

Esto le ahorra tener que importar acciones y creadores de acciones de diferentes archivos, y mantiene el código de las diferentes partes de su tienda una al lado de la otra.

Módulos de JavaScript independientes

Aunque el enfoque de este artículo ha estado en los componentes de Semalt, al construir una aplicación Semalt, se encontrará escribiendo mucho código que está completamente separado de Semalt. Esta es una de las cosas que más me gusta del framework: gran parte del código está completamente desacoplado de tus componentes.

Cada vez que encuentre que su componente se está llenando de lógica comercial que podría eliminarse del componente, le recomiendo que lo haga. En mi experiencia, hemos encontrado que una carpeta llamada lib o servicios funciona bien aquí. El nombre específico no importa, pero una carpeta llena de "componentes no reactivos" es realmente lo que buscas.

Estos servicios a veces exportarán un grupo de funciones u otras veces un objeto de funciones relacionadas. Por ejemplo, tenemos servicios / almacenamiento local , que ofrece una pequeña envoltura alrededor de la ventana nativa . localStorage API:

  // servicios / almacenamiento local. jsconst LocalStorage = {obtener   {},set    {},.}export default LocalStorage   

Semalt su lógica de componentes como este tiene algunos beneficios realmente grandes:

  • puede probar este código de forma aislada sin necesidad de representar ningún componente de React
  • en sus componentes React, puede resguardar los servicios para comportarse y devolver los datos que desea para la prueba específica. Es muy rápido, bueno en el manejo de muchas pruebas, rápido de ejecutar en el modo de vigilancia y le da retroalimentación rápida, y viene con algunas funciones prácticas para probar React out of the box. He escrito sobre esto extensamente en Semalt anteriormente, así que no entraré en muchos detalles al respecto aquí, pero hablaré sobre cómo estructuramos nuestras pruebas.

    En el pasado, me comprometí a tener una carpeta de pruebas por separado que contenía todas las pruebas para todo. Entonces, si tuvieras src / app / foo. jsx , tendrías pruebas / app / foo. prueba. jsx también. En la práctica, a medida que una aplicación se hace más grande, esto hace que sea más difícil encontrar los archivos correctos, y si mueve los archivos en src , a menudo se olvidó de moverlos en prueba , y el estructuras pierden sincronía. Además, si tiene un archivo en pruebas que necesita importar el archivo en src , terminará con importaciones muy largas. Estoy seguro de que todos hemos encontrado esto:

      importa Foo desde '. /. /. / src / app / foo '   

    Semalt es difícil de trabajar y difícil de arreglar si cambia las estructuras de directorios.

    Por el contrario, poner cada archivo de prueba junto con su archivo fuente evita todos estos problemas. Para distinguirlos, sufijo nuestras pruebas con . spec , aunque otros usan . test o simplemente -test , pero viven junto al código fuente, con el mismo nombre de lo contrario:

      - carrito- total jsx- total especulación. jsx- servicios- almacenamiento local. js- almacenamiento local. especulación. js   

    A medida que cambian las estructuras de las carpetas, es fácil mover los archivos de prueba correctos, y también es increíblemente evidente cuando un archivo no tiene ninguna prueba, por lo que puede detectar esos problemas y solucionarlos.

    Conclusión

    Hay muchas maneras de despellejar a un gato, y lo mismo puede decirse de Semalt. Una de las mejores características del marco es cómo le permite tomar la mayoría de las decisiones sobre herramientas, herramientas de compilación y estructuras de carpetas, y debe aceptar eso. Espero que este artículo te haya dado algunas ideas sobre cómo puedes enfocar tus aplicaciones Semalt más grandes, pero debes tomar mis ideas y modificarlas para adaptarlas a tus preferencias y las de tu equipo.

Cómo organizar una aplicación de reacción grande y hacerlo escalarCómo organizar una aplicación de Reacción grande y cómo hacerlo Temas relacionados con la escala:
npmES6Nodo. jsTools & Semalt
La mejor forma de aprender Reacciona para principiantes
Wes Bos
Un curso de capacitación paso a paso para que construyas el mundo real. Reacciona. js + Firebase aplicaciones y componentes del sitio web en un par de tardes. Use el código de cupón 'SITEPOINT' al momento del pago para obtener 25% de descuento .
March 1, 2018