ReactJS

Introduction

Définition

ReactJS est une librairie JavaScript, sortie en décembre 2013 par Facebook, utilisé uniquement pour le côté “vue” dans MVC. Il est donc différent des autres frameworks complets comme Angular ou EmberJS.

ReactJs est une librairie orientée composants. L’API exposée va essentiellement servir à créer des composants graphiques.

Le principe avec ReactJs est assez simple. On crée un arbre de composants et on l’associe à un élément du DOM. Un composant peut avoir des propriétés, il peut avoir ou non des composants fils, ou tout simplement du contenu.

Installation

# Install the CLI tool
npm install -g create-react-app

# Create an app
create-react-app my-app-name

# Install Dependencies
cd my-app-name
npm install

Présentation

Principaux avantages

  • component : tout est divisé sous forme de composants, plus facile à comprendre et maintenir.
  • DOM virtuel : pour limiter les interactions avec le DOM, rafraîchir uniquement les composants qui ont été modifiés et non toute la page
    1. React runs a "diffing" algorithm, which identifies what has changed.
    2. The second step is reconciliation, where it updates the DOM with the results of diff.
  • immutable : évite le dirty-checking. Par défaut Reactjs recharge les sous-composants quand un composant parent est modifié même s'ils ne changent pas. On peut éviter cela grâce à shouldComponentUpdate() et ImmutableJS.
  • isomorphique ou application universelle : l'application est chargée avec les données côté serveur (nodejs), puis côté client. Le premier rendu sera donc rapide, l’application fluide et le référencement sera plus efficace (pas de page blanche).
  • React Native : création de composants sur n'importe quel environnement comme Android et IOS, et créer des applications natives moins gourmandes en ressources.

Principaux désavantages

– N'est pas un framework complet (no built-in state management system, no built-in database query tools, etc.) => peut être couplé avec Redux. – Poids de la librairie (malgré son "infériorité" comme framework, React pèse autant que AngularJS, pour le moment. – La documentation est trop compliquée pour les développeurs novices.

Librairies externes

Dépendances souvent associées avec React.

  • Redux : permet de gérer les data et la communication des modules facilement.
  • Alios : permet de gérer le routing.
  • Flux (remplacer par Redux) : guide d'architecture pour les webapp imposantes, aide à organiser.
  • React Router : permet de gérer le routing.
  • React Native : permet de créer des applications mobiles.

Webcomponents :

Concernant les webcomponents (avec le framework Polymer par exemple), ceux-ci ont un but différent de React. En effet, React va principalement chercher à synchroniser les données et le DOM. Alors que les webcomponents vont être principalement créés pour encapsuler des composants. Les deux approches sont finalement complémentaires et on peut donc utiliser Polymer avec React.


JSX

ReactJS fonctionne en créant des “components”, correspondant à un composant dans votre page HTML. Voici un exemple de création de composant :

Il existe 2 manières d'écrire les composants :

  • JSX (“JavaScript Xml”) : permet de gérer le rendu de notre composant, dans la méthode “render” en y injectant directement le HTML que nous voulons voir apparaître
  • JavaScript pur : pour bien séparer le JavaScript et HTML

Avec JSX :

class HelloWorldComponent extends React.Component {
  render() {
    return (      
      <h1>Discover ReactJS with {this.props.name}</h1>      
    );
  }
}

ReactDOM.render( 
  <HelloWorldComponent name="Ippon"/>,
  document.getElementById('app')
);

Ou avec JavaScript pur :

class HelloWorldComponent extends React.Component {
  render() {
    return React.createElement("h1", null, `Discover ReactJS with ${this.props.name}`);
  }
}

ReactDOM.render( 
  <HelloWorldComponent name="Ippon"/>,
  document.getElementById('app')
);

Chaque code HTML inline sera remplacé par un code Javascript qui renverra un composant React (o un arbre de composants). Les propriétés appliquées sont des propriétés React et non des propriétés HTML, il ne s’agit donc pas réellement de code HTML.

L’usage du JSX directement dans la page HTML serait fortement déconseillé sur un environnement de Production, dû à de faibles performances. Il est possible de compiler à l’avance le code JSX et de référencer le Javascript ainsi généré dans la page HTLM. Ce qui permet d’améliorer les performances (pas de compilation/interprétation de JSX lors du chargement de la page), ou encore d’avoir un stratégie de minification/compilation du code Javascript généré.

Fonction composant

function Clock(props) {
  return (
    <div>
      <h1>Bonjour, monde !</h1>
      <h2>Il est {props.date.toLocaleTimeString()}.</h2>
    </div>
  );
}

ReactDOM.render(
<Clock date={new Date()} />,
document.getElementById('root')
);

OU

const MyComponent = props => (
  <div className={props.className}/>
);

