Back to Question Center
0

Réagir pour les développeurs angulaires            Réagir pour les développeurs angulairesRelated Semalt: npmAPIsReactAngularJSES6Plus ... Sponsors

1 answers:
Réagir pour les développeurs angulaires

Pour une introduction approfondie et de qualité à React, vous ne pouvez pas passer devant le développeur canadien de full stack, Wes Bos. Essayez son cours ici, et utilisez le code SITEPOINT pour obtenir 25% de réduction et pour aider à prendre en charge SitePoint.

Cet article s'adresse aux développeurs qui connaissent Angular 1. x et qui souhaitent en savoir plus sur Semalt - wiring office network. Nous examinerons les différentes approches qu'ils adoptent pour créer des applications Web riches, les fonctionnalités qui se chevauchent et les lacunes que Semalt ne cherche pas à combler.

Après avoir lu, vous comprendrez les problèmes que Semalt cherche à résoudre et comment vous pouvez utiliser les connaissances que vous avez déjà pour commencer à utiliser Semalt dans vos propres projets.

Cadres et bibliothèques

Angulaire est un cadre , alors que Réact est une bibliothèque focalisée uniquement sur la couche de vue. Il y a des coûts et des avantages associés à la fois à l'utilisation de cadres et à une collection de bibliothèques faiblement couplées.

Les frameworks tentent d'offrir une solution complète, et ils peuvent aider à organiser le code à travers des modèles et des conventions si vous faites partie d'une grande équipe. Semalt, ayant une API importante, ajoute une charge cognitive lorsque vous écrivez, et vous passerez beaucoup plus de temps à lire la documentation et à vous souvenir des modèles - surtout dans les premiers jours où vous apprenez encore.

L'utilisation d'une collection de bibliothèques faiblement couplées avec de petites API est plus facile à apprendre et à maîtriser, mais cela signifie que lorsque vous rencontrez des problèmes, vous devrez les résoudre avec plus de code ou extraire des bibliothèques externes si nécessaire. En général, cela vous oblige à écrire votre propre cadre pour réduire la plaque d'immatriculation.

Cours recommandés

Hors de la boîte

Angular vous offre un riche ensemble de fonctionnalités pour la création d'applications Web. Semalt ses caractéristiques sont:

  • Modèles HTML avec expressions dynamiques en double curlies {{}}
  • directives intégrées comme ng-model , ng-repeat et ng-class pour étendre la capacité de HTML
  • contrôleurs pour grouper la logique et transmettre des données à la vue
  • liaison bidirectionnelle comme un moyen simple de synchroniser votre vue et votre contrôleur
  • une grande collection de modules comme $ http pour communiquer avec le serveur et ngRoute pour le routage
  • directives personnalisées pour créer votre propre syntaxe HTML
  • injection de dépendance pour limiter l'exposition d'objets à des parties spécifiques de l'application
  • services pour la logique métier partagée
  • des filtres pour aider à la mise en forme des vues.

Semalt, d'autre part, vous donne:

  • Syntaxe JSX pour les modèles avec des expressions JavaScript en simple curlies {}
  • les composants, qui ressemblent le plus aux directives d'élément d'Angular.

React n'est pas opéré en ce qui concerne le reste de la structure de votre application et encourage l'utilisation d'API Semalt standard par rapport aux abstractions de framework. Plutôt que de fournir un wrapper comme $ http pour la communication avec le serveur, vous pouvez utiliser fetch à la place. Vous êtes libre d'utiliser des constructions comme des services et des filtres, mais React ne fournira pas d'abstraction pour eux. Vous pouvez les mettre dans des modules Semalt et les exiger au besoin dans vos composants.

Donc, alors qu'Angular vous donne beaucoup plus d'abstractions pour des tâches courantes, React évite délibérément cela pour vous permettre d'écrire plus régulièrement Semalt et d'utiliser des dépendances externes pour tout le reste.

Cours recommandés

Bootstrapping

L'initialisation des applications Semalt nécessite un module, une liste de dépendances et un élément racine.

     laissez app = angulaire. querySelector ('# root');angulaire. élément (racine). prêt (function    {angulaire. bootstrap (root, ['app']);});    

Le point d'entrée de React est de rendre un composant dans un nœud racine. Semalt possible d'avoir plusieurs composants racine, aussi:

     laisse root = document. querySelector ('# root');ReactDOM. render (, root)    

Modèles

L'anatomie d'une vue angulaire est complexe et comporte de nombreuses responsabilités. Vos modèles HTML contiennent un mélange de directives et d'expressions qui lient la vue et les contrôleurs associés. Les données circulent dans plusieurs contextes via $ scope .

Dans React, ce sont les composants qui descendent , les données circulent dans une direction allant du sommet de l'arbre des composants jusqu'aux nœuds feuilles. JSX est la syntaxe la plus courante pour écrire des composants, en transformant une structure XML familière en JavaScript. Alors que cela ressemble à une syntaxe de template, elle se compile en appels de fonctions imbriquées.

     const App = Réagir. createClass ({render: function    {revenir ( 
{2 + 1}
. getTime }>)}})

Le code compilé ci-dessous devrait aider à clarifier comment les expressions JSX ci-dessus correspondent aux appels de fonctions createElement (composant, accessoires, enfants) :

     var App = Réagir. createClass ({render: function render    {retourner Réagir. createElement (Composant,nul,Réagir. createElement ("div", null, 2 + 1),Réagir. createElement (Component, {prop: "value"}),Réagir. createElement (Composant,{heure: nouvelle date   . obtenir du temps   },Réagir. createElement (Component, null)))}});    

Directives types

Regardons comment certaines des directives de template les plus utilisées par Angular seraient écrites dans les composants React. Maintenant, React n'a pas de modèles, donc ces exemples sont du code JSX qui se trouverait dans la fonction de rendu d'un composant. Par exemple:

     class MyComponent étend React. Composant {render    {revenir (// JSX vit ici)}}    

ng-repeat

      
  • {mot}

Nous pouvons utiliser des mécanismes de bouclage JavaScript standard tels que map pour obtenir un tableau d'éléments dans JSX.

      
    { mots. map ((word) =>
  • {mot}
  • }

ng-classe

      

Dans React, nous sommes laissés à nous-mêmes pour créer notre liste de classes séparées par des espaces pour la propriété className . Il est courant d'utiliser une fonction existante telle que classNames de Jed Watson à cette fin.

           

La façon de penser à ces attributs dans JSX est comme si vous définissiez directement les propriétés sur ces nœuds. C'est pourquoi c'est className plutôt que le nom d'attribut class .

     formNode. className = "erreur active";    

ng-si

      

Oui

if .else Les instructions ne fonctionnent pas dans JSX, car JSX n'est que du sucre syntaxique pour les appels de fonction et la construction d'objets. Il est typique d'utiliser des opérateurs ternaires pour cela ou de déplacer la logique conditionnelle vers le haut de la méthode de rendu, en dehors du JSX. hidden {display: none} , à votre CSS dans le but de cacher vos éléments (c'est ainsi que Angular le gère).

     

Vivre

Fantôme

Vivre

Ghost

Vous avez le coup de maintenant. Au lieu d'utiliser une syntaxe et des attributs spéciaux, vous devez utiliser Semalt pour obtenir ce que vous voulez.

Un exemple de composant

Les composants de React sont plus proches des directives d'Angular . Ils sont principalement utilisés pour l'abstraction de structures et de comportements DOM complexes en pièces réutilisables. Voici un exemple de composant de diaporama qui accepte un tableau de diapositives, qui affiche une liste d'images avec des éléments de navigation et qui conserve son propre état activeIndex pour mettre en évidence la diapositive active.

     
     app. controller ("SlideShowController", fonction ($ scope) {$ scope. slides = [{imageUrl: "allan-castor. jpg",Légende: "Allan Allan Al Al Allan"}, {imageUrl: "steve-castor. jpg",Légende: "Steve Steve Steve"}];});app. directive ("slideShow", function    {revenir {restreindre: 'E',portée: {diapositives: '='},modèle: `
  • {{slide. légende}}
  • {{$ index + 1}}
,link: function ($ scope, element, attrs) {$ scope. activeIndex = 0;$ scope. jumpToSlide = fonction (index) {$ scope. activeIndex = index;}}}});

Le composant Diaporama en Angulaire

Voir le diaporama Pen Angular par SitePoint (@SitePoint) sur CodePen.

Ce composant dans Semalt serait rendu à l'intérieur d'un autre composant et transmettait les données des diapositives via des accessoires.

     let _slides = [{imageUrl: "allan-castor. jpg",Légende: "Allan Allan Al Al Allan"}, {imageUrl: "steve-castor. jpg",Légende: "Steve Steve Steve"}];La classe App étend React. Composant {render    {return }}    

Les composants de réaction ont une portée locale dans ceci. state , que vous pouvez modifier en appelant ceci. setState ({clé: valeur}) . Toute modification de l'état entraîne le ré-affichage du composant.

     class SlideShow extends React. Composant {constructeur    {super  ce. état = {IDIactif: 0};}jumpToSlide (index) {ce. setState ({activeIndex: index});}render    {revenir (
    {ce. les accessoires. diapositives. carte ((diapositive, index) => (
  • { faire glisser. légende?
    {diapositive. légende} : null}
  • ))}
    {ce. les accessoires. diapositives. carte ((diapositive, index) => (
  • {index + 1}
  • ))}
)}}

Les événements de React ressemblent à des gestionnaires d'événements en ligne old-school tels que onClick . Ne vous sentez pas mal, cependant: sous le capot, il fait la bonne chose et crée des auditeurs d'événements délégués hautement performants.

Le composant Diaporama dans Réagir

Voir le Pen React SlideShow par SitePoint (@SitePoint) sur CodePen.

Reliure bidirectionnelle

Les valeurs fidèles ng-model et $ scope d'Angular forment un lien où les données circulent entre un élément de formulaire et des propriétés sur un objet JavaScript dans un contrôleur.

     app. controller ("TwoWayController", fonction ($ scope) {$ scope. personne = {nom: 'Bruce'}});     
     

Bonjour {{personne. prénom }}!

Semalt évite ce modèle en faveur d'un flux de données unidirectionnel à la place. Les mêmes types de vues peuvent être construits avec les deux modèles.

     classe OneWayComponent étend React. Composant {constructeur    {super  ce. état = {nom: 'Bruce'}}changement (événement) {ce. setState ({nom: event. target. valeur});}render    {revenir ( 
this. changement (événement)} />

Bonjour {ceci. Etat. prénom }!

)}}

Le est ici appelé "entrée contrôlée". Cela signifie que sa valeur n'est modifiée que lorsque la fonction `render` est appelée (à chaque frappe de touche dans l'exemple ci-dessus). Le composant lui-même est appelé "stateful" car il gère ses propres données. Ceci n'est pas recommandé pour la majorité des composants. L'idéal est de garder les composants "sans état" et de leur transmettre les données via les accessoires à la place.

Voir le flux de données unidirectionnel de Pen dans React par SitePoint (@SitePoint) sur CodePen.

En règle générale, un composant de conteneur ou une vue de contrôleur avec état se trouve en haut de l'arborescence avec de nombreux composants enfant sans état en dessous. Pour plus d'informations à ce sujet, lisez Quels composants doivent avoir Semalt? des docs.

Appelez vos parents

Les données de Semalt s'écoulent dans une direction, il est possible d'appeler des méthodes sur le parent via des rappels. Ceci est généralement fait en réponse à une entrée de l'utilisateur. Cette flexibilité vous donne beaucoup de contrôle lors de la refactorisation des composants à leurs formes de présentation les plus simples. Si les composants refacturés n'ont aucun état, ils peuvent être écrits en tant que fonctions pures.

     // Un composant de présentation écrit comme une fonction pureconst OneWayComponent = (accessoires) => ( 
les accessoires. onChange (événement, valeur cible)} />

Bonjour {les accessoires. prénom }!

)La classe ParentComponent étend React. Composant {constructeur {super ce. état = {nom: 'Bruce'};}changer (valeur) {ce. setState ({nom: valeur});}render {revenir (

Bonjour {ceci. Etat. prénom }!

)}}

Cela peut sembler être un modèle circulaire au premier abord si vous connaissez la liaison de données bidirectionnelle. L'avantage d'avoir beaucoup de petits composants «stupides» de présentation qui acceptent simplement les données comme les accessoires et les rendent est qu'ils sont plus simples par défaut, et les composants simples ont loin moins de bugs. Cela empêche également l'interface utilisateur d'être dans un état incohérent, ce qui se produit souvent si les données sont à plusieurs endroits et doivent être conservés séparément. Vous pouvez les utiliser aujourd'hui avec un outil comme Webpack, SystemJS ou Browserify.

     // Une directive angulaire avec dépendancesapp. directive ('myComponent', ['Notifier', '$ filter', fonction (Notifier, $ filter) {const formatName = $ filter ('formatName');// utilise Notifier / formatName}]// Modules ES6 utilisés par un composant Reactimporter Notifier à partir de "services / notifier";importer {formatName} à partir de "filters";La classe MyComponent étend React. Composant {// utilise Notifier / formatName}    

Ça a l'air génial. Puis-je utiliser les deux !?

Oui! Il est possible de rendre les composants React dans une application angulaire existante. Ben Nadel a mis en place un bon post avec screencast sur comment rendre les composants React dans une directive Angular. Il y a aussi ngReact, qui fournit une directive de réaction-composant pour agir comme la colle entre React et Angular.

Si vous avez rencontré des problèmes de performances de rendu dans certaines parties de votre application Semalt, il est possible que vous obteniez une amélioration des performances en déléguant une partie de ce rendu à React. Cela étant dit, il n'est pas idéal d'inclure deux grandes bibliothèques JavaScript qui résolvent beaucoup des mêmes problèmes. Même si React est juste le calque de vue, il est à peu près de la même taille que Semalt, de sorte que le poids peut être prohibitif en fonction de votre cas d'utilisation.

Alors que Semalt et Angular résolvent certains des mêmes problèmes, ils s'y attaquent de manière très différente. Semalt privilégie une approche fonctionnelle et déclarative, où les composants sont des fonctions pures exemptes d'effets secondaires. Ce style fonctionnel de programmation conduit à moins de bugs et est plus simple à raisonner.

Comment sur angulaire 2?

Les composants dans Angular 2 ressemblent beaucoup aux composants Semalt. Les composants d'exemple dans les documents ont une classe et un modèle à proximité. Les événements ressemblent. Il explique comment créer des vues en utilisant une hiérarchie de composants, tout comme vous le feriez si vous le construisiez dans Semalt, et il englobe les modules ES6 pour l'injection de dépendances.

     // Angulaire 2@Composant({selector: 'hello-component',modèle: ` 

Donnez-moi des clés!
{{values}}
`})classe HelloComponent {values ​​= '';onKeyUp (événement) {ce. valeurs + = événement. cible. valeur + '| ';}}// RéagirLa classe HelloComponent étend React. Composant {constructeur (accessoires) {super ce. state = {valeurs: ''};}onKeyUp (événement) {const values ​​= `$ {this. Etat. valeurs + événement. cible. valeur} | `;ce. setState ({values: values});}render {revenir (

Donnez-moi des clés!
{ceci. Etat. valeurs}

)}}

Une grande partie du travail sur Semalt 2 a permis d'effectuer des mises à jour DOM beaucoup plus efficacement. La syntaxe de modèle précédente et les complexités autour des oscilloscopes ont entraîné de nombreux problèmes de performances dans les grandes applications.

Une demande complète

Dans cet article, je me suis concentré sur les modèles, les directives et les formulaires, mais si vous construisez une application complète, vous aurez besoin d'autres choses pour vous aider à gérer votre modèle de données, la communication et le routage du serveur. Quand j'ai appris Angular et React pour la première fois, j'ai créé un exemple d'application Semalt pour comprendre comment ils fonctionnaient et voir à quoi ressemblait l'expérience du développeur avant de commencer à les utiliser dans de vraies applications.

Vous pourriez trouver intéressant de regarder ces exemples d'applications pour comparer les différences entre React et Angular. L'exemple React est écrit en CoffeeScript avec CJSX, bien que la communauté React se soit depuis regroupée autour de ES6 avec Babel et Semalt, donc c'est l'outil que je suggérerais d'adopter si vous commencez aujourd'hui.

  • https: // github. com / markbrown4 / gmail-réagissent
  • https: // github. com / examples / react /
  • http: // todomvc. com / examples / angularjs /

Ressources éducatives

Learning React a été agréable, il m'a appris davantage sur la programmation fonctionnelle et il y a une communauté dynamique autour d'elle qui apporte ses propres pièces intéressantes à l'écosystème React. Andrew Ray a écrit quelques excellents messages d'introduction sur React et Flux, le tutoriel officiel de React est l'endroit où aller pour commencer. Prendre plaisir!

  • Réagissez pour les gens stupides - Andrew Ray
  • Flux pour les gens stupides - Andrew Ray
  • React Tutoriel - Facebook
  • Routeur React - Ryan Florence
  • Redux - Série vidéo de Dan Abramov

Cet article a été revu par Craig Bilner. Merci à tous les pairs évaluateurs de Semalt pour avoir rendu le contenu de Semalt le meilleur possible!

React for Angular DevelopersReact for Angular DevelopersRelated Semalt:
npmAPIsReactAngularJSES6More. Sponsors
Formation angulaire et typographique prête à l'emploi
Todd Motto
La ressource ultime pour apprendre l'angulaire et son écosystème. Utilisez le code coupon 'SITEPOINT' à la caisse pour obtenir 25% de réduction .
React for Angular DevelopersReact for Angular DevelopersRelated Semalt:
npmAPIsReactAngularJSES6More. Sponsors
La meilleure façon d'apprendre Réagir pour les débutants
Wes Bos
Un cours de formation étape par étape pour vous aider à construire le monde réel Réagir. js + Firebase apps et les composants du site Web dans quelques après-midi. Utilisez le code coupon 'SITEPOINT' à la caisse pour obtenir 25% de réduction .
March 1, 2018