Headless WordPress con React



Una introducción a la construcción de sitios web desacoplados con WordPress utilizando la API REST de WordPress y Create React App

En los últimos meses, me he interesado mucho por la API REST de WordPress (de aquí en adelante denominada WP-API) y por React. He estado escribiendo una serie introductoria a la WP-API, pero he decidido hacer una pausa para un post más completo y detallado.

Este post describirá cómo empezar a construir aplicaciones web desacopladas (o “headless”) de WordPress con Create React App y la WP-API. Aunque este post se va a centrar en React para el frontend, algunos de los conceptos generales siguen siendo aplicables si quieres construir tu frontend con algo más como Angular, Rx, Ember o Vue.

Y no tienes que parar con las aplicaciones web. Puedes usar la WP-API para potenciar no sólo aplicaciones web, sino también aplicaciones móviles, aplicaciones para consolas de juegos y más, simultáneamente.

Antes de empezar, no dudes en clonar el repositorio de esta demo.



¿Por qué?



¿Por qué WordPress?

Tu primera pregunta puede ser “¿por qué debería importarme que WordPress tenga una API?”. Ya he escrito un poco sobre esto en otro post, pero si no te apetece abrir otra pestaña, aquí tienes lo más destacado:

  1. A partir de noviembre, WordPress ya alimenta más del 27% de la web. Y a partir de la versión 4.7, lanzada hace apenas un par de meses, todos los endpoints de contenido para la WP-API están ahora incluidos en el núcleo de WordPress, por lo que millones de nuevas APIs acaban de ponerse en línea.
  2. WordPress es súper fácil de usar. Esta puede ser la mayor razón por la que WordPress ha visto una adopción tan generalizada. Permite a cualquiera, incluso a personas sin conocimientos técnicos, crear y editar un sitio web. No hay ninguna otra herramienta con la misma cantidad de características y soporte en existencia que sea tan empoderante como WordPress.
  3. WordPress es una potente plataforma de gestión de contenidos. Es un concepto erróneo común entre algunos desarrolladores que nunca han utilizado WordPress (o que no lo han utilizado en mucho tiempo) que WordPress es simplemente para los blogs. Si bien es genial para los blogs, en realidad es genial para gestionar eficazmente el contenido personalizado a través de Custom Post Types.



¿Porque crear React App?

A menos que hayas estado viviendo bajo una roca en el mundo del desarrollo web, sin duda ya has oído hablar de React. Entrar en el fondo de React está más allá del alcance de este artículo, pero sí quiero presentarte Crear React App, la forma más fácil de empezar con React.

Comenzar con React en sí es bastante fácil. Puedes soltar React y ReactDOM en tu aplicación hoy mismo:

<script src="https://unpkg.com/react@15/dist/react.js"></script>
<script src="https://unpkg.com/react-dom@15/dist/react-dom.js"></script>

Pero si estás pensando en usar React en más de una pequeña parte de tu aplicación, la profundidad de la madriguera puede ser rápidamente abrumadora. Querer aprender React en profundidad suele llevar a una plétora de cosas de más que aprender: ES6, JSX, Babel, Webpack, y mucho más - cada uno de estos requiere una inversión de tiempo significativa para realmente entender.

Entonces, incluso después de adquirir un conocimiento profundo de estos temas, seguirás gastando una cantidad significativa de tiempo en la configuración en la mayoría de los proyectos no triviales.
¿Pero qué pasa si sólo quieres probar React en sí mismo? O ¿qué pasa si quieres empezar con un conjunto de valores predeterminados de configuración y luego modificar esos valores predeterminados a medida que avanzas?

Bueno, hay esperanza: Create React App.

El verano pasado, Facebook lanzó Create React App, una herramienta de caldera con un conjunto sensato de normas de configuración para que puedas empezar rápidamente con el propio React y luego bajar a la madriguera a tu propio ritmo.

Create React App viene con Webpack, ESLint, Babel, Autoprefixer, Jest, y otras grandes herramientas de la comunidad.



¿Por qué WordPress sin cabeza?

Bien, así que WordPress es genial. React es genial. Entonces, ¿por qué deberíamos combinar los dos?

  1. JavaScript es el futuro de WordPress. A finales de 2015, Automattic, la empresa detrás de WordPress, reescribió toda su aplicación de administración (codificada como “Calypso”) en JavaScript. Y unas semanas más tarde, Matt Mullenweg, CEO de Automattic, dio una tarea masiva a todos los desarrolladores de WordPress: “aprender JavaScript, en profundidad.”.
  2. Porque una división frontend/backend es buena para el mundo - tanto para los usuarios como para los desarrolladores. Es posible mejorar las experiencias de los usuarios. El mantenimiento de grandes bases de código es más eficiente. Mejor rendimiento.
  3. Se puede hacer un uso más eficiente de las bases de código.
  4. Su empresa puede contratar talento más especializado. Los ingenieros de frontend no tienen por qué saber de WordPress y viceversa. En lugar de contratar a un desarrollador de temas/plugins de WordPress generalista, puedes contratar roles separados que tengan cada uno un conocimiento profundo de la ingeniería de frontend y de WordPress, respectivamente. <p< li=””> </p<>



¡Adelante!

Bien, ahora que hemos establecido por qué esto es importante, ¡vamos a entrar en materia!



Qué vamos a construir

Para este tutorial, vamos a construir una aplicación sencilla que muestre datos sobre cada una de las películas de Star Wars. Los datos serán suministrados por una API REST de WordPress que construiremos, y los consumiremos con un frontend React construido con Create React App.



Paso uno: Crear nueva instalación de WordPress

.No voy a profundizar mucho en esto, ya que hay miles de recursos en la red para configurar una instalación de WordPress.

Si es la primera vez que te adentras en WordPress, entonces asumiré que no tienes un entorno local configurado. Hay algunas soluciones out-of-the-box, como MAMP y DesktopServer, que son geniales para ponerse en marcha rápidamente. Actualmente, estoy usando Vagrant con Vagrant Vagrants y VVV Variable.

Una vez que tengas tu nueva instalación de WordPress configurada, sigue adelante y visita tu panel de administración: http://your-site.dev/wp-admin



Paso dos: Instalar el plugin de la API de REST de WordPress (puede no ser necesario)

Este paso sólo es necesario si estás ejecutando una versión de WordPress anterior a la 4.7. Puede comprobar qué versión de WordPress está ejecutando yendo a Dashboard>Updates:

~

A partir de WordPress 4.7, la WP-API está integrada en el núcleo de WordPress. Así que si está ejecutando la versión 4.7 o superior, está listo para ir.

De lo contrario, vaya a Plugins>Añadir nuevo y busque “WordPress REST API (Versión 2)”. Siga adelante, instálelo y luego actívelo.



Paso tres: Comprobación de sanidad

Enciende tu herramienta de solicitud de API favorita (a mí me gusta usar Postman) o una ventana de Terminal si lo prefieres.

Descarga una petición GET a http://your-site.dev/wp-json/. Deberías obtener de vuelta algún JSON que contenga todos los recursos de tu sitio WordPress y sus respectivos endpoints.

Para una demostración rápida, envíe una petición GET a http://your-site.dev/wp-json/wp/v2/posts/1

Debería obtener de vuelta JSON con información sobre el post de prueba “¡Hola Mundo!” que viene con todas las nuevas instalaciones de WordPress por defecto. Si ya has eliminado el post de prueba, no obtendrás nada de vuelta.



Paso cuatro: Instalar plugins para este proyecto

Lo siguiente que hay que hacer es instalar los plugins que necesitaremos para este proyecto de demostración. Sigue adelante e instala estos y luego vuelve para la explicación de cada uno (a menos que se indique lo contrario, cada uno puede buscarse e instalarse desde Plugins>Add New).



CPT UI

Los tipos de entradas personalizadas (CPT) son una de las características más potentes de WordPress. Te permite crear tipos de contenido personalizados para ir más allá de las Entradas y Páginas por defecto que trae WordPress.

Aunque es ciertamente posible (y bastante trivial) crear CPTs a través de PHP, realmente me gusta lo fácil que es usar la interfaz de usuario de CPT. Además, si estás leyendo esto sin experiencia previa en WordPress, prefiero que puedas centrarte en la propia WP-API en lugar de en WordPress y PHP.

Para nuestra demostración, vamos a crear un CPT llamado Películas.

Voy a cubrir cómo añadir manualmente el CPT Movies, pero si quieres saltarte eso y simplemente importar los datos, ve a CPT UI>Tools y pega lo siguiente:

{
"películas": {
"name": "películas",
"label": "Películas",
"singular_label": "Película",
"description": "",
"public": "true",
"publicly_queryable": "true",
"show_ui": "true",
"show_in_nav_menus": "true",
"show_in_rest": "true",
"rest_base": "movies",
"has_archive": "false",
"has_archive_string": "",
"exclude_from_search": "false",
"capability_type": "post",
"hierarchical": "false",
"rewrite": "true",
"rewrite_slug": "",
"rewrite_withfront": "true",
"query_var": "true",
"query_var_slug": "",
"menu_position": "",
"show_in_menu": "true",
"show_in_menu_string": "",
"menu_icon": "",
"supports": [
"título",
"editor",
"miniatura"
],
"taxonomías": [],
"etiquetas": {
"nombre_menú": "",
"all_items": "",
"add_new": "",
"add_new_item": "",
"edit_item": "",
"new_item": "",
"view_item": "",
"search_items": "",
"not_found": "",
"not_found_in_trash": "",
"parent_item_colon": "",
"featured_image": "",
"set_featured_image": "",
"remove_featured_image": "",
"use_featured_image": "",
"archives": "",
"insert_into_item": "",
"uploaded_to_this_item": "",
"filter_items_list": "",
"items_list_navigation": "",
"items_list": ""
},
"custom_supports": ""
}
}

Ahora el proceso manual:

  1. Ir a la interfaz de usuario de CPT>Añadir/editar tipos de postes.
  2. Ahora para el proceso manual:
  3. Ve a la UI de CPT>Add/Edit Post Types
  4. Añadir/Editar tipos de post.
  5. Para el Post Type Slug, introduce películas - este es el slug de la URL que utilizará WordPress.
  6. Para el tipo de post, introduzca películas, este es el slug de la URL que utilizará WordPress.
  7. Para la etiqueta plural, introduce Películas
  8. Para la etiqueta singular, introduzca <código>Película</código>
  9. IMPORTANTE: Desplácese hasta el área de Configuración y encuentre la opción “Mostrar en la API REST”. Por defecto, está configurada en Falso. Si no la cambias a True, no podrás consultar este CPT usando la WP-API. Justo debajo de esa opción, deberías ver la opción “REST API base slug “ - puedes introducir películas aquí.
  10. Desplázate hasta abajo y haz clic en Añadir tipo de publicación.

Deberías ver aparecer una nueva opción de Películas en la barra lateral:


Campos personalizados-avanzados

Hablando en términos de base de datos, si los CPT son las tablas, los Campos Personalizados son las columnas. En realidad no es así como WordPress almacena los CPTs y los Campos Personalizados en su base de datos, pero me parece que esta ilustración es útil para aquellos que tienen poca o ninguna experiencia en WordPress. Los CPTs son el recurso (es decir, “Películas”) y los Campos Personalizados son los metadatos sobre ese recurso (es decir, “Año de lanzamiento, Clasificación, Descripción”).

Advanced Custom Fields (ACF) es el plugin para los campos personalizados de WordPress. Por supuesto, puedes crear Campos Personalizados con PHP (al igual que los CPT), pero ACF es un gran ahorro de tiempo (y es una delicia usarlo).

Puedes conseguir éste desde Plugins>Add New, pero si quieres usar la función de importación para importar mis datos de ejemplo, necesitarás la versión Pro, que puedes encontrar aquí).

Si tienes la versión Pro, ve a Custom Fields>Tools después de activar el plugin. Entonces puedes pegar este JSON para importar los campos que necesitarás:

[
{
"key": "group_582cf1d1ea6ee",
"title": "Datos de la película",
"fields": [
{
"key": "field_582cf1d9956d7",
"label": "Año de publicación",
"name": "release_year",
"type": "número",
"instrucciones": "",
"requerido": 0,
"conditional_logic": 0,
"wrapper": {
"anchura": "",
"class": "",
"id": ""
},
"default_value": "",
"placeholder": "",
"prepend": "",
"append": "",
"min": "",
"max": "",
"paso": ""
},
{
"key": "field_582cf1fc956d8",
"label": "Rating",
"name": "rating",
"type": "número",
"instrucciones": "",
"requerido": 0,
"conditional_logic": 0,
"wrapper": {
"anchura": "",
"class": "",
"id": ""
},
"default_value": "",
"placeholder": "",
"prepend": "",
"append": "",
"min": "",
"max": "",
"paso": ""
},
{
"key": "field_5834d24ad82ad",
"label": "Descripción",
"name": "descripción",
"type": "textarea",
"instrucciones": "",
"requerido": 0,
"conditional_logic": 0,
"wrapper": {
"anchura": "",
"class": "",
"id": ""
},
"default_value": "",
"placeholder": "",
"maxlength": "",
"rows": "",
"new_lines": "wpautop"
}
],
"location": [
[
{
"param": "post_type",
"operator": "==",
"value": "películas"
}
]
],
"menu_order": 0,
"position": "normal",
"style": "default",
"label_placement": "top",
"instruction_placement": "label",
"hide_on_screen": "",
"active": 1,
"description": ""
}
]

Si no tienes la versión Pro, aquí tienes cómo configurar tus campos personalizados:



Crear el Grupo de Campos

ACF organiza colecciones de campos personalizados en grupos de campos. Esto es específico del dominio de ACF. Eso es todo lo que realmente necesita saber sobre los Grupos de Campos por ahora.

1.Vaya a Campos personalizados>Grupos de campos

  1. Haga clic en “Añadir nuevo”
  2. Para el título del grupo de campos, introduzca “Datos de la película”
  3. Desplácese hacia abajo hasta que vea el metabox Ubicación. Configure este Grupo de campos para que sólo se muestre si el Tipo de publicación es igual a Película:

A continuación, puede desplazarse hasta el metabox de Configuración. Deberías poder dejar todas estas opciones configuradas en sus valores predeterminados, pero igualmente puedes darle un repaso en comparación con esta captura de pantalla:

Después, haga clic en Actualizar para guardar la configuración del grupo de campos.



Crear los campos personalizados

Primero, cree un campo de año de publicación:

Etiqueta del campo: Release Year
Nombre del campo: release_year
Tipo de campo: Número
¿Es obligatorio? No

A continuación se encuentra el campo Calificación:

Etiqueta del campo: Rating
Nombre del campo: rating
Tipo de campo: Número
¿Es obligatorio? No

Y por último, el campo Descripción:

Etiqueta del campo: Descripción
Nombre del campo: descripción
Tipo de campo: Área de texto
¿Es obligatorio? No

No olvides hacer clic en Actualizar para guardar tus nuevos Campos Personalizados.

Ahora, si vas a Movies>Add New, y luego te desplazas un poco hacia abajo, deberías ver un metabox llamado Movie Data (el nombre de tu grupo de campos) junto con cada uno de los Custom Fields que creaste dentro de él:



ACF to REST API

Ahora que tenemos nuestros campos personalizados, necesitamos exponerlos a la WP-API. ACF no viene actualmente con soporte para WP-API, pero hay una gran solución de plugin de la comunidad llamada ACF to REST API. Todo lo que tienes que hacer es instalar (puedes encontrarlo buscándolo en Plugins>Add New) y activarlo, e inmediatamente expondrá tus campos personalizados de ACF a la API.

Si hubiéramos creado nuestros campos personalizados directamente a través de PHP (sin usar un plugin), también hay un par de funciones ingeniosas para exponer el campo a la API. Más sobre eso aquí.



Paso Cinco: Importación de datos del puesto

Este es el último paso para que nuestra instalación de WordPress esté lista para servir nuestros datos de Star Wars.

Primero tenemos que inportar todas las películas, por suerte yo ya he hecho todo el trabajo manual y lo único que tienes que hacer es pedírmelo 🙂 . Vaya a herramientas>importar, en la parte inferior de la página deberás ver una opción para instalarlo.

Después de que se instale el WordPress Import, deberías ver un enlace para ejecutar el importador. Haz clic en él y importa este archivo en la siguiente pantalla.

La siguiente pantalla te pedirá que asignes los posts importados a un autor. Puedes simplemente asignarlos a tu cuenta de administrador por defecto y hacer clic en Enviar:

Por último, ve a Películas>Todas las películas. Deberías ver un listado de las películas de Star Wars (Episodios 1-7). Debido a que desarrollé en mi entorno local, el archivo de importación no pudo importar las imágenes destacadas para las Películas (no pudo obtenerlas del servidor de origen), por lo que tendrás que añadirlas manualmente (sólo lleva unos 30 segundos).

Mi forma preferida (y la más rápida) es pasar por encima de cada una de las entradas de la página Todas las películas y mantener pulsado Comando (Control en Windows) y hacer clic en Editar para cada una. Esto abrirá una pestaña para cada Película.