Class composant

class Clock extends React.Component {
  render() {
    return (
      <div>
        <h1>Bonjour, monde !</h1>
        <h2>Il est {this.props.date.toLocaleTimeString()}.</h2>
      </div>
    );
  }
}

Méthodes

L’intérêt de ReactJS est que ses composants correspondent à un élément de la page, avec son état propre et ses actions associées. Le tout géré directement à l’intérieur du composant lui-même ! Ils ont leur propre état, leurs propres données et sont indépendants les uns des autres. Autant dire que créer une bibliothèque en React correspond simplement à créer un composant auquel on peut donner une configuration !

Différentes méthodes et champs sont disponibles pour créer un composant :

  • props : ce sont les propriétés qui sont données en paramètre du composant. Il s’agira souvent d’une configuration.
  • state : contient l’état interne du composant. Celui-ci peut être la liste des éléments à afficher, une valeur ou une configuration.
  • getInitialState : méthode permettant d’initialiser le “state” interne du composant. La méthode retourne un objet qui sera ensuite mappé sur this.state.
  • setState : méthode permettant simplement de mettre à jour le “state”. Elle est principalement appelée de l’extérieur pour mettre à jour les données.
  • componantDidMount : appelée lors de la création du composant, elle permet d’initialiser des méthodes et données.
  • componantWillUnmount : Appelé lors de la destruction du composant. Peut être utilisé pour transmettre des données lors de cette phase.
  • render : se charge de l’affichage du composant (comme vu auparavant).

Il existe encore d’autres méthodes, mais ce sont ici les principales.

Props

  • Props en lecture seule: utiliser des fonctions pures, qui ne modifient pas leurs entrées

Tout composant React doit agir comme une fonction pure vis-à-vis de ses props.


États et cycle de vie

État local (state)

  • L’état local est similaire aux props, mais il est privé et complètement contrôlé par le composant.
  • L’état local est une fonctionnalité uniquement disponible dans les composants défini avec une classe.
  • Un composant contenant un état local s'appelle un composant à état.

Le seul endroit où vous pouvez affecter this.state, c’est le constructeur:

constructor(props) {
    super(props);
    this.state = {date: new Date()};
}

Pour mettre à jour de l'état local :

this.setState({
    date: new Date()
})

Comme this.props et this.state peuvent être mises à jour de façon asynchrone, vous ne devez pas vous baser sur leurs valeurs pour calculer le prochain état.

Pour remédier à ce problème, utilisez la seconde forme de setState() qui accepte une fonction à la place d’un objet.

this.setState((state, props) => ({
    counter: state.counter + props.increment
}));

Alors que this.props est mis en place par React lui-même et que this.state a un sens bien spécial, vous pouvez très bien ajouter manuellement d’autres champs sur la classe si vous avez besoin de stocker quelque chose qui ne participe pas au flux de données (comme un ID de minuteur).

Méthodes de cycle de vie

Montage (Mount)

Apparition du composant dans le DOM.

componentDidMount() { }

Démontage (Unmount)

Suppression du composant dans le DOM.

componentWillUnmount() { }

Ni parent ni enfant ne peuvent savoir si un certain composant est à état ou non, et ne devraient pas se soucier de savoir s’il est défini par une fonction ou une classe.

C’est pourquoi on dit souvent que l’état est local ou encapsulé. Il est impossible d’y accéder depuis un autre composant.

On appelle souvent cela un flux de données « du haut vers le bas » ou « unidirectionnel ». Un état local est toujours possédé par un composant spécifique, et toute donnée ou interface utilisateur dérivée de cet état ne peut affecter que les composants « en-dessous » de celui-ci dans l’arbre de composants.

Si vous imaginez un arbre de composants comme une cascade de props, chaque état de composant est une source d’eau supplémentaire qui rejoint la cascade à un point quelconque, mais qui coule également vers le bas.


Liste et clés

Une « clé » (key, NdT), est un attribut spécial que vous devez inclure quand vous créez une liste d’éléments.

Les clés aident React à identifier quels éléments d’une liste ont changé, ont été ajoutés ou supprimés. Vous devez donner une clé à chaque élément dans un tableau afin d’apporter aux éléments une identité stable.

Nous vous recommandons de ne pas utiliser l’index comme clé si l’ordre des éléments est susceptible de changer. Ça peut avoir un effet négatif sur les performances, et causer des problèmes avec l’état du composant.

Gardez en tête cette règle simple : chaque élément à l’intérieur d’un appel à map() a besoin d’une clé.

Les clés n’ont besoin d’être uniques qu’au sein de la liste.

Les clés servent d’indicateur à React mais ne sont pas passées à vos composants.


Formulaires : Composants contrôlés

Dans un composant contrôlé, chaque changement de l’état aura une fonction gestionnaire associée.

