Discussion :

[laurentSc]

Bonsoir,

je lis un fichier CSV et je compte analyser chaque colonne. Ce que je pensais faire, c'est créer une classe pour chaque colonne, comme ça :

Code php :

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

1
2
3
4
5
6
7
 
while (false !== ($fields = fgetcsv($handle, $buffer, $this->sep)) ) {     
                $line_csv=[];    
                $line_csv[0]=new Field0($fields[0]);
                $line_csv[1]=new Field1($fields[1]);
                ...
                $line_csv[23]=new Field23($fields[23]);

donc pour la colonne X $line_csv[X]=new FieldX($fields[X]); avec la classe FieldX :
FieldX :

Code php :

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
<?php
namespace Classes\Olivier;
 
 
class FieldX
{
    private $name;
   /* Constructor */
public function __construct($value)
  {
    if (is_string($value))
        $this->name=$value;
  }
 
public function __tostring()
  {
      return($this->name);
  }    
} //end FieldX

Ca fait un code sacrément lourd (et plein de boulot). Comme je pense (et espère) qu'on peut faire mieux, j'ai pas été loin. Quelle amélioration me proposez-vous ?

[rawsrc]

salut Laurent

parser un CSV avec 24 colonnes=24 classes ?

tu dérailles ou quoi ?
Ce n'est parce que tu t'es mis à la prog objet qu'il faut te sentir obligé de pondre des classes à tout bout de champ !
Bon sens, raisonnement et simplicité : voilà, ce que tu dois utiliser en premier.

Alors fais toi une simple fonction de validation d'un ligne du csv et puis c'est tout : utilise les closures si tu veux mais par pitié ne t'embarque pas dans 24 classes !

[laurentSc]

Non, je ne déraille pas et il était clair que c'était lourdingue, donc je me suis très vite arrêté mais je n'avais pas d'idée comment faire simple et j'avoue que je sèche encore ; peux-tu préciser comment utiliser les closures ?

[rawsrc]

liste d'abord les tests de validation que tu souhaites faire.

[laurentSc]

En fait, pour l'instant, je ne vois que des tests de type (is_string ou is_integer ou une date (je sais faire)) avec éventuellement au préalable une manipulation (exemple : un champ "id" avec un préfixe INC, donc d'abord supprimer le préfixe puis vérifier si le reste est bien integer).

[rawsrc]

pour les tests natifs, t'as besoin de rien pour ceux qui nécessitent un peu plus, tu peux faire dans ce style (closure) :

Code :

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

1
2
3
4
5
6
7
8
9
$is_date = function($date): bool {
    $formats = ['M d, Y', 'M d Y', 'M d', 'M-d'];
    foreach ($formats as $f) {
        if (\DateTime::createFromFormat($f, $date) !== false) {
            return true;
        }
    }
    return false;
};

[grunk]

Il faut vraiment que tu t'entraines à penser objet.

A quel moment avoir des classes Field0,1,2 ... semble une représentation logique ? A la limite tu peux avoir une classe qui représente un champs , donc une classe Field , mais elle est unique pour tous les champs.

Tu pourrais imaginer quelque chose comme :

Code :

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

1
2
3
4
5
$field1 = new Field($fields[0]);
$field1->isValid('string');
 
$field2 = new Field($fields[1]);
$field2->isValid('date');

Mais on tombe dans le cas où on créer des objets pour le plaisir de créer des objets et ça devient contre productif.
Creer un objet ça à un coût (en ram, en cpu et temps de développement), certes minime mais il existe. Donc si on peut obtenir un code tout aussi clair et fonctionnel sans objet , autant s'en passer.

Comme le dit rawsrc tu peux tout à fait utiliser directement les fonction du langage.

Si tu veux structurer un peu tu peu avoir une classe utilitaire Validator avec des fonctions statique du genre : Validator::isString() , Validator::isDate() que tu peux utiliser à ta guise.

[laurentSc]

Je n'ai jamais pensé que créer une collection de classes était logique. Par contre, ne voyant pas comment coder, j'ai mis la seule chose qui me passait par la tête, pour montrer où j'en étais.
Maintenant, j'essaie d'utiliser vos conseils. Ce que j'en ai déduit (dite-moi si je suis sur la bonne voie), c'est de créer une classe utilitaire avec des propriétés statiques qui seraient des closures.
Voici où j'en suis ; l'éditeur me dit

Constant expression contains invalid operations

Code php :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class Validator
{//propriété statique closure
    private static $is_date = function($date): bool {
        $formats = ['M d, Y', 'M d Y', 'M d', 'M-d'];
        foreach ($formats as $f) {
            if (\DateTime::createFromFormat($f, $date) !== false) {
                return true;
            }
        }
        return false;
    };
}
 
$date=Validator::$is_date;

[rawsrc]

cette syntaxe n'est pas possible.

Si tu veux absolument une classe : inspire toi du conseil :

Si tu veux structurer un peu tu peu avoir une classe utilitaire Validator avec des fonctions statique du genre : Validator::isString() , Validator::isDate() que tu peux utiliser à ta guise.

[grunk]

C'est soit closure , soit classe mais pas les deux mélangés.
Le quoi choisir est une question de de préférence personnelle.

[rawsrc]

personnellement j'utilise les deux mixés : j'ai une classe de validation avec des composants enfichables qui sont des closures.
Cela te permet de rajouter très facilement des validateurs perso dans un système de validation générique.

[grunk]

personnellement j'utilise les deux mixés : j'ai une classe de validation avec des composants enfichables qui sont des closures.
Cela te permet de rajouter très facilement des validateurs perso dans un système de validation générique.

On parle de LaurentSC là
Il me semble important d'éviter de mélanger trop de notions

[Invité]

On parle de LaurentSC là

laurentSc, alias frankensteinSc !
Donnez-lui des bouts de code, il en fait un MONSTRE !!

C'est aussi pour "ça" qu'on l'aime / l'apprécie / le supporte !
Toujours imprévisible !!

Sacré Laurent !! (N.B. ça va mieux, ta jambe ? Tu t'es remis au sport ?)

• https://vercorshandisport.org/vhs/20...ns-le-luberon/

Sincèrement :

[laurentSc]

ça va mieux, ta jambe ? Tu t'es remis au sport ?

Si j'ai pas répondu vite, c'est que ce matin, sortie de ski de fond (le vendredi, je travaille pas)(chez moi (Vercors) y a un peu de neige et la nuit ça gèle, donc là où y a des canons, ils les font tourner). Cet après-midi, rien à voir avec le sport...

[Invité]

...donc là où y a des canons...

Moi, les canons, je les bois !!
A ta santé !!!

[Trehinos]

Pour rester sur une sémantique de Field plutôt que de Validator, pourquoi ne pas faire un tableau d'objets ? Surtout que ce numéro ne semble avoir aucune incidence sur le corps de la classe...

Une remarque sur le code de base : (false !== condition) est inutile ici, un array non vide est évalué à true dans un while.
Une remarque sur "les" classe(s) : une seule classe Field, devrait suffire. S'il faut pouvoir distinguer les objets, il suffit d'ajouter une propriété $name et bien sûr renommer l'actuel $name en $value puisqu'elle contient la valeur et non le "nom" du champ.

Code PHP :

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
<?php
use Classes\Olivier\Field;
 
// load $handle
 
$first = true;
$names = [];
while ($fields = fgetcsv($handle, $buffer, $this->sep)) { // 0 plutôt que $buffer serait plus simple...
 
    // Si la première ligne contient les titres des colonnes, sinon supprimer le bloc
    if ($first) {
        foreach ($fields as $field) {
            $names[] = $field;
        }
        $first = false;
        continue;
    }
 
    // On fait une itération sur chaque élément de $fields qui est un array
    $line_csv = [];
    $index = 0;
    foreach ($fields as $field) {
        $line_csv[] = new Field($names[$index++], $field);
    }
 
    // se servir de $line_csv (j'imagine)
    // ici on peut faire
    $field = $line_csv[$index_quelconque];
    $fieldName = $field->getName();
    $fieldValue = "$field";
 
}

Code PHP :

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
<?php
namespace Classes\Olivier;
 
class Field // pas de X
{
    private $name;
    private $value;
 
    // Constructor
    public function __construct(string $name, string $value)
    {
        // Pas besoin de is_string() en PHP 7
        $this->name = $name;
        $this->value = $value;
    }
 
    public function getName() : string
    {
        return $this->name;
    }
 
    public function __tostring() // un getValue(): string aurait une plus forte sémantique que __toString() (qui est ambigüe du point de vue utilisateur :
    {                                      //                                                                on affiche value, name, les deux ?)
        return $this->value;
    }
}

Reste à valider les lignes (count($names) === count($line_csv) par exemple et remplacer $names[$index++] par $names[$index++] ?? '')
et à valider les champs (en méthodes de classe static public function isString(): bool, static public function isDate(): bool par exemple, ou séparer la sémantique de Validator comme proposé).