URL significatives pour les applications web dynamiques

Introduction

Les applications web modernes utilisent des URL significatives pour aider les utilisateurs. Les utilisateurs sont plus susceptibles de liker une page et de revenir si la page utilise une URL significative qu'ils peuvent retenir et utiliser pour accéder directement à une page. Dans ce laboratoire, nous nous concentrerons sur la manière de mettre en œuvre des URL dynamiques et d'attacher plusieurs règles à une fonction dans Flask.

Décorateur de route

Dans cette étape, vous utiliserez le décorateur route() pour lier plusieurs fonctions de vue à plusieurs URL.

1. Ouvrez le fichier route_decorator.py, importez la classe Flask et créez une instance de celle-ci.

from flask import Flask
app = Flask(__name__)

2. Ensuite, nous utilisons le décorateur route() pour créer deux routes, / et /hello, lier les fonctions de vue correspondantes, et les faire retourner respectivement Page d'accueil et Bonjour, monde.

@app.route('/')
def index():
    return 'Page d\'accueil'

@app.route('/hello')
def hello():
    return 'Bonjour, monde'

3. Créez un point d'entrée main du script pour démarrer l'application Flask sur le port 5000, en activant le mode debug.

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=5000, debug=True)

4. Pour exécuter l'application, utilisez d'abord les commandes suivantes pour lancer l'application Flask dans le terminal :

python3 route_decorator.py

Ensuite, ouvrez l'onglet "Web 5000" situé en haut de l'interface, actualisez la page, et vous devriez voir le message Page d'accueil.

Pour la route /hello, vous pouvez ajouter le suffixe hello directement dans la barre d'adresse ci-dessus.

Ensuite, la page affichera le message Bonjour, monde.

Règles variables

Dans cette étape, vous ajouterez des sections variables à une URL en marquant les sections avec <variable_name>. Facultativement, vous pouvez utiliser un convertisseur pour spécifier le type de l'argument, comme <converter:variable_name>.

1. Ouvrez le fichier variable_rules.py, importez d'abord la classe Flask et escape, puis créez une instance de la classe Flask.

from flask import Flask
from markupsafe import escape
app = Flask(__name__)

2. Dans le décorateur route(), ajoutez les modèles <variable_name> et <converter:variable_name> pour créer des URL dynamiques avec des sections variables. Faites en sorte que les fonctions de vue retournent des chaînes formatées.

@app.route('/user/<username>')
def show_user_profile(username):
    ## Affiche le profil de l'utilisateur correspondant
    return f'Utilisateur {escape(username)}'

@app.route('/post/<int:post_id>')
def show_post(post_id):
    ## Affiche le post avec l'ID donné, l'ID est un entier
    return f'Post {post_id}'

@app.route('/path/<path:subpath>')
def show_subpath(subpath):
    ## Affiche le sous-chemin après /path/
    return f'Sous-chemin {escape(subpath)}'

• Voici un tableau des types de convertisseurs courants :

3. Créez un point d'entrée main du script pour démarrer l'application Flask sur le port 5001, en activant le mode debug.

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=5001, debug=True)

4. Pour exécuter l'application, utilisez d'abord les commandes suivantes pour lancer l'application Flask dans un nouveau terminal :

python3 variable_rules.py

Ensuite, ouvrez l'onglet "Web 5001" situé en haut de l'interface, ajoutez le suffixe user/Alice directement dans la barre d'adresse ci-dessus.

Ensuite, la page affichera le message Utilisateur Alice.

5. Vous pouvez également répéter les mêmes opérations pour les suffixes post/1 et path/some/path. Pour le suffixe post/1, il affiche le message Post 1. Pour le suffixe path/some/path, il affiche le message Sous-chemin some/path.

Comportement de redirection

Dans cette étape, vous allez apprendre que deux règles diffèrent en ce qui concerne l'utilisation d'un slash final.

1. Ouvrez le fichier redirection_behavior.py, importez la classe Flask et créez une instance de celle-ci.

from flask import Flask
app = Flask(__name__)

2. Utilisez le décorateur route() pour créer une route appelée /projects/ avec une fonction de vue appelée projects.

@app.route('/projects/')
def projects():
    return 'La page des projets'

L'URL canonique pour le point de terminaison projects a un slash final. C'est similaire à un dossier dans un système de fichiers. Si vous accédez à l'URL sans slash final (/projects), Flask vous redirige vers l'URL canonique avec le slash final (/projects/).

3. Créez une autre route appelée /about avec une fonction de vue appelée about.

@app.route('/about')
def about():
    return 'La page à propos'

L'URL canonique pour le point de terminaison about n'a pas de slash final. C'est similaire au nom de chemin d'un fichier. Accéder à l'URL avec un slash final (/about/) produit une erreur 404 Non trouvé. Cela aide à maintenir les URL uniques pour ces ressources, ce qui aide les moteurs de recherche à éviter d'indexer la même page deux fois.

4. Créez un point d'entrée main du script pour démarrer l'application Flask sur le port 5002, en activant le mode debug.

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=5002, debug=True)

5. Pour exécuter l'application, utilisez d'abord les commandes suivantes pour lancer l'application Flask dans un nouveau terminal :

python3 redirection_behavior.py

Ensuite, ouvrez l'onglet "Web 5002" situé en haut de l'interface, ajoutez le suffixe projects directement dans la barre d'adresse ci-dessus.

Ensuite, la page affichera le message La page des projets, car elle est redirigée vers la route /projects/.

Ajoutez un autre suffixe about/ au lieu de projects :

Vous devriez voir le message Non trouvé, ce qui indique une erreur 404. Changez le suffixe en about, puis elle peut afficher le message correct La page à propos.

Construction d'URL

Dans cette étape, vous utiliserez la fonction url_for() pour construire une URL vers une fonction spécifique. Elle accepte le nom de la fonction comme premier argument et un nombre quelconque d'arguments clés, chacun correspondant à une partie variable de la règle d'URL. Les parties variables inconnues sont ajoutées à l'URL comme paramètres de requête.

1. Ouvrez le fichier url_building.py, et importez d'abord la classe Flask et url_for. N'oubliez pas également de créer une instance de la classe Flask.

from flask import Flask, url_for
app = Flask(__name__)

2. Utilisez le décorateur route() pour créer trois routes, et définissez les fonctions de vue correspondantes.

@app.route('/')
def index():
    return 'index'

@app.route('/login')
def login():
    return 'login'

@app.route('/user/<username>')
def profile(username):
    return f'{username}\'s profile'

3. Nous utilisons la méthode test_request_context() pour tester url_for(). Elle indique à Flask de se comporter comme s'il gérait une requête même si nous utilisons une invite Python.

with app.test_request_context():
    print(url_for('index'))
    print(url_for('login'))
    print(url_for('login', next='/'))
    print(url_for('profile', username='John Doe'))

• url_for('index') génère une URL pour la fonction de vue index, donnant /.
• url_for('login') génère une URL pour la fonction de vue login, donnant /login.
• url_for('login', next='/') génère une URL pour la fonction de vue login et inclut un paramètre de requête supplémentaire next, donnant `/login?next=/.
• url_for('profile', username='John Doe') génère une URL pour la fonction de vue profile avec la variable username définie sur John Doe, donnant /user/John%20Doe

4. Exécutez directement le fichier url_building.py dans un nouveau terminal :

python3 url_building.py

Il devrait afficher :

/
/login
/login?next=/
/user/John%20Doe

Résumé

Dans ce laboratoire, nous avons appris diverses méthodes pour créer des URL significatives, ce qui est très important lors de la conception d'une application web. En utilisant habilement les capacités de routage de Flask, vous pouvez créer des URL organisées et intuitives qui améliorent l'expérience de l'utilisateur.