Pourquoi utiliser la fonction sprintf en PHP?

J'essaie d'en savoir plus sur la fonction PHP sprintf () mais php.net ne m'a pas beaucoup aidé car je suis toujours confus, pourquoi voudriez-vous l'utiliser?

Jetez un œil à mon exemple ci-dessous.

Pourquoi utiliser ceci:

$output = sprintf("Here is the result: %s for this date %s", $result, $date);

Lorsque cela fait la même chose et qu'il est plus facile d'écrire IMO:

$output = 'Here is the result: ' .$result. ' for this date ' .$date;

Est-ce que j'ai râté quelque chose?

sprintf possède toutes les capacités de formatage du printf d'origine, ce qui signifie que vous pouvez faire bien plus que simplement insérer des valeurs de variables dans des chaînes.

Par exemple, spécifiez le format des nombres (hexadécimal, décimal, octal), le nombre de décimales, le remplissage, etc. Google pour printf et vous trouverez de nombreux exemples. L' article de wikipedia sur printf devrait vous aider à démarrer.

Il existe de nombreux cas d'utilisation de sprintf, mais une façon de les utiliser est de stocker une chaîne comme celle-ci: "Bonjour, mon nom est% s" dans une base de données ou comme constante dans une classe PHP. De cette façon, lorsque je veux utiliser cette chaîne, je peux simplement le faire:

$name = 'Josh';
// $stringFromDB = 'Hello, My Name is %s';
$greeting = sprintf($stringFromDB, $name);
// $greetting = 'Hello, My Name is Josh'

Essentiellement, cela permet une certaine séparation dans le code. Si j'utilise «Bonjour, mon nom est% s» à de nombreux endroits dans mon code, je peux le changer en «% s est mon nom» à un endroit et il se met à jour partout ailleurs automatiquement, sans avoir à accéder à chaque instance et à se déplacer concaténations.

Une autre utilisation de sprintfest dans les applications localisées comme arguments poursprintf ne doivent pas nécessairement être dans l'ordre dans ils apparaissent dans la chaîne de format.

Exemple:

$color = 'blue';
$item = 'pen';

sprintf('I have a %s %s', $color, $item);

Mais une langue comme le français ordonne les mots différemment:

$color = 'bleu';
$item = 'stylo';

sprintf('J\'ai un %2$s %1$s', $color, $item);

(Oui, mon français est nul: j'ai appris l'allemand à l'école!)

En réalité, vous utiliseriez gettext pour stocker les chaînes localisées, mais vous voyez l'idée.

C'est plus facile à traduire.

echo _('Here is the result: ') . $result . _(' for this date ') . $date;

Les chaînes de traduction (gettext) sont maintenant:

• Voici le résultat:
• pour cette date

Une fois traduit dans une autre langue, cela peut être impossible ou il en résulte des phrases très étranges.

Maintenant si vous avez

echo sprintf(_("Here is the result: %s for this date %s"), $result, $date);

Les chaînes de traduction (gettext) sont maintenant:

• Voici le résultat:% s pour cette date% s

Ce qui a beaucoup plus de sens et il est beaucoup plus flexible de traduire dans d'autres langues

La meilleure raison que j'ai trouvée est que cela vous permet de placer toutes les chaînes de langue dans votre fichier de langue où les gens peuvent les traduire et les commander selon les besoins - mais vous savez toujours que quel que soit le format de la chaîne - vous souhaitez afficher le nom des utilisateurs.

Par exemple, votre site indiquera "Bienvenue à nouveau [[Utilisateur]]" en haut de la page. En tant que programmeur, vous ne savez pas ou souciez pas de la façon dont les gars de l'interface utilisateur vont écrire cela - vous savez simplement qu'un nom d'utilisateur va être affiché quelque part dans un message.

Ainsi, vous pouvez intégrer le message dans votre code sans vous soucier de la nature de ce message.

Fichier Lang (EN_US):

...
$lang['welcome_message'] = 'Welcome back %s';
...

Ensuite, vous pouvez prendre en charge tout type de message dans n'importe quelle langue en l'utilisant dans votre code php actuel.

sprintf($lang['welcome_message'], $user->name())

pourquoi voudriez-vous l'utiliser?

Cela s'avère très utile lors de l'utilisation d'une source (externe) pour les chaînes de langue. Si vous avez besoin d'un nombre fixe de variables dans une chaîne multilingue donnée, il vous suffit de connaître le bon ordre:

en.txt

not_found    = "%s could not be found."
bad_argument = "Bad arguments for function %s."
bad_arg_no   = "Bad argument %d for function %s."

hu.txt

not_found    = "A keresett eljárás (%s) nem található."
bad_argument = "Érvénytelen paraméterek a(z) %s eljárás hívásakor."
bad_arg_no   = "Érvénytelen %d. paraméter a(z) %s eljárás hívásakor."

Les variables insérées n'ont même pas besoin d'être au début ou à la fin dans plusieurs langues, seul leur ordre compte.

Bien sûr, vous pouvez écrire votre propre fonction pour effectuer ce remplacement, sans aucun doute même avec de légères augmentations de performances, mais il est beaucoup plus rapide de simplement (étant donné que vous avez une classe Languagepour lire les chaînes de langage) :

/**
 * throws exception with message($name = "ExampleMethod"):
 *  - using en.txt: ExampleMethod could not be found.
 *  - using hu.txt: A keresett eljárás (ExampleMethod) nem található.
 */
throw new Exception(sprintf(Language::Get('not_found'), $name));

/**
 * throws exception with message ($param_index = 3, $name = "ExampleMethod"):
 *  - using en.txt: Bad argument 3 for function ExampleMethod.
 *  - using hu.txt: Érvénytelen 3. paraméter a(z) ExampleMethod eljárás hívásakor.
 */
throw new Exception(sprintf(Language::Get('bad_arg_no'), $param_index, $name));

Il est également livré avec toutes les capacités de printf, est donc également une ligne unique pour le formatage de nombreux types de variables, par exemple:

• précision de sortie des nombres à virgule flottante , ou
• remplir les entiers avec des zéros non significatifs .

Comme mentionné, il permet le formatage des données d'entrée. Par exemple, forcer 2dp, des nombres à 4 chiffres, etc. C'est très utile pour construire des chaînes de requête MySQL.

Un autre avantage est qu'il vous permet de séparer la disposition de la chaîne des données qui y sont introduites, presque comme si vous introduisiez des paramètres. Par exemple, dans le cas d'une requête MySQL:

// For security, you MUST sanitise ALL user input first, eg:
$username = mysql_real_escape_string($_POST['username']); // etc.
// Now creating the query:
$query = sprintf("INSERT INTO `Users` SET `user`='%s',`password`='%s',`realname`='%s';", $username, $passwd_hash, $realname);

Cette méthode a bien sûr d'autres utilisations, comme lors de l'impression de la sortie au format HTML, etc.

Edit: Pour des raisons de sécurité , lorsque vous utilisez une technique comme ci-dessus, vous devez nettoyer toutes les variables d'entrée avec mysql_real_escape_string()avant d'utiliser cette méthode , pour éviter les attaques d'insertion MySQL. Si vous analysez une entrée non autorisée, votre site et votre serveur seront piratés . (À l'exception, bien sûr, des variables qui ont été entièrement construites par votre code et dont la sécurité est garantie.)

Utilisation de sprintf () est beaucoup plus propre et plus sûre pour formater votre chaîne.

Par exemple, lorsque vous traitez avec des variables d'entrée, cela évite les surprises inattendues en spécifiant à l'avance le format attendu (par exemple, que vous attendez la chaîne [ %s] ou le nombre [ %d]). Cela pourrait potentiellement aider avec le risque possible d' injection SQL , mais cela n'empêchera pas si la chaîne se compose de guillemets.

Cela aide également à traiter les flottants, vous pouvez spécifier explicitement la précision des chiffres (par exemple %.2f ) qui vous évite d'utiliser les fonctions de conversion.

L'autre avantage est que la plupart des principaux langages de programmation ont leur propre implémentation de sprintf(), donc une fois que vous vous êtes familiarisé avec celui-ci, il est encore plus facile à utiliser, plutôt que d'apprendre un nouveau langage (comme comment concaténer des chaînes ou convertir les flottants).

En résumé, c'est une bonne pratique à utiliser afin d'avoir un code plus propre et plus lisible.

Par exemple, voyez l' exemple réel ci-dessous :

$insert .= "('".$tr[0]."','".$tr[0]."','".$tr[0]."','".$tr[0]."'),";

Ou un exemple simple qui imprime par exemple '1','2','3','4':

print "foo: '" . $a . "','" . $b . "'; bar: '" . $c . "','" . $d . "'" . "\n";

et impression avec une chaîne formatée:

printf("foo: '%d','%d'; bar: '%d','%d'\n", $a, $b, $c, $d);

où printf()est équivalent à sprintf(), mais il génère une chaîne formatée au lieu de la renvoyer (à la variable).

Lequel est le plus lisible?

Même si je pensais la même chose à moins que je ne l'utilise récemment. Lorsque vous générez des documents en fonction des entrées utilisateur, cela sera pratique.

"<p>Some big paragraph ".$a["name"]." again have tot ake care of space and stuff .". $a["age"]. "also would be hard to keep track of punctuations and stuff in a really ".$a["token"]. paragarapoh.";

QUI peut être facilement écrit comme

sprintf("Some big paragraph %s. Again have to take care of space and stuff.%s also wouldnt be hard to keep track of punctuations and stuff in a really %s paragraph",$a,$b,$c);

Ce:

"<p>Some big paragraph ".$a["name"]." again have to take care of space and stuff .". $a["age"]. "also would be hard to keep track of punctuations and stuff in a really ".$a["token"]. paragraph.";

Pourrait également être écrit:

"<p>Some big paragraph {$a['name']} again have to take care of space and stuff .{$a['age']} also would be hard to keep track of punctuations and stuff in a really {$a['token']} paragraph.";

À mon avis, c'est plus clair à lire, mais je peux voir l'utilité de la localisation ou du formatage.

Certains des cas typiques sont ceux où vous avez besoin d'un contrôle plus précis sur le format de sortie. Il peut être difficile, par exemple, de s'assurer qu'une valeur spécifique a une quantité spécifique d'espaces remplis à l'avant, en fonction de sa longueur, ou qu'un nombre est sorti dans un format précis spécifique.

Il y a beaucoup d'exemples dans le manuel PHP

Aussi ce qui vient de votre exemple de "plus facile à écrire" ... Alors que l'écho peut être plus facile à écrire, le sprintf est plus facile à lire, surtout si vous avez beaucoup de variables.

Une autre raison d'utiliser sprintf ou printf peut être que vous souhaitez laisser un utilisateur définir le format de sortie d'une certaine valeur - vous pouvez en toute sécurité leur permettre de définir un format de sortie compatible sprintf.

Oh, et votre exemple est en fait faux pour une partie. sprintfrenvoie la chaîne, mais echone le fait pas - la echorenvoie immédiatement et ne retourne rien, tandis sprintfque la renvoie simplement.

1. Si vous avez utilisé C / C ++, alors vous seriez habitué à la fonction sprintf.

2. Il y a de fortes chances que la deuxième ligne soit moins efficace. Echo est conçu comme une commande de sortie, tandis que sprintf est conçu pour effectuer une substitution de jeton de chaîne. Je ne suis pas une personne PHP, mais je soupçonne qu'il y a plus d'objets impliqués dans l'écho. S'il agit comme le ferait Java, il crée une nouvelle chaîne chaque fois que quelque chose est ajouté à la liste, vous vous retrouverez donc avec 4 chaînes créées.

Parfois, j'ai quelque chose comme ça, que je considère un peu plus facile à lire:

$fileName = sprintf('thumb_%s.%s', 
                    $fileId,
                    $fileInfo['extension']);

J'utilise généralement sprintf pour m'assurer qu'un identifiant provenant de l'entrée utilisateur est un entier par exemple:

// is better use prepared statements, but this is practical sometimes
$query = sprintf("SELECT * from articles where id = %d;",$_GET['article_id']);

Est également utilisé pour faire des modèles rudimentaires (pour les mails html ou autres), afin que vous puissiez réutiliser un modèle dans de nombreux endroits:

$mail_body = "Hello %s, ...";
$oneMail = sprintf($mail_body, "Victor");
$anotherMail = sprintf($mail_body, "Juan");

Il est également très utile de formater les nombres dans différentes représentations (octal, contrôler la décimale, etc.).

define('TEXT_MESSAGE', 'The variable "%s" is in the middle!');

sprintf(TEXT_MESSAGE, "Var1");
sprintf(TEXT_MESSAGE, "Var2");
sprintf(TEXT_MESSAGE, "Var3");

sprintf est particulièrement utile lors du formatage de chaînes utilisant des nombres. Par exemple,

$oranges = -2.34;
echo sprintf("There are %d oranges in the basket", $oranges);

Output: There are -2 oranges in the basket

Les oranges sont formatées sous la forme d'un nombre entier (-2), mais s'enrouleront en nombres positifs si l'on utilise% u pour les valeurs non signées. Pour éviter ce comportement, j'utilise la fonction absolue, abs (), pour arrondir le nombre vers zéro comme suit:

$oranges = -5.67;
echo sprintf("There are %d oranges in the basket", abs($oranges));

Output: There are 5 oranges in the basket

Le résultat final est une instruction avec une lisibilité élevée, une construction logique, un formatage clair et une flexibilité pour l'ajout de variables supplémentaires si nécessaire. À mesure que le nombre de variables augmente en combinaison avec les fonctions qui manipulent ces variables, les avantages deviennent plus évidents. Comme dernier exemple:

$oranges = -3.14;
$apples = 1.5;
echo sprintf("There are %d oranges and %d apples", abs($oranges), abs($apples));

Output: There are 3 oranges and 4 apples

Le côté gauche de l'instruction sprintf exprime clairement la chaîne et les types de valeurs attendues, tandis que le côté droit exprime clairement les variables utilisées et comment elles sont manipulées.

Eh bien, sprintf a de nombreuses capacités comme nous connaissons un exemple ci-dessous:

Il y a quelques mois, j'avais besoin de convertir les secondes en format heure: minute: secondes Comme $t = 494050 //seconds je voulais imprimer comme 137 h 14 m 10 ssi je suis venu avec la fonction php, springf()je tiens simplement les secondes $tet echo sprintf("%02d h %s%02d m %s%02d s", floor($t/3600), $f, ($t/60)%60, $f, $t%60);me donne137 h 14 m 10 s

sprintf () est très utile si nous savons comment l'utiliser.

L'argument est le même pour l'utilisation des modèles. Vous voudrez séparer votre Textsleev des valeurs de variable réelles. Outre les pouvoirs supplémentaires de sprintf dont nous parlons, c'est juste une question de style.

Un très bon cas d'utilisation de sprintf est la sortie de formats de nombres remplis et aussi, lors du mélange de différents types dans une chaîne. Il peut être plus facile à lire dans de nombreux cas et rend très simple l'impression de différentes représentations de la même variable, en particulier numériques.

L'utilisation de la fonction sprintf () par rapport à la concaténation ordinaire présente l'avantage de pouvoir appliquer différents types de mise en forme aux variables à concaténer.

Dans votre cas, vous avez

$output = sprintf("Here is the result: %s for this date %s", $result, $date);

et

$output = 'Here is the result: ' .$result. ' for this date ' .$date;

Prenons $result = 'passed'; date = '23rd';

En utilisant la concaténation ordinaire, vous ne pouvez obtenir que la sortie:

Here is the result: passed for this date 23rd

Cependant, si vous utilisez, sprintf()vous pouvez obtenir une sortie modifiée telle que:

$output = sprintf('Here is the result: %.4s for this date %.2s',$result,$date);
echo $output;

Production:

Here is the result: pass for this date 23

sprintf()est assez similaire à printf(). Si vous savez printf()en détails alors sprintf()et mêmevsprintf() n'est pas vraiment difficile à comprendre.

l' une des choses qui diffère sprintf()de printf()est que vous aurez besoin de déclarer une variable pour attraper la sortie de la fonction car il n'imprime pas directement / quoi que ce soit d' écho. Voyons les extraits de code suivants:

printf("Hello %s", "world"); // "Hello world"

sprintf("Hello %s", "world"); // does not display anything

echo sprintf("Hello %s", "world"); // "Hello world"

$a = sprintf("Hello %s", "world"); // does not display anything

echo $a;// "Hello world"

J'espère que cela pourra aider.

L'un «produit», l'autre «retourne», c'est l'une des principales différences.

printf() Les sorties

sprintf() Retour

Vous devez être prudent lorsque vous utilisez sprintf en boucle:

$a = 'Anton';
$b = 'Bert';
$c = 'Corni';
$d = 'Dora';
$e = 'Emiel';
$f = 'Falk';
$loops = 10000000;

$time = microtime(true);

for ($i = 0; $i < $loops; $i++)
{
    $test = $a . $b . $c . $d . $e . $f;
}

$concatTime = microtime(true) - $time;

$time = microtime(true);

for ($i = 0; $i < $loops; $i++)
{
    $test = "$a $b $c $d $e $f";
}

$concat2Time = microtime(true) - $time;

$time = microtime(true);

for ($i = 0; $i < $loops; $i++)
{
    $test = sprintf('%s %s %s %s %s %s', $a, $b, $c, $d, $e, $f);
}

$sprintfTime = microtime(true) - $time;

echo 'Loops: ' . $loops . '<br>';
echo '\'$a . $b . $c . $d . $e . $f\'' . ' needs ' . $concatTime  . 's<br>';
echo '"$a $b $c $d $e $f"' . ' needs ' . $concat2Time  . 's<br>';
echo 'sprintf(\'%s %s %s %s %s %s\', $a, $b, $c, $d, $e, $f)' . ' needs ' . $sprintfTime  . 's<br>';

Ce qui conduit aux heures suivantes (sur ma machine locale avec PHP 7.2):

Boucles: 10000000

«$ a. $ b. $ c. $ d. $ e. $ f 'a besoin de 1,4507689476013s

"$ a $ b $ c $ d $ e $ f" nécessite 1,9958319664001s

sprintf ('% s% s% s% s% s% s', $ a, $ b, $ c, $ d, $ e, $ f) a besoin de 9.1771278381348s

Je l'utilise pour les messages aux utilisateurs ou pour d'autres "jolis" types de fonctionnalités. Par exemple, si je sais que je vais utiliser le nom de l'utilisateur.

$name = 'Some dynamic name';

Et ayez plusieurs messages à utiliser dans cette situation. (C'est-à-dire, bloquer ou suivre un autre utilisateur)

$messageBlock = 'You have blocked %s from accessing you.';
$messageFollow = 'Following %s is a great idea!';

Vous pouvez créer une fonction générale qui fait quelque chose à l'utilisateur et ajouter cette chaîne, et quelle que soit la structure de la phrase, elle devrait être plutôt jolie. Je n'aime toujours pas simplement ajouter des chaînes ensemble et utiliser constamment la notation par points et fermer et rouvrir des chaînes juste pour donner une belle apparence à une phrase. J'étais un fan au début, comme la plupart des autres, mais cela semble assez utile lorsque plusieurs chaînes doivent être manipulées et que vous ne voulez pas coder en dur le placement de la variable à chaque fois.

Pensez-y, qu'est-ce qui a l'air mieux?

return $messageOne === true ? $name.'. Please use the next example' : 'Hi '.$name.', how are you?'

Ou

$message = $messageOne === true ? 'Option one %s' 
: ($messageTwo === true ? 'Option Two %s maybe?' : '%s you can choose from tons of grammatical instances and not have to edit variable placement and strings');

return sprintf($message, $name);

Bien sûr, c'est une étape supplémentaire, mais que se passe-t-il si vos vérifications conditionnelles font un tas d'autres choses fonctionnelles, alors les citations et les ajouts commencent à gêner le codage fonctionnel.