[Tableaux] Optimisation

Version imprimable

26/01/2006, 00h38
marcha

[Tableaux] Optimisation
Bonjour,

J'ai une fonction qui me retourne le nième mot d'une chaine. Les
mots sont séparés par des underscore.

Pour l'instant je fait ceci:
Code:

1 2 3 4 5 6 7 function getMot($chaine, $n) { $mots = explode('_', $chaine); return $mots[$n]; } $mot = getMot("mot0_mot1_mot2_mot3", 2);
Dans ce cas, $mot vaut "mot2"

J'utilise cette fonction bcp de fois par requête.

Ma question est, y'a-t-il une technique plus rapide pour faire ça ?
26/01/2006, 01h00
ePoX

Citation:

J'utilise cette fonction bcp de fois par requête.

Peut être qu'il serait plus interessant d'optimiser cette partie du script ?

Parceque la fonction je ne voi pas trop quoi modifier à part un passage par référence.... Mais dans ce cas précis j'ai le sentiment que c'est une optimisation de pauvre.

Sinon en utilisant les expression regilère on pourrais faire même chose mais je ne sais pas si c'est plus rapide :/ (j'en doute un peu d'ailleurs)
26/01/2006, 01h57
marcha

regexp, peut-être :)

le explode c'est lent, ça crée un tableau en mémoire, ce qui n'est
pas utile dans mon cas.

peux être avec des strpos successifs et un substr ça peut être meilleur.

qqn sait comment faire une regexp pour extraire un nième mot ?
26/01/2006, 09h35
gofono_bass

salut,
moi aussi je doute un peu du fait que les regexp soient plus interessants pour toi,

Citation:

Il faut toujours privilégier la fonction standard PHP à la création d'une regex effectuant le même travail.

(lu sur www.expreg.com)

Je propose cette solution. A benchmarker...

Code:

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
 
<pre><?php
 
function getMot($chaine, $nb) {
    if ($nb >= 0) {
        $start = 0;
        $count = 0;
        while(($end = strpos($chaine, '_', $start)) !== FALSE && $count++ < $nb) {
            $start = $end + 1;
        }
        if ($end === FALSE) {
            if ($nb === $count) {
                return substr($chaine, $start);
            }
        } else {
            return substr($chaine, $start, $end - $start);
        }
    }
    return false;
}
 
var_dump(getMot("mot0_mot1_mot2_mot3", -1)); 
var_dump(getMot("mot0_mot1_mot2_mot3", 0)); 
var_dump(getMot("mot0_mot1_mot2_mot3", 1)); 
var_dump(getMot("mot0_mot1_mot2_mot3", 2)); 
var_dump(getMot("mot0_mot1_mot2_mot3", 3)); 
var_dump(getMot("mot0_mot1_mot2_mot3", 4)); 
 
?>

Ce qui me donne :

Code:

1
2
3
4
5
6
bool(false)
string(4) "mot0"
string(4) "mot1"
string(4) "mot2"
string(4) "mot3"
bool(false)

26/01/2006, 12h02
gofono_bass

je pense que la solution de Mr N est meiux que les regexp, elle utilise les fontions standard sur les string (substr) qui sont plus rapides et plsu legeres que les regexp

Bon ben le benchmark n'est pas en ma faveur ! =>

Code:

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
<pre><?php
 
function microtime_float()
{
  list($usec, $sec) = explode(" ", microtime());
  return ((float)$usec + (float)$sec);
}
$iterations = 10000;
 
 
function getMot1($chaine, $nb) {
    if ($nb >= 0) {
        $start = 0;
        $count = 0;
        while(($end = strpos($chaine, '_', $start)) !== FALSE && $count++ < $nb) {
            $start = $end + 1;
        }
        if ($end === FALSE) {
            if ($nb === $count) {
                return substr($chaine, $start);
            }
        } else {
            return substr($chaine, $start, $end - $start);
        }
    }
    return false;
}
 
$start = microtime_float();
for($i = 0 ; $i < $iterations ; $i++) {
    getMot1("mot0_mot1_mot2_mot3", -1); 
    getMot1("mot0_mot1_mot2_mot3", 0); 
    getMot1("mot0_mot1_mot2_mot3", 1); 
    getMot1("mot0_mot1_mot2_mot3", 2); 
    getMot1("mot0_mot1_mot2_mot3", 3); 
    getMot1("mot0_mot1_mot2_mot3", 4); 
}
var_dump('strpos: '.(microtime_float()-$start));
 
 
 
function getMot2($chaine, $n) {
  $mots = explode('_', $chaine);
  return @$mots[$n];
} 
 
$start = microtime_float();
for($i = 0 ; $i < $iterations ; $i++) {
    getMot2("mot0_mot1_mot2_mot3", -1); 
    getMot2("mot0_mot1_mot2_mot3", 0); 
    getMot2("mot0_mot1_mot2_mot3", 1); 
    getMot2("mot0_mot1_mot2_mot3", 2); 
    getMot2("mot0_mot1_mot2_mot3", 3); 
    getMot2("mot0_mot1_mot2_mot3", 4); 
}
var_dump('explode: '.(microtime_float()-$start));
 
?>

Ce qui donne :

Code:

1
2
string(24) "strpos: 0.56960797309875"
string(25) "explode: 0.40343880653381"

Par contre c'est l'inverse avec 109 mots :
Code:

1 2 string(24) "strpos: 0.63147401809692" string(24) "explode: 2.6236159801483"

26/01/2006, 13h23
Yogui

Bonjour
Peut-être que l'optimisation pourrait être appliquée en amont, lors de la création de la chaîne à exploser ? J'opterais plutôt pour des tableaux les uns dans les autres.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
string(17) "chaine: moto_moto"
string(24) "strpos: 0.44666600227356"
string(25) "explode: 0.41120791435242"
string(27) "chaine: moto_moto_moto_moto"
string(24) "strpos: 0.59903693199158"
string(25) "explode: 0.49221301078796"
string(47) "chaine: moto_moto_moto_moto_moto_moto_moto_moto"
string(24) "strpos: 0.61698222160339"
string(25) "explode: 0.50959300994873"
string(87) "chaine: moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto"
string(24) "strpos: 0.68266797065735"
string(25) "explode: 0.69452905654907"
string(167) "chaine: moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto_moto"
string(24) "strpos: 0.74992990493774"
string(24) "explode: 1.0116171836853"

Conclusion : A partir de 15 mots => strpos, en dessous => explode...

Arf Mr.N, je vois qu'on a travaillé en parallel :) j'ai aussi fait mon
petit prog de mesure :-)

Code:

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
<?
function microtime_float() {
  list($usec, $sec) = explode(" ", microtime());
  return ((float)$usec + (float)$sec);
}
 
function getMot1($chaine, $n) {
  $mots = explode('_', $chaine);
  return $mots[$n];
}
 
function getMot2($chaine, $nb) {
    if ($nb >= 0) {
        $start = 0;
        $count = 0;
        while(($end = strpos($chaine, '_', $start)) !== FALSE && $count++ < $nb) {
            $start = $end + 1;
        }
        if ($end === FALSE) {
            if ($nb === $count) {
                return substr($chaine, $start);
            }
        } else {
            return substr($chaine, $start, $end - $start);
        }
    }
    return false;
}
 
function getMot3($chaine, $nb) {
	$start = 0;
	for($i=0;$i<$nb;$i++) {
		if( ($next=strpos($chaine, '_', $start)) === false ) break;
		$start = $next+1;		
	}
	$end = strpos($chaine, '_', $start);
	if($end) return substr($chaine, $start, $end - $start);
	return substr($chaine, $start);
}
 
function compare($chaine, $n) {
	$loops = 10000;
	echo "<h2>TEST: $chaine $n</h2>";
 
	$start = microtime_float();
	for($i=0;$i<$loops;$i++) getMot1($chaine, $n);
	$dur = (microtime_float() - $start);
	echo "getMot1 (explode)".$dur."<br>";
 
	$start = microtime_float();
	for($i=0;$i<$loops;$i++) getMot2($chaine, $n);
	$dur = (microtime_float() - $start);
	echo "getMot2 (substr 1)".$dur."<br>";
 
	$start = microtime_float();
	for($i=0;$i<$loops;$i++) getMot3($chaine, $n);	
	$dur = (microtime_float() - $start);
	echo "getMot3 (substr 2)".$dur."<br>";
 
	echo "<br>";
}
 