En cada una de las páginas de edición, en la barra lateral derecha, busque el metabox Imagen destacada y haga clic en Establecer imagen destacada. Aquí tienes un archivo ZIP con cada una de las imágenes que necesitarás. O puedes usar cualquier otra imagen que quieras.

Para la primera, lo más fácil es subir todas las imágenes al modal de Imagen que ves cuando haces clic en Establecer Imagen Destacada y luego sólo seleccionar la que necesitas para esa primera Película (esto te ahorrará el tiempo de subir cada imagen individualmente en todas tus Películas):

Si esto parece poco claro, aquí hay un GIF que espero que tenga más sentido que mi pobre intento de explicación.

Para cada Película, asegúrate de hacer clic en Actualizar después de seleccionar la imagen destacada.

¡Ahora ya está listo! Ahora deja tu servidor WordPress en funcionamiento y sigamos adelante.



Paso seis: Instalar – Crear la App de React

Asumiendo que ya tienes Node y npm instalados en tu máquina, simplemente ejecuta este comando:

npm install -g create-react-app

¡Eso es todo! Ya estás listo para usar Create React App.



Paso siete: Crear la aplicación

cd en el directorio en el que quieras crear el frontend (no tiene por qué ser (ni debería ser) el mismo directorio que tu instalación de WordPress). A continuación, ejecute:

create-react-app headless-wp

El proceso tardará unos minutos, pero una vez completado deberías poder cd en el directorio headless-wp recién creado. Desde allí, ejecuta:

npm start

Este comando dispara una serie de cosas, pero todo lo que necesitas saber por el momento es que arrancará un servidor de desarrollo de Webpack. Tu navegador debería abrirse automáticamente en http://localhost:3000:

Puedes dejar el servidor funcionando en tu shell. La recarga en caliente refrescará automáticamente tu página web cada vez que guardes un archivo.



Paso ocho: Crea tu componente

Dado que esta aplicación de demostración es muy simple, sólo usaremos un componente. Podríamos crear fácilmente otro componente (es tan fácil como crear otro archivo ComponentName.js e importarlo en su componente padre), pero en su lugar vamos a editar nuestro componente App.js.

Abre <código>App.js</código>. Puedes seguir adelante y eliminar todo el código existente de este archivo excepto la primera y la última línea.

En este punto, App.js debería tener el siguiente aspecto:

importar React, { Component } from 'react';
export default App;

A continuación, crea la función render() para este componente. Esta función se llama cada vez que el estado cambia. Si no estás seguro de lo que significa esto, ten un poco de paciencia. Pronto tendrá sentido.

App.js debería tener ahora este aspecto:

importar React, { Component } from 'react';
class App extends Component {
  render() {
    return (
      <div>
        <h2>Películas de Star Wars</h2>
      </div>
    )
  }
}
export default App;

Lo que devuelva render() es lo que se pinta en el DOM. Si guardas este archivo y vuelves a tu navegador, debería recargarse automáticamente y deberías ver este h2 que hemos creado:

Esto está muy bien y todo, pero ¿qué pasa con todos esos grandes datos que almacenamos en WordPress sobre las películas de Star Wars? Es hora de conseguir esos datos!

Actualiza App.js así:

importar React, { Component } from 'react';
class App extends Component {
  constructor() {
    super();
    this.state = {
      películas: []
    }
  }
componentDidMount() {
    let dataURL = "http://headless-wp.dev/wp-json/wp/v2/movies?_embed";
    fetch(dataURL)
      .then(res => res.json())
      .then(res => {
        this.setState({
          películas: res
        })
      })
  }
render() {
return (
      <div>
        <h2>Películas de Star Wars</h2>
      </div>
    )
  }
}
export default App;

Acabamos de añadir dos nuevas funciones a nuestra función render(): constructor() y componentDidMount().

La función constructor() es donde inicializamos el estado. Dado que sólo estamos tratando con algunos JSON sobre nuestras películas, nuestro estado va a ser bastante simple. Nuestro estado inicial será simplemente un array vacío de películas ya que estamos esperando recuperar ese JSON.

La función componentDidMount() se dispara después de que el componente se monte. Este es el mejor lugar para hacer llamadas a la API externa, así que aquí es donde hemos añadido nuestro código para usar la fetch API para coger todas las películas de nuestra API de WordPress (¡asegúrate de actualizar la URL para reflejar tu propia URL!). A continuación, tomamos la respuesta, la analizamos como JSON y la introducimos en nuestro objeto de estado.Una vez que la respuesta es empujada a nuestro estado, el componente se re-renderizará disparando la función render() porque el estado ha cambiado. Pero esto no importa ahora mismo, porque actualmente nuestra función render() sigue devolviendo sólo un div con un h2 dentro.

Vamos a arreglar eso.

Ahora vamos a añadir un poco de código extra a nuestra función render() que tomará el JSON de nuestro estado (actualmente almacenado en this.state.movies) y mapa cada película y sus datos en un div.

App.js debería tener ahora este aspecto:

importar React, { Component } from 'react';
class App extends Component {
  constructor() {
    super();
    this.state = {
      películas: []
    }
  }
componentDidMount() {
    let dataURL = "http://headless-wp.dev/wp-json/wp/v2/movies?_embed";
    fetch(dataURL)
      .then(res => res.json())
      .then(res => {
        this.setState({
          películas: res
        })
      })
  }
render() {
    let movies = this.state.movies.map((movie, index) => {
      return <div key={index}>
      <img src={película._embedded['wp:featuredmedia'][0].media_details.sizes.large.source_url} />
      <p><strong>Título:</strong> {movie.title.rendered}</p>
      <p><strong>Año de lanzamiento:</strong> {movie.acf.release_year}</p>
      <p><strong>Clasificación:</strong> {movie.acf.rating}</p>
      <div><strong>Descripción:</strong><div peligrosamenteSetInnerHTML={ {__html: movie.acf.description} } /></div>
      </div>
    });
devolver (
      <div>
        <h2>Películas de Star Wars</h2>
      </div>
    )
  }
}
export default App;

Si guardas tu archivo, la página se recargará, pero seguirás sin ver los datos de la película de Star Wars cargados en la página. Eso es porque hay una última cosa que añadir. Estamos asignando cada una de nuestras películas a sus respectivos divs, y luego almacenando todas esas películas dentro de la variable películas en nuestra función render(). Ahora sólo tenemos que decirle a nuestra función render() que devuelva nuestra variable películas añadiendo {películas} debajo de nuestro h2.

Finalizado App.js:

importar React, { Component } from 'react';
class App extends Component {
  constructor() {
    super();
    this.state = {
      películas: []
    }
  }
componentDidMount() {
    let dataURL = "http://headless-wp.dev/wp-json/wp/v2/movies?_embed";
    fetch(dataURL)
      .then(res => res.json())
      .then(res => {
        this.setState({
          películas: res
        })
      })
  }
render() {
    let movies = this.state.movies.map((movie, index) => {
      return <div key={index}>
      <img src={película._embedded['wp:featuredmedia'][0].media_details.sizes.large.source_url} />
      <p><strong>Título:</strong> {movie.title.rendered}</p>
      <p><strong>Año de lanzamiento:</strong> {movie.acf.release_year}</p>
      <p><strong>Clasificación:</strong> {movie.acf.rating}</p>
      <div><strong>Descripción:</strong><div peligrosamenteSetInnerHTML={ {__html: movie.acf.description} } /></div>
      </div>
    });
devolver (
      <div>
        <h2>Películas de Star Wars</h2>
        {películas}
      </div>
    )
  }
}
export default App;

Vuelve a la ventana de tu navegador y deberías ver los datos de Star Wars después de que la página se recargue:



Seguimos

Esto es sólo el principio de lo que puedes hacer con la WP-API y React. Ambos tienen muchas otras características y ambos tienen enormes comunidades.

Puedes llevar la WP-API más allá aprendiendo sobre autenticación y peticiones POST, endpoints personalizados y consultas más complejas.

Y como he dicho antes, Create React App está hecho para que solo te mojes los pies. Cuando estés listo para aprender más, puedes aprender más sobre cosas como Redux, ES6, Webpack, React Native, y más.

Cubriré muchos de estos temas y más en futuros posts, así que asegúrate de volver. O si prefieres que te envíen estos posts directamente a tu bandeja de entrada, escríbeme un email y te añadiré a mi lista de correo.



¿Preguntas?¡Estoy encantado de ayudar! Dejar un comentario abajo es la forma más rápida de obtener una respuesta (además, ¡ayuda a otros que tienen el mismo problema!). Si no, escríbeme en Twitter o escríbeme un correo electrónico y haré lo que pueda para ayudarte.

Categorías : # wordpress

Deja una respuesta

Tu dirección de correo electrónico no será publicada.