Les boucles sont-elles le meilleur moyen de construire une table?

Question

Je dois construire un tableau HTML qui montre les données pour les utilisateurs par rapport aux pages visitées. Il semble klunky à utiliser pour et/ou foreach boucles, mais je ne peux pas penser à quelque chose de mieux. J'utilise PHP, mais je suppose que c'est un langage agnostique.

Answer 1

éviter des boucles est probablement pas possible, sinon la mise en œuvre, il se produira encore au niveau de la machine.

Cependant, si vous voulez essayer de rester « pur » sans le code méchant, vous pouvez au moins faire:

$tableformat = '<table><thead>%s</thead><tbody>%s</tbody></table>'; 
$rowformat = '<tr>%s</tr>'; 
$cellformat = '<td>%s</td>'; 

$hdata = ''; 
foreach($data[0] as $cellname => $cellvalue) 
{ 
    $hdata .= sprintf($cellformat, $cellname); 
} 
$hdata = sprintf($rowformat, $hdata); 
$rdata = ""; 
foreach($data as $rownum => $rowvalue) 
{ 
    $row = ""; 
    foreach($rowvalue as $colname => $colvalue) 
    { 
     $row .= sprintf($cellformat, $colvalue); 
    } 
    $rdata .= sprintf($rowformat,$row); 
} 
return sprintf($tableformat, $hdata, $rdata); 

Au moins de cette façon, il pourrait être un peu maintenable. et vous ne vous inquiétez pas des chaînes incomplètes.

Vous pouvez également subsitutue une partie de ce code avec

$hdata = "<tr><td>" . implode("</td><td>", array_keys($data[0])) . "</td></tr>"; 
    $rdata .= "<tr><td>" . implode("</td><td>", $rowvalue) . "</td></tr>"; 

qui, tout en étant assez concise, sera peut-être vous mettre dans un peu d'eau chaude par la suite et il aura besoin recodage. (et implode en interne exécute une boucle, donc c'est un perdre-perdre).

Si cela ne vous dérange pas la tête sur des appels de fonctions supplémentaires (et encore des boucles en cours d'exécution), cela pourrait faire pour le code plus concis, sans trop de points négatifs:

$tableformat = '<table><thead>%s</thead><tbody>%s</tbody></table>'; 
$rowformat = '<tr>%s</tr>'; 
$cellformat = '<td>%s</td>'; 

function tr($cells) 
{ 
    $o = ""; 
    foreach($cells as $i => $v) 
    { 
     $o .= sprintf($cellformat, $v); 
    } 
    return sprintf($rowformat, $o); 
} 


return sprintf($tableformat, 
       tr(array_keys($data[0])), 
       implode("", array_map('tr', $data))); 

Mais attention, thats difficile à lire, et vous gardez cela un jour, vous vous réveillerez avec un zézaiement.

Answer 2

Eh bien, si vous avez plusieurs lignes, avec des données formatées de façon similaire dans chaque ligne, je ne peux pas penser à un moyen de créer une table qui évite d'utiliser une boucle. Ce genre de chose est essentiellement ce pour quoi les boucles ont été inventées.

Si vous nous avez donné plus de détails sur la table que vous voulez construire, peut-être que nous pouvons formuler une meilleure méthode.

Answer 3

Si vous n'utilisez pas une sorte de boucle alors vous devrez câbler le nombre de lignes et de colonnes dans votre code, ce qui est probablement une idée

Answer 4

bien pire Si les données de la table est dynamique alors vous devez utiliser une boucle. Même si vous obtenez un composant qui génère la table pour vous, il utilisera une boucle en interne.

Answer 5

Cela dépend de votre définition de «meilleur». Les boucles FOR feront bien l'affaire. Je ne suis pas un programmeur PHP, mais en .NET, vous pouvez utiliser le Répéteur, une sorte de modèle que vous pouvez utiliser pour déclarer la table HTML. Il a des modèles pour l'en-tête, le pied de page et chaque élément. Vous liez une source de données au répéteur, et il générera la table HTML pour vous un peu plus élégamment que d'utiliser des boucles FOR. J'imagine qu'il pourrait y avoir une sorte d'équivalent templating en PHP.

En fin de compte, cependant, même le répéteur utilise une sorte de boucle ...

Answer 6

Je recommande fortement le moteur de template Smarty pour PHP. Cela vous permettra de déplacer votre table (et la boucle associée, qui est inévitable) dans le modèle en utilisant la syntaxe Smarty, afin qu'elle soit plus claire et plus séparée de votre logique métier. Vous pourriez remplacer presque tout le code de votre exemple par quelques balises simples dans un extrait de code HTML. Découvrez le cours intensif sur la page Smarty pour un exemple d'utilisation d'une table.

Answer 7

J'utilise généralement des boucles et implode pour cela, en PHP. Dans un langage qui supporte la programmation fonctionnelle, je le ferais différemment.

function render_table($data) { 
    $html = '<table>'; 
    $tr = array(); 
    foreach (array_keys($data[0]) as $key) { 
    $tr[] = '<th>' . htmlspecialchars($key) . '</th>'; 
    } 
    $html .= "\n" . '<thead>' . "\n" . '<tr>' . "\n" . implode("\n", $tr) . '</tr>' . '</thead>'; 
    $tbody = array(); 
    foreach ($data as $row) { 
    $tr = array(); 
    foreach ($row as $value) { 
     $tr[] = '<td>' . htmlspecialchars($value) . '</td>'; 
    } 
    $tbody[] = '<tr>' . "\n" . implode("\n", $tr) . '</tr>'; 
    } 
    $html .= "\n" . '<tbody>' . "\n" . implode("\n", $tbody) . '</tbody>'; 
    $html .= '</table>'; 
    return $html; 
} 

Answer 8

Pourquoi voulez-vous éviter les boucles? Si vous avez un ensemble d'éléments et que vous souhaitez afficher chaque élément, il est évident que la boucle est la solution évidente.

Si vous essayez de séparer le modèle de la vue ou d'écrire un code plus lisible, c'est bien; mais les boucles ne sont pas intrinsèquement mauvaises.