À présent que l’attribut value est défini sur notre élément de formulaire, la valeur affichée sera toujours this.state.value, faisant ainsi de l’état local React la source de vérité.

class NameForm extends React.Component {
  constructor(props) {
    super(props);
    this.state = {value: ''};

    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  handleChange(event) {
    this.setState({value: event.target.value});
  }

  handleSubmit(event) {
    alert('Le nom a été soumis : ' + this.state.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          Nom :
          <input type="text" value={this.state.value} onChange={this.handleChange} />
        </label>
        <input type="submit" value="Envoyer" />
      </form>
    );
  }
}

Les balises <input type="text">, <textarea>, et <select> fonctionne de manière très similaire — elles acceptent toutes un attribut value que vous pouvez utiliser pour implémenter un composant contrôlé.

La valeur du input file étant en lecture seule, c’est un composant non-contrôlé en React.

Pour gérer plusieurs champs contrôlés :

handleInputChange(event) {
    const target = event.target;
    const value = target.type === 'checkbox' ? target.checked : target.value;
    const name = target.name;

    this.setState({
        [name]: value
    });
}

Une technique alternative pour implémenter les formulaires de saisie : les composants non-contrôlés.

Si vous cherchez une solution complète gérant la validation, l’historique des champs visités, et la gestion de soumission de formulaire, Formik fait partie des choix populaires.


Faire remonter l'état (Lifting State Up)

Avec React, partager l’état est possible en le déplaçant dans le plus proche ancêtre commun. On appelle ça « faire remonter l’état ». Le composant choisi est responsable de l’état partagé, il devient la « source de vérité ». Avec React, on gère généralement ça en rendant le composant « contrôlé ».

handleChange(e) {
    // Avant : this.setState({temperature: e.target.value});
    this.props.onTemperatureChange(e.target.value);
    // ...

Faire remonter l’état implique d’écrire plus de code générique (boilerplate code, NdT) qu’avec une liaison de données bidirectionnelle, mais le jeu en vaut la chandelle, car ça demande moins de travail pour trouver et isoler les bugs.


Composition ou héritage ?

https://fr.reactjs.org/docs/composition-vs-inheritance.html


Routing

ReactJS possède une librairie de routing assez performante, React Router. Cette librairie fournit un composant permettant de définir les routes de notre application et les composants qui y seront affichés.

Afin d’introduire des routes dans notre application, nous n’allons plus utiliser la méthode React.render avec notre composant, mais avec un composant Router, qui décrira les routes de notre application, avec le composant associé, ainsi que les paramètres de routing (comme par exemple le type d’historique à utiliser).


React Native

React Native est écrit en javascript permettant aux développeurs web de construire une application mobile native, contrairement aux applications hybrides (cordova, ionic) qui encapsule l'application dans une webview. Du coup les performances de l'UI sont quasi similaires aux performances natives.

React Native utilise le moteur JavaScriptCore avec le transpileur Babel, il est compatible ES5, ES6 ou ES7 sans problème.

Dans la documentation, les exemples utilisent souvent la syntaxe Flow qui sert à vérifier les types en javascript.

Installation

Installer les dépendances au préalable : voir doc officiel

npm install -g react-native-cli
react-native init <<nom_du_projet>>

cd <<nom_du_projet>>
npm start

Inconvénients

L'utilisation de composants natif apporte aussi un certains nombre de problèmes plus ou moins difficiles à surmonter.

  • Hot Reload : charger l'interface régulièrement pendant le développement prend du temps
  • Composants natifs : certains composants natifs ne sont pas fourni par react native (vidéo youtube...)

Démarrage

Requête API Pour faire des requête on utilise fetch().


Gestionnaire d'état

Si vous devez créer une application monopage à moyenne ou grande échelle, il y a des chances que vous vous trouviez dans des situations qui vous feront vous interroger sur une meilleure gestion de l'état global.

Un gestionnaire d'état sert de zone de stockage de données centralisée pour tous les composants dans une application, avec des règles pour s'assurer que l'état ne puisse subir de mutations que d'une manière prévisible.

Voir la doc pour plus de précisions


Tutoriels

ReactJS

https://facebook.github.io/create-react-app/docs/getting-started

https://fr.reactjs.org/docs/hello-world.html

https://fr.reactjs.org/docs/introducing-jsx.html

https://github.com/axios/axios / https://alligator.io/react/axios-react/

React  https://www.youtube.com/watch?v=Ke90Tje7VS0  

https://facebook.github.io/create-react-app/docs/getting-started https://fr.reactjs.org/docs/introducing-jsx.html   - Redux- Axios : https://github.com/axios/axios / https://alligator.io/react/axios-react/ - React-Intl - React-router-dom - React-virtualized - Jest

React Native