(PHP4, PHP5, PHP7)

sprintf - Renvoie une chaîne formatée

Liste des paramètres

Une chaîne de format se compose de zéro ou plusieurs directives : des caractères ordinaires (sauf % ), qui sont copiés directement dans la chaîne résultante, et descripteurs de transformation, dont chacun est remplacé par l'un des paramètres. Cela s'applique aux deux sprintf(), et à printf().

Chaque spécificateur de conversion est constitué d'un signe de pourcentage ( % ), suivi d'un ou plusieurs éléments supplémentaires (dans l'ordre dans lequel ils sont répertoriés ici) :

1. Facultatif descripteur de personnage, indiquant comment le signe (- ou +) sera appliqué au numéro. Par défaut, seul le signe moins est utilisé si le nombre est négatif. Ce spécificateur fait que les nombres positifs affichent également un signe plus et a été ajouté dans PHP 4.3.0.
2. Facultatif spécificateur de remplissage, qui spécifie quel caractère sera utilisé pour remplir le résultat à la longueur requise. Il peut s'agir d'un espace ou 0 . La valeur par défaut est l'espace. Un caractère alternatif peut être spécifié à l'aide d'un guillemet simple ( " ). Voir les exemples ci-dessous.
3. Facultatif descripteur d'alignement, qui spécifie l'alignement à gauche ou à droite. Par défaut il est aligné à droite, - utilisé pour l’alignement à gauche.
4. Numéro facultatif spécificateur de largeur, qui spécifie le nombre minimum de caractères que contiendra le résultat de cette conversion.
5. Facultatif descripteur de précision, spécifié sous la forme d'un point ("".") suivi d'une chaîne décimale facultative qui spécifie le nombre de décimales à afficher pour les nombres à virgule flottante. Lorsqu'il est utilisé avec des chaînes, ce spécificateur agit comme un point de coupure qui définit la limite maximale de caractères. Vous pouvez également préciser le symbole utilisé pour compléter le chiffre entre le point et le chiffre.

6. Spécificateur de type, qui spécifie comment traiter le type de données de l'argument. Types valides :

   • % - symbole de pourcentage. L'argument n'est pas utilisé.
   • b- l'argument est traité comme un entier et affiché sous la forme d'un nombre binaire.
   • c- l'argument est traité comme un entier et affiché sous forme de caractère avec le code ASCII correspondant.
   • d- l'argument est traité comme un entier et affiché sous la forme d'un nombre décimal signé.
   • e- l'argument est interprété comme un nombre en notation scientifique (par exemple 1,2e+2). Le spécificateur de précision indique le nombre de décimales depuis PHP 5.2.1. Dans les versions antérieures, il indiquait le nombre de chiffres significatifs (un signe en moins).
   • E- similaire %e, mais utilise une lettre majuscule (par exemple, 1.2E+2).
   • F- l'argument est traité comme un nombre à virgule flottante et est également affiché en fonction des paramètres régionaux.
   • F- l'argument est traité comme un nombre à virgule flottante et est également affiché, mais sans dépendre des paramètres régionaux. Disponible à partir de PHP 4.3.10 et PHP 5.0.3.
   • g %e Et %F.
   • g- sélectionne l'entrée la plus courte parmi %E Et %F.
   • o- l'argument est traité comme un entier et affiché comme un nombre octal.
   • s- l'argument est traité comme une chaîne.
   • toi- l'argument est traité comme un entier et affiché comme un nombre décimal non signé.
   • X- l'argument est traité comme un entier et affiché sous la forme d'un nombre hexadécimal (minuscule).
   • X- l'argument est traité comme un entier et affiché sous la forme d'un nombre hexadécimal (en majuscule).

Les variables seront converties dans le type approprié pour le spécificateur :

Gestion des types

Taper	Spécificateur
chaîne	s
entier	d, toi, c, o, X, X, b
double	g, g, e, E, F, F

Attention

Essayer d'utiliser une combinaison de chaînes et de spécificateurs de largeur avec des codages nécessitant plus d'un octet par caractère peut produire des résultats inattendus.

La chaîne de format prend en charge la numérotation et la réorganisation des paramètres. Par exemple:

Exemple #1 Changer l'ordre des paramètres

$num = 5 ;
$emplacement = "arbre" ;

$format = "%d singes sont assis sur %s";

?>

Ce code affichera "5 singes assis sur un arbre". Imaginez maintenant que la chaîne de format soit contenue dans un fichier séparé, qui sera ensuite traduit dans une autre langue, et nous la réécrivons comme ceci :

Exemple #2 Changer l'ordre des paramètres

$format = "Il y a %d singes assis sur %s";
echo sprintf ($format, $num, $location);
?>

Il y a un problème : l'ordre des spécificateurs de conversion ne correspond pas à l'ordre des arguments. Nous ne voulons pas changer le code et nous devons spécifier quel argument correspond à quel spécificateur de conversion.

Exemple #3 Changer l'ordre des paramètres

$format = "Il y a %1$d singes assis sur %2$s";
echo sprintf ($format, $num, $location);
?>

La numérotation des arguments a une autre utilité : elle vous permet d'imprimer le même argument plusieurs fois sans transmettre de paramètres supplémentaires à la fonction.

Exemple #4 Changer l'ordre des paramètres

$format = "Il y a %1$d singes assis sur %2$s.
C'est génial d'avoir %2$s assis sur %1$d singes.";
echo sprintf ($format, $num, $location);
?>

Lors de la modification de l'ordre des paramètres descripteur de poste n$ doit venir immédiatement après le signe de pourcentage ( % ) avant tous les autres descripteurs, comme le montre l'exemple ci-dessous.

Exemple #5 Spécification d'un caractère complémentaire

echo sprintf ("%".9d\n" , 123 );
echo sprintf ("%".09d\n" , 123 );
?>

123 000000123

Exemple #6 Utilisation du spécificateur de position et en conjonction avec d'autres descripteurs

$format = "Il y a %1$04d singes assis sur %2$s";
echo sprintf ($format, $num, $location);
?>

Le résultat de l'exécution de cet exemple :

0005 singes assis sur un arbre

Commentaire:

Une tentative a été faite pour utiliser un spécificateur de position supérieur à PHP_INT_MAX, la fonction générera un avertissement sprintf() .

Attention

Le c le spécificateur de type ignore le remplissage et la largeur

Valeurs de retour

Renvoie une chaîne formatée selon format .

Exemples

Exemple n°7 sprintf(): remplissage avec des zéros

$n = 43951789 ;
$u = - 43951789 ;
$c = 65 ; // ASCII 65 est "A"

// notez que le double %% est affiché sous la forme d'un simple "%"
printf ("%%b = "%b"\n" , $n ); // représentation binaire
printf ("%%c = "%c"\n" , $c ); // affiche un caractère ascii, similaire à la fonction chr()
printf ("%%d = "%d"\n" , $n ); // entier régulier
printf ("%%e = "%e"\n" , $n ); // notation scientifique
printf ("%%u = "%u"\n" , $n ); // représentation entière non signée d'un nombre positif
printf ("%%u = "%u"\n" , $u ); // représentation entière non signée d'un nombre négatif
printf ("%%f = "%f"\n" , $n ); // représentation d'un nombre à virgule flottante
printf ("%%o = "%o"\n" , $n ); // représentation octale
printf ("%%s = "%s"\n" , $n ); // doubler
printf ("%%x = "%x"\n" , $n ); // représentation hexadécimale (minuscules)
printf ("%%X = "%X"\n" , $n ); // représentation hexadécimale (majuscule)

Printf ("%%+d = "%+d"\n" , $n ); // descripteur de signe avec un entier positif
printf ("%%+d = "%+d"\n" , $u ); // descripteur de signe avec un entier négatif
?>

Le résultat de l'exécution de cet exemple :

% b = "10100111101010011010101101"% c = "A"% d = "43951789"% e = "4.39518e + 7"% u = "43951789"% u = "4251015507"% f = "43951789.000000"% O = "247523 255 " %s = "43951789" %x = "29ea6ad" %X = "29EA6AD" %+d = "+43951789" %+d = "-43951789"

Exemple #8 printf(): descripteurs de chaînes

$s = "singe" ;
$t = "beaucoup de singes" ;

Printf("[%s]\n" , $s ); // sortie de ligne normale
printf ("[%10s]\n" , $s ); // aligner à droite avec les espaces
printf ("[%-10s]\n" , $s ); // alignement à gauche avec des espaces
printf ("[%010s]\n" , $s ); // le remplissage nul fonctionne également avec les chaînes
printf ("[%"#10s]\n" , $s ); // utilise votre propre caractère "#" complémentaire
printf ("[%10.10s]\n" , $t ); // alignement à gauche avec coupure de 10 caractères
?>

Imprime une chaîne, une valeur de variable ou une expression.
Syntaxe:

Imprimer (argument de chaîne)

La fonction print() imprime l'argument arg, qui peut être une variable ou une expression.

vsprintf()

Renvoie une chaîne formatée (PHP 4 >= 4.1.0, PHP 5)

Description:

String vsprintf (format de chaîne, arguments du tableau)

Cette fonction est similaire à sprintf(), mais elle prend un tableau plutôt qu'un nombre variable d'arguments.

Imprime une ou plusieurs valeurs.
Syntaxe:

Écho(chaîne arg1, chaîne...)

La fonction echo() affiche les valeurs des paramètres répertoriés.
echo() est en fait une construction de langage, elle ne nécessite donc pas de parenthèses même si plusieurs arguments sont utilisés.
echo "Les sauts de ligne présents dans le code sont enregistrés et utilisés dans la sortie."
"pour éviter cette utilisation."
« opérateur de concaténation » ;

Affiche la chaîne formatée.
Syntaxe:

Int printf(format de chaîne [, arguments mixtes, ...]);

Fait la même chose que sprintf(), seule la chaîne résultante n'est pas renvoyée, mais envoyée au navigateur de l'utilisateur.

Effectue le formatage de chaîne avec substitution de variable.
Syntaxe:

Sprintf($format [,args, ...])

Cette fonction renvoie une chaîne construite à partir d'une chaîne de format contenant des caractères spéciaux qui seront ensuite remplacés par les valeurs des variables correspondantes dans la liste d'arguments.
La chaîne de format $format peut inclure des commandes de formatage précédées d'un caractère %.
Tous les autres caractères sont copiés tels quels dans la chaîne de sortie. Chaque spécificateur de format (c'est-à-dire le caractère % et les commandes suivantes) correspond à un et un seul paramètre spécifié après le paramètre $format. Si vous devez placer % dans le texte comme symbole normal, vous devez le doubler :

Echo sprintf("Le pourcentage était %d%%",$percentage);

Chaque spécificateur de format contient un maximum de cinq éléments (dans l'ordre dans lequel ils apparaissent après le caractère %) :

Spécificateur de taille de champ facultatif qui spécifie le nombre de caractères qui seront alloués à la valeur de sortie.
En tant que caractères fictifs (si la valeur est inférieure à la taille du champ pour l'afficher)
un espace ou 0 peut être utilisé, la valeur par défaut est un espace. Vous pouvez spécifier n'importe quel autre caractère de remplissage si vous le spécifiez dans la chaîne de format, précédé d'une apostrophe.
Spécificateur d'alignement facultatif qui spécifie si le résultat sera aligné à droite ou à gauche du champ. La valeur par défaut est l'alignement à droite, mais vous pouvez spécifier l'alignement à gauche en spécifiant le symbole - (moins).

Un nombre facultatif qui spécifie la taille du champ pour afficher la valeur. Si le résultat n'est pas dans le champ, alors il « s'étendra » au-delà des bords de ce champ, mais ne sera pas tronqué.
Un nombre facultatif, précédé d'un point ".", qui spécifie le nombre de décimales qu'il y aura dans la chaîne résultante.
Ce spécificateur n'est pris en compte que si un nombre à virgule flottante est généré, sinon il est ignoré.
Enfin, le spécificateur obligatoire (remarque - le seul obligatoire !) du type de valeur qui sera placé dans la chaîne de sortie :

b - l'argument suivant de la liste est affiché sous forme d'entier binaire
c - le symbole avec le code spécifié dans l'argument est affiché
d - entier
f - nombre à virgule flottante
o - entier octal
s - chaîne de caractères
x - entier hexadécimal avec des lettres minuscules de a à z
X est un entier hexadécimal avec les lettres majuscules A-Z

Voici comment spécifier la précision des nombres à virgule flottante :

$argent1 = 68,75 ;
$argent2 = 54,35 ;
$argent = $argent1 + $argent2 ;
// echo $money affichera "123.1"...
$formatté = sprintf("%01.2f", $argent);
// echo $formatted affichera "123.10" !

Voici un exemple de sortie d'un entier précédé du nombre requis de zéros :

$isodate=sprintf("%04d-%02d-%02d",$année,$mois,$jour);

Interprète la chaîne selon le format et entre les valeurs dans les variables.

Syntaxe:

Sscanf mixte (chaîne str, format de chaîne [, chaîne var1 ...])

La fonction sscanf() est l'opposé de la fonction printf().

Il interprète la chaîne str selon le format, similaire à la spécification printf().

Lorsque seulement deux arguments sont spécifiés, les valeurs résultantes sont renvoyées dans un tableau.

// obtention du numéro de série$serial = sscanf("SN/235-0001", "SN/%3d-%4d");
echo $série*10000+$série; // sorties : 2350001
// et date de production$date = "01 janvier 2000";
list($mois, $jour, $année) = sscanf($date, "%s %d %d");
echo "Date : $année-".substr($mois,0,3)."-$journ";
// sorties : 2000-Jan-01

Lors de la spécification de paramètres facultatifs supplémentaires (ils doivent être transmis par référence)

la fonction renvoie leur numéro. Les variables qui ne reçoivent pas de valeurs ne sont pas prises en compte dans la valeur de retour.

// génère un enregistrement XML à partir de la chaîne $auth = "765tLewis Carroll";
$n = sscan($auth,"%dt%s %s", &$id, &$first, &$last);
écho "
$d'abord
$dernier
n";

fprintf()

Description:

Int fprintf (descripteur de ressource, format de chaîne [, arguments mixtes])

Écrit une chaîne créée à l'aide de la chaîne de format dans le flux dont le handle est passé au handle. L'argument format est discuté en détail dans la description de la fonction sprintf().

fprintf() : remplissage avec des zéros

retour;

fprintf($fp, "%04d-%02d-%02d", $année, $mois, $jour);
// écrit la date formatée dans le fichier date.txt
?>

fprintf() : formatage des valeurs monétaires

si (!($fp = fopen("currency.txt", "w")))
retour;

$argent1 = 68,75 ;
$argent2 = 54,35 ;
$argent = $argent1 + $argent2 ;
// echo $money affichera "123.1" ;
$len = fprintf($fp, "%01.2f", $argent);
// la chaîne "123.10" est écrite dans le fichier monnaie.txt

echo "$len octets écrits dans le fichier monnaie.txt" ;
?>

vfprintf()

Écrit une chaîne formatée dans un flux (PHP 5)

Description:

Int vfprintf (descripteur de ressource, format de chaîne, arguments du tableau)

Écrit une chaîne, formatée selon le format, dans la ressource de flux spécifiée par handle. Le formatage s'effectue de la même manière que sprintf().

Fonctionne de la même manière que fprintf(), mais prend un tableau d'arguments plutôt qu'un nombre variable d'arguments.

Renvoie la longueur de la chaîne de sortie.

Voir aussi : printf(), sprintf(), sscanf(), fscanf(), vsprintf() et number_format().
Exemples

vfprintf() : entiers avec zéro

si (!($fp = fopen("date.txt", "w")))
retour;

vfprintf($fp, "%04d-%02d-%02d", array($année, $mois, $jour));
// écrira la date ISO formatée dans date.txt
?>

vprintf()

Génère une chaîne formatée (PHP 4 >= 4.1.0, PHP 5)

Description:

Int vprintf (format de chaîne, arguments du tableau)

Affiche les valeurs du tableau args, formatées selon l'argument de format décrit dans la documentation de la fonction sprintf().

Cette fonction est similaire à printf(), mais elle prend un tableau plutôt qu'un nombre variable d'arguments.

Renvoie la longueur de la chaîne de sortie

Format de nombre()

Formate un nombre avec séparation des groupes (PHP 3, PHP 4, PHP 5)

Description:

Chaîne number_format (nombre flottant [, entiers décimaux])

chaîne number_format (nombre flottant, décimales entières, chaîne dec_point, chaîne milliers_sep)

number_format() renvoie le nombre formaté. La fonction prend un, deux ou quatre arguments (et non trois) :

Si un seul argument est passé, le nombre sera formaté sans la partie fractionnaire, mais avec une virgule (",") entre les groupes de chiffres de 3.

Si deux arguments sont passés, le nombre sera formaté avec des décimales après les points ("") et des virgules (",") entre les groupes de chiffres de 3.

Si les quatre arguments sont passés, le nombre sera formaté avec des décimales après le point et avec un séparateur entre les groupes de chiffres de 3, en utilisant dec_point comme point décimal et milliers_sep comme séparateur de groupe.

Seul le premier caractère de la chaîne milliers_sep est utilisé. Par exemple, si vous transmettez foo en tant que milliers_sep pour formater le nombre 1000, number_format() renvoie 1f000.

Exemple d'utilisation de number_format()

En France, il est courant d'utiliser 2 décimales (« ») et un espace (« ») comme séparateur de groupe. Ce formatage est obtenu à l'aide du code suivant :

$nombre = 1234,56 ;

// Format anglais (par défaut)
$english_format_number = number_format($number);
// 1,234

//Format français
$nombre_format_francais = number_format($number, 2, ",", " ");
// 1 234,56

$numéro = 1234,5678 ;

// Format anglais sans séparateurs de groupes
$english_format_number = number_format($number, 2, ".", "");
// 1234.57

imprimer("comment formater", paramètre1, paramètre2, ...) -- affiche le résultat à l'écran

$résultat= sprintf(""..", .., .., ...) - la même chose, seule la ligne n'est pas affichée, mais placée dans $result

Citation de la traduction du manuel ( EXEMPLES ci-dessous:-):

sprintf

sprintf -- renvoie une chaîne formatée

Description

sprintf (format chaîne, mixte...) ;

Renvoie une chaîne traitée selon la chaîne de format format .

Une chaîne de format contenant zéro ou plusieurs directives : caractères normaux (sauf %) qui sont copiés directement dans le résultat, et qui sont copiés directement dans le résultat, et descriptions des changements, dont chacun effectue des actions spécifiques. Ceci s'applique également à sprintf() et à printf()

Chaque instruction de modification se compose des éléments suivants, dans l'ordre :

Supplémentaire spécificateur de remplissage, qui indique quels caractères seront utilisés pour compléter le résultat à la taille de chaîne correcte. Il peut s'agir d'espaces ou de 0 (caractère zéro). Par défaut, il est rempli d'espaces. Un caractère de remplissage alternatif peut être spécifié avec un guillemet simple ("). Voir les exemples ci-dessous.

Supplémentaire descripteur d'alignement, qui indique que le résultat doit être aligné à gauche ou à droite. Par défaut, l'alignement est aligné à droite ; - le caractère entraînera un alignement à gauche.

Supplémentaire spécificateur de largeur, qui indique le nombre de caractères (minimum) avec lequel ce remplacement peut être effectué.

Supplémentaire descripteur de précision, qui indique le nombre de décimales à afficher pour les nombres à virgule flottante. Ce descripteur n'a aucun effet sur les types autres que double. (une autre fonction utile pour formater les nombres est Format de nombre() .)

1. Spécificateur de type, qui indique comment le type de données de l'argument doit être traité. Types possibles :

   % est le symbole du pourcentage. Aucun argument requis.

   b - l'argument est traité comme un entier et représenté comme un nombre binaire.

   c - l'argument est traité comme un entier et représenté comme un caractère avec une valeur ASCII.

   d - l'argument est traité comme un entier et représenté sous forme de nombre décimal.

   f - l'argument est traité comme double et représenté sous forme de nombre à virgule flottante.

   o - l'argument est traité comme un entier et représenté comme un nombre octal.

   s - l'argument est interprété et représenté sous forme de chaîne.

   x - l'argument est traité comme un entier et représenté sous la forme d'un nombre hexadécimal (avec des lettres minuscules).

   X - l'argument est traité comme un entier et représenté sous la forme d'un nombre hexadécimal (avec des lettres en majuscules).

Exemples

Exemple 2. sprintf : formatage de la devise $argent1 = 68,75 ; $argent2 = 54,35 ; $argent = $argent1 + $argent2 ; // echo $money affichera "123.1" ; $formatté = sprintf("%01.2f", $argent); // echo $formatted affichera "123.10" Exemples Tout ce qui est écrit >>> entre ces parenthèses <<< est le résultat de la fonction (c'est-à-dire un exemple de sortie à l'écran) $s="MyString"; -> ligne %s $f=12345.6789 ; -> fractionnaire %f $d=12345 ; -> entier %d 10ème système : 0123456789 16numéros %x 16ème système : 0123456789abcdef 16numéros %X 16ème système : 0123456789ABCDEF 8numéros %o 8ème système : 01234567 2numéros %b 2ème système : 01 il suffit d'imprimer le numéro : printf("%d", $ d); >>> 12345<<< просто выводим 16число: printf("%X",123456789); >>>75BCD15<<< просто выводим 2число: printf("%b",$d); >>> 11000000111001 <<< просто выводим дробное число: printf("%f",$f); >>> 12345.6789 <<< дополнение чисел нулями: printf("%010d",$d); >>> 0000012345 <<< округление до 3х знаков после запятой: printf("%.3f",$f); >>> 12345.679 <<< просто выводим число + посторонний текст: printf("посторонний%dтекст",$d); >>> outsider12345texte<<< вывод нескольких переменных - последовательное перечисление printf("%d-%f-%s",$d,$f,$s); >>> 12345-12345.678900-MaChaîne<<< выравнивание (ширина 20 символов) по правому краю, пустоту заполняем "_": printf("%"_20s",MyString); >>> ____________MaChaîne<<< выравнивание по левому краю, пустоту заполняем "x": printf("%-"x20s",MyString); >>> MaChaînexxxxxxxxxxxx<<< Voir d'autres exemples ici :

La fonction de sortie de console standard en C est printf. Sa description est contenue dans le fichier d'en-tête stdio.h. Grâce à cette fonction, vous pouvez envoyer des données ou des messages utilisateur vers la console. Le langage C est sensible à la casse. Par exemple, les deux fonctions printf et scanf sont différentes de leurs fonctions similaires Printf et Scanf. Tous les caractères des fonctions printf et scanf doivent également être écrits en minuscules. L'un des exemples les plus simples de C printf, qui imprime le message d'accueil familier Hello World, est :

Définition des fonctions du groupe printf dans le fichier "stdio.h"

Le fichier "stdio.h" fait référence à la bibliothèque d'entrées/sorties standard du langage C. La description de printf et des fonctions similaires y est donnée comme suit :

Les fonctions répertoriées chargent des données à partir de certains emplacements, les convertissent en chaîne de caractères et les envoient aux flux de sortie spécifiés.

La famille de fonctions printf

Les fonctions du groupe printf en C sont utilisées pour traiter et formater la sortie des données vers le flux standard. De plus, les fonctions printf et vprintf écrivent dans le flux stdout standard, les fonctions fprintf et vfprintf envoient les valeurs des arguments de sortie à un flux de sortie spécifié et snprintf, sprintf, vsnprintf et vsprintf écrivent des données dans une chaîne de caractères. Toutes les fonctions répertoriées fonctionnent à l'aide d'une chaîne de format spécifiant les conversions d'arguments requises pour la sortie.

La fonction fprintf écrit le résultat dans le flux de sortie. La fonction sprintf affiche le résultat dans un tampon, qui est une chaîne de caractères. Le comportement de la fonction n'est pas défini si la chaîne à afficher dépasse la taille du tableau tampon.

La fonction snprintf, comme la précédente, écrit les données dans un tampon de chaîne. La chaîne de caractères résultante se termine par un caractère nul, sauf si bufsz (taille du tampon) est nul. Sinon, si bufsz vaut zéro, alors rien n'est sorti dans le tampon, et le tampon lui-même peut très bien être un pointeur nul, mais la valeur de retour (le nombre d'octets qui auraient dû être écrits) est toujours calculée.

La fonction printf_s fonctionne fondamentalement de la même manière que printf, à une exception près. La principale différence dans la description de printf_s en C et de printf est la suivante : la fonction printf_s vérifie la chaîne de format pour les caractères valides, contrairement à printf, qui vérifie uniquement la chaîne de format pour un pointeur nul.

Examinons de plus près la fonction printf.

description générale

En C, l'impression des caractères sur la sortie standard se fait en appelant la fonction printf. La commande printf en C formate un ensemble de données de sortie et l'envoie à la sortie standard. Les valeurs transmises en tant qu'arguments à la fonction sont affichées sur la console selon la chaîne de format spécifiée, qui contient à son tour deux types d'éléments. Le premier type concerne les caractères affichés à l'écran, et les éléments qui déterminent les caractéristiques du format de données et sont responsables de la méthode de présentation des arguments lors de la sortie appartiennent au deuxième type.

Lors de la sortie de variables avec printf en C, des combinaisons spécifiques de caractères dans la chaîne d'argument sont remplacées par des données converties en fonction de ces caractères, et chaque type de données a ses propres spécifications de format de sortie.

Type de fonction et valeur de retour

La fonction printf renvoie une valeur entière indiquant le nombre de caractères imprimés à l'écran. Par exemple, vous pouvez attribuer :

int k = printf("Bonjour %c %d %s", "a", 11, "tout le monde !"),

puis la valeur de la variable k peut facilement déterminer si une erreur s'est produite lors de la sortie. Si une valeur négative est renvoyée (si la fonction a renvoyé "-1"), on peut conclure qu'une erreur s'est produite lors de son exécution.

Syntaxe et dépendances

Pour utiliser la fonction printf, vous devez inclure le fichier d'en-tête "stdio.h" comme suit :

#inclure

Le modèle de fonction ressemble à :

int printf(const char *format, ...)

Les points de suspension font référence à une liste d’arguments à afficher. La fonction printf peut être utilisée avec un nombre différent d'arguments, mais le premier est toujours délimité par des guillemets doubles des deux côtés, et chacun des suivants doit être séparé du précédent par une virgule. Ce qui est écrit entre guillemets et qui n'est pas une spécification de format est imprimé sans modification, sinon, si un spécificateur est rencontré, son type de valeur est copié.

Formulaire de spécification des spécifications de format :

%[flags][largeur][.position][longueur]type

Formatage avec printf dans les valeurs de sortie C

La chaîne de format spécifiée entre parenthèses après le nom de la fonction appelée est lue dans un seul sens : de gauche à droite, et le premier argument spécifié après cette ligne elle-même n'est imprimé que si la première spécification est rencontrée. Jusqu'à la fin de la chaîne de format, les spécifications qui y sont spécifiées lanceront la conversion et l'impression des arguments suivants. Dans une chaîne de format, le caractère espace est traité comme un caractère normal et est affiché lorsqu'il n'est pas utilisé dans une expression de spécification de format.

Le caractère « % » indique le début de la spécification du format de sortie, suivi du code du format. Tous les champs de la spécification sont des nombres ou des caractères individuels qui définissent les conditions de formatage.

La sortie printf formatée en C a ses propres particularités. Si le nombre d'arguments répertoriés dépasse le nombre de spécifications de format, ils sont ignorés et ne sont pas imprimés. Sinon, s'il y a plus de spécifications de format que de valeurs dans la liste des arguments à imprimer, le résultat de l'appel de fonction n'est pas déterminé.

Pour indiquer explicitement quel argument utiliser, il est possible d'utiliser "%m$" au lieu de "%" et "*m$" au lieu de "*", avec m, une valeur décimale entière, indiquant la position de l'argument souhaité. (l'indexation commence à une heure) .

Possibilités

Indicateurs utilisés dans la chaîne de format

Drapeau	Description
-	Aligner le résultat à gauche dans le champ de sortie
+	Lors de l'impression d'une valeur numérique comportant un signe, le "+" est obligatoirement imprimé avant la valeur positive (par défaut, seul "-" est imprimé avant la valeur négative)
0	Pour les nombres entiers et à virgule flottante, des zéros non significatifs sont utilisés à la place des espaces pour remplir les chiffres de gauche lorsque la largeur du champ est spécifiée comme étant supérieure à la longueur du nombre. Pour les entiers, l'indicateur est ignoré si la précision est explicitement spécifiée. Pour les autres conversions utilisant cet indicateur, le comportement de la fonction n'est pas défini. Le flag "0" est ignoré si le flag "-" est présent
espace	Si le résultat d'une expression signée ne commence pas par ce caractère de signe ou est vide, un espace est ajouté au résultat. Le flag "espace" est ignoré si le flag "+" est présent
#	Une autre forme de conversion est effectuée

Divers spécificateurs de format

Spécificateur de format	Utilisation et description de printf C	Type d'argument
%	Écrire le "%" littéral
c	Sortie d'un caractère. L'argument est converti en un type char non signé. Lors de l'utilisation du modificateur "l", l'argument est converti en chaîne de caractères	caractère non signé
s	Imprime une chaîne de caractères. L'argument doit être un pointeur vers l'élément de départ du tableau char	caractère *
d je	Impression de la représentation décimale d'une valeur entière signée	int
o	Sortie d'une représentation octale d'une valeur entière non signée	entier non signé
X X	Représentation hexadécimale de sortie d’une valeur entière non signée. Les caractères "a", "b", "c", "d", "e", "f" sont utilisés pour convertir "x". Et transformer "X" - "A", "B", "C", "D", "E", "F"	entier non signé
toi	Conversion décimale de sortie sans valeur entière signée. Si la valeur convertie et la précision sont toutes deux égales à 0, aucun caractère n'est généré	entier non signé
F F	Impression de la représentation décimale d'un nombre à virgule flottante signé	double
e E	Produit une notation scientifique décimale, arrondie et convertie de sorte qu'il y ait un chiffre avant le point décimal et que le nombre de chiffres après le point décimal corresponde à la précision de la représentation (la précision par défaut est 6, et si 0 est spécifié, alors le le symbole décimal n’est pas du tout affiché). Le caractère "e" s'affiche en majuscule ou en minuscule selon la conversion	double
un UN	Représentation hexadécimale de sortie d'un nombre à virgule flottante	double
g g	Afficher la représentation décimale d'un nombre à virgule flottante ou sa représentation exponentielle décimale en fonction de la valeur et de la précision	double
n	Renvoie le nombre d'éléments imprimés par printf. Le résultat est écrit dans la variable pointée par l'argument. La spécification ne peut pas contenir d'indicateurs, de largeur de champ ou de précision	entier *
p	Sortie du pointeur	vide *

Modificateur de largeur de champ

La ligne de format dans printf C peut écrire un entier après le signe de pourcentage et avant la commande format. Il s'agit d'un modificateur de largeur de champ et affecte la présentation des données affichées. La plus petite largeur de champ destinée à une valeur est déterminée par ce nombre, et la présence d'un tel modificateur si l'argument est plus petit que le champ qui lui est attribué entraîne l'ajout d'espaces ou de zéros au résultat. L'espace réservé par défaut est le caractère espace, mais vous pouvez le définir sur zéro en préfixant la spécification de largeur. Le modificateur spécifie une largeur minimale, et toute valeur supérieure à ce minimum s'imprimera sans interférence. Un nombre, par exemple, composé de moins de huit caractères et imprimé avec la spécification « %08d » sera complété aux huit caractères requis avec des zéros.

Des modificateurs similaires peuvent également spécifier des paramètres de précision ou d'alignement.

Modificateur de précision

Le modificateur de précision est utilisé pour déterminer le nombre de décimales à imprimer dans la représentation numérique. Pour ajouter un modificateur de précision, vous devez mettre un point après la spécification de la largeur du champ et spécifier la valeur de précision souhaitée après. Le modificateur de précision est défini pour les formats "e", "f", "a", "E", "A" et "F". Pour les nombres entiers, le modificateur définit le nombre de chiffres affichés, en ajoutant des zéros au chiffre de gauche si nécessaire, et lors de l'affichage de nombres rationnels, il détermine le nombre requis de décimales. Pour les variables chaîne, le nombre suivant le point dans le modificateur de précision détermine la longueur maximale du champ pour la sortie. Par exemple, étant donné la spécification de format « %4.8s », une chaîne sera générée dont la longueur est comprise entre quatre et huit caractères si elle est dépassée, les caractères les plus à l'extérieur seront omis.

Autres modificateurs de format

L'alignement par défaut est aligné à droite, mais cela peut être modifié en plaçant un signe "-" après le "%". Cette spécification de format définit l'alignement à gauche.

De plus, la fonction printf peut faire la distinction entre les types courts et longs de valeurs entières à imprimer. Les spécificateurs valides sont "o", "d", "u", "i", "x" et "X". Le type de valeur longue est spécifié par le modificateur « l » et le type de valeur courte par le modificateur « h ». Par exemple, lors de la sortie d'un entier long et d'une valeur entière courte non signée, les spécifications de format sont respectivement "%ld" et "%hu".

Exemples

1. Description de printf C et les résultats de l'appel de chaque fonction :

2. Affichez un simple message de dialogue :

printf("message");

3. Code du programme :

Les expressions spécifiées avant les spécifications de format sont imprimées à l'écran, tout comme les arguments qui suivent la chaîne de format. Le résultat de l'exécution des fonctions printf C ci-dessus, description de la sortie :

Cet exemple illustre l'affichage en utilisant différents formats de chaînes, de variables entières, de caractères et de nombres à virgule flottante.

Fonction d'entrée standard scanf et exemples de son utilisation

La fonction scanf est utilisée pour lire la saisie au clavier. La description de printf et scanf en C est fournie dans le fichier d'en-tête "stdio.h".

scanf("spécificateurs de format",&valeur1,&valeur2, ...);

Un exemple simple de travail avec la fonction scanf :

#inclure

Pour sortie formatée en PHP Deux fonctionnalités intéressantes sont utilisées : printf() Et sprintf(). Ils ont de nombreuses capacités, dont nous parlerons dans cet article.

Je dirai tout de suite que la différence entre printf() Et sprintf() seulement que le premier affiche la chaîne directement dans le flux de sortie (par exemple, vers le navigateur) et que le second la renvoie.

Un paramètre de fonction est une chaîne qui a caractères avec %, appelés spécificateurs, Et caractères sans %, appelés directives. Les directives restent inchangées une fois formatées, mais le spécificateur conduit à la substitution d'autres paramètres de fonction (en suivant la ligne de format).

Il existe plusieurs spécificateurs regroupés en un seul groupe (un commun % ), dont l'ordre est le suivant :

1. Spécificateur de remplissage. Vous permet de remplir une chaîne à une taille spécifiée avec un caractère spécifique. Par défaut, ce caractère est un espace.
2. Spécificateur d'alignement. Ce spécificateur vous permet de définir l'alignement des lignes à droite (par défaut) ou à gauche (si vous spécifiez " - ").
3. Spécificateur de largeur minimale. Si le résultat a une longueur de chaîne plus courte, il sera rempli de caractères du spécificateur de remplissage jusqu'à la largeur spécifiée.
4. Spécificateur de précision. Vous permet de spécifier le nombre de décimales à laisser pour un nombre à virgule flottante.
5. Spécificateur de type. Ce spécificateur spécifie le type de données à afficher. Il y en a 8, mais en pratique on utilise les suivants :
   • d- un entier sous forme décimale.
   • F- un nombre à virgule flottante sous forme décimale.
   • s- doubler.

Regardons le classique exemple pour afficher une date formatée:

$année = 2012 ;
$mois = 9 ;
$jour = 28 ;
printf("Date d'écriture : %02d.%02d.%04d", $jour, $mois, $année);
?>

Il n'est pas difficile de deviner que le résultat sera la ligne suivante : " Date de rédaction de l'article : 28/09/2012". Veuillez noter combien de groupes de spécificateurs, car de nombreux paramètres sont transmis en plus du format lui-même. La ligne " Date de rédaction de l'article :" est une directive, et elle reste inchangée. Regardons maintenant à titre d'exemple le deuxième groupe de prescripteurs, qui est responsable du mois. Les autres groupes sont absolument identiques.

• %
• 0 - un caractère avec lequel le paramètre spécifié sera rempli à la largeur requise.
• 2 - largeur minimale. En conséquence, si la longueur de la ligne est inférieure, elle sera remplie 0 .
• d- sera affiché sous forme d'entier. Si on met par exemple b(un autre spécificateur de type), alors le même numéro sera affiché, mais sous forme binaire.

Je vais t'en donner un autre populaire exemple d'utilisation de la fonction printf (et sprintf()) associé aux nombres arrondis :

$x = 12,596123 ;
printf("%06.2f", $x); // "012.60" sera affiché
?>

Regardons le premier argument de la fonction printf():

• % - le début du groupe de spécificateurs.
• 0 - caractère à remplir à la longueur requise.
• 6 - la longueur requise (le point est bien entendu également inclus dans cette longueur).
• .2 - précision jusqu'à 2 décimales.
• F- type de nombre à virgule flottante. En fait, l’arrondi n’a de sens que pour ce type.

Comme vous pouvez le voir, Fonctions printf() et sprintf() faciliter la résolution de problèmes apparemment assez complexes. Par conséquent, vous devez absolument les avoir dans votre arsenal.