[Tableaux] Optimisation

**marcha** · 25/01/2006, 23h38

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 :

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

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 ?

**ePoX** · 26/01/2006, 00h00

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)

**marcha** · 26/01/2006, 00h57

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 ?

**gofono_bass** · 26/01/2006, 08h35

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

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)

**Mr N.** · 26/01/2006, 11h00

Je propose cette solution. A benchmarker...

Code :

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
 
<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 :

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

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

**gofono_bass** · 26/01/2006, 11h02

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

**Mr N.** · 26/01/2006, 12h01

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

Code :

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
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 :

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

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

**Mr N.** · 26/01/2006, 12h12

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

Code :

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

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

**Yogui** · 26/01/2006, 12h23

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.

**Mr N.** · 26/01/2006, 13h35

Code :

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

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...

**marcha** · 26/01/2006, 13h41

Arf Mr.N, je vois qu'on a travaillé en parallel

j'ai aussi fait mon
petit prog de mesure :-)

Code :

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
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é ?

**gofono_bass** · 26/01/2006, 13h43

Je persiste a dire que les regexp sont plus lourdes et plus lentes...

**marcha** · 26/01/2006, 13h45

Moi je ne crois que ce que je mesure :-)

**Kioob** · 26/01/2006, 13h50

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...

**Mr N.** · 26/01/2006, 14h02

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.

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...

**Kioob** · 26/01/2006, 14h30

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

**Mr N.** · 26/01/2006, 14h53

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

**marcha** · 26/01/2006, 16h04

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.

**Mr N.** · 26/01/2006, 16h11

il y a aussi strtok ...

**marcha** · 26/01/2006, 16h34

Merci Mr.N.

Code :

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

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.

[Tableaux] Optimisation

Langage PHP

Discussions similaires

Partager

Partager