Le Guide Angular | Marmicode
  • Le Guide Angular par Marmicode
  • Pourquoi Angular ?
  • ECMAScript 6+
    • Un Peu d'Histoire
    • Propriétés du Langage
    • "Single-Threaded" donc Asynchrone
    • Event Loop
    • Classes
    • Hoisting is Dead: var vs. let vs. const
    • this & "binding"
    • Arrow Functions
    • Template Strings
    • Syntactic Sugar
      • Spread
      • Destructuring
      • Rest
      • Object Literal Property Value Shorthand
    • Named Parameters
    • Compatibilité
  • TypeScript
    • Pourquoi TypeScript ?
    • De l'ECMAScript au TypeScript
    • Visibilité des Propriétés
    • Typing des Propriétés
    • Types
    • Interfaces
    • Inference
    • Duck Typing
    • Duck Typing Patterns
      • Compatibilité de Librairies
      • Entity Constructor
    • Décorateurs
      • Décorateurs de Propriété
      • Décorateurs de Classe
      • Décorateurs de Méthode & Paramètres
    • Quelques Liens
  • Tools
    • Clavier mécanique
    • Git
    • Command Line
    • NodeJS
    • NPM
    • Yarn
      • Pourquoi Yarn ?
      • Définition et Installation des Dépendances
      • Scripts
      • Mise à Jour et Automatisation
    • Chrome
    • IntelliJ / WebStorm / VSCode
      • Raccourcis clavier IntelliJ / WebStorm
    • Floobits
    • Angular CLI
    • StackBlitz
    • Compodoc
  • Angular
    • Bootstrap
    • Composants
      • Root Component
      • Template Interpolation
      • Property Binding
      • Class & Style Binding
      • Event Binding
      • *ngIf
      • *ngFor
      • L'approche MVC
      • Création de Composants
      • Exemple
    • Container vs. Presentational Components
    • Interaction entre Composants
      • Input
      • Output
      • Exemple
    • Change Detection
      • Les Approches Possibles
      • Fonctionnement de la Change Detection
      • Optimisation de la Change Detection
      • Immutabilité
      • Quelques Liens
    • Project Structure & Modules
      • Entry Point
      • Définition d'un Module
      • Root Module
      • Feature Module
      • Shared Module
      • Exemple
    • Dependency Injection
      • Qu'est-ce que la "Dependency Injection" ?
      • Injection d'un Service Angular
      • Services & Providers
      • Portée des Services
      • Tree-Shakable Services
      • Class vs Injection Token
      • Exemple
    • Callback Hell vs. Promise vs. Async / Await
      • Callback Hell
      • Promise
      • Async / Await
    • Observables
      • Reactive Programming
      • Promise vs Observable
      • Subscribe
      • Unsubscribe ⚠️
      • Création d'un Observable
      • Opérateurs
        • Définition d'un Opérateur
        • Lettable Operators vs Legacy Methods
        • map
        • filter
        • mergeMap & switchMap
        • shareReplay
        • buffer
        • debounceTime
        • distinctUntilChanged
        • retry
      • Quelques Liens
      • Talks
    • Http
      • Pourquoi HttpClient ?
      • Utilisation de HttpClient
      • Utilisation dans un Service
      • Gestion de la Subscription ⚠️
    • State Management
      • Quelques Liens
      • Talks
    • GraphQL
    • Formulaires
      • Template-driven Forms 🤢
      • Reactive Forms 👍
        • Avantages des "Reactive Forms"
        • La boite à outils des "Reactive Forms"
        • Validation
        • Observation des Changements
    • Directives
      • Attribute Directive
      • Structural Directive
    • Pipes
    • Routing
      • Mise en Place du Routing
      • Lazy Loading
      • Project Structure
      • Route Guards
    • Testing
      • Unit-Testing
        • 📺Introduction au Test-Driven Development
        • Jasmine
        • Unit-Test Synchrone
        • Test-Driven Development
        • Unit-Test Asynchrone
        • TestBed
        • Unit-Test d'un Service
        • Unit-Test d'un Composant
        • Unit-Test et Spies
        • Unit-Test et HttpClient
      • End-to-End
      • Talks
    • Sécurité
      • Quelques Liens
    • Animation
    • Internationalisation
    • Quelques Liens
  • Cookbook
    • Authentification et Autorisation
    • Remplacement Dynamique de Composants
    • Lazy Loading without Router
    • Project Structure
    • SCAM Modules
    • Setup a Mock ReSTful API
  • Autres Ressources
  • Stay Tuned
    • 🎁-20% sur nos workshops avec le code GUIDEANGULAR
    • 🐦Suivez-moi !
    • 📺Cours Vidéo
    • 📬Newsletter
    • 📝Blog
  • Nos Services
    • Formation Angular
    • Atelier Unit-Testing Angular
    • Atelier Architecture Angular
    • Consultation à Distance & Code Review
  • Nos Guides
    • Guide Agile
    • Guide API ReST
    • Guide NodeJS
Propulsé par GitBook
Sur cette page
  • Comment ?
  • Pourquoi ?
  • Centraliser et uniformiser
  • Utiliser les dépendances locales
  • Automatiser
  • yarn run vs npm run
  1. Tools
  2. Yarn

Scripts

Comment ?

La section scripts du fichier package.json permet tout simplement de définir des tâches utilisées par les développeurs ou pour l'automatisation (intégration continue etc...).

{
    "scripts": {
        "deploy": "tools/deploy.sh",
        "hello": "cowsay 👋",
        "start": "webpack-dev-server"
    },
    "devDependencies": {
        "cowsay": "*",
        "webpack-dev-server": "*"
    }
}

Il suffit ensuite d'exécuter yarn en lui indiquant le script à exécuter :

yarn hello

et on obtient le résultat suivant :

yarn run v1.6.0
$ cowsay 👋
 ___
< 👋 >
 ---
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
✨  Done in 0.16s.

Pourquoi ?

Centraliser et uniformiser

La section scripts est utilisée comme point d'entrée commun pour toute l'équipe et les outils d'automatisation afin d'uniformiser les commandes utilisées et de centraliser l'information.

Utiliser les dépendances locales

En lançant la commande yarn start, Yarn va d'abord rechercher la commande webpack-dev-server dans le dossier node_modules local (plus exactement, le dossier node_modules/.bin) avant d'utiliser les commandes globalement installées sur la machine.

Le but est d'éviter les dépendances globales et donc l'hétérogénéité des versions.

Les développeurs et outils d'automatisation n'ont donc besoin que de deux prérequis : NodeJS et Yarn.

Automatiser

Avant et après l'exécution de yarn install, Yarn lance respectivement les scripts preinstall et postinstall qui permettent donc d'enrichir la phase d'installation afin d'installer par exemple les dépendances d'autres langages et frameworks.

yarn run vs npm run

Pour exécuter une commande avec yarn et lui passer des options, il n'y a pas de surprise :

yarn hello -s # -s => stoned cow
yarn run v1.6.0
$ cowsay 👋 -s
 ___
< 👋 >
 ---
        \   ^__^
         \  (**)\_______
            (__)\       )\/\
             U  ||----w |
                ||     ||
✨  Done in 0.16s.

Cela exécute donc la commande cowsay 👋 -s.

En revanche, avec NPM, il faut lancer la commande run et malheureusement c'est NPM qui consomme les options et dans ce cas particulier, NPM interprète l'option -s qui dans son cas veut dire --silent.

npm run hello -s
 ___
< 👋 >
 ---
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Pour passer des options, voici la syntaxe à utiliser :

npm run hello -- -s
> cowsay 👋 "-s"

 ___
< 👋 >
 ---
        \   ^__^
         \  (**)\_______
            (__)\       )\/\
             U  ||----w |
                ||     ||

Donc pour résumer :

yarn hello -s <=> npm run hello -- -s

A vous de choisir.

Pour remédier à certains de ces problèmes et apporter de nouvelles fonctionnalités, l'équipe NPM a produit une nouvelle commande npx que l'on vous recommande d'éviter principalement pour des raisons de sécurité. Le danger de cette commande est qu'elle installe automatiquement le module que vous lui passez en paramètre et l'exécute immédiatement.

Une typo et vous êtes cuits si vous tombez sur module malveillant.

Exemple :

npx run hello
Error: Cannot find module './hello'

StackOverflow + Social Engineering = Remote Code Execution

PrécédentDéfinition et Installation des DépendancesSuivantMise à Jour et Automatisation

Dernière mise à jour il y a 5 ans

Si vous déployez votre application sur Heroku , Heroku détecte la présence du fichier package.json, lance la commande yarn install puis la commande yarn heroku-postbuild qui vous permet de personnaliser le build de votre application.

Fiouf ! Nous venons d'installer inconsciemment le module run () qui a ensuite essayer d'exécuter un fichier hello de notre projet. 😱

https://www.heroku.com/
https://yarnpkg.com/en/package/run