One place for hosting & domains

      Comment traiter les données des requêtes entrantes dans Flask


      Introduction

      Les applications web doivent souvent traiter les données des requêtes entrantes fournies par les utilisateurs. Cette charge utile peut prendre la forme de chaînes de requête, de données de formulaires et d’objets JSON. Flask, comme tout autre framework web, vous permet d’accéder aux données d’une requête.

      Au cours de ce tutoriel, vous allez créer une application Flask avec trois itinéraires qui acceptent soit les chaînes de requête, les données de formulaire ou les objets JSON.

      Conditions préalables

      Pour suivre ce tutoriel, vous aurez besoin de :

      Ce tutoriel a été vérifié avec Pipenv v2020.11.15, Python v3.9.0 et Flask v1.1.2.

      Créer le projet

      Afin de pouvoir découvrir les différentes façons d’utiliser des requêtes, vous devrez créer une application Flask. Même si l’application donnée en exemple utilise une structure simplifiée pour les fonctions et les itinéraires de visualisation, vous pouvez appliquer tout ce que vous apprendrez au cours de ce tutoriel à toute méthode qui permet d’organiser vos affichages sous forme, par exemple, d’un affichage par catégories, de plans d’action ou d’une extension comme Flask-Via.

      Vous devrez tout d’abord créer un répertoire de projet. Ouvrez votre terminal et exécutez la commande suivante :

      • mkdir flask_request_example

      Ensuite, naviguez vers le nouveau répertoire :

      Ensuite, installez Flask. Ouvrez votre terminal et exécutez la commande suivante :

      La commande pipenv créera un virtualenv pour ce projet, un Pipfile, installera flask et un Pipfile.lock.

      Pour activer le virtualenv du projet, exécutez la commande suivante :

      Pour accéder aux données entrantes dans Flask, vous devez utiliser l'objet request. L'objet request contient toutes les données entrantes de la requête, qui incluent, entre autres, le typemime, le référent, l'adresse IP, les données brutes, la méthode HTTP et les en-têtes.

      Bien que toutes les informations que contient l'objet request soient utiles, pour les besoins de cet article, vous allez vous concentrer sur les données qui sont normalement fournies directement par l'appelant du terminal.

      Pour accéder à l'objet de requête dans Flask, vous devez l'importer à partir de la bibliothèque Flask :

      from flask import request
      

      Vous aurez alors la possibilité de l'utiliser dans l'une de vos fonctions d'affichage.

      Utilisez votre éditeur de code pour créer un fichier app.py. Importez Flask et l'objet request. Configurez également des itinéraires pour query-example, form-example et json-example:

      app.py

      # import main Flask class and request object
      from flask import Flask, request
      
      # create the Flask app
      app = Flask(__name__)
      
      @app.route('/query-example')
      def query_example():
          return 'Query String Example'
      
      @app.route('/form-example')
      def form_example():
          return 'Form Data Example'
      
      @app.route('/json-example')
      def json_example():
          return 'JSON Object Example'
      
      if __name__ == '__main__':
          # run app in debug mode on port 5000
          app.run(debug=True, port=5000)
      

      Ensuite, ouvrez votre terminal et démarrez l'application avec la commande suivante :

      L'application démarrera sur le port 5000. Vous pourrez alors visualiser chaque itinéraire dans votre navigateur en utilisant les liens suivants :

      http://127.0.0.1:5000/query-example (or localhost:5000/query-example)
      http://127.0.0.1:5000/form-example (or localhost:5000/form-example)
      http://127.0.0.1:5000/json-example (or localhost:5000/json-example)
      

      Le code établit trois itinéraires. En visualisant chaque itinéraire, les messages « Requy String Example », « Form Data example » et « JSON Object example » s'afficheront respectivement.

      Utiliser les arguments de requête

      On utilise souvent les arguments URL que vous ajoutez à une chaîne de requête pour transmettre des données à une application web. Alors qu'en navigant sur le Web, vous rencontrerez probablement une chaîne de requête auparavant.

      Une chaîne de requête ressemble à ce qui suit :

      example.com?arg1=value1&arg2=value2
      

      La chaîne de requête commence après le caractère du point d'interrogation (?) :

      example.com?arg1=value1&arg2=value2
      

      Et intègre des paires de valeurs clés séparées par un caractère de perluète (&) :

      example.com?arg1=value1&arg2=value2
      

      Pour chaque pair, la clé est suivie du caractère égal (=), puis de la valeur.

      arg1 : value1
      arg2 : value2
      

      Les chaînes de requête vous seront utiles pour transmettre les données sur lesquelles l'utilisateur n'a pas besoin d'agir. Vous pouvez générer une chaîne de requête quelque part dans votre application et l'ajouter à une URL afin que, lorsqu'un utilisateur soumet une requête, les données soient automatiquement transmises pour elles. Une chaîne de requête peut également être générée par les formulaires qui ont pour méthode GET.

      Ajoutons une chaîne de requête à l'itinéraire query-example. Dans cet exemple hypothétique, vous allez renseigner le nom d'un langage de programmation qui s'affichera à l'écran. Créez une clé de « langage » et une valeur de « Python » :

      http://127.0.0.1:5000/query-example?language=Python
      

      Si vous exécutez l'application et que vous naviguez vers cette URL, vous verrez qu'elle affiche toujours le message « Request String Example ».

      Vous devrez alors programmer la partie qui gère les arguments de la requête. Ce code lira le contenu de la clé language en utilisant soit request.args.get('language') ou request.args['language'].

      En appelant request.args.get('language'), l'exécution de l'application continuera si la clé language n'existe pas dans l'URL. Le cas échéant, la méthode affichira le résultat None.

      En appelant request.args['language'], l'application renverra une erreur 400 si la clé de la langue n'existe pas dans l'URL.

      Lorsque vous travaillez avec des chaînes de requête, nous vous recommandons d'utiliser request.args.get() pour empêcher l'application d'entrer en échec.

      Lisons la clé language et affichons-la comme la sortie.

      Modifiez l'itinéraire query-example dans app.py en utilisant le code suivant :

      app.py

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          return '''<h1>The language value is: {}</h1>'''.format(language)
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/query-example?language=Python
      

      Le navigateur devrait afficher le message suivant :

      Output

      The language value is: Python

      L'argument provenant de l'URL est affecté à la variable language et ensuite renvoyé au navigateur.

      Pour ajouter d'autres paramètres de chaîne de requête, vous pouvez ajouter les perluètes et de nouvelles paires clé-valeur à la fin de l'URL. Créez une clé « framework » et une valeur « Flask » :

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask
      

      Et si vous en voulez plus, continuez à ajouter des perluettes et des paires clé-valeur. Créez une clé « website » et une valeur « DigitalOcean » :

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Pour accéder à ces valeurs, vous devrez à nouveau utiliser soit request.args.get() ou request.args[]. Utilisons-les toutes les deux pour voir ce qu'il se passe lorsqu'une clé est manquante. Modifiez l'itinéraire query_example pour attribuer la valeur des résultats à des variables, puis affichez-les :

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          # if key doesn't exist, returns a 400, bad request error
          framework = request.args['framework']
      
          # if key doesn't exist, returns None
          website = request.args.get('website')
      
          return '''
                    <h1>The language value is: {}</h1>
                    <h1>The framework value is: {}</h1>
                    <h1>The website value is: {}'''.format(language, framework, website)
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Le navigateur devrait afficher le message suivant :

      Output

      The language value is: Python The framework value is: Flask The website value is: DigitalOcean

      Supprimez la clé language de l'URL :

      http://127.0.0.1:5000/query-example?framework=Flask&website=DigitalOcean
      

      Le navigateur devrait afficher le message suivant accompagné de None si aucune valeur language n'est fournie :

      Output

      The language value is: None The framework value is: Flask The website value is: DigitalOcean

      Supprimez la clé framework de l'URL :

      http://127.0.0.1:5000/query-example?language=Python&website=DigitalOcean
      

      Le navigateur devrait rencontrer une erreur, étant donné qu'il s'attend à trouver une valeur pour framework :

      Output

      werkzeug.exceptions.BadRequestKeyError werkzeug.exceptions.BadRequestKeyError: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. KeyError: 'framework'

      Vous comprenez maintenant de quelle manière sont traitées les chaînes de requête. Passons au prochain type de données entrantes.

      Utiliser les données de formulaire

      Les données des formulaires proviennent d'un formulaire qui a été envoyé en tant que requête POST à un itinéraire. Par conséquent, au lieu de voir les données dans l'URL (sauf si le formulaire est soumis avec une requête GET), les données du formulaire seront transmises à l'application en coulisses. Même si vous ne pouvez pas facilement voir les données du formulaire qui sont transmises, votre application est tout de même en capacité de les lire.

      Pour le démontrer, modifiez l'itinéraire form-example dans app.py pour accepter les requêtes à la fois GET et POST. Le formulaire suivant est renvoyé :

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          return '''
                    <form method="POST">
                        <div><label>Language: <input type="text" name="language"></label></div>
                        <div><label>Framework: <input type="text" name="framework"></label></div>
                        <input type="submit" value="Submit">
                    </form>'''
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/form-example
      

      Le navigateur devrait afficher un formulaire avec deux champs de saisie (un pour language et un pour framework) et un bouton Submit.

      Le plus important à savoir sur ce formulaire, c'est qu'il effectue une requête POST sur le même itinéraire qui a généré le formulaire. Les clés qui seront lues dans l'application proviennent toutes des attributs name qui se trouvent sur nos entrées de formulaire. Dans ce cas, langage et framework correspondent aux noms des entrées. Vous y aurez donc accès dans l'application.

      Dans la fonction d'affichage, vous devrez alors vérifier si la méthode de requête est GET ou POST. S'il s'agit d'une requête GET, vous pouvez afficher le formulaire. Dans le cas contraire, s’il s'agit d'une requête POST, vous devrez alors traiter les données entrantes.

      Modifiez l'itinéraire form-example dans app.py en utilisant le code suivant :

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          # handle the POST request
          if request.method == 'POST':
              language = request.form.get('language')
              framework = request.form.get('framework')
              return '''
                        <h1>The language value is: {}</h1>
                        <h1>The framework value is: {}</h1>'''.format(language, framework)
      
          # otherwise handle the GET request
          return '''
                 <form method="POST">
                     <div><label>Language: <input type="text" name="language"></label></div>
                     <div><label>Framework: <input type="text" name="framework"></label></div>
                     <input type="submit" value="Submit">
                 </form>'''
      

      Ensuite, exécutez l'application et naviguez jusqu'à l'URL :

      http://127.0.0.1:5000/form-example
      

      Renseignez le champ language avec la valeur Python et le champ framework avec la valeur Flask. Ensuite, appuyez sur Submit.

      Le navigateur devrait afficher le message suivant :

      Output

      The language value is: Python The framework value is: Flask

      Vous comprenez maintenant de quelle manière sont traitées les chaînes de requête. Passons au prochain type de données entrantes.

      Utiliser des données JSON

      Les données JSON sont généralement construites par un processus qui appelle l'itinéraire.

      Voici à quoi ressemble un exemple d'objet JSON :

      {
        "language": "Python",
        "framework": "Flask",
        "website": "Scotch",
        "version_info": {
          "python": "3.9.0",
          "flask": "1.1.2"
        },
        "examples": ["query", "form", "json"],
        "boolean_test": true
      }
      

      Cette structure peut permettre la transmission de données bien plus complexes par opposition aux chaînes de requête et aux données de formulaires. Dans l'exemple, vous voyez des objets JSON imbriqués et un tableau d'éléments. Flask peut gérer ce format de données.

      Modifiez l'itinéraire form-example dans app.py pour accepter les requêtes POST et ignorer les autres requêtes comme GET :

      app.py

      @app.route('/json-example', methods=['POST'])
      def json_example():
          return 'JSON Object Example'
      

      Contrairement au navigateur web qui sert à interroger les chaînes et les données de formulaire, pour les besoins de cet article, afin d'envoyer un objet JSON, vous utiliserez Postman pour envoyer des requêtes personnalisées aux URL.

      Remarque : si vous avez besoin d'aide pour naviguer sur l'interface Postman pour les requêtes, consultez la documentation officielle.

      Dans Postman, ajoutez l'URL et configurez le type sur POST. Sur l'onglet body, changez la valeur sur raw et sélectionnez JSON dans la liste déroulante.

      Ces paramètres sont nécessaires pour permettre à Postman d'envoyer les données JSON correctement. Par conséquent, votre application Flask comprendra qu'elle reçoit JSON :

      POST http://127.0.0.1:5000/json-example
      Body
      raw JSON
      

      Ensuite, copiez l'exemple JSON précédent dans la saisie de texte.

      Envoyez la requête. Vous devriez recevoir la réponse « JSON Object Example ». Il s'agit d'une approche assez étrange, mais il faudra vous y attendre, car il reste encore à écrire le code qui permet de gérer la réponse des données JSON.

      Pour lire les données, vous devez comprendre de quelle manière Flask traduit les données JSON en structures de données Python :

      • Tout ce qui est un objet est converti en un dict. Python {"key" : "value"}, dans JSON cela correspond à somedict['key'] qui renvoie une valeur dans Python.
      • Un tableau dans JSON est converti en une liste dans Python. Étant donné que la syntaxe est la même, voici un exemple de liste : [1,2,3,4,5]
      • Les valeurs entre crochets dans l'objet JSON deviennent des chaînes dans Python.
      • Les valeurs booléennes true et false deviennent True et False dans Python.
      • Enfin, les numéros sans parenthèse se transforment en numéros dans Python.

      Travaillons maintenant sur le code afin de pouvoir lire les données JSON entrantes.

      Tout d'abord, attribuons tout ce qui se trouve dans l'objet JSON à une variable en utilisant request.get_json().

      request.get_json() convertit l'objet JSON en données Python. Attribuons maintenant les données des requêtes entrantes aux variables et renvoyons-les en apportant les modifications suivantes à l'itinéraire json-example :

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = request_data['language']
          framework = request_data['framework']
      
          # two keys are needed because of the nested object
          python_version = request_data['version_info']['python']
      
          # an index is needed because of the array
          example = request_data['examples'][0]
      
          boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Notez de quelle manière vous accédez aux éléments qui ne sont pas au niveau supérieur. ['version']['python'] est utilisé, car vous êtes en train de saisir un objet imbriqué. Et ['example'][0] permet d'accéder à l'index 0 dans le tableau des exemples.

      Si l'objet JSON envoyé avec la requête n'est pas accessible dans votre fonction de visualisation, cela signifie que la requête échouera. Si vous ne souhaitez pas qu'elle échoue en l'absence d'une clé, il vous faudra préalablement vérifier si la clé existe avant d'essayer d'y accéder.

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = None
          framework = None
          python_version = None
          example = None
          boolean_test = None
      
          if request_data:
              if 'language' in request_data:
                  language = request_data['language']
      
              if 'framework' in request_data:
                  framework = request_data['framework']
      
              if 'version_info' in request_data:
                  if 'python' in request_data['version_info']:
                      python_version = request_data['version_info']['python']
      
              if 'examples' in request_data:
                  if (type(request_data['examples']) == list) and (len(request_data['examples']) > 0):
                      example = request_data['examples'][0]
      
              if 'boolean_test' in request_data:
                  boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Exécutez l'application et envoyez l'exemple de requête JSON en utilisant Postman. Dans la réponse, vous obtiendrez la sortie suivante :

      Output

      The language value is: Python The framework value is: Flask The Python version is: 3.9 The item at index 0 in the example list is: query The boolean value is: false

      Désormais, vous comprenez de quelle manière sont manipulés les objets JSON.

      Conclusion

      Au cours de ce tutoriel, vous avez créé une application Flask avec trois itinéraires qui acceptent soit les chaînes de requête, les données de formulaire ou les objets JSON.

      En outre, n'oubliez pas que toutes les approches ont bien pris en compte la problématique récurrente de l'échec normal généré par l'absence d'une clé.

      Avertissement : le nettoyage des entrées des utilisateurs n'a pas été abordé dans cet article. Le nettoyage des entrées des utilisateurs permet de garantir que les données lues par l'application ne génèrent pas la défaillance inattendue d'un élément ou ne contournent pas les mesures de sécurité.

      Si vous souhaitez en savoir plus sur Flask, veuillez consulter notre page thématique Flask dans laquelle vous trouverez des exercices et des projets de programmation.



      Source link

      Utiliser Grep et les expressions régulières pour rechercher des modèles de texte en Linux


      Introduction

      grep est l’une des commandes les plus pratiques dans un environnement de terminaux Linux. L’accronyme grep signifie « global regular expression print » (rechercher globalement les correspondances avec l’expression régulière). Cela signifie que vous pouvez utiliser grep pour voir si l’entrée qu’il reçoit correspond à un modèle spécifié. Apparemment trivial, ce programme est extrêmement puissant. Sa capacité à trier les entrées en fonction de règles complexes fait qu’il est couramment utilisé dans de nombreuses chaînes de commande.

      Au cours de ce tutoriel, vous allez explorer les options de la commande grep. Ensuite, vous allez approfondir vos connaissances dans l’utilisation des expressions régulières qui vous permettront d’effectuer des recherches plus avancées.

      Launch an Interactive Terminal!

      Utilisation de base

      Au cours de ce tutoriel, vous allez utiliser grep pour rechercher plusieurs mots et plusieurs phrases dans GNU General Public License version 3.

      Si vous utilisez un système Ubuntu, vous pouvez trouver le fichier dans le dossier /usr/share/common-licenses. Copiez-le dans votre répertoire home :

      • cp /usr/share/common-licenses/GPL-3 .

      Si vous êtes sur un autre système, utilisez la commande curl pour en télécharger une copie :

      • curl -o GPL-3 https://www.gnu.org/licenses/gpl-3.0.txt

      Vous allez également utiliser le fichier de licence BSD de ce tutoriel. Sous Linux, vous pouvez utiliser la commande suivante pour le copier dans votre répertoire home :

      • cp /usr/share/common-licenses/BSD .

      Si vous êtes sur un autre système, créez le fichier en utilisant la commande suivante :

      • cat << 'EOF' > BSD
      • Copyright (c) The Regents of the University of California.
      • All rights reserved.
      • Redistribution and use in source and binary forms, with or without
      • modification, are permitted provided that the following conditions
      • are met:
      • 1. Redistributions of source code must retain the above copyright
      • notice, this list of conditions and the following disclaimer.
      • 2. Redistributions in binary form must reproduce the above copyright
      • notice, this list of conditions and the following disclaimer in the
      • documentation and/or other materials provided with the distribution.
      • 3. Neither the name of the University nor the names of its contributors
      • may be used to endorse or promote products derived from this software
      • without specific prior written permission.
      • THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
      • ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      • IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      • ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
      • FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      • DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      • OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      • HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      • LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      • OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      • SUCH DAMAGE.
      • EOF

      Maintenant que vous avez les fichiers, vous pouvez commencer à travailler avec grep.

      Dans sa forme la plus basique, vous pouvez utiliser grep pour trouver les correspondances avec des modèles littéraux dans un fichier texte. Cela signifie que si vous passez une commande grep pour rechercher un mot, le système imprimera chaque ligne du fichier qui contient le mot en question.

      Exécutez la commande suivante pour utiliser grep et trouver ainsi toutes les lignes qui contiennent le mot GNU :

      Le premier argument, GNU, est le modèle que vous recherchez alors que le second, GPL-3, est le fichier saisi dans lequel vous souhaitez faire votre recherche.

      La sortie affichera chacune des lignes qui contient le texte modèle :

      Output

      GNU GENERAL PUBLIC LICENSE The GNU General Public License is a free, copyleft license for the GNU General Public License is intended to guarantee your freedom to GNU General Public License for most of our software; it applies also to Developers that use the GNU GPL protect your rights with two steps: "This License" refers to version 3 of the GNU General Public License. 13. Use with the GNU Affero General Public License. under version 3 of the GNU Affero General Public License into a single ... ...

      Sur certains systèmes, le modèle que vous recherchez sera mis en surbrillance dans la sortie.

      Options courantes

      Par défaut, grep recherchera le modèle exact spécifié dans le fichier d'entrée et renverra les lignes qu'il trouvera. Vous pouvez rendre ce comportement plus pratique en ajoutant quelques balises facultatives à grep.

      Si vous souhaitez que grep ignore la « case » de votre paramètre de recherche et que vous recherchez des variations à la fois en majuscule et en minuscule, vous pouvez spécifier l'option -i ou --ignore-case.

      Recherchez chaque instance du mot license (en majuscule, minuscule ou les deux) dans le même fichier qu'auparavant avec la commande suivante :

      Les résultats incluent : LICENSE, license et License :

      Output

      GNU GENERAL PUBLIC LICENSE of this license document, but changing it is not allowed. The GNU General Public License is a free, copyleft license for The licenses for most software and other practical works are designed the GNU General Public License is intended to guarantee your freedom to GNU General Public License for most of our software; it applies also to price. Our General Public Licenses are designed to make sure that you (1) assert copyright on the software, and (2) offer you this License "This License" refers to version 3 of the GNU General Public License. "The Program" refers to any copyrightable work licensed under this ... ...

      S'il y avait une instance avec LiCeNsE, elle aurait également été renvoyée.

      Si vous souhaitez trouver toutes les lignes qui ne contiennent pas le modèle spécifié, vous pouvez utiliser l'option -v ou --invert-match.

      Recherchez chaque ligne qui ne contient pas le mot the dans la licence BSD en exécutant la commande suivante :

      Vous verrez la sortie suivante :

      Output

      All rights reserved. Redistribution and use in source and binary forms, with or without are met: may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ... ...

      Étant donné que vous n'avez pas précisé l'option « ignorer case », les deux derniers éléments ont été renvoyés comme ne comportant pas le mot the.

      Il vous sera souvent utile de connaître le numéro de la ligne sur laquelle les correspondances sont trouvées. Pour se faire, vous pouvez utiliser l'option -n ou --line-number. Ré-exécutez l'exemple précédent en ajoutant la balise précédente :

      Vous verrez le texte suivant :

      Output

      2:All rights reserved. 3: 4:Redistribution and use in source and binary forms, with or without 6:are met: 13: may be used to endorse or promote products derived from this software 14: without specific prior written permission. 15: 16:THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 17:ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ... ...

      Vous pouvez maintenant référencer le numéro des lignes dans le cas où vous souhaiteriez modifier chacune des lignes qui ne contient pas the. Cela est particulièrement pratique lorsque vous travaillez avec un code source.

      Expressions régulières

      Au cours de l'introduction, vous avez appris que grep signifiait « rechercher globalement les correspondances avec l'expression rationnelle ». Une « expression régulière » est une chaîne de texte qui décrit un modèle de recherche spécifique.

      La manière dont les diverses applications et langages de programmation implémentent les expressions régulières est légèrement différente. Au cours de ce tutoriel, vous allez uniquement aborder un petit sous-ensemble de la façon dont grep décrit ses modèles.

      Correspondances littérales

      Dans les exemples précédents de ce tutoriel, lorsque vous avez recherché les mots GNU et the, en réalité, vous avez recherché les expressions régulières de base qui correspondaient à la chaîne exacte de caractères GNU et the. Les modèles qui spécifient exactement les caractères à mettre en correspondance se nomment « literals » car ils correspondent littéralement au modèle, character-for-character.

      Il est plus facile de les considérer comme une correspondance à une chaîne de caractères plutôt qu'à un mot. La distinction deviendra plus importante à mesure que les modèles que vous aborderez seront plus complexes.

      La correspondance se fera sur tous les caractères alphabétiques et numériques (ainsi que certains autres caractères) littéralement à moins qu'un autre mécanisme d'expression ne vienne la modifier.

      Correspondances avec les ancres

      Les ancres sont des caractères spéciaux qui spécifient à quel endroit de la ligne une correspondance est considérée comme valable.

      Par exemple, en utilisant des ancres, vous pouvez spécifier que vous souhaitez uniquement obtenir les lignes qui comportent GNU tout au début de la ligne. Pour cela, vous pouvez utiliser la balise ^ avant la chaîne littérale.

      Exécutez la commande suivante pour rechercher le fichier GPL-3 et trouver les lignes où GNU se trouve au tout début d'une ligne :

      Vous verrez apparaître les deux lignes suivantes :

      Output

      GNU General Public License for most of our software; it applies also to GNU General Public License, you may choose any version ever published

      De la même façon, vous devez utiliser l'ancre $ à la fin d'un modèle pour indiquer que la correspondance ne sera valable que si elle se trouve à la fin d'une ligne.

      Cette commande permettra de faire la correspondance avec chaque ligne se terminant par le mot and dans le fichier GPL-3 :

      Vous verrez la sortie suivante :

      Output

      that there is no warranty for this free software. For both users' and The precise terms and conditions for copying, distribution and License. Each licensee is addressed as "you". "Licensees" and receive it, in any medium, provided that you conspicuously and alternative is allowed only occasionally and noncommercially, and network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and provisionally, unless and until the copyright holder explicitly and receives a license from the original licensors, to run, modify and make, use, sell, offer for sale, import and otherwise run, modify and

      Correspondance avec tout caractère

      Dans les expressions régulières, le caractère du point (.) signifie que tout caractère individuel peut exister à l'endroit spécifié.

      Par exemple, pour trouver toute correspondance dans le fichier GPL-3 qui contient deux caractères et puis la chaine cept, vous devez utiliser le modèle suivant :

      Vous verrez la sortie suivante :

      Output

      use, which is precisely where it is most unacceptable. Therefore, we infringement under applicable copyright law, except executing it on a tells the user that there is no warranty for the work (except to the License by making exceptions from one or more of its conditions. form of a separately written license, or stated as exceptions; You may not propagate or modify a covered work except as expressly 9. Acceptance Not Required for Having Copies. ... ...

      Comme vous pouvez le voir, la sortie affiche des instances à la fois de accept et except ainsi que des variations des deux mots. Le modèle devrait également trouver les correspondances avec z2cept s'il y en avait.

      Expressions entre parenthèses

      En plaçant un groupe de caractères entre parenthèses ([ et ]), vous pouvez spécifier que le caractère qui se trouve à cette position peut être l'un des caractères du groupe entre parenthèses.

      Par exemple, pour trouver les lignes qui en contiennent too ou two, vous devez spécifier ces variations succinctement en utilisant le modèle suivant :

      La sortie montre que les deux variations existent dans le fichier :

      Output

      your programs, too. freedoms that you received. You must make sure that they, too, receive Developers that use the GNU GPL protect your rights with two steps: a computer network, with no transfer of a copy, is not conveying. System Libraries, or general-purpose tools or generally available free Corresponding Source from a network server at no charge. ... ...

      La notation des parenthèses vous offre quelques options intéressantes. Vous pouvez utiliser un modèle qui trouve toutes les correspondances sauf les caractères entre parenthèses en commençant la liste de caractères entre parenthèses par un ^

      Dans cet exemple, nous trouverons le modèle .ode mais ne fera pas correspondre le modèle code :

      Voici la sortie qui s'affichera :

      Output

      1. Source Code. model, to give anyone who possesses the object code either (1) a the only significant mode of use of the product. notice like this when it starts in an interactive mode:

      Notez que dans la seconde ligne renvoyée, il y a, en fait, le mot code. Il ne s'agit pas d'un échec de l'expression régulière ou de grep. Au contraire, cette ligne a été renvoyée car plus tôt dans la ligne, le système a trouvé le modèle mode qui se trouve dans le mot model. La ligne a été renvoyée car il y avait une instance qui correspond au modèle.

      Une autre des fonctionnalités utiles des parenthèses est que vous pouvez spécifier une gamme de caractères au lieu de saisir chaque caractère disponible individuellement.

      Ainsi, si vous le souhaitez, vous pouvez trouver toutes les lignes qui commencent par une lettre majuscule avec le modèle suivant :

      Voici la sortie que vous verrez :

      Output

      GNU General Public License for most of our software; it applies also to States should not allow patents to restrict development and use of License. Each licensee is addressed as "you". "Licensees" and Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an System Libraries, or general-purpose tools or generally available free Source. User Product is transferred to the recipient in perpetuity or for a ... ...

      À cause de certains des problèmes de tri hérités, il est souvent plus juste d'utiliser les catégories de caractères POSIX à la place des gammes de caractères que vous venez d'utiliser.

      Il existe plusieurs caractères qui sont en-dehors du champ de ce guide, mais voici un exemple qui accomplira la même procédure que celle de l'exemple précédent en utilisant la catégorie de caractères [:upper:] dans un sélectionneur de parenthèses :

      • grep "^[[:upper:]]" GPL-3

      La sortie sera la même qu'auparavant.

      Répéter le modèle Zero ou More Times

      Enfin, l'un des méta-caractères les plus couramment utilisés est l'astérisque ou *, qui signifie « répétez le caractère précédent ou l'expression zero ou more times ».

      Pour trouver chaque ligne dans le fichier GPL-3 qui contient des parenthèses d'ouverture et de fermeture, avec seulement des lettres et des espaces uniques entre les deux, utilisez l'expression suivante :

      • grep "([A-Za-z ]*)" GPL-3

      Vous verrez la sortie suivante :

      Output

      Copyright (C) 2007 Free Software Foundation, Inc. distribution (with or without modification), making available to the than the work as a whole, that (a) is included in the normal form of Component, and (b) serves only to enable use of the work with that (if any) on which the executable work runs, or a compiler used to (including a physical distribution medium), accompanied by the (including a physical distribution medium), accompanied by a place (gratis or for a charge), and offer equivalent access to the ... ...

      Jusqu'à présent, vous avez utilisé les points, les astérisques et d'autres caractères dans vos expressions. Cependant, vous aurez parfois besoin de rechercher ces caractères spécifiques.

      Éviter le méta-caractères

      Parfois, vous aurez besoin de trouver un point ou une parenthèse d'ouverture en tant que tel, tout particulièrement lorsque vous travaillerez avec un code source ou des fichiers de configuration. Étant donné que ces caractères ont une signification spéciale dans les expressions régulières, vous devez « échapper » ces caractères pour indiquer à grep que vous ne souhaitez pas utiliser leur signification spéciale dans ce cas.

      Vous pouvez éviter des caractères en utilisant un caractère de barre oblique inverse () devant le caractère qui devrait normalement avoir une signification spéciale.

      Par exemple, pour trouver toutes les lignes qui commencent par une lettre majuscule et se termine par un point, utilisez l'expression suivante qui évite le point final afin qu'elle représente un point littéral et non pas le sens habituel « any character » :

      Voici la sortie qui s'affichera :

      Output

      Source. License by making exceptions from one or more of its conditions. License would be to refrain entirely from conveying the Program. ALL NECESSARY SERVICING, REPAIR OR CORRECTION. SUCH DAMAGES. Also add information on how to contact you by electronic and paper mail.

      Prenons maintenant en considération d'autres options d'expressions régulières.

      Expressions régulières étendues

      La commande grep prend en charge un langage d'expression plus vaste en utilisant la balise -E ou en appelant la commande egrep au lieu de grep.

      Ces options vous donne la possibilité d'utiliser des « expressions régulières étendues ». Les expressions régulières étendues incluent tous les méta-caractères de base ainsi que les méta-caractères supplémentaires qui permettent d'exprimer des caractères plus complexes.

      Regroupement

      L'une des capacités les plus utiles qu'offrent les expressions régulières étendues est la possibilité de regrouper des expressions ensemble et de les manipuler ou d'y faire référence en tant qu'une seule unité.

      Groupez les expressions ensemble à l'aide de parenthèses. Si vous souhaitez utiliser des parenthèses sans utiliser des expressions régulières étendues, vous pouvez les éviter avec la barre oblique inverse pour activer cette fonctionnalité.

      Les trois expressions suivantes se valent en termes de fonctionnalité :

      • grep "(grouping)" file.txt
      • grep -E "(grouping)" file.txt
      • egrep "(grouping)" file.txt

      Alternance

      Tout comme les expressions entre parenthèses peuvent spécifier différents choix possibles de correspondance avec des caractères uniques, l'alternance vous permet de spécifier des correspondances alternatives pour les chaînes de caractères ou ensembles d'expression.

      Pour indiquer une alternance, utilisez le caractère de barre droite |. Ils sont souvent utilisés dans des regroupements entre parenthèses pour spécifier qu'une sur deux ou plusieurs des possibilités devraient être considérées comme une correspondance.

      La commande suivante trouvera soit GPL ou General Public Licence dans le texte :

      • grep -E "(GPL|General Public License)" GPL-3

      Le résultat ressemblera à ce qui suit :

      Output

      The GNU General Public License is a free, copyleft license for the GNU General Public License is intended to guarantee your freedom to GNU General Public License for most of our software; it applies also to price. Our General Public Licenses are designed to make sure that you Developers that use the GNU GPL protect your rights with two steps: For the developers' and authors' protection, the GPL clearly explains authors' sake, the GPL requires that modified versions be marked as have designed this version of the GPL to prohibit the practice for those ... ...

      Avec l'alternance, vous pouvez faire votre sélection entre plus de deux options en ajoutant des choix supplémentaires dans le groupe de sélection séparé par des caractères supplémentaires de barre oblique (|).

      Quantificateurs

      Comme le méta-caractère * qui correspond au caractère précédent ou au caractère défini sur zero ou more times, d'autres méta-caractères disponibles dans des expressions régulières étendues permettent de spécifier le nombre d'événements.

      Pour trouver une correspondance de caractère zero ou one times, vous pouvez utiliser le ? . Cela rend le caractère ou les ensembles de caractères précédents optionnels, par essence.

      La commande suivante cherche les correspondances de copyright et right en plaçant copy dans un groupe optionnel :

      • grep -E "(copy)?right" GPL-3

      Vous verrez la sortie suivante :

      Output

      Copyright (C) 2007 Free Software Foundation, Inc. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License "Copyright" also means copyright-like laws that apply to other kinds of ...

      Le caractère + correspond à l'apparition une ou plusieurs fois d'une expression. Il est presque similaire au méta-caractère *, mais avec le caractère +, l'expression doit correspondre au moins une fois.

      L'expression suivante correspond à la chaîne free plus un ou plusieurs caractères qui ne sont pas des caractères d'espacement :

      • grep -E "free[^[:space:]]+" GPL-3

      Vous verrez la sortie suivante :

      Output

      The GNU General Public License is a free, copyleft license for to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to When we speak of free software, we are referring to freedom, not have the freedom to distribute copies of free software (and charge for you modify it: responsibilities to respect the freedom of others. freedomss that you received. You must make sure that they, too, receive protecting users' freedom to change the software. The systematic of the GPL, as needed to protect the freedom of users. patents cannot be used to render the program non-free.

      Spécifier la répétition de correspondance

      Pour spécifier le nombre de fois qu'une correspondance est répétée, utilisez les caractères d'accolade ({ et }). Ces caractères vous permettent de spécifier avec exactitude un numéro, une plage ou une limite supérieure ou inférieure pour le nombre de fois qu'une correspondance à une expression est trouvée.

      Utilisez l'expression suivante pour trouver toutes les lignes dans le fichier GPL-3 qui contiennent trois voyelles :

      • grep -E "[AEIOUaeiou]{3}" GPL-3

      Chaque ligne renvoyée contient un mot avec trois voyelles :

      Output

      changed, so that their problems will not be attributed erroneously to authors of previous versions. receive it, in any medium, provided that you conspicuously and give under the previous paragraph, plus a right to possession of the covered work so as to satisfy simultaneously your obligations under this

      Pour trouver la correspondance avec tous les mots qui ont entre 16 et 20 caractères, utilisez l'expression suivante :

      • grep -E "[[:alpha:]]{16,20}" GPL-3

      Vous verrez la sortie suivante :

      Output

      certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. c) Prohibiting misrepresentation of the origin of that material, or

      Seules les lignes contenant des mots de cette longueur s'afficheront.

      Conclusion

      grep est une fonctionnalité pratique pour trouver des modèles dans des fichiers ou la hiérarchie du système de fichiers. Il est donc conseiller de passer un peu de temps pour se familiariser avec ses options et sa syntaxe.

      Les expressions régulières sont encore plus versatiles et peuvent être utilisées avec plusieurs programmes populaires. Par exemple, de nombreux éditeurs de texte implémentent des expressions régulières pour rechercher et remplacer du texte.

      En outre, la plupart des langages de programmation modernes utilisent des expressions régulières pour exécuter des procédures sur des données spécifiques. Une fois que vous aurez compris les expressions régulières, vous pourrez transférer ces connaissances sur plusieurs tâches informatiques courantes, de la recherche avancée dans votre éditeur de texte à la validation des entrées de l'utilisateur.



      Source link

      Verwenden des SMTP-Servers von Google


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Eine wenig bekannte Funktion von Gmail und Google Apps E-Mail ist der portable SMTP-Server von Google. Anstatt Ihren eigenen Postausgangsserver auf Ihrem DigitalOcean-Droplet oder Kubernetes-Cluster verwalten zu müssen, können Sie die SMTP-Servereinstellungen von Google mit einem beliebigen Skript oder Programm konfigurieren, das Sie zum Versenden von E-Mails verwenden möchten. Sie benötigen lediglich entweder (i) ein kostenloses Gmail-Konto oder (ii) ein kostenpflichtiges G Suite-Konto.

      Vorteile

      Sie haben die Möglichkeit, die von Ihnen über den SMTP-Server gesendeten E-Mails von Google speichern und indizieren zu lassen, sodass alle Ihre gesendeten E-Mails auf den Servern von Google durchsuchbar und gesichert sind. Wenn Sie sich entscheiden, Ihr Gmail- oder G Suite-Konto auch für Ihre eingehenden E-Mails zu verwenden, haben Sie alle Ihre E-Mails an einem praktischen Ort. Da der SMTP-Server von Google nicht den Port 25 verwendet, verringern Sie außerdem die Wahrscheinlichkeit, dass ein ISP Ihre E-Mails blockiert oder als Spam kennzeichnet.

      Einstellungen

      Der SMTP-Server von Google erfordert Authentifizierung. Hier erfahren Sie, wie Sie diese in Ihrem Mail-Client oder Ihrer Anwendung einrichten:

      Anmerkung: Bevor Sie beginnen, sollten Sie laut Google die Sicherheitseinstufung Ihres Mail-Clients oder Ihrer Anwendung überprüfen. Wenn Sie ein Programm verwenden, das von Google als nicht sicher eingestuft wird, wird Ihre Nutzung blockiert, es sei denn, Sie aktivieren weniger sichere Anwendungen (eine Sicherheitseinstellung, die von Google nicht empfohlen wird) oder erstellen ein anwendungsspezifisches App-Passwort. Weitere Sicherheitsinformationen finden Sie unter diesem Link zur Ermittlung der besten Vorgehensweise für Ihren Mail-Client oder Ihre Anwendung.

      1. SMTP-Server (d. h., Postausgangsserver): smtp.gmail.com
      2. SMTP-Benutzername: Ihre vollständige Gmail- oder G Suite-E-Mail-Adresse (z. B. [email protected] oder example@your_domain)
      3. SMTP-Passwort: Ihr Gmail- oder G Suite-E-Mail-Passwort
      4. SMTP-Port: 465
      5. SMTP TLS/SSL erforderlich: Ja

      Damit Google Ihre gesendeten E-Mails automatisch in den Ordner „Gesendet“ kopiert, müssen Sie außerdem überprüfen, ob der IMAP-Zugriff für Ihr Konto aktiviert ist.

      Gehen Sie dazu in die Gmail-Einstellungen und klicken Sie auf die Registerkarte Weiterleitung und POP/IMAP. Scrollen Sie nach unten zu dem Abschnitt IMAP-Zugriff und stellen Sie sicher, dass der IMAP-Zugriff für Ihr Konto aktiviert ist.

      Anmerkung: Google schreibt die Absenderzeile jeder E-Mail, die Sie über seinen SMTP-Server senden, automatisch in die mit dem Konto verknüpfte Standard-E-Mail-Adresse um, wenn die verwendete Adresse nicht in der Adressenliste E-Mail senden als in den Einstellungen von Gmail oder G Suite enthalten ist. Sie können die Liste überprüfen, indem Sie auf dem Einstellungsbildschirm auf die Registerkarte Konten und Import gehen.

      Sie müssen sich dieser Nuance bewusst sein, da sie sich auf die Darstellung Ihrer E-Mail aus der Sicht des Empfängers auswirkt und auch die Einstellung Antworten an einiger Programme beeinflussen kann.

      Sendebeschränkungen

      Google begrenzt die Menge der E-Mails, die ein Benutzer über den portablen SMTP-Server senden kann. Diese Begrenzung beschränkt die Anzahl der täglich gesendeten Nachrichten auf 99 E-Mails; die Beschränkung wird automatisch 24 Stunden nach Erreichen der Beschränkung aufgehoben.

      Zusammenfassung

      Sie haben nun die Möglichkeit, den SMTP-Server von Google zu verwenden. Wenn diese vereinfachte Option nicht ausreicht, können Sie die Installation und Konfiguration von Postfix als reinen Sende-SMTP-Server in Betracht ziehen.



      Source link