Discussion :

[laurentSc]

Pour aller vite, j'ai mis ça :

Code :

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

1
2
3
4
5
 public function getReader() {
        while ( false !== $fields = fgetcsv($this->handle,1024,';' )) {
            yield $fields;
        }
    }

mais la ligne 1 du CSV reste valide alors qu'elle ne devrait pas

[EDIT] Le séparateur semble être pris en compte vu que le var_dump retourne un array alors qu'avant c'était une string.

[CosmoKnacki]

Voici un exemple fonctionnel avec tes données:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
abstract class CSV
{
    protected string $delimiter = ',';
    protected string $protection = '"';
    protected string $escape = '\\';
 
    protected ?int $fieldsNumber = null;
 
    protected ?array $headers = null;
 
    public function setDelimiter(string $delimiter):void {
        $this->delimiter = $delimiter;
    }
 
    protected function HasHeaders():bool {
        return (bool) $this->headers;
    }
 
    protected abstract function checkFieldsNumber(int $fieldsNumber):bool;
 
}
 
interface ReaderInterface
{
    public function getReader();
}
 
class CSVReader extends CSV implements ReaderInterface
{
    protected $handle;
 
    public function __construct($handle)
    {
        if ( gettype($handle) !== 'resource' || get_resource_type($handle) !== 'stream' )
            throw new InvalidArgumentException();
 
        $this->handle = $handle;
    }
 
    public function getReader() {
        // on détermine le nombre de colonnes d'après l'entête ou la première ligne de donneés
        if ( $this->headers ) {
            $this->fieldsNumber = count($this->headers);
        } else {
            if ( false !== $fields = fgetcsv($this->handle, 1024, $this->delimiter) ) {
                $this->fieldsNumber = count($fields);
 
                yield $fields;
            }
        }
 
        while ( false !== $fields = fgetcsv($this->handle, 1024, $this->delimiter) ) {
            if ( $this->checkFieldsNumber(count($fields)) ) {
                yield $fields;
            } else {
                throw new Exception('Invalid number of fields');
            }
 
        }
 
    }
 
    public function setHeaders() {
        if ( $this->handle ) {
            if ( false !== $headers = fgetcsv($this->handle, 1024, $this->delimiter) ) {
                $this->headers = $headers;
            }        
        }
 
    }
 
    public function getHeaders():?array {
        return $this->headers;
    }
 
    protected function checkFieldsNumber(int $fieldsNumber):bool {
        return $this->fieldsNumber === $fieldsNumber;
    }
}
 
interface ValidatorInterface
{
     public function validate($value):bool;
}
 
class FieldValidator implements ValidatorInterface
{
    protected $constraints;
 
    public function __construct($constraints) {
        $this->constraints = $constraints;
    }
 
    public function validate($value):bool {
        foreach ($this->constraints as $constraint) {
            if ( $constraint($value) === false ) {
                return false;
            }
        }
        return true;
    }
}
 
class RowValidator implements ValidatorInterface
{
    protected $validators;
 
    public function __construct(array $validators) {
        $this->validators = $validators;
    }
 
    public function validate($fields):bool {
        foreach ($fields as $k => $field) {
            if ( $this->validators[$k]->validate($field) === false ) {
                return false;
            }
        }
        return true;
    }        
}
 
$data = <<<'EOD'
SESAID;ALTERNATEIDS;PLATFORM
SE100008;(none);Software Engineering
SESA10038;(none);Software Engineering
SESA100675;(none);Software Engineering
SESA101072;(none);Software Engineering
SESA101549;(none);Software Engineering
SESA101659;(none);Software Engineering
SESA101844;(none);Software Engineering
EOD;
 
$url = 'data:text/plain,' . $data;
 
if ( false === $handle = fopen($url, 'rb') ) {
    throw new Exception('impossible d\'ouvrir le fichier');
}
 
$reader = new CSVReader($handle);
$reader->setDelimiter(';');
$reader->setHeaders();
$genRow = $reader->getReader();
print_r($reader->getHeaders());
 
$rowValidator = new RowValidator([
    new FieldValidator([
        fn($v) => (bool) preg_match('/\ASESA[0-9]{5}\z/', $v) // le résultat doit être un booléen (preg_match renvoie 0)
        //fn($v) => (1==1)
    ]),
    new FieldValidator([
        fn($v) => (1==0) //cette fonction devrait renvoyer false
    ]),
    new FieldValidator([
        fn($v) => (1==1)
    ])
]); /* le tableau passé à la classe RowValidator contient 3 items qui sont 3 instances de la classe FieldValidator. A chaque instance, je passe un tableau constitué d'un seul item. Pour le premier, c'est l'évaluation d'une regexp ; pour le 2e, une fonction qui retourne toujours false et pour la 3e, une fonction qui retourne toujours true. Bien sûr, c'est que pour le test !*/
 
$nl = PHP_EOL; // ou '<br>'
$i = 0;
foreach ($genRow as  $fields) {
    echo "ligne ", $i, $nl;
 
    var_dump($fields);
 
 
    if ( !$rowValidator->validate($fields) ) {
        echo "ligne".$i++." non valide";
    } else {
        echo "ligne".$i++." valide";
    }
    echo str_repeat($nl, 2);
}

Attention avec une fonction comme preg_match qui renvoie 0 lorsque qu'aucune correspondance n'est trouvée et non false. Le validateur fait une comparaison stricte. (il faut donc s'assurer que le retour du test est bien de type booléen).

[laurentSc]

Merci pour ta réponse hier, que je ne vois que tout de suite ! (qui marche bien).

Cela dit :
avis d'un expert : Dans ton cas c'est utiliser un bazooka pour tuer une mouche. Donc l'étude de cette piste (pas loin d'une semaine) m'a fait découvrir plein de concepts (nouveaux pour moi) du PHP, et je conserve le code de test effectué, mais vu la taille limitée de mes fichiers CSV, je vais garder la piste de tout écrire dans un tableau plutôt que d'utiliser un générateur.

[CosmoKnacki]

Dans ton cas c'est utiliser un bazooka pour tuer une mouche

Certes on peut clairement faire la même chose en moins de 30 lignes (et encore), mais ce sera sans encapsulation du code et pour produire quelque chose de spécialisé pour ton cas et donc non réutilisable pour d'autres, ce qui n'a rien à voir avec de la POO. Or, si je ne m'abuse, le titre de ta question est "traiter des fichiers CSV en POO: quelle conception est mieux ?".
Donc la réponse est d'écrire un système de classes assez générales pour pouvoir être utilisé quelque soit la situation:

• indépendant de la source de données
• avec ou sans entête
• avec des caractères spéciaux différents (séparateur, protection, échappement)
• quelque soit le nombre de ligne (= lazy evaluation donc un generator et pas un array)
• vérifiant l'intégrité de la source (notamment le nombre constant de colonnes, car dans le cas contraire ce n'est pas un fichier CSV)
• pouvant être étendu pour l'écriture de données CSV

Et pas d'écrire la première cyberbouse qui fonctionne dans ton cas particulier et commençant par l'instruction class.

D'autre part, quelque chose de relativement restreint comme les données CSV est, à mon avis, un bon sujet d'étude pour se coller à la conception objet. (Plutôt que de se lancer bille en tête dans quelque chose de trop vaste qui te mèneras à l'abandon ou au n'importe quoi.)

[laurentSc]

quelque chose de relativement restreint comme les données CSV

Je suis dessus depuis septembre 2019 ! En fait, jamais fait de POO ni de MVC auparavant.

Mon code prend déjà en compte la plupart de tes critères (à part la taille évidemment).

cyberbouse

J'aime bien le terme

Vu la difficulté rencontrée pour suivre ton approche, je préfère rester sur une approche que je maîtrise davantage.

Je suis fort loin de ta compétence et même si j'ai bien apprécié tes conseils, je préfère rester sur un terrain que je maîtrise.

Au fait, l'expert en question, c'est rawsrc.