quelle logiciel / éditeur permet de faire ou détecter de la refactorisation simple (répétition de lignes) ?

**borlandcpp2018** · 27/04/2018, 17h12

bonjour,

ce n'est pas de l'humour mais de l'évidence.
Là je corrige un long script écrit par autrui, dedans il y a une multitude de lignes de code qui sont répétées et qui ont un sens.

par exemple :
position y+= 1 ;

Cela correspond à un saut de ligne.

du coup, je me dis , je devrais en faire une fonction, et pour cela, détecter que cette ligne se répète à de multiple endroit.
j'ai vu que dans Notepad ++, on povait rechercher le Nb de fois qu'une ligne est répété.
Mais je n'ai trouvé aucun éditeur de texte qui comptabilise chaque ligne (afin de savoir quelles instructions d'une seule ligne sont tout le temps répétées et devraient être factorisée).

avez-vous une idée d'un éditeur de texte qui ferait ça ?

par exemple, qui indiquerait :

a=a+1 : 45 occurrences
position y+= 1 ; 36 occurrences
//todo : 12 occurrences

merci de votre aide à tous.

**Pyramidev** · 27/04/2018, 19h15

Bonjour,

S'il suffit de compter le nombre d'occurrences de chaque ligne, alors cela peut se coder facilement en Python.

Voici le code correspondant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

"""
Ce script lit un fichier et affiche les lignes qui y apparaissent plusieurs
fois, en indiquant combien de fois elles apparaissent.
Ce code a été testé avec Python 3.6.4.
"""

#####################
# Imports and types #
#####################

import os

#########
# Paths #
#########

filePath = 'test.txt'

#############
# Main code #
#############

if __name__ == '__main__':
	try:
		mapFromLineToNumberOfOccurrences = {}
		with open(filePath) as file:
			for line in file:
				if line not in mapFromLineToNumberOfOccurrences:
					mapFromLineToNumberOfOccurrences[line] = 1
				else:
					mapFromLineToNumberOfOccurrences[line] += 1
		for line in mapFromLineToNumberOfOccurrences:
			count = mapFromLineToNumberOfOccurrences[line]
			if count > 1:
				print(line[0:-1] + ' : ' + str(count) + ' occurrences')
	except Exception as e:
		print('Error: ' + str(e))
	os.system('pause')

Si le fichier 'test.txt' contient le même texte que mon script Python, alors le résultat sera :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
""" : 2 occurrences
 : 6 occurrences
##################### : 2 occurrences
######### : 2 occurrences
############# : 2 occurrences

Un avantage du Python est qu'on peut très facilement faire des choses simples avec, même quand on ne connaît quasiment pas ce langage. En effet, quand on cherche sur internet comment faire telles et telles opérations basiques, on tombe très vite sur des liens StackOverflow qui expliquent comment faire.

Néanmoins, pour être un peu plus à l'aise avec Python, je conseille de lire le tutoriel du site officiel.

À part ça, voici une autre version du script plus difficile à lire quand on débute, mais avec du code plus découpé, plus réutilisable et avec du typage fort vérifié avec mypy :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

"""
Ce script lit un fichier et affiche les lignes qui y apparaissent plusieurs
fois, en indiquant combien de fois elles apparaissent.
Ce code a été testé avec Python 3.6.4.
L'analyse statique du code a été validée par mypy 0.570.
"""

#####################
# Imports and types #
#####################

import os
from typing import Iterable, Mapping, MutableMapping, TypeVar

T = TypeVar('T')

#########
# Paths #
#########

filePath : str = 'test.txt'

#############
# Main code #
#############

def _mainImpl() -> None:
	with open(filePath) as file:
		mapFromLineToNumberOfOccurrences : Mapping[str, int] = countOccurrencesOfEachElement(file)
	printMapFromLineToNumberOfOccurrences(mapFromLineToNumberOfOccurrences)

def countOccurrencesOfEachElement(iterable : Iterable[T]) -> MutableMapping[T, int]:
	result : MutableMapping[T, int] = {}
	for element in iterable:
		if element not in result:
			result[element] = 1
		else:
			result[element] += 1
	return result

def printMapFromLineToNumberOfOccurrences(mapFromLineToNumberOfOccurrences : Mapping[str, int]) -> None:
	for line in mapFromLineToNumberOfOccurrences:
		count : int = mapFromLineToNumberOfOccurrences[line]
		if count > 1:
			print(line[0:-1] + ' : ' + str(count) + ' occurrences')

if __name__ == '__main__':
	try:
		_mainImpl()
	except Exception as e:
		print('Error: ' + str(e))
	os.system('pause')

Attention, dans les deux scripts que j'ai écrits, deux lignes qui ne diffèrent que d'un seul caractère - même blanc - seront considérées comme différentes. Donc tu devras probablement adapter le code à tes besoins.

Edit 2018-04-27-20h13 : étourderies corrigées
Edit 2018-04-27-20h51 : ajout de la gestion des erreurs avec try-except.