set_time_limit (200);
echo "<h1>Mots longs</h1>";
compare("hshdjkashjkdhaskjdasda_asdaskdhkashdjkashjkdhas_asdhasjdhasjkhdjkashd_asdaskdkashdjkhasjkdhk_asdjashjdhasjkhdjk", 0);
compare("hshdjkashjkdhaskjdasda_asdaskdhkashdjkashjkdhas_asdhasjdhasjkhdjkashd_asdaskdkashdjkhasjkdhk_asdjashjdhasjkhdjk", 1);
compare("hshdjkashjkdhaskjdasda_asdaskdhkashdjkashjkdhas_asdhasjdhasjkhdjkashd_asdaskdkashdjkhasjkdhk_asdjashjdhasjkhdjk", 2);
compare("hshdjkashjkdhaskjdasda_asdaskdhkashdjkashjkdhas_asdhasjdhasjkhdjkashd_asdaskdkashdjkhasjkdhk_asdjashjdhasjkhdjk", 3);
compare("hshdjkashjkdhaskjdasda_asdaskdhkashdjkashjkdhas_asdhasjdhasjkhdjkashd_asdaskdkashdjkhasjkdhk_asdjashjdhasjkhdjk", 4);
echo "<h1>Mots courts</h1>";
compare("a_b_c_d", 0);
compare("a_b_c_d", 1);
compare("a_b_c_d", 2);
compare("a_b_c_d", 3);
/*
var_dump(getMot3("mot0_mot1_mot2_mot3", -1));
var_dump(getMot3("mot0_mot1_mot2_mot3", 0));
var_dump(getMot3("mot0_mot1_mot2_mot3", 1));
var_dump(getMot3("mot0_mot1_mot2_mot3", 2));
var_dump(getMot3("mot0_mot1_mot2_mot3", 3));
var_dump(getMot3("mot0_mot1_mot2_mot3", 4));
*/
 
 
?>

En effet, le explode est plus rapide, j'ai essayé une variante de
ta fonction, mais ça donne rien de sérieux.

Je pense que le explode est plus rapide parce que il y a moins de
code PHP à "interpreter", (même si c'est plus ou moins compilé)

Mais je reste persuadé que la création d'une table est lente, et
qu'il y a peut être moyen de faire des regexp.

Je suis une pince en regexp, mais je pense qu'il doit être possible
de construire une regexp d'après le paramètre $n (qui indique le mot
à extraire). et de lancer celle-ci, mais d'apres ce que j'en connais, les
regexp retourne les résultats dans un tableau, du coup ça n'a pas
grand intérêt. A moins qu'il y aie une autre possiblité ?

26/01/2006, 14h43
gofono_bass

Je persiste a dire que les regexp sont plus lourdes et plus lentes...
26/01/2006, 14h45
marcha

Moi je ne crois que ce que je mesure :-)
26/01/2006, 14h50
Kioob

Mr N : au lieu de repartir au début de la chaine à chaque fois, ne vaudrait il pas mieux repartir de là où le précédent appel s'est arrêté ?

Je suppose qu'il y a moyen de gagner pas mal d'itérations là dessus...
26/01/2006, 15h02
Mr N.

Citation:

Envoyé par marcha

En effet, le explode est plus rapide,

Si tu regarde mon dernier test, il est plus rapide pour une chaine avec un petit (< 10-15) nombre de mots. Au delà, il faut préférer le strpos.

Citation:

Envoyé par Kioob

au lieu de repartir au début de la chaine à chaque fois, ne vaudrait il pas mieux repartir de là où le précédent appel s'est arrêté ?

Euh ben tout dépend de l'utilisation... c'est vrai que si on fait une boucle pour récupérer les mots un par un c'est tout à fait pertinent, mais si l'appel se fait une fois sur un index au pif ca l'est moins...
26/01/2006, 15h30
Kioob

à priori ici c'est pour extraire des données d'une base de données, donc il prendra tous les mots, non ?
26/01/2006, 15h53
Mr N.

Citation:

Envoyé par Kioob

à priori ici c'est pour extraire des données d'une base de données, donc il prendra tous les mots, non ?

vi. J'avais lu en diagonale le sujet de départ :oops:
26/01/2006, 17h04
marcha

J'ai pas vraiment précisé l'utilisation et m'en excuse, je voulais pas charger.

En fait j'utilise ça pour des traductions, par exemple:

define('TXT_FIRSTNAME', 'Prénom_Firstname_Vorname');
define('LANGUAGES', 'fr,en,de');

echo translate(TXT_FIRSTNAME, en);

la fonction translate recherche la position de 'en' dans Languages puis
extrait le mot de TXT_FIRSTNAME à cette même position.

C'est une technique parmis d'autre pour les traductions. J'utilise aussi le
chargement (include) d'un fichiers php propre à chaque langue:

fr-textes.php:
define('TXT_FIRSTNAME', 'Prénom');

en-textes.php:
define('TXT_FIRSTNAME', 'Firstname');

etc...

Dans ce cas, je n'inclu que le fichier de la langue voulue.

Merci à tous pour vos suggestions.
26/01/2006, 17h11
Mr N.

il y a aussi strtok ...
26/01/2006, 17h34
marcha
Merci Mr.N.
Code:

1 2 3 4 5 function getMot3($chaine, $nb) { $tok = strtok($chaine, '_'); while($nb-->0) $tok = strtok('_'); return $tok; }
C'est plus rapide que explode pour 2 mots de taille normale, après ça
devient plus lent.

ça reste une solution intéressante si je n'ai que 3 langues, étant donné
que la langue la plus courrante est placée en premier dans mes listes.
27/01/2006, 11h18
Yogui

Salut

Pfiou, je n'aurais jamais cherché aussi complexe (à développer) pour faire des traductions :/
J'aime bien les fichiers séparés, pour ma part. La doc PHP préconise l'utilisation de l'extension gettext mais je n'en suis pas fan...
27/01/2006, 12h38
Mr N.

Citation:

Envoyé par Kirkis

La doc PHP préconise l'utilisation de l'extension gettext mais je n'en suis pas fan...

Pourquoi ? Ton avis m'intéresse :)
27/01/2006, 13h23
Yogui

Citation:

Envoyé par Mr N.

Citation:

Envoyé par Kirkis

La doc PHP préconise l'utilisation de l'extension gettext mais je n'en suis pas fan...

Pourquoi ? Ton avis m'intéresse :)

Hmmm, simplement parce que si tu modifies le texte dans la langue par défaut (même une simple coquille, une espace ou quoi que ce soit), tu es obligé de modifier de la même manière absolument tous les fichiers de traduction...
Si tu utilisais simplement des tableaux associatifs, il est peu probable que tu veuilles un jour changer les clefs de tes tableaux !

[Edit] Pour faire une analogie approximative, gettext() gère plus ou moins le texte d'une page comme des clefs d'un tableau associatif... Si tu modifies le texte, la clef n'est plus la même et gettext() ne trouve pas la traduction.
Reprenez-moi si je me trompe !
27/01/2006, 19h57
Mr N.

Oui je suis d'accord, mais l'avantage est que tu peux lire ton code avec le message à traduire en clair, plutot que de passer par des clefs qui ne sont pas forcément pertinente...
27/01/2006, 21h00
FrankOVD

Dépendament de comment tu arrive a avoir une chaine du genre moto_moto_moto_moto il serait plus efficace de placer au départ tous les mots dans un tableau. À moins bien sûr que ce ne soit pas la même chaine à chaque fois que tu appelle ta fonction.
28/01/2006, 00h07
marcha

Citation:

Envoyé par FrankOVD

Dépendament de comment tu arrive a avoir une chaine du genre moto_moto_moto_moto il serait plus efficace de placer au départ tous les mots dans un tableau. À moins bien sûr que ce ne soit pas la même chaine à chaque fois que tu appelle ta fonction.

C'est une remarque intéressante qui va ouvrir un nouveau débat :-)

Supposons la situation suivante, j'ai un fichier php avec quelques define
pour associer des clés à des textes en plusieurs langues, par exemple:

define('TXT_RED', 'Rouge_Red_Rot');
...

Dans ce cas il faut une fonction comme celle qu'on a débatu dans ce post
pour extraire le mot dans la bonne langue.

L'autre approche dont tu parles ressemble à ceci, si j'ai bien compris:

$traductions['TXT_RED'] = array('Rouge', 'Red', 'Rot');
...

Je pense que la recherche dans un tableau est très rapide.
Par contre je pense que l'initialisation du tableau $traductions
est plus lente que des define (c'est une supposition, mais ça me
parait raisonnable)

Donc, dans le cas d'un fichier de traduction, il arrive souvent que
tous les mots qui s'y trouvent ne soient pas utilisés par chaque
requêtes. pourtant ils sont tous parsés, compilés, instanciés à chaque
requête.

Quant à l'utilisation de ces mots, elle est souvent unique, par exemple
les libellés des champs d'un formulaire d'édition, les messages d'erreur,
les libellés des boutons.

Je pense qu'il est préférable d'utiliser des define plutot qu'un tableau associatif pour les traductions, vos avis sur la question m'intéressent :-)
28/01/2006, 11h14
Mr N.

+1 ePox
Et aussi n'inclure que les fichiers de langues spécifiques à l'action effectuée. Par exemple, dans le cas d'un e-commerce, pas la peine d'inclure les fichiers de langues concernant la commande si l'utilisateur affiche la description d'un produit.
29/01/2006, 00h00
marcha

Vos remarques sont tout a fait justifiées. J'utilise
les fichiers séparés de define pour les mots récurrents, du genre
ok, annuler, envoyer, supprimer etc...

A l'autre extrême, il y a les messages d'erreurs, ceux-ci sont très rarement
affichés et ne devrait pas être chargés tant qu'ils ne sont pas nécessaires.

La technique des fichiers séparés dans ce cas, produit trop de fichiers. Je
préfère qqch du genre: die(translate('erreur_error_fehler'));

Donc ma question initiale ne concernait qu'une partie de mes traductions,
celle des mots qui ne sont pas assez utilisisés pour être centralisés dans des
fichiers séparés.