mysql fetch assoc VS tableau mysql fetch
Voici deux méthodes couramment utilisées dans la plupart des codes php pour extraire des données mysql.
mysql_fetch_array()mysql_fetch_assoc()
Maintenant, j'ai une grande base de données. Pour récupérer des données en boucle (while), quoi de plus rapide et de mieux?
J'ai trouvé ce repère .
Quel est ton choix?
Cela dépend de la configuration de vos tables:
mysql_fetch_array() renvoie essentiellement deux tableaux, l'un avec un index numérique et l'autre avec un index de chaîne associatif.
Donc, si vous utilisez mysql_fetch_array() sans spécifier MYSQL_ASSOC ou MYSQL_NUM, ou si vous spécifiez MYSQL_BOTH, vous renverrez deux tableaux (essentiellement ce que mysql_fetch_assoc() et mysql_fetch_row() renverraient) pour que mysql_fetch_assoc() soit plus rapide.
Si la configuration de votre table est correcte et que la requête est écrite correctement, mysql_fetch_assoc() est la voie à suivre, la lisibilité du code en ce qui concerne $result['username'] est plus facile à comprendre que $result[0].
La benchark montrée dans votre exemple utilise mysql_fetch_array () sans aucun argument pour spécifier MYSQL_ASSOC ou MYSQL_NUM. Par conséquent, sa valeur par défaut est MYSQL_BOTH ... cela faussera plutôt le résultat car il doit charger deux fois plus d'éléments de tableau que mysql_fetch_assoc (). Donc, je dirais que ce n'est pas une référence valide.
En réalité, il devrait y avoir très peu de choses à différencier entre mysql_fetch_array () avec MYSQL_ASSOC et mysql_fetch_assoc (), et ce ne sera certainement pas le plus gros overhead de votre script.
Je préfère fetch_assoc. Il retourne un "tableau associatif" (comme un dictionnaire python). Cela signifie que votre tableau est indexé par chaîne (dans mon cas habituel).
La valeur par défaut pour fetch_array donne à la fois des index numérotés et des index associatifs.
Mais je n’utilise jamais les index numérotés, alors j’aime l’obtenir un peu plus vite avec fetch_assoc
Ceci est le résultat de mysql_fetch_array ()
$row['fieldname'] = 'some value';
ou
$row[0] = some value';
Ceci est le résultat de mysql_fetch_assoc () ne renverra que
$row['fieldname'] = 'some value';
La "taille" des résultats de la requête importe peu dans ce cas.
mysql_fetch_array() génère généralement une surcharge en renvoyant un tableau associatif plus / résultats indexés.
Il faut décider du type de requête et des résultats souhaités sur l’utilisation de mysql_fetch_array() ou mysql_fetch_assoc().
Si les frais généraux sont "négligeables" et que je suis sûr que la requête aboutit et que je sais qu'il n'y a qu'un seul résultat, je le fais parfois:
$q = mysql_query('SELECT `column1`,`column2` FROM `table` WHERE `id` = 123');
list($column1,$column2) = mysql_fetch_array($q);
mysql_free_result($q);
Pour les procédures itératives (comme une boucle while), cela ne suffit pas. Lorsqu'il n'est pas nécessaire d'extraire rapidement les résultats (via un opérateur list) et que le résultat doit être traité ultérieurement dans le code, j'utilise toujours mysql_fetch_assoc() *.
* Lorsque forcé à réellement utilisez les fonctions de récupération de données procédurales obsolètes de PHP. Il existe des alternatives .
Un point supplémentaire à garder à l'esprit est que fetch_assoc() peut ne pas renvoyer toutes les colonnes que vous attendez. Si 2 colonnes de sortie ont le même nom, seule la dernière instance de cette colonne sera récupérée par fetch_assoc(). Par exemple, la requête suivante:
SELECT * FROM orders LEFT JOIN line_items ON orders.id = line_items.order_id
En supposant que les deux tables ont une colonne appelée id, le tableau associatif résultant aura une clé appelée id dont la valeur est définie sur line_items.id et vous ne pourrez pas extraire orders.id du résultat!
Vous pouvez contourner ce problème de noms de colonnes en double et continuer à utiliser fetch_assoc() en aliasant manuellement vos colonnes SELECT, en attribuant à chaque colonne un alias unique:
SELECT
o.id AS order_id, #unique alias
i.id AS line_item_id, #unique alias
o.date,
i.qty,
i.price
FROM orders o
LEFT JOIN line_items i ON i.order_id = o.id
Ou vous pouvez passer à l'aide de fetch_array(), ce qui vous permettra d'accéder à id par index au lieu de par clé
Bien http://php.net/manual/en/function.mysql-fetch-assoc.php states
Remarque: Performance
Il est important de noter que l’utilisation de mysql_fetch_assoc () n’est pas beaucoup plus lente que celle de mysql_fetch_row (), alors qu’elle apporte une valeur ajoutée non négligeable.
La différence ne devrait donc pas être une source d'inquiétude.
mysql_fetch_array () vs mysql_fetch_assoc ()
mysql_fetch_array (): Retourne un tableau qui correspond à la ligne récupérée et déplace le pointeur de données interne au-dessus. pour une meilleure documentation, cliquez ici! pour en savoir plus mysql_fetch_assoc (): équivaut à appeler mysql_fetch_array () avec MYSQL_ASSOC pour le second paramètre facultatif. Il ne retourne qu'un tableau associatif.
mysql_fetch_assoc() serait probablement le meilleur choix. Il y a une légère baisse des performances (l'extension mysql doit rechercher les noms des colonnes, mais cela ne devrait se produire qu'une fois, quel que soit le nombre de lignes que vous avez), mais probablement pas assez pour justifier l'utilisation de mysql_fetch_array() à la place. mysql_fetch_array() peut être utile si vous ne sélectionnez qu'une colonne.
Je suppose que cela dépend de votre définition de gros. À partir de ce point de repère, vous pouvez constater que ce n’est qu’avant d’effectuer plus de 1 000 000 000 de reprises que vous obtenez réellement une différence mesurable. Votre base de données est-elle si grosse? Sinon, choisissez ce qui est plus facile à utiliser (c'est-à-dire aller chercher un tableau associatif).
Un autre point à prendre en compte, s’il est si grand qu’il existe une différence mesurable, alors je trouverais un moyen d’utiliser des fonctions de ce type ensemble. Pensez à utiliser MySQLi ou encore mieux à utiliser PDO!