Analogues en Python et JavaScript. Deuxième partie

Nous continuons de publier une traduction d'une série d'articles sur les similitudes et les différences entre les deux langues.

Aujourd'hui, nous allons parler de la sérialisation des dictionnaires, du JSON, des habitués, des erreurs et des exceptions.

Autres articles de cette série:

1. La première partie est la conversion de type, l'opérateur ternaire, l'accès à une propriété par nom de propriété, les dictionnaires, les listes, les chaînes, la concaténation des chaînes.
2. Cet article
3. Troisième partie : Python et JS modernes: modèles de chaînes (lignes f), décompression de liste, fonctions lambda, itérations de liste, générateurs, ensembles.
4. La quatrième partie concerne les arguments de fonction, la création et l'utilisation de classes, l'héritage, les accesseurs de définition et les propriétés de classe.

Json

Lorsque vous travaillez avec de nombreuses API, il est pratique de sérialiser des objets en objets JSON pour faciliter le transfert et l'analyse ultérieure.

Python possède un module json standard:

import json json_data = json.dumps(dictionary, indent=4) dictionary = json.loads(json_data) 

Ici, nous formaterons JSON avec une indentation de 4 espaces.

Dans JS, il existe un objet JSON avec des méthodes pour créer et analyser des chaînes JSON:

 json_data = JSON.stringify(dictionary, null, 4); dictionary = JSON.parse(json_data); 

Analyser les chaînes avec des habitués

Dans le dernier article, nous avons combiné plusieurs lignes en une seule. Mais comment diviser une longue chaîne en plusieurs, surtout si le séparateur n'est pas un seul caractère comme une virgule, mais toute une gamme d'options différentes? C'est là que les expressions régulières et la méthode split() viennent à la rescousse.

En Python, la méthode split() fait référence à un modèle d'expression régulière. Voici comment diviser une chaîne de texte en phrases de ponctuation:

 import re #     "!?."         delimiter = re.compile(r'[!?\.]+\s*') text = "Hello!!! What's new? Follow me." sentences = delimiter.split(text) # sentences == ['Hello', "What's new", 'Follow me', ''] 

Dans JS, la méthode split() fait référence aux chaînes:

 //     "!?."         delimiter = /[!?\.]+\s*/; text = "Hello!!! What's new? Follow me."; sentences = text.split(delimiter) // sentences === ["Hello", "What's new", "Follow me", ""] 

Recherche régulière par motif

Les expressions régulières sont souvent utilisées pour valider les données des formulaires.
Par exemple, pour vérifier l'exactitude de l'adresse e-mail entrée, elle doit être comparée au modèle d'expression régulière.

En Python, cela ressemblera à ceci:

 import re # name, "@", and domain pattern = re.compile(r'([\w.+\-]+)@([\w\-]+\.[\w\-.]+)') match = pattern.match('hi@example.com') # match.group(0) == 'hi@example.com' # match.group(1) == 'hi' # match.group(2) == 'example.com' 

Si une section de texte correspond à un modèle, l'utilisation de la méthode group() renvoie la section entière dans laquelle vous pouvez sélectionner des groupes individuels définis dans le modèle.

0 - toute la (sous-) correspondance de ligne, 1 - le premier groupe, 2 - le second, etc.

Si aucune correspondance n'est trouvée, un objet de type None sera retourné.

Dans JS, il existe une méthode de chaîne match() qui retourne la partie correspondante d'une chaîne ou null .

 // name, "@", and domain pattern = /([\w.+\-]+)@([\w\-]+\.[\w\-.]+)/; match = 'hi@example.com'.match(pattern); // match[0] === 'hi@example.com' // match[1] === 'hi' // match[2] === 'example.com' 

Dans JS, l'objet correspondant ressemble à un tableau. L'élément d'index [0] est la (sous-) ligne entière qui correspond, le 1er élément est le premier groupe, le 2e est le deuxième, etc. - le tout conformément aux groupes définis dans le modèle.

Parfois, en plus de la recherche, il est nécessaire de déterminer la position de l'échantillon dans le texte. Cela peut être fait en utilisant la méthode search() .
En Python, cette méthode fait référence aux expressions régulières et renvoie un objet correspondant. Cet objet correspondant a une méthode start() qui retourne le début de l'occurrence de cette sous-chaîne dans la ligne principale:

 text = 'Say hi at hi@example.com' first_match = pattern.search(text) if first_match: start = first_match.start() # start == 10 

La méthode JS possède une méthode de search() par chaîne search() renvoie l'index du début de la sous-chaîne. Ou -1 si aucune correspondance n'a été trouvée.

 text = 'Say hi at hi@example.com'; first_match = text.search(pattern); if (first_match > -1) { start = first_match; // start === 10 } 

Remplacer par un motif à l'aide d'expressions régulières

En règle générale, un remplacement de modèle est nécessaire lorsque vous souhaitez effacer des données ou ajouter des propriétés au texte. Par exemple, nous pouvons prendre une ligne et créer toutes les adresses e-mail rencontrées des liens:

Python a une méthode de modèle regex sub() pour cela:

 html = pattern.sub( r'<a href="mailto:\g<0>">\g<0></a>', 'Say hi at hi@example.com', ) # html == 'Say hi at <a href="mailto:hi@example.com">hi@example.com</a>' 

Les développeurs JS peuvent utiliser la méthode de chaîne replace() :

 html = 'Say hi at hi@example.com'.replace( pattern, '<a href="mailto:$&">$&</a>', ); // html === 'Say hi at <a href="mailto:hi@example.com">hi@example.com</a>' 

En Python, les groupes correspondants sont disponibles en tant que \g<0>, \g<1>, \g<2> , etc.
En JS, comme $&, $1, $2 , etc.

Il est également possible de remplacer la partie correspondante par une fonction. Ces fonctions sont utiles lors du remplacement de l'habillage du texte source ou pour le comptage, la collecte ou l'obtention d'autres informations sur le texte. Par exemple, lorsque j'utilise un appel de fonction lors du remplacement, je peux écrire la coloration syntaxique HTML.

Modifions toutes les adresses e-mail dans les LETTRES MAJUSCULES.

En Python, la fonction replace obtient l'objet correspondant. Nous utilisons la méthode group () pour effectuer des actions avec le texte correspondant et le renvoyer en remplacement:

 text = pattern.sub( lambda match: match.group(0).upper(), 'Say hi at hi@example.com', ) # text == 'Say hi at HI@EXAMPLE.COM' 

Dans JS, la fonction replace obtient la correspondance de la chaîne entière, première occurrence, seconde, etc. Nous effectuons les actions nécessaires et renvoyons la ligne modifiée:

 text = 'Say hi at hi@example.com'.replace( pattern, function(match, p1, p2) { return match.toUpperCase(); } ); // text === 'Say hi at HI@EXAMPLE.COM' 

Gestion des erreurs

Contrairement à Python, le JavaScript basé sur un navigateur frontal n'est généralement pas utilisé pour écrire / lire des fichiers ou accéder à des bases de données. Par conséquent, les blocs try..catch assez rares dans JS par rapport aux blocs try..except en Python.

Mais, dans tous les cas, la gestion des erreurs peut être effectuée dans un script utilisateur, appelé à partir d'une fonction de bibliothèque et intercepté dans le code principal.

Dans l'exemple MyException suivant, nous allons définir notre MyException , la MyException dans une fonction, et voir comment l'attraper et la gérer dans le bloc try..except..finally :

 class MyException(Exception): def __init__(self, message): self.message = message def __str__(self): return self.message def proceed(): raise MyException('Error happened!') try: proceed() except MyException as err: print('Sorry! {}'.format(err)) finally: print('Finishing') 

Le code JS suivant fait de même - nous définissons la classe MyException , la MyException dans une fonction, l'interceptons et la traitons dans un bloc try..catch..finally :

 function MyException(message) { this.message = message; this.toString = function() { return this.message; } } function proceed() { throw new MyException('Error happened!'); } try { proceed(); } catch (err) { if (err instanceof MyException) { console.log('Sorry! ' + err); } } finally { console.log('Finishing'); } 

Dans les deux langues, la classe MyException a un paramètre de message et une méthode pour la représentation sous forme de chaîne en fonction de la valeur du message .

Bien sûr, les exceptions ne doivent être levées / levées qu'en cas d'erreur. Et si vous avez identifié cette erreur dans votre module.

Conclusions

• La sérialisation vers / depuis JSON est assez simple - ce qui est en Python, ce qui est en JS.
• Les habitués sont un puissant outil de traitement de texte dans les deux langues.
• Vous pouvez effectuer des remplacements à l'aide de fonctions.
• Pour les cas plus complexes, vous pouvez utiliser les appels, l'interception et la gestion des erreurs.

Comme cela a été dit la dernière fois, vous pouvez faire correspondre ligne par ligne les exemples de code fournis ici pour comprendre des structures de données similaires et des méthodes de travail avec elles: chaînes, tableaux, dictionnaires, accès aux objets.

Dans la partie suivante, nous parlerons des modèles de texte, des listes de décompression, des fonctions lambda, des itérations sans utiliser d'index, de générateurs et d'ensembles.