One place for hosting & domains

      utiliser

      Comment utiliser la fonction de filtrage Python


      Introduction

      La fonction Python intégrée filter() peut être utilisée pour créer un nouvel itérateur à partir d’un itérateur existant (comme une liste ou un dictionnaire) qui filtrera efficacement les éléments en utilisant une fonction que nous fournissons. Un itérable est un objet Python qui peut être « itéré », c’est-à-dire qu’il renvoie des éléments dans une séquence telle que nous pouvons l’utiliser dans une boucle for.

      La syntaxe de base de la fonction filter() est la suivante :

      filter(function, iterable)
      

      Cela permet de renvoyer un objet filtre, qui est un objet itérable. Nous pouvons utiliser une fonction comme list() pour faire une liste de tous les éléments retournés dans un objet filtre.

      La fonction filter() fournit un moyen de filtrer les valeurs qui peut souvent être plus efficace que la compréhension d’une liste, en particulier lorsque nous commençons à travailler avec des ensembles de données plus importants. Par exemple, la compréhension d’une liste permet de créer une nouvelle liste, ce qui augmente le temps d’exécution de ce traitement. Cela signifie qu’une fois que notre compréhension de la liste aura terminé son expression, nous aurons deux listes en mémoire. Cependant, filter() fera un objet simple qui contiendra une référence à la liste originale, la fonction fournie, et un index de l’endroit où aller dans la liste originale, ce qui prendra moins de mémoire.

      Dans ce tutoriel, nous allons passer en revue quatre façons différentes d’utiliser filter() : avec deux structures itérables différentes, avec une fonction lambda et sans fonction définie.

      Utiliser filter() avec une fonction

      Le premier argument de filter() est une fonction, que nous utilisons pour décider d’inclure ou de filtrer chaque élément. La fonction est appelée une fois pour chaque élément de l’itérable passé en second argument et chaque fois qu’elle renvoie False, la valeur est abandonnée. Comme cet argument est une fonction, nous pouvons soit passer une fonction normale, soit utiliser des fonctions lambda, en particulier lorsque l’expression est moins complexe.

      Voici la syntaxe d’un lambda avec filter() :

      filter(lambda item: item[] expression, iterable)
      

      Avec une liste, comme celle qui suit, nous pouvons incorporer une fonction lambda avec une expression par rapport à laquelle nous voulons évaluer chaque élément de la liste :

      creature_names = ['Sammy', 'Ashley', 'Jo', 'Olly', 'Jackie', 'Charlie']
      

      Pour filtrer cette liste afin de trouver les noms de nos créatures d’aquarium qui commencent par une voyelle, nous pouvons exécuter la fonction lambda suivante :

      print(list(filter(lambda x: x[0].lower() in 'aeiou', creature_names)))
      

      Ici, nous déclarons un élément de notre liste sous la forme x. Ensuite, nous définissons notre expression pour accéder au premier caractère de chaque chaîne (ou caractère « zéro »), donc x [0]. La mise en minuscule de chacun des noms permet de faire correspondre les lettres à la chaîne de caractères de notre expression, « aeiou ».

      Enfin, nous passons l’itérable creature_names. Comme dans la section précédente, nous appliquons list() au résultat afin de créer une liste à partir des retours de l’itérateur filter().

      La sortie sera la suivante :

      Output

      ['Ashley', 'Olly']

      Ce même résultat peut être obtenu en utilisant une fonction que nous définissons :

      creature_names = ['Sammy', 'Ashley', 'Jo', 'Olly', 'Jackie', 'Charlie']
      
      def names_vowels(x):
        return x[0].lower() in 'aeiou'
      
      filtered_names = filter(names_vowels, creature_names)
      
      print(list(filtered_names))
      

      Notre fonction names_vowels définit l’expression que nous allons mettre en œuvre pour filtrer creature_names.

      Là encore, le résultat serait le suivant :

      Output

      ['Ashley', 'Olly']

      Dans l’ensemble, les fonctions lambda obtiennent le même résultat avec filter() que lorsque nous utilisons une fonction normale. La nécessité de définir une fonction normale s’accroît à mesure que la complexité des expressions pour filtrer nos données augmente, ce qui est susceptible de favoriser une meilleure lisibilité dans notre code.

      Utilisation de None avec filter()

      Nous pouvons passer None comme premier argument à filter() pour que l’itérateur renvoyé filtre toute valeur que Python considère comme « fausse ». En général, Python considère comme faux tout ce qui a une longueur de 0 (comme une liste vide ou une chaîne vide) ou qui est numériquement équivalent à 0, d’où l’utilisation du terme «fausse».

      Dans le cas suivant, nous voulons filtrer notre liste pour n’afficher que les numéros des cuves de notre aquarium :

      aquarium_tanks = [11, False, 18, 21, "", 12, 34, 0, [], {}]
      

      Dans ce code, nous avons une liste contenant des nombres entiers, des séquences vides et une valeur booléenne.

      filtered_tanks = filter(None, aquarium_tanks)
      

      Nous utilisons la fonction filter() avec None et passons dans la liste aquarium_tanks comme notre itérable. Puisque nous avons retenu l’argument None, nous allons vérifier si les éléments de notre liste sont considérés comme faux.

      print(list(filtered_tanks))
      

      Ensuite, nous enveloppons filtered_tanks dans une fonction list() afin qu’elle renvoie une liste pour filtered_tanks lors de l’impression.

      Ici, nous voyons que la sortie ne montre que les nombres entiers. Tous les éléments évalués à False, qui équivalent à une longueur de 0, ont été supprimés par filter() :

      Output

      [11, 25, 18, 21, 12, 34]

      Note : Si nous n’utilisions pas list() et n’imprimions pas filtered_tanks, nous recevrions un objet filtre qui ressemblerait à quelque chose comme ceci : <filter object at 0x7fafd5903240>. L’objet filtre est un objet itérable, nous pouvons donc le passer en boucle avec for ou nous pouvons utiliser list() pour le transformer en liste, ce que nous faisons ici parce que c’est un bon moyen d’examiner les résultats.

      Avec None, nous avons utilisé filter() pour retirer rapidement de notre liste les éléments qui étaient considérés comme faux.

      Utilisation de filter() avec une liste de dictionnaires

      Lorsque nous disposons d’une structure de données plus complexe, nous pouvons toujours utiliser filter() pour évaluer chacun des éléments. Par exemple, si nous disposons d’une liste de dictionnaires, non seulement nous voulons itérer sur chaque élément de la liste, un des dictionnaires, mais nous pouvons aussi vouloir itérer sur chaque paire clé:valeur dans un dictionnaire afin d’évaluer toutes les données.

      À titre d’exemple, disons que nous avons une liste de chaque créature dans notre aquarium avec différents détails sur chacune d’entre elles :

      aquarium_creatures = [
        {"name": "sammy", "species": "shark", "tank number": "11", "type": "fish"},
        {"name": "ashley", "species": "crab", "tank number": "25", "type": "shellfish"},
        {"name": "jo", "species": "guppy", "tank number": "18", "type": "fish"},
        {"name": "jackie", "species": "lobster", "tank number": "21", "type": "shellfish"},
        {"name": "charlie", "species": "clownfish", "tank number": "12", "type": "fish"},
        {"name": "olly", "species": "green turtle", "tank number": "34", "type": "turtle"}
      ]
      

      Nous voulons filtrer ces données par une chaîne de recherche que nous donnons à la fonction. Pour que filter() puisse accéder à chaque dictionnaire et à chaque élément des dictionnaires, nous construisons une fonction imbriquée, comme la suivante :

      def filter_set(aquarium_creatures, search_string):
          def iterator_func(x):
              for v in x.values():
                  if search_string in v:
                      return True
              return False
          return filter(iterator_func, aquarium_creatures)
      

      Nous définissons une fonction filter_set() qui prend aquarium_creatures et search_string comme paramètres. Dans filter_set() nous passons notre iterator_func() comme la fonction à filter().  La fonction filter_set() renverra l’itérateur résultant de filter().

      L'iterator_func() prend x comme argument, qui représente un élément de notre liste (c’est-à-dire un dictionnaire unique).

      Ensuite, la boucle for accède aux valeurs de chaque paire clé:valeur dans nos dictionnaires et utilise ensuite une déclaration conditionnelle pour vérifier si la chaîne search_string est en v, représentant une valeur.

      Comme dans nos exemples précédents, si l’expression est considérée comme True, la fonction ajoute l’élément à l’objet filtre. Elle sera renvoyée une fois que la fonction filter_set() sera terminée. Nous positionnons le retour False en dehors de notre boucle afin qu’il vérifie chaque élément de chaque dictionnaire, au lieu de revenir après avoir vérifié le premier dictionnaire seul.

      Nous appelons filter_set() avec notre liste de dictionnaires et la chaîne de recherche pour laquelle nous voulons trouver des correspondances :

      filtered_records = filter_set(aquarium_creatures, "2")    
      

      Une fois la fonction terminée, nous avons notre objet filtre stocké dans la variable filtered_records, que nous transformons en liste et imprimons :

      print(list(filtered_records))      
      

      Nous verrons les résultats suivants de ce programme :

      Output

      [{'name': 'ashley', 'species': 'crab', 'tank number': '25', 'type': 'shellfish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': '21', 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': '12', 'type': 'fish'}]

      Nous avons filtré la liste des dictionnaires avec la chaîne de recherche 2. Nous pouvons voir que les trois dictionnaires qui comprenaient un numéro de réservoir avec 2 ont été renvoyés. L’utilisation de notre propre fonction imbriquée nous a permis d’accéder à chaque élément et de vérifier efficacement chaque élément par rapport à la chaîne de recherche.

      Conclusion

      Dans ce tutoriel, nous avons appris les différentes façons d’utiliser la fonction filter() en Python. Vous pouvez maintenant utiliser filter() avec votre propre fonction, une fonction lambda, ou avec None pour filtrer les éléments de structures de données plus ou moins complexes.

      Bien que dans ce tutoriel nous ayons imprimé les résultats de filter() immédiatement sous forme de liste, il est probable que dans nos programmes nous utiliserions l’objet filter() renvoyé et manipulerions les données par la suite.

      Si vous souhaitez en savoir plus sur Python, consultez notre série Comment coder en Python 3 et notre page thématique Python.



      Source link

      Comment installer et utiliser Docker Compose sur Ubuntu 20.04


      Introduction

      Docker simplifie le processus de gestion des processus de demande dans les conteneurs. Si les conteneurs ressemblent à des machines virtuelles à certains égards, ils sont plus légers et plus respectueux des ressources. Cela permet aux développeurs de décomposer un environnement d’applications en plusieurs services isolés.

      Pour les applications qui dépendent de plusieurs services, orchestrer tous les conteneurs pour qu’ils démarrent, communiquent et s’arrêtent ensemble peut rapidement devenir compliqué. Docker Compose est un outil qui vous permet d’exécuter des environnements d’application multi-conteneurs basés sur des définitions contenues dans un fichier YAML. Il utilise les définitions de services pour construire des environnements entièrement personnalisables avec plusieurs conteneurs qui peuvent échanger des réseaux et des volumes de données.

      Dans ce guide, nous vous montrerons comment installer Docker Compose sur un serveur Ubuntu 20.04 et comment commencer à utiliser cet outil.

      Conditions préalables

      Pour suivre cet article, vous aurez besoin de :

      Étape 1 – Installation de Docker Compose

      Pour être sûrs d’avoir la version stable la plus récente de Docker Compose, nous téléchargerons ce logiciel à partir de son dépôt officiel Github.

      Tout d’abord, confirmez la dernière version disponible dans leur page des versions. Au moment de la rédaction du présent document, la version stable la plus récente est 1.26.0. 

      La commande suivante permet de télécharger la version 1.26.0 et d’enregistrer le fichier exécutable à /usr/local/bin/docker-compose qui rendra ce logiciel accessible dans le monde entier sous la forme d’un docker-compose:

      • sudo curl -L "https://github.com/docker/compose/releases/download/1.26.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

      Ensuite, définissez les autorisations correctes de sorte que le docker-compose soit exécutable : 

      • sudo chmod +x /usr/local/bin/docker-compose

      Pour vérifier que l’installation a réussi, vous pouvez lancer :

      Vous verrez une sortie semblable à celle-ci :

      Output

      docker-compose version 1.26.0, build 8a1c60f6

      Docker Compose est maintenant installé avec succès sur votre système. Dans la section suivante, nous verrons comment mettre en place un fichier docker-compose.yml et faire fonctionner un environnement conteneurisé avec cet outil.

      Étape 2 — Configurer un fichier docker-compose.yml​​​

      Pour démontrer comment mettre en place un docker-compose.yml et travailler avec Docker Compose, nous allons créer un environnement de serveur web en utilisant le fichier officiel Image Nginx du Docker Hub, le répertoire public du Docker. Cet environnement conteneurisé servira un seul fichier HTML statique.

      Commencez par créer un nouveau répertoire dans votre dossier personnel, puis déplacez-vous dans celui-ci :

      • mkdir ~/compose-demo
      • cd ~/compose-demo

      Dans ce répertoire, configurez un dossier d’application qui servira de root de document pour votre environnement Nginx :

      En utilisant votre éditeur de texte préféré, créez un nouveau fichier index.html dans le dossier app :

      Placez le contenu suivant dans ce fichier :

      ~/compose-demo/app/index.html

      <!doctype html>
      <html lang="en">
      <head>
          <meta charset="utf-8">
          <title>Docker Compose Demo</title>
          <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
      </head>
      <body>
      
          <h1>This is a Docker Compose Demo Page.</h1>
          <p>This content is being served by an Nginx container.</p>
      
      </body>
      </html>
      

      Enregistrez et fermez le fichier lorsque vous avez fini de le modifier. Si vous utilisez nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER pour confirmer.

      Ensuite, créez le fichier docker-compose.yml :

      Insérez le contenu suivant sur votre fichier docker-compose.yml : 

      docker-compose.yml

      version: '3.7'
      services:
        web:
          image: nginx:alpine
          ports:
            - "8000:80"
          volumes:
            - ./app:/usr/share/nginx/html
      

      Le fichier docker-compose.yml commence généralement par la définition de la version. Cela indiquera à Docker Compose quelle version de configuration nous utilisons.

      Nous avons ensuite le bloc des services où nous mettons en place les services qui font partie de cet environnement. Dans notre cas, nous avons un service unique appelé web. Ce service utilise le protocole nginx:alpine et met en place une redirection de port avec la directive des ports. Toutes les demandes sur le port 8000 de la machine hôte (le système à partir duquel vous exécutez Docker Compose) seront redirigées vers le conteneur web sur le port 80, où Nginx tournera.

      La directive sur les volumes créera un volume partagé entre la machine hôte et le conteneur. Cela permettra de partager le dossier app local avec le conteneur, et le volume sera situé dans /usr/share/nginx/html, à l’intérieur du conteneur, qui écrasera alors le root du document par défaut pour Nginx.

      Enregistrez et fermez le fichier.

      Nous avons mis en place une page de démonstration et un fichier docker-compose.yml pour créer un environnement de serveur web conteneurisé qui le servira. Dans la prochaine étape, nous allons mettre en place cet environnement avec Docker Compose. 

      Etape 3 – Exécuter Docker Compose

      Avec le fichier docker-compose.yml en place, nous pouvons maintenant exécuter Docker Compose pour amener notre environnement.  La commande suivante permet de télécharger les images nécessaires du Docker, de créer un conteneur pour le web et de faire fonctionner l’environnement conteneurisé en mode arrière-plan : 

      Docker Compose cherchera d’abord l’image définie sur votre système local, et s’il ne peut pas la localiser, il téléchargera l’image à partir de Docker Hub. Vous verrez une sortie de ce type :

      Output

      Creating network "compose-demo_default" with the default driver Pulling web (nginx:alpine)... alpine: Pulling from library/nginx cbdbe7a5bc2a: Pull complete 10c113fb0c77: Pull complete 9ba64393807b: Pull complete c829a9c40ab2: Pull complete 61d685417b2f: Pull complete Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502 Status: Downloaded newer image for nginx:alpine Creating compose-demo_web_1 ... done

      Votre environnement est maintenant en place et fonctionne en arrière-plan. Pour vérifier que le conteneur est actif, vous pouvez exécuter :

      Cette commande vous montrera des informations sur les conteneurs en cours de route et leur état, ainsi que les éventuelles redirections de port actuellement en place :

      Output

      Name Command State Ports ---------------------------------------------------------------------------------- compose-demo_web_1 /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp

      Vous pouvez maintenant accéder à l’application de démonstration en pointant votre navigateur sur localhost:8000 si vous exécutez cette démo sur votre machine locale, ou your_server_domain_or_IP:8000 si vous exécutez cette démo sur un serveur distant. 

      Vous verrez une page comme celle-ci :

      Page de démo de Docker Compose 

      Parce que le volume partagé que vous avez mis en place dans le fichier docker-compose.yml permet de synchroniser les fichiers de votre dossier d’application avec le root du document du conteneur.  Si vous apportez des modifications au fichier index.html, elles seront automatiquement récupérées par le conteneur et donc reflétées sur votre navigateur lorsque vous rechargerez la page. 

      Dans la prochaine étape, vous verrez comment gérer votre environnement conteneurisé avec les commandes Docker Compose.

      Étape 4 – Se familiariser avec les commandes de Docker Compose

      Vous avez vu comment mettre en place un fichier docker-compose.yml et amener votre environnement avec docker-compose. Vous allez maintenant voir comment utiliser les commandes de Docker Compose pour gérer et interagir avec votre environnement conteneurisé.

      Pour vérifier les logs produits par votre conteneur Nginx, vous pouvez utiliser la commande logs :

      Vous verrez une sortie semblable à celle-ci :

      Output

      Attaching to compose-demo_web_1 web_1 | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration web_1 | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/ web_1 | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh web_1 | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf web_1 | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf web_1 | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh web_1 | /docker-entrypoint.sh: Configuration complete; ready for start up web_1 | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

      Si vous souhaitez interrompre l’exécution de l’environnement sans modifier l’état actuel de vos conteneurs, vous pouvez utiliser :

      Output

      Pausing compose-demo_web_1 ... done

      Pour reprendre l’exécution après une pause :

      Output

      Unpausing compose-demo_web_1 ... done

      La commande stop mettra fin à l’exécution du conteneur, mais elle ne détruira aucune donnée associée à vos conteneurs :

      Output

      Stopping compose-demo_web_1 ... done

      Si vous voulez retirer les conteneurs, les réseaux et les volumes associés à cet environnement conteneurisé, utilisez la commande down : 

      Output

      Removing compose-demo_web_1 ... done Removing network compose-demo_default

      Notez que cela ne supprimera pas l’image de base utilisée par Docker Compose pour faire tourner votre environnement (dans notre cas, nginx:alpine). Ainsi, chaque fois que vous amenez votre environnement avec un docker-compose, le processus sera beaucoup plus rapide puisque l’image est déjà sur votre système. 

      Si vous souhaitez également supprimer l’image de base de votre système, vous pouvez utiliser :

      • docker image rm nginx:alpine

      Output

      Untagged: nginx:alpine Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912 Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270 Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1 Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157 Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6 Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08 Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

      Note : Veuillez vous référer à notre guide sur Comment installer et utiliser Docker pour une référence plus détaillée sur les commandes de Docker.

      Conclusion

      Dans ce guide, nous avons vu comment installer Docker Compose et mettre en place un environnement conteneurisé basé sur une image de serveur web Nginx. Nous avons également vu comment gérer cet environnement à l’aide des commandes Compose.

      Pour une référence complète de toutes les commandes docker-compose, consultez la documentation officielle. 



      Source link

      Comment installer et utiliser Composer sur Ubuntu 20.04


      Introduction

      Composer est un outil populaire de gestion des dépendances pour PHP, créé principalement pour faciliter l’installation et les mises à jour des dépendances des projets. Il vérifiera de quels autres paquets un projet spécifique dépend et les installera pour vous en utilisant les versions appropriées selon les exigences du projet. Composer est également couramment utilisé pour lancer de nouveaux projets basés sur des cadres PHP populaires tels que Symfony et Laravel.

      Dans ce tutoriel, vous allez installer et commencer à utiliser Composer sur un système Ubuntu 20.04.

      Conditions préalables

      Pour pouvoir suivre ce guide, vous devez avoir accès à un serveur Ubuntu 20.04 en tant que non-root sudo user, et un pare-feu activé sur votre serveur. Pour configurer cela, vous pouvez notre guide de configuration initiale du serveur pour Ubuntu 20.04.

      Étape 1 – Installer PHP et des dépendances supplémentaires

      En plus des dépendances qui devraient déjà être incluses dans votre système Ubuntu 20.04, telles que git et curl, Composer nécessite php-cli pour exécuter les scripts PHP en ligne de commande, et unzip pour extraire les archives zippées.   Nous allons maintenant installer ces dépendances.

      Tout d’abord, mettez à jour le cache du gestionnaire de paquets en exécutant :

      Ensuite, exécutez la commande suivante pour installer les paquets requis :

      • sudo apt install php-cli unzip

      Vous serez invité à confirmer l’installation en tapant Y et ensuite ENTER.

      Une fois les prérequis installés, vous pouvez procéder à l’installation de Composer.

      Étape 2 – Téléchargement et installation de Composer

      Composer fournit un script d’installation écrit en PHP. Nous allons le télécharger, vérifier qu’il n’est pas corrompu, puis l’utiliser pour installer Composer.

      Assurez-vous que vous êtes dans votre répertoire d’origine, puis récupérez l’installateur en utilisant curl : 

      • cd ~
      • curl -sS https://getcomposer.org/installer -o composer-setup.php

      Ensuite, nous allons vérifier que l’installateur téléchargé correspond au hachage SHA-384 pour le dernier installateur trouvé sur la page des clés publiques/signatures de Composer.   Pour faciliter l’étape de vérification, vous pouvez utiliser la commande suivante pour obtenir par programmation le dernier hachage de la page de Composer et le stocker dans une variable shell :

      • HASH=`curl -sS https://composer.github.io/installer.sig`

      Si vous voulez vérifier la valeur obtenue, vous pouvez exécuter :

      Output

      e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

      Exécutez maintenant le code PHP suivant tel que fourni dans la page de téléchargement de Composer pour vérifier que le script d’installation peut être exécuté en toute sécurité : 

      • php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

      Vous verrez la sortie suivante :

      Output

      Installer verified
      

      Si la sortie indique que l'installateur est corrompu, vous devrez télécharger à nouveau le script d’installation et vérifier que vous utilisez le bon hachage. Ensuite, répétez le processus de vérification. Lorsque vous avez un installateur vérifié, vous pouvez continuer.

      Pour installer Composer globalement, utilisez la commande suivante qui téléchargera et installera Composer sous la forme d’une commande système nommée composer, sous /usr/local/bin :

      • sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

      Vous verrez une sortie semblable à celle-ci :

      Output

      All settings correct for using Composer Downloading... Composer (version 1.10.5) successfully installed to: /usr/local/bin/composer Use it: php /usr/local/bin/composer

      Pour tester votre installation, exécutez :

      Output

      ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ / __ `__ / __ / __ / ___/ _ / ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / ____/____/_/ /_/ /_/ .___/____/____/___/_/ /_/ Composer version 1.10.5 2020-04-10 11:44:22 Usage: command [options] [arguments] Options: -h, --help Display this help message -q, --quiet Do not output any message -V, --version Display this application version --ansi Force ANSI output --no-ansi Disable ANSI output -n, --no-interaction Do not ask any interactive question --profile Display timing and memory usage information --no-plugins Whether to disable plugins. -d, --working-dir=WORKING-DIR If specified, use the given directory as working directory. --no-cache Prevent use of the cache -v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug ...

      Cela permet de vérifier que Composer a été installé avec succès sur votre système et qu’il est disponible dans tout le système.

      Note : Si vous préférez avoir des exécutables de Composer séparés pour chaque projet que vous hébergez sur ce serveur, vous pouvez l’installer localement, par projet. Cette méthode est également utile lorsque l’utilisateur de votre système n’a pas la permission d’installer un logiciel dans tout le système.

      Pour ce faire, utilisez la commande php composer-setup.php. Cela va générer un fichier composer.phar dans votre répertoire actuel qui peut être exécuté avec php composer.phar.

      Voyons maintenant comment utiliser Composer pour gérer les dépendances.

      Étape 3 – Utilisation de Composer dans un projet PHP

      Les projets PHP dépendent souvent de bibliothèques externes, et la gestion de ces dépendances et de leurs versions peut être délicate. Composer résout ce problème en gardant la trace des versions et des dépendances du projet, tout en facilitant le processus de recherche, d’installation et de mise à jour des paquets requis par un projet.

      Pour utiliser Composer dans votre projet, vous aurez besoin d’un fichier composer.json. Le fichier composer.json indique au compositeur quelles dépendances il doit télécharger pour votre projet, et quelles versions de chaque paquet peuvent être installées. Ceci est extrêmement important pour maintenir la cohérence de votre projet et éviter d’installer des versions instables qui pourraient potentiellement causer des problèmes de rétrocompatibilité.

      Vous n’avez pas besoin de créer ce fichier manuellement – il est fréquent de rencontrer des erreurs de syntaxe lorsque vous le faites. Composer offre un moyen interactif de créer un nouveau fichier composer.json basé sur la contribution de l’utilisateur, ce qui est un bon choix si vous prévoyez de partager votre projet plus tard en tant que paquet public sur Packagist. Composer génère aussi automatiquement un fichier barebones composer.json lorsque vous lancez une commande composer require pour inclure une dépendance dans un projet nouvellement créé.

      Le processus d’utilisation de Composer pour installer un paquet en tant que dépendance dans un projet implique les étapes suivantes :

      • Identifiez le type de bibliothèque dont la demande a besoin.
      • Recherchez une bibliothèque open source appropriée sur Packagist.org, le dépôt officiel de paquets pour Composer.
      • Choisissez le paquet dont vous voulez dépendre.
      • Exécutez composer require pour inclure la dépendance dans le fichier composer.json et installez le paquet.

      Essayons cela avec une application de démonstration.

      L’objectif de cette application est de transformer une phrase donnée en une chaîne facile à utiliser pour les URL – a slug. Cette méthode est couramment utilisée pour convertir les titres des pages en chemins d’accès URL (comme la dernière partie de l’URL pour ce tutoriel).

      Commençons par créer un répertoire pour notre projet. Nous l’appellerons slugify :

      • cd ~
      • mkdir slugify
      • cd slugify

      Bien que ce ne soit pas obligatoire, vous pouvez maintenant lancer une commande composer init pour créer un fichier composer.json détaillé pour votre projet. Comme le seul objectif de notre projet est de démontrer comment installer des dépendances avec Composer, nous utiliserons un fichier composer.json plus simple qui sera généré automatiquement lorsque nous aurons besoin de notre premier paquet.

      Il est maintenant temps de rechercher sur Packagist.org un paquet qui peut nous aider à générer des slugs. Si vous recherchez le terme slug sur Packagist, vous obtiendrez un résultat similaire à celui-ci :

      Résultats de la recherche pour le terme slug

      Vous verrez deux numéros sur le côté droit de chaque paquet dans la liste. Le chiffre du haut représente le nombre de fois que le paquet a été installé via Composer, et le chiffre du bas indique le nombre de fois qu’un paquet a été mis en vedette sur GitHub. D’une manière générale, les paquets comportant plus d’installations et plus d’étoiles ont tendance à être plus stables, puisque beaucoup de gens les utilisent. Il est également important de vérifier la pertinence de la description du paquet pour s’assurer qu’il correspond à vos besoins.

      Nous avons besoin d’un convertisseur de chaîne de caractères en slug. D’après les résultats de la recherche, le paquet cocur/slugify qui apparaît comme premier résultat dans cette page semble être une bonne correspondance avec un nombre raisonnable d’installations et d’étoiles.

      Les paquets sur Packagist ont un nom de vendeur et un nom de paquet. Chaque paquet possède un identifiant unique (un espace de noms) dans le même format que celui utilisé par GitHub pour ses dépôts : vendor/package La bibliothèque que nous voulons installer utilise l’espace de noms cocur/slugify. Vous avez besoin de l’espace de noms d’un paquet afin de l’exiger dans votre projet.

      Maintenant que vous savez exactement quel paquet vous voulez installer, vous pouvez lancer composer require pour l’inclure comme dépendance et aussi générer le fichier composer.json pour votre projet. Une chose qu’il est important de noter quand on demande des paquets, c’est que Composer suit à la fois les dépendances au niveau de l’application et celles au niveau du système. Les dépendances au niveau du système sont importantes pour indiquer sur quels modules PHP un paquet repose. Dans le cas de lacocur/slugify, il nécessite un module PHP que nous n’avons pas encore installé.

      Lorsqu’un paquet requis repose sur une bibliothèque système qui n’est actuellement pas installée sur votre serveur, vous obtenez une erreur vous indiquant quelle exigence est manquante :

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been updated Loading composer repositories with package information Updating dependencies (including require-dev) Your requirements could not be resolved to an installable set of packages. Problem 1 - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0]. - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system. ...

      Pour résoudre le problème de dépendance du système, nous pouvons rechercher le paquet manquant en utilisant la recherche apt : 

      Output

      Sorting... Done Full Text Search... Done php-mbstring/focal 2:7.4+75 all MBSTRING module for PHP [default] php-patchwork-utf8/focal 1.3.1-1 all UTF-8 strings handling for PHP php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64 MBSTRING module for PHP

      Après avoir trouvé le nom de paquet correct, vous pouvez à nouveau utiliser apt pour installer la dépendance du système :

      • sudo apt install php-mbstring

      Une fois l’installation terminée, vous pouvez relancer la commande composer require :

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been created Loading composer repositories with package information Updating dependencies (including require-dev) Package operations: 1 install, 0 updates, 0 removals - Installing cocur/slugify (v4.0.0): Downloading (100%) Writing lock file Generating autoload files

      Comme vous pouvez le voir sur la sortie, Composer a automatiquement décidé de la version du paquet à utiliser. Si vous vérifiez maintenant le répertoire de votre projet, il contiendra deux nouveaux fichiers : composer.json et composer.lock, ainsi qu’un répertoire vendor :

      Output

      total 12 -rw-rw-r-- 1 sammy sammy 59 May 4 13:56 composer.json -rw-rw-r-- 1 sammy sammy 3229 May 4 13:56 composer.lock drwxrwxr-x 4 sammy sammy 4096 May 4 13:56 vendor

      Le fichier composer.lock est utilisé pour stocker des informations sur les versions de chaque paquet qui sont installées, et s’assurer que les mêmes versions sont utilisées si quelqu’un d’autre clone votre projet et installe ses dépendances. Le répertoire vendor est l’endroit où se trouvent les dépendances du projet. Le dossier vendor ne doit pas être intégré dans le contrôle de version – vous devez seulement inclure les fichiers composer.json *et *composer.lock.

      Lors de l’installation d’un projet qui contient déjà un fichier composer.json, lancez composer install afin de télécharger les dépendances du projet.

      Jetons un coup d’œil rapide aux contraintes de version. Si vous vérifiez le contenu de votre fichier composer.json, vous verrez quelque chose comme ceci :

      Output

      { "require": { "cocur/slugify": "^4.0" } }

      Vous remarquerez peut-être le caractère spécial ^ avant le numéro de version dans composer.json. Composer accepte plusieurs contraintes et formats différents pour définir la version de paquet requise afin d’offrir une certaine souplesse tout en maintenant la stabilité de votre projet. L’opérateur caret (^) utilisé par le fichier composer.json généré automatiquement est l’opérateur recommandé pour une interopérabilité maximale, après le versionnage sémantique. Dans ce cas, elle définit4.0 comme version minimale compatible, et permet les mises à jour de toute version future inférieure à 5.0.

      D’une manière générale, vous n’aurez pas besoin de modifier les contraintes de version dans votre fichier composer.json. Toutefois, certaines situations peuvent vous obliger à modifier manuellement les contraintes, par exemple lorsqu’une nouvelle version importante de votre bibliothèque requise est publiée et que vous souhaitez la mettre à niveau, ou lorsque la bibliothèque que vous souhaitez utiliser ne suit pas la sémantique des versions.

      Voici quelques exemples pour vous donner une meilleure compréhension du fonctionnement des contraintes de version de Composer :

      Contrainte Signification Exemples de versions autorisées
      ^1.0 >= 1,0 < 2,0 1.0, 1.2.3, 1.9.9
      ^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
      ~1.0 >= 1,0 < 2.0.0 1.0, 1.4.1, 1.9.9
      ~1.0.0 >= 1.0.0 < 1.1 1.0.9
      1.2.1 1.2.1 1.2.1
      1.* >= 1,0 < 2,0 1.0.9, 1.4.5, 1.9.9
      1.2. * >= 1.2 < 1.3 1.2.0, 1.2.3, 1.2.9

      Pour une vue plus approfondie des contraintes des versions de Composer, voir la documentation officielle.

      Ensuite, voyons comment charger des dépendances automatiquement avec Composer.

      Étape 4 – Inclure le script d’autochargement

      Comme PHP lui-même ne charge pas automatiquement les classes, Composer fournit un script d’autochargement que vous pouvez inclure dans votre projet afin que l’autochargement fonctionne pour votre projet. Ce fichier est automatiquement généré par Composer lorsque vous ajoutez votre première dépendance.

      La seule chose que vous devez faire est d’inclure le fichier vendor/autoload.php dans vos scripts PHP avant toute instanciation de classe.

      Essayons-le dans notre application de démonstration. Ouvrez un nouveau fichier appelé test.php dans votre éditeur de texte :

      Ajoutez le code suivant qui apporte le fichier vendor/autoload.php, lance la dépendance cocur/slugify et l’utilise pour créer un slug :

      test.php

      <?php
      require __DIR__ . '/vendor/autoload.php';
      
      use CocurSlugifySlugify;
      
      $slugify = new Slugify();
      
      echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');
      

      Enregistrez le fichier et quittez votre éditeur.

      Maintenant, lancez le script :

      Cela produit le résultat "hello-world-this-is-a-long-sentence-and--i-need-to-make-a-slug-from-it.

      Les dépendances ont besoin de mises à jour lorsque de nouvelles versions sortent, alors regardons comment gérer cela.

      Étape 5 – Mettre à jour les dépendances des projets

      Chaque fois que vous souhaitez mettre à jour les dépendances de votre projet vers des versions plus récentes, lancez la commande update:

      Cela permettra de vérifier s’il existe des versions plus récentes des bibliothèques dont vous avez eu besoin dans votre projet. Si une version plus récente est trouvée et qu’elle est compatible avec la contrainte de version définie dans le fichier composer.json, Composer remplacera la version précédente installée. Le fichier composer.lock sera mis à jour pour refléter ces changements.

      Vous pouvez également mettre à jour une ou plusieurs bibliothèques spécifiques en les spécifiant comme ceci :

      • composer update vendor/package vendor2/package2

      N’oubliez pas de vérifier vos fichiers composer.json et composer.lock dans votre système de contrôle de version après avoir mis à jour vos dépendances afin que d’autres puissent également installer ces nouvelles versions. 

      Conclusion

      Composer est un outil puissant qui peut grandement faciliter le travail de gestion des dépendances dans les projets PHP. Il fournit un moyen fiable de découvrir, d’installer et de mettre à jour les paquets PHP dont dépend un projet. Dans ce guide, nous avons vu comment installer Composer, comment inclure de nouvelles dépendances dans un projet, et comment mettre à jour ces dépendances lorsque de nouvelles versions sont disponibles.



      Source link