array

PHP: Come creare un array di etichette da una tabella dati

di

Può capitare di dover generare report di etichette, per esempio codici a barre, da una tabella normalizzata contenente i valori delle quantità in un campo. A noi, però, serve poter stampare tante etichette quanto è il valore ‘quantità’ di ogni singolo pezzo.
Ora, sebbene normalmente sia sufficiente, per ogni record, ciclare tante volte per il valore del campo quantità, in certi casi potrebbe essere comodo avere una funzione che fa questo per noi. In particolar modo quando è necessario utilizzare parecchie volte questa procedura.

Immaginiamo di avere una tabella come la seguente, risultato magari di una SELECT

rifnomecodiceqta
a001chiodichd0013
a001vitivt0012
a002rivettirvt0014
a002puntept0011

Simuliamo di aver immagazzinato la query in un array multidimensionale associativo, attraverso l’istruzione mysql_fetch_array:

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

$data=array
(
    0 => array
        (
            'rif' => 'a001',
            'nome' => 'chiodi',
            'codice' => 'chd001',
            'qta' => 3
        ),
    1 => array
        (
            'rif' => 'a001',
            'nome' => 'viti',
            'codice' => 'vt001',
            'qta' => 2
        ),
    2 => array
        (
            'rif' => 'a002',
            'nome' => 'rivetti',
            'codice' => 'rvt001',
            'qta' => 4
        ),
    3 => array
        (
            'rif' => 'a002',
            'nome' => 'punte',
            'codice' => 'pt001',
            'qta' => 1
        )
);

Lo sviluppo della funzione prevede, come dati di input: l’array dei dati, il nome del campo che contiene le quantità, e il nome dei due campi in base ai quali ordinare l’array.
Ovviamente è possibile modificare questo codice per permettere l’ordinamento con un maggior numero di chiavi. In output la funzione fornisce l’array delle etichette già ordinato.

Vediamo il codice:

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

function labelmaker($table,$qty,
                    $order1,$order2,
                    $typeorder1=SORT_ASC,
                    $typeorder2=SORT_ASC)
{
  $newdata=array(); // array di appoggio
  $max=count($table);
  for($i=0;$i<$max;$i++){
    foreach ($table[$i] as $k => $value) {
      if($k==$qty && $value>1)
      {
        $q=$table[$i][$k];
        $table[$i][$k]=1;
        for($j=1;$j<$q;$j++)
        {
          array_push($newdata, $table[$i]);
        }
      }
    }
  }
//Unione dei due array
  $res = array_merge($table, $newdata);
// Ottiene un array di colonne per le chiavi
  foreach ($res as $key => $row) {
      $arrorder1[$key] = $row[$order1];
      $arrorder2[$key] = $row[$order2];
  }
// Ordina l'array in base alle chiavi
  array_multisort($arrorder1, $typeorder1,
        $arrorder2, $typeorder2, $res);
    return $res;
}

Note: la funzione accetta l’array in input passato come valore, e restituisce un nuovo array. Questo comporta inevitabilmente un consumo di memoria, in considerazione del fatto che
l’algoritmo prevede anche l’utilizzo di un array di ‘appoggio’, è bene utilizzare questa procedura per una mole di dati ragionevole!

Infine, la funzione viene fornita ‘as is’, senza controllo di errori, né prove efficaci in produzione.

Ecco come viene richiamata:

$lblarr= labelmaker($data,"qta",
         "rif","nome",SORT_ASC,SORT_ASC);

Mostriamo il risultato:

echo '<pre>';
print_r($lblarr);
echo '</pre>';

E questo è il risultato:

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

Array
(
    [0] => Array
        (
            [rif] => a001
            [nome] => chiodi
            [codice] => chd001
            [qta] => 1
        )
    [1] => Array
        (
            [rif] => a001
            [nome] => chiodi
            [codice] => chd001
            [qta] => 1
        )
    [2] => Array
        (
            [rif] => a001
            [nome] => chiodi
            [codice] => chd001
            [qta] => 1
        )
    [3] => Array
        (
            [rif] => a001
            [nome] => viti
            [codice] => vt001
            [qta] => 1
        )
    [4] => Array
        (
            [rif] => a001
            [nome] => viti
            [codice] => vt001
            [qta] => 1
        )
    [5] => Array
        (
            [rif] => a002
            [nome] => punte
            [codice] => pt001
            [qta] => 1
        )
    [6] => Array
        (
            [rif] => a002
            [nome] => rivetti
            [codice] => rvt001
            [qta] => 1
        )
    [7] => Array
        (
            [rif] => a002
            [nome] => rivetti
            [codice] => rvt001
            [qta] => 1
        )
    [8] => Array
        (
            [rif] => a002
            [nome] => rivetti
            [codice] => rvt001
            [qta] => 1
        )
    [9] => Array
        (
            [rif] => a002
            [nome] => rivetti
            [codice] => rvt001
            [qta] => 1
        )
)

Conclusioni:

Questa funzione può costituire il prototipo per tutti i casi in
cui si ha la necessità di produrre stampe di etichette, da assegnare a singoli pezzi,
in modo direttamente proporzionale ad un certo quantitativo definito in tabella.

Riferimenti ed approfondimenti: