Karakterláncot, változó értéket vagy kifejezést nyomtat.
Szintaxis:

Nyomtatás (karakterlánc)

A print() függvény kiírja az arg argumentumot, amely lehet változó vagy kifejezés.

vsprintf()

Formázott karakterláncot ad vissza (PHP 4 >= 4.1.0, PHP 5)

Leírás:

String vsprintf (karakterlánc formátum, tömb args)

Ez a függvény hasonló a sprintf()-hez, de egy tömböt vesz igénybe, nem pedig változó számú argumentumot.

Egy vagy több értéket nyomtat.
Szintaxis:

Echo(karakterlánc arg1, karakterlánc...)

Az echo() függvény megjeleníti a felsorolt ​​paraméterek értékeit.
Az echo() valójában egy nyelvi konstrukció, így nincs szükség zárójelekre, még akkor sem, ha több argumentumot használunk.
echo "A kódban lévő sortörések mentésre kerülnek és a kimenetben használatosak."
"hogy elkerülje ezt a felhasználást."
"összefűzési operátor";

Adja ki a formázott karakterláncot.
Szintaxis:

Int printf(string formátum [, vegyes args, ...]);

Ugyanazt csinálja, mint a sprintf(), csak az eredményül kapott karakterláncot nem adja vissza, hanem elküldi a felhasználó böngészőjének.

Változóhelyettesítéssel karakterláncformázást hajt végre.
Szintaxis:

Sprintf($formátum [,args, ...])

Ez a függvény egy olyan formátumból összeállított karakterláncot ad vissza, amely néhány speciális karaktert tartalmaz, amelyeket később az argumentumlistában szereplő megfelelő változók értékei helyettesítenek.
A $format formátum karakterlánc tartalmazhat formázási parancsokat, amelyeket egy % karakter előz meg.
Az összes többi karakter a kimeneti karakterláncba másolódik. Minden formátumspecifikátor (vagyis a % karakter és a következő parancsok) egy és csak egy, a $format paraméter után megadott paraméternek felel meg. Ha a %-t normál szimbólumként kell elhelyeznie a szövegben, akkor meg kell dupláznia:

Echo sprintf("A százalék %d%% volt",$százalék);

Minden formátummeghatározó legfeljebb öt elemet tartalmazhat (a % karakter után megjelenő sorrendben):

Egy opcionális mezőméret-specifikáció, amely meghatározza, hogy hány karakter legyen lefoglalva a kimeneti értékhez.
Helyőrző karakterként (ha az érték kisebb, mint a megjelenítendő mező mérete)
szóköz vagy 0 használható, az alapértelmezett szóköz. Bármilyen más kitöltő karaktert megadhat, ha a formátum karakterláncban adja meg, előtte egy aposztróf.
Egy opcionális igazítás-meghatározó, amely megadja, hogy az eredmény a mező jobb vagy bal oldalához igazodik-e. Az alapértelmezés a jobbra igazítás, de megadhatja a balra igazítást a - (mínusz) szimbólum megadásával.

Opcionális szám, amely megadja az érték megjelenítésére szolgáló mező méretét. Ha az eredmény nem szerepel a mezőben, akkor a mező szélein túl fog „nyúlni”, de nem lesz csonkolva.
Egy opcionális szám, amelyet egy pont előz meg, amely megadja, hogy hány tizedesjegy legyen a kapott karakterláncban.
Ezt a specifikációt csak akkor veszi figyelembe, ha lebegőpontos szám kerül kiadásra, ellenkező esetben figyelmen kívül hagyja.
Végül a kimeneti karakterláncba kerülő érték típusának kötelező (megjegyzés - az egyetlen kötelező!) specifikációja:

b - a listából a következő argumentum bináris egész számként kerül kiadásra
c - megjelenik az argumentumban megadott kóddal rendelkező szimbólum
d - egész szám
f - lebegőpontos szám
o - oktális egész szám
s - karakterlánc
x - hexadecimális egész szám kicsikkel a-z betűk
X egy hexadecimális egész szám, nagybetűkkel A-Z

A következőképpen adhatja meg a lebegőpontos számok pontosságát:

$pénz1 = 68,75;
2 dollár = 54,35;
$pénz = $pénz1 + $pénz2;
// echo $money "123.1" lesz a kimenete...
$formázott = sprintf("%01.2f", $pénz);
// echo $formázott "123.10" lesz!

Íme egy példa egy egész szám kiadására, amelyet a szükséges számú nulla előz meg:

$isodate=sprintf("%04d-%02d-%02d",$év,$hónap,$nap);

A karakterláncot a formátumnak megfelelően értelmezi, és az értékeket változókba írja be.

Szintaxis:

Vegyes sscanf(string str, string format [, string var1 ...])

Az sscanf() függvény a printf() függvény ellentéte.

Formátum szerint értelmezi az str stringet, hasonlóan a printf() specifikációhoz.

Ha csak két argumentum van megadva, a kapott értékek egy tömbben kerülnek visszaadásra.

// a sorozatszám lekérése$serial = sscanf("SN/235-0001", "SN/%3d-%4d");
echo $soros*10000+$soros; // kimenetek: 2350001
// és a gyártás dátuma$date = "2000. január 01";
lista($hónap, $nap, $év) = sscanf($date, "%s %d %d");
echo "Dátum: $év-".substr($hónap,0,3)."-$nap";
// kimenetek: 2000-jan-01

További opcionális paraméterek megadásakor (ezeket referenciaként kell átadni)

a függvény visszaadja a számukat. Azokat a változókat, amelyek nem kapnak értéket, nem veszik figyelembe a visszatérési értékben.

// XML rekord létrehozása a $auth = "765tLewis Carroll" karakterláncból;
$n = sscan($auth,"%dt%s %s", &$id, &$first, &$last);
visszhang"
$első
$utolsó
n";

fprintf()

Leírás:

Int fprintf (erőforráskezelő, karakterláncformátum [, vegyes args])

A formázási karakterlánc segítségével létrehozott karakterláncot ír abba az adatfolyamba, amelynek leíróját átadjuk a kezelőnek. A format argumentumról a sprintf() függvény leírása részletesen szól.

fprintf(): kitöltés nullákkal

Visszatérés;

fprintf($fp, "%04d-%02d-%02d", $év, $hónap, $nap);
// a dátum.txt fájlba írja a formázott dátumot
?>

fprintf(): pénzbeli értékek formázása

if (!($fp = fopen("currency.txt", "w")))
Visszatérés;

$pénz1 = 68,75;
2 dollár = 54,35;
$pénz = $pénz1 + $pénz2;
// echo A $money "123.1"-et fog kiadni;
$len = fprintf($fp, "%01.2f", $pénz);
// a "123.10" karakterlánc a pénznem.txt fájlba kerül

echo "$len bájt a valuta.txt fájlba írva";
?>

vfprintf()

Formázott karakterláncot ír egy adatfolyamba (PHP 5)

Leírás:

Int vfprintf (erőforrás-leíró, karakterlánc-formátum, tömb-args)

Formátum szerint formázott karakterláncot ír a handle által megadott adatfolyam-erőforráshoz. A formázás a sprintf()-hez hasonlóan történik.

Ugyanúgy működik, mint az fprintf(), de változó számú argumentum helyett argumentumtömböt vesz fel.

A kimeneti karakterlánc hosszát adja vissza.

Lásd még: printf(), sprintf(), sscanf(), fscanf(), vsprintf() és number_format().
Példák

vfprintf(): nullával kitöltött egész számok

if (!($fp = fopen("dátum.txt", "w")))
Visszatérés;

vfprintf($fp, "%04d-%02d-%02d", array($év, $hónap, $nap));
// a formázott ISO-dátumot a date.txt fájlba írja
?>

vprintf()

Formázott karakterláncot ad ki (PHP 4 >= 4.1.0, PHP 5)

Leírás:

Int vprintf (karakterlánc formátum, tömb args)

Az args tömb értékeit adja ki, a sprintf() függvény dokumentációjában leírt format argumentum szerint formázva.

Ez a függvény hasonló a printf()-hez, de inkább egy tömböt vesz igénybe, mint változó számú argumentumot.

A kimeneti karakterlánc hosszát adja vissza

number_format()

Csoportbontással formáz egy számot (PHP 3, PHP 4, PHP 5)

Leírás:

String number_format (lebegő szám [, int decimális])

string number_format (lebegő szám, int tizedesjegy, karakterlánc dec_point, string ezers_sep)

A number_format() a formázott számot adja vissza. A függvény egy, kettő vagy négy argumentumot vesz fel (nem hármat):

Ha csak egy argumentumot adunk meg, a szám tört rész nélkül, de a 3-as számjegycsoportok között vesszővel ("") kerül formázásra.

Ha két argumentumot adunk át, a szám tizedesjegyekkel lesz formázva a pontok (".") és vesszőkkel (",") a 3-as számjegycsoportok között.

Ha mind a négy argumentumot átadja, a szám tizedesjegyekkel lesz formázva a pont után, és a 3-as számjegycsoportok között elválasztójelet használ, tizedesvesszőként a dec_point, csoportelválasztóként pedig a ezers_sep értéket.

A ezers_sep karakterláncnak csak az első karaktere kerül felhasználásra. Például, ha az 1000-es szám formázásához a foo-t adjuk át ezers_sep-ként, a number_format() 1f000-et ad vissza.

Példa a number_format() használatára

Franciaországban általános a két tizedesjegy (",") és a szóköz (" ") használata csoportelválasztóként. Ez a formázás a következő kóddal érhető el:

$szám = 1234,56;

// angol formátum (alapértelmezett)
$angol_formátum_szám = szám_formátum($szám);
// 1,234

// Francia formátum
$nombre_format_francais = szám_formátum($szám, 2, ",", " ");
// 1 234,56

$szám = 1234,5678;

// Angol formátum csoportelválasztó nélkül
$angol_formátum_szám = szám_formátum($szám, 2, ".", "");
// 1234.57

A PHP sprintf függvénye lehetővé teszi számos argumentum konvertálását és egyetlen karakterláncba illesztését. A formázási specifikációk lehetővé teszik, hogy karakterekkel, karakterláncokkal, egész számokkal és valós számokkal dolgozzon.

A függvény táblázatos információk formázására és sablonok létrehozására szolgál. Használható a forrásadatok előzetes formalizálására egy bizonyos struktúrában, megváltoztatva azok tartalmát vagy sorrendjét.

PHP sprintf() függvény szintaxisa

A függvény eredménye egy karaktersorozat, amely meghatározott adatokból, függvényparaméterekből meghatározott sorrendben alakul ki:

• formátum karakterlánc;
• érvek listája.

A formázáshoz bármilyen kialakítást és logikát használhat, beleértve a HTML-címkéket is. Bár a sprintf használatára nincsenek korlátozások, a PHP kézikönyv a konverziós specifikációkat inkább a numerikus információk felé határozza meg.

A format elem egy % karakterrel kezdődik és egy minősítő karakterrel végződik. A formázási lehetőségek többsége a numerikus információk területén található. Nagyon praktikus, ha egy számot bináris és hexadecimális formátumba lehet konvertálni. Itt a PHP sprintf függvényét aligha érdemes helyettesíteni.

A fenti példa rávilágít az argumentumok elnevezésére és az x specifikáció X-től való megkülönböztetésére vonatkozó szabályokra. A formázott argumentumsorozatra mutató hivatkozások helyes használata fontos a helyes eredmény érdekében. A számozás mindig 1-től kezdődik.

A hivatkozások használatának sorrendje nem számít, de fontos megjegyezni: a PHP sprintf függvénye az összes % elemet (az argumentumszám megadása nélkül) egymás után veszi figyelembe az általános listában. Sem a számnak, sem a konkrét paraméterszámokkal megadott % elemek sorrendjének nincs köze az általános lista számozásához.

Példa leírása a sprintf használatára PHP-ben

Ha az argumentumot közvetlenül nem lehet stringként kezelni, akkor a formátum string kezelése és a digitális információ kimenete az eredmény karakterláncba nem jelent problémát.

A példa első két sorában (az Arg1, Arg2c és Arg2p argumentumok kimenete) az első argumentum - a karakterlánc (pozíciónév) úgy kerül kiadásra, ahogy van. A harmadik argumentum 12 (14) karaktert foglal el a kimenetben. Az első sor a bal oldali számot nullákkal igazítja, összesen 12 karakter hosszúságig. A pont után négy karakter van. A második sor a jobb oldali számot (a tört részt) 14 karakterre igazítja. Egy jel, hogy jobbra kell igazodnia, a - szimbólum.

A formátum karakterlánc egy szabályos karakterlánc. Számított kifejezéseket illeszthet be. Ebben az esetben a ($cL) és ($cR) beillesztések egy másik szám kiemelésére szolgálnak. Ez minden példában világosabbá és könnyebben írhatóvá tette a formátum karakterláncát.

Formátumkarakterlánc generálása

A PHP munkája oroszul, vagy a sprintf függvény, a tolmács munkája természetes és kényelmes környezetben. Valójában egy HTML-oldal PHP kód beillesztésekkel bármilyen kontextust képvisel bármilyen nyelven. Ez nem az a szabadság, amelyet a JavaScript biztosít böngészőkörnyezetben.

Az orosz tartalom PHP-ben történő kiadásához nem kell cirill betűt kódolni, de néha az iconv() konverziós függvényt kell használni. Mindenesetre minden elérhető és olvasható.

A PHP-kód HTML-oldalba történő beillesztésének szövege világos és releváns. Használat a karakterláncban:

Változó érték ABC=($ABC) egység

A beszúrás ($ABC) csak egyszer számít, és csak egyszer kerül végrehajtásra.

A PHP-kód oldalon történő végrehajtásának jellemzői

Tolmács csak egyszer megtekinti az oldalt és csak egyszer lecseréli a betéteket ($ABC) az értékükre. A programozó saját belátása szerint használhatja a kifejezést "csak egyszer", arra kényszerítve a PHP-t, hogy ismételten megközelítse a kívánt eredményt.

Mindenesetre, miután a HTML oldalt elküldtük a böngészőnek, nincs benne PHP kód.

Ha a böngésző egy oldaleleme kapcsolatba lép a szerverrel, akkor elindíthat egy új PHP szkriptet. Itt a beillesztések ($ABC) nagyon relatívak, és nincs garancia a helyes eredményre. De a sprintf PHP-ben való használata egy ilyen lehetőség dinamikája.

A fejlesztő nem csak egy ilyen beillesztés kívánt végrehajtását kaphatja meg, hanem megváltoztathatja azt a sort is, amelyre átviszi a kívánt értéket.

A tartalom kialakulásának pillanata

Természetes, hogy a PHP-ben rejlő lehetőségeket HTML-oldalak beszúrásaként, a teljes oldal generálására szolgáló eszközként használjuk fel. Itt kezdődik az oldal. Amint az oldal létrejön, és a látogató valóban megérkezik az oldalra, akkor a modern elképzelések szerint:

• az oldal nem módosítható;
• hiányzik a felhasználó Azonos ez tiltott.

Valójában a látogató felkereste az oldalt, és megkapta az első választ HTML kód formájában. Teljesen helytelen megváltoztatni ezt a választ – ez azt jelenti, hogy közöljük a látogatóval, hogy az oldal megváltoztatja azt. De az oldalnak megfelelően és az ő kezdeményezésére kell reagálnia a látogató cselekedeteire.

A látogató érkezése az első válasz. A látogatói akció az oldal adekvát reakciója és felkészítése a látogató minden várható következő lépésére.

A látogató kezdeményezésére az oldal dinamikájáért a felelősség jelentős része a JavaScriptre hárul, de az csak a böngészőben működik, és csak AJAX kéréseket tud küldeni a szervernek. A szerver minden hívása elindíthat egy PHP szkriptet. De az oldalképzés pillanata és a kérésre adott válasz pillanata jelentősen különbözik.

A PHP sprintf függvény ideális eszköz a válaszsablon dinamikus generálására és a kívánt értékkel való kitöltésére.

PHP kód módosítása futás közben

A kóddinamika ötlete az első programozási nyelvvel együtt született, és ma már minden modern programozási nyelvben jelen van.

A kód végrehajtása az eval (kódsor) segítségével ma biztonsági résnek számít, de annyira népszerű, mint amennyire veszélyes.

A kód futás közbeni megváltoztatásához ma már nem kell az eval() függvényt használni. Ez inkább egy gyors reggeli, egy-két parancs végrehajtása, nem pedig gyakorlati alap a kívánt dinamika felépítéséhez.

A PHP sprintf() függvénye lehetővé teszi egy szkriptsablon megtervezését, például egy objektumkódot, amely akkor kerül meghívásra, amikor egy adott látogatói művelet megtörténik. Az a bevett gyakorlat, hogy az objektumok testeit önálló fájlok formájában rögzítik, ideális megoldást jelentenek azok megváltoztatására az oldal működése során.

A sprintf() funkcionalitását kiegészítő eszközök használatával nem csak az adott látogató tevékenységei eredményeként használt objektumokat módosíthatja, hanem ezt a dinamikát átviheti a többi látogatóval való együttműködésre is: ez az oldal fejlesztése, működőképességének dinamikája, a munkatapasztalatok és ismeretek felhalmozódása.

A konzol szabványos kimeneti funkciója C-ben a printf. Leírását az stdio.h fejlécfájl tartalmazza. Ezzel a funkcióval adatokat vagy felhasználói üzeneteket küldhet ki a konzolra. A C nyelv megkülönbözteti a kis- és nagybetűket. Például a két függvény, a printf és a scanf különbözik a hasonló Printf és Scanf függvényektől. A printf és scanf függvények minden karakterét szintén kisbetűvel kell írni. A C printf egyik legegyszerűbb példája, amely az ismerős hello world üdvözletet nyomtatja ki:

A printf csoport függvényeinek meghatározása az "stdio.h" fájlban

Az "stdio.h" fájl a szabványos C nyelvű bemeneti/kimeneti könyvtárra utal, amelyben a printf és hasonló funkciók leírása a következőképpen szerepel:

A felsorolt ​​függvények bizonyos helyekről töltik be az adatokat, karakterláncokká alakítják, és meghatározott kimeneti folyamokba küldik.

A printf függvénycsalád

A C nyelvű printf csoportfüggvények a szabványos adatfolyamba történő kimenet feldolgozására és formázására szolgálnak. Ezenkívül a printf és a vprintf függvények a szabványos stdout adatfolyamba írnak, az fprintf és vfprintf függvények elküldik a kimeneti argumentumok értékeit egy meghatározott kimeneti adatfolyamba, az snprintf, sprintf, vsnprintf és vsprintf pedig egy karakterláncba írnak adatokat. Az összes felsorolt ​​függvény olyan formátumkarakterlánc használatával működik, amely megadja a kimenethez szükséges argumentumkonverziókat.

Az fprintf függvény az eredményt a kimeneti adatfolyamba írja. A sprintf függvény az eredményt egy pufferbe adja ki, amely egy karakterlánc. A függvény viselkedése definiálatlan, ha a kiadandó karakterlánc meghaladja a puffertömb méretét.

Az snprintf függvény az előzőhöz hasonlóan egy string pufferbe írja az adatokat. Az eredményül kapott karakterlánc null-végű, hacsak a bufsz (pufferméret) nem nulla. Ellenkező esetben, ha a bufsz nulla, akkor semmi nem kerül kimenőbe a pufferbe, és maga a puffer is lehet nulla mutató, de a visszatérési érték (az írandó bájtok száma) továbbra is kiszámításra kerül.

A printf_s függvény alapvetően ugyanúgy működik, mint a printf, egy dolgot kivéve. A fő különbség a printf_s leírásában a C-ben és a printf-ben a következő: a printf_s függvény ellenőrzi, hogy a formátum karakterláncban vannak-e érvényes karakterek, ellentétben a printf-vel, amely csak a formátumkarakterláncot ellenőrzi nullmutató esetén.

Nézzük meg közelebbről a printf függvényt.

Általános leírása

C-ben a karakterek szabványos kimenetre történő nyomtatása a printf függvény meghívásával történik. A printf parancs C-ben formázza a kimeneti adatok halmazát, és elküldi az stdout-nak. A függvénynek argumentumként átadott értékek a megadott formátumú karakterláncnak megfelelően kerülnek ki a konzolra, amely viszont kétféle elemet tartalmaz. Az első típus a képernyőn megjelenő karakterek, a második típusba azok az elemek tartoznak, amelyek meghatározzák az adatformátum jellemzőit, és felelősek a kimenet során az argumentumok bemutatásának módjáért.

Amikor a változókat printf-vel adjuk ki C-ben, az argumentum-karakterlánc meghatározott karakterkombinációit a karakterek szerint átalakított adatok helyettesítik, és minden adattípusnak megvannak a saját kimeneti formátum-specifikációi.

A függvény típusa és visszatérési értéke

A printf függvény egy egész értéket ad vissza, amely a képernyőre nyomtatott karakterek számát jelzi. Például hozzárendelheti:

int k = printf("Szia %c %d %s", "a", 11, "mindenki!"),

majd a k változó értékéből könnyen megállapítható, hogy történt-e hiba a kimenet során. Ha negatív értéket ad vissza (ha a függvény "-1"-et adott vissza), akkor arra következtethetünk, hogy hiba történt a végrehajtása során.

Szintaxis és függőségek

A printf függvény használatához a következőképpen kell szerepeltetnie az "stdio.h" fejlécfájlt:

#beleértve

A függvénysablon így néz ki:

int printf(const char *formátum, ...)

Az ellipszis a kiadandó argumentumok listájára utal. A printf függvény különböző számú argumentummal használható, de az elsőt mindig dupla idézőjelek határolják el mindkét oldalon, és minden következőt vesszővel kell elválasztani az előzőtől. Ami dupla idézőjelben van írva, és nem formátumspecifikáció, az változtatás nélkül kerül kinyomtatásra, ellenkező esetben, ha egy megadóval találkozunk, annak értéktípusát másoljuk.

Űrlap a formátumspecifikációk megadásához:

%[zászlók][szélesség][.pozíció][hossz]típus

Formázás printf-vel C kimeneti értékekben

A hívott függvény neve után zárójelben megadott formátum karakterlánc csak egy irányban olvasható: balról jobbra, és maga az e sor után megadott első argumentum csak akkor kerül kinyomtatásra, ha az első specifikációval találkozunk. A formátum karakterlánc végéig az abban megadott specifikációk kezdeményezik a későbbi argumentumok konvertálását és kinyomtatását. A formátumú karakterláncban a szóköz karaktert normál karakterként kezeli, és akkor kerül kiadásra, ha nem használja a formátumspecifikációs kifejezésben.

A „%” karakter jelzi a kimeneti formátum specifikációjának elejét, majd a formátumkódot. A specifikáció összes mezője egyedi számok vagy karakterek, amelyek meghatározzák a formázási feltételeket.

A formázott printf kimenetnek C-ben megvannak a maga sajátosságai. Ha a felsorolt ​​argumentumok száma meghaladja a formátumspecifikációk számát, a rendszer kihagyja őket, és nem nyomtatja ki őket. Ellenkező esetben, ha a nyomtatandó argumentumok listájában több formátumspecifikáció van, mint érték, a függvényhívás eredménye nem kerül meghatározásra.

A használandó argumentum kifejezett jelzéséhez használhat "%m$"-t a "%" helyett és "*m$"-t "*" helyett, m-vel pedig egy egész decimális érték, amely a kívánt argumentum pozícióját jelzi. (az indexelés egykor kezdődik) .

Lehetőségek

A formátumban használt zászlók

Zászló	Leírás
-	Az eredmény balra igazítása a kimeneti mezőben
+	Előjeles numerikus érték nyomtatásakor a „+” a pozitív érték elé kerül nyomtatásra (alapértelmezés szerint csak a „-” kerül kinyomtatásra a negatív érték elé)
0	Egész számok és lebegőpontos számok esetén a bevezető nullákat használnak szóköz karakterek helyett a bal oldali számjegyek kitöltésére, ha a mező szélessége nagyobb, mint a szám hossza. Egész számok esetén a jelzőt figyelmen kívül hagyja, ha a pontosság kifejezetten meg van adva. Más, ezt a jelzőt használó konverziók esetén a függvény viselkedése nincs meghatározva. A „0” jelzőt figyelmen kívül hagyja, ha a „-” jelző jelen van
hely	Ha egy előjeles kifejezés kimeneti eredménye nem ezzel az előjellel kezdődik, vagy üres, akkor szóközt kell hozzáadni az eredményhez. A „szóköz” jelzőt figyelmen kívül hagyja, ha a „+” jelző jelen van
#	Az átalakítás egy alternatív formáját hajtják végre

Különféle formátum-specifikációk

Formátummeghatározó	A printf C használata és leírása	Az érv típusa
%	A szó szerinti "%" beírása
c	Egy karakter kimenete. Az argumentum előjel nélküli karaktertípussá alakul. Az "l" módosító használatakor az argumentum karaktersorozattá alakul	előjel nélküli char
s	Nyomtasson ki egy karakterláncot. Az argumentumnak egy mutatónak kell lennie a char tömb kezdőelemére	char*
d én	Előjeles egész érték decimális ábrázolásának nyomtatása	int
o	Előjel nélküli egész érték oktális megjelenítése	aláíratlan int
x x	Előjel nélküli egész érték hexadecimális megjelenítése. Az "a", "b", "c", "d", "e", "f" karakterek az "x" konvertálására szolgálnak. És az "X" - "A", "B", "C", "D", "E", "F" átalakításához	aláíratlan int
u	Kimeneti decimális konverzió előjeles egész szám nélkül. Ha a konvertált érték és a pontosság egyaránt 0, akkor nem jelenik meg karakter	aláíratlan int
f F	Előjeles lebegőpontos szám decimális ábrázolásának nyomtatása	kettős
e E	Tizedes tudományos jelölést ad ki, kerekítve és úgy konvertálva, hogy a tizedesvessző előtt egy számjegy legyen, és a tizedesvessző utáni számjegyek száma megfeleljen az ábrázolás pontosságának (az alapértelmezett pontosság 6, és ha 0 van megadva, akkor a tizedesjel egyáltalán nem jelenik meg). Az „e” karakter a konverziótól függően kis- vagy nagybetűvel jelenik meg	kettős
a A	Egy lebegőpontos szám hexadecimális megjelenítése	kettős
g G	Egy lebegőpontos szám decimális ábrázolását vagy decimális exponenciális ábrázolását adja ki az értéktől és a pontosságtól függően	kettős
n	A printf által kinyomtatott elemek számát adja vissza. Az eredményt az argumentum által mutatott változóba írjuk. A specifikáció nem tartalmazhat zászlókat, mezőszélességet vagy pontosságot	int *
p	Mutató kimenet	érvénytelen *

Mezőszélesség módosító

A printf C formátumsora egész számot írhat a százalékjel után és a format parancs elé. Ez egy mezőszélesség módosító, és befolyásolja a megjelenített adatok megjelenítését. Az értékhez tartozó legkisebb mezőszélességet ez a szám határozza meg, és egy ilyen módosító jelenléte, ha az argumentum kisebb, mint a hozzá rendelt mező, szóközöket vagy nullákat ad az eredményhez. Az alapértelmezett helyőrző a szóköz, de nullára is állíthatja a szélesség specifikáció előtagjának megadásával. A módosító meghatároz egy minimális szélességet, és minden ennél nagyobb érték interferencia nélkül nyomtat. Például egy nyolcnál kevesebb karakterből álló, „%08d” specifikációval nyomtatott szám a szükséges nyolc karakterre lesz kitöltve nullákkal.

Hasonló módosítók pontossági vagy igazítási paramétereket is megadhatnak.

Pontosság módosító

A precíziós módosító a számábrázolásban nyomtatandó tizedesjegyek számának meghatározására szolgál. Precíziós módosító hozzáadásához a mezőszélesség-meghatározás után egy pontot kell tenni, és utána meg kell adni a kívánt pontossági értéket. A precíziós módosító az "e", "f", "a", "E", "A" és "F" formátumokhoz van definiálva. Egész számok esetén a módosító beállítja a megjelenített számjegyek számát, szükség esetén nullákat ad a bal oldali számjegyhez, és racionális számok megjelenítésekor meghatározza a szükséges tizedesjegyek számát. A karakterlánc-változók esetében a precíziós módosító pont utáni szám határozza meg a kimenet maximális mezőhosszát. Például a „%4.8s” formátumspecifikáció miatt egy karakterlánc kerül kiadásra, amelynek hossza négy és nyolc karakter közötti tartományba esik; túllépése esetén a legkülső karakterek kimaradnak.

Egyéb formátummódosítók

Az alapértelmezett igazítás jobbra igazított, de ez megváltoztatható, ha a "%" után egy "-" jelet helyez el. Ez a formátumspecifikáció a balra igazítást állítja be.

Ezenkívül a printf függvény különbséget tud tenni a nyomtatandó egész értékek rövid és hosszú típusai között. Az érvényes specifikációk a következők: "o", "d", "u", "i", "x" és "X". A hosszú érték típusát az "l", a rövid érték típusát a "h" módosító adja meg. Például egy hosszú egész szám és egy rövid előjel nélküli int érték kiadásakor a formátum specifikációi "%ld" és "%hu" lesznek.

Példák

1. A printf C leírása és az egyes függvények meghívásának eredményei:

2. Jelenítsen meg egy egyszerű párbeszédpanelt:

printf("üzenet");

3. Program kód:

A formátumspecifikációk előtt megadott kifejezések, valamint a formátum karakterláncot követő argumentumok megjelennek a képernyőn. A fenti printf C függvények végrehajtásának eredménye, a kimenet leírása:

Ez a példa a megjelenítést szemlélteti karakterláncok, egész változók, karakterek és lebegőpontos számok különböző formátumainak használatával.

Standard bemeneti függvény scanf és példák a használatára

A scanf funkció a billentyűzet bevitelének olvasására szolgál. A printf és scanf leírása C nyelven az „stdio.h” fejlécfájlban található.

scanf("formátummeghatározók",&érték1,&érték2, ...);

Egy egyszerű példa a scanf függvény használatára:

#beleértve

printf("hogyan kell formázni", 1. paraméter, 2. paraméter, ...) -- az eredményt megjeleníti a képernyőn

$eredmény= sprintf(..", .., .., ...) - ugyanaz, csak a sor nem kerül kiadásra, hanem a $eredménybe kerül

Idézet a kézikönyv fordításából ( PÉLDÁK lent:-):

sprintf

sprintf -- formázott karakterláncot ad vissza

Leírás

sprintf (sztring formátum, vegyes ...);

A formátum karakterláncának megfelelően feldolgozott karakterláncot ad vissza formátum .

Olyan formátumkarakterlánc, amely nulla vagy több direktívát tartalmaz: szabályos karakterek (kivéve a %), amelyeket közvetlenül az eredménybe másol a rendszer, és amelyeket közvetlenül az eredménybe másol, és változások leírásai, amelyek mindegyike meghatározott műveleteket hajt végre. Ez vonatkozik a sprintf()és ahhoz printf()

Minden változási nyilatkozat a következő elemekből áll, sorrendben:

További padding specifier, amely megmondja, hogy milyen karaktereket használunk az eredmény megfelelő karakterlánc-méretre való feltöltéséhez. Ezek lehetnek szóközök vagy 0 (nulla karakter). Alapértelmezés szerint szóközökkel van kitöltve. Egy alternatív kitöltési karakter megadható egyetlen idézőjellel ("). Lásd az alábbi példákat.

További igazítási leíró, amely szerint az eredményt balra vagy jobbra kell igazítani. Alapértelmezés szerint az igazítás jobbra van igazítva; - karakter balra igazítást eredményez.

További szélesség-meghatározó, amely azt mondja meg, hogy ez a csere hány karakterrel (minimum) végezhető el.

További precíziós leíró, amely megmondja, hogy hány tizedesjegyet kell megjeleníteni a lebegőpontos számoknál. Ez a leíró nincs hatással a dupla típusokra. (egy másik hasznos funkció a számok formázásához number_format() .)

1. Típusmeghatározó, amely megmondja, hogyan kell kezelni az argumentum adattípusát. Lehetséges típusok:

   % a százalék szimbólum. Nem szükséges érv.

   b - az argumentumot egész számként kezeli, és bináris számként ábrázolja.

   c - az argumentumot egész számként kezeli, és ASCII értékű karakterként ábrázolja.

   d - az argumentumot egész számként kezeli, és decimális számként ábrázolja.

   f - az argumentumot a rendszer duplaként kezeli, és lebegőpontos számként ábrázolja.

   o - az argumentumot egész számként kezeli, és oktális számként ábrázolja.

   s - az argumentumot karakterláncként értelmezi és ábrázolja.

   x - az argumentumot egész számként kezeli, és hexadecimális számként ábrázolja (kisbetűkkel).

   X – az argumentumot egész számként kezeli, és hexadecimális számként ábrázolja (nagybetűkkel).

Példák

Példa 2. sprintf: valuta formázás $pénz1 = 68,75; 2 dollár = 54,35; $pénz = $pénz1 + $pénz2; // echo A $money "123.1"-et fog kiadni; $formázott = sprintf("%01.2f", $pénz); // echo $formázott "123.10" lesz Példák Minden, ami le van írva >>> ilyen zárójelek között <<< a függvény eredménye (azaz egy példa a képernyőre történő kimenetre) $s="MyString"; -> %s sor $f=12345.6789; -> tört %f $d=12345; -> egész %d 10. rendszer: 0123456789 16 számok %x 16. rendszer: 0123456789abcdef 16 számok %X 16. rendszer: 0123456789ABCDEF 8számok %o 8. rendszer: 01234. szám nyomtatás: %b2ndf:6" 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); >>> kívülálló12345szöveg<<< вывод нескольких переменных - последовательное перечисление printf("%d-%f-%s",$d,$f,$s); >>> 12345-12345.678900-MyString<<< выравнивание (ширина 20 символов) по правому краю, пустоту заполняем "_": printf("%"_20s",MyString); >>> ____________MyString<<< выравнивание по левому краю, пустоту заполняем "x": printf("%-"x20s",MyString); >>> MyStringxxxxxxxxxxxxx<<< Lásd a többi példát itt:

(PHP 4, PHP 5, PHP 7)

sprintf - Formázott karakterláncot ad vissza

A paraméterek listája

Egy formátum karakterlánc nulla vagy több direktívából áll: közönséges karakterek (kivéve % ), amelyek közvetlenül a kapott karakterláncba másolódnak, és transzformációs leírók, amelyek mindegyikét egy-egy paraméter helyettesíti. Ez mindkettőre vonatkozik sprintf(), és a printf().

Minden konverzióspecifikátor egy százalékjelből áll ( % ), amelyet egy vagy több további elem követ (az itt felsorolt ​​sorrendben):

1. Választható karakterleíró, jelezve, hogy a (- vagy +) jel hogyan kerül alkalmazásra a számra. Alapértelmezés szerint csak a mínuszjelet használja, ha a szám negatív. Ez a specifikáció azt eredményezi, hogy a pozitív számok is pluszjelet jelenítenek meg, és a PHP 4.3.0-ban került hozzáadásra.
2. Választható padding specifier, amely megadja, hogy melyik karaktert használja az eredmény a kívánt hosszúságúra való feltöltéséhez. Lehet szóköz ill 0 . Az alapértelmezett a szóköz. Egy alternatív karakter megadható egyetlen idézőjel ( " ). Lásd alább a példákat.
3. Választható igazítási leíró, amely a balra vagy jobbra igazítást határozza meg. Alapértelmezés szerint jobbra van igazítva, - balra igazításhoz használják.
4. Opcionális szám szélesség-meghatározó, amely megadja a karakterek minimális számát, amelyet az átalakítás eredménye tartalmazni fog.
5. Választható precíziós leíró, pontként (.") megadva, amelyet egy opcionális decimális karakterlánc követ, amely megadja, hogy hány tizedesjegyet kell megjeleníteni a lebegőpontos számoknál. Ha karakterláncokkal együtt használjuk, ez a specifikátor vágási pontként működik, amely beállítja a maximális karakterkorlátot. A pont és a szám között megadhatja a szám kiegészítéséhez használt szimbólumot is.

6. Típusmeghatározó, amely meghatározza az argumentum adattípusának kezelését. Érvényes típusok:

   • % - százalékos szimbólum. Az érvelést nem használják.
   • b- az argumentumot egész számként kezeli, a kimenetet pedig bináris számként.
   • c- az argumentumot egész számként kezeli, és karakterként adja ki a megfelelő ASCII kóddal.
   • d- az argumentumot egész számként kezeli, és előjeles decimális számként adja ki.
   • e- az argumentumot tudományos jelölésű számként értelmezzük (például 1,2e+2). A pontosság megadja a tizedesjegyek számát a PHP 5.2.1 óta. A korábbi verziókban a jelentős számjegyek számát jelezte (egy jellel kevesebb).
   • E- hasonló %e, de nagybetűt használ (például 1,2E+2).
   • f- az argumentumot a rendszer lebegőpontos számként kezeli, és a területi beállítástól függően is megjelenik.
   • F- az argumentumot a rendszer lebegőpontos számként kezeli, és szintén kimenetre kerül, de nem függ a területtől. PHP 4.3.10-től és PHP 5.0.3-tól kezdve elérhető.
   • g %eÉs %f.
   • G- kiválasztja a legrövidebb bejegyzést %EÉs %f.
   • o- az argumentumot egész számként, a kimenetet pedig oktális számként kell kezelni.
   • s- az argumentumot karakterláncként kezeli.
   • u- az argumentumot egész számként kezeli, és előjel nélküli decimális számként adja ki.
   • x- az argumentumot egész számként kezeli, és hexadecimális számként (kisbetűként) adja ki.
   • x- az argumentumot egész számként kezeli, és hexadecimális számként adja ki (nagybetűvel).

A változók a specifikációnak megfelelő típusra lesznek konvertálva:

Típuskezelés

típus	Meghatározó
húr	s
egész szám	d, u, c, o, x, x, b
kettős	g, G, e, E, f, F

Figyelem

Karakterenként egynél több bájtot igénylő kódolású karakterláncok és szélesség-meghatározók kombinációjának használata váratlan eredményekhez vezethet.

A formátum karakterlánc támogatja a paraméterek számozását és átrendezését. Például:

1. példa A paraméterek sorrendjének megváltoztatása

$szám = 5 ;
$hely = "fa" ;

$formátum = "%d majom ül a %s-on";

?>

Ez a kód a következőt írja ki: "5 majom ül egy fán". Most képzeljük el, hogy a formátum karakterlánc egy külön fájlban van, amelyet ezután lefordítunk egy másik nyelvre, és átírjuk a következőképpen:

2. példa A paraméterek sorrendjének megváltoztatása

$formátum = "%d majom ül a %s-on";
echo sprintf ($formátum, $szám, $hely);
?>

Probléma van: a konverziós specifikációk sorrendje nem egyezik az argumentumok sorrendjével. Nem akarjuk megváltoztatni a kódot, és meg kell adnunk, hogy melyik argumentum melyik konverzióspecifikátornak felel meg.

3. példa A paraméterek sorrendjének megváltoztatása

$formátum = "%1$d majom ül a %2$s-on";
echo sprintf ($formátum, $szám, $hely);
?>

Az argumentumszámozásnak van egy másik haszna is: lehetővé teszi, hogy ugyanazt az argumentumot többször is kinyomtassuk anélkül, hogy további paramétereket adnánk át a függvénynek.

4. példa A paraméterek sorrendjének megváltoztatása

$formátum = "%1$d majom ül a %2$s-on.
Nagyszerű, hogy %2$s %1$d majmon ül.";
echo sprintf ($formátum, $szám, $hely);
?>

A paraméterek sorrendjének megváltoztatásakor pozícióleíró n$ közvetlenül a százalékjel után kell jönnie ( % ) az összes többi leíró előtt, amint az az alábbi példában látható.

5. példa Komplement karakter megadása

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

123 000000123

6. példa A pozíciómeghatározó használata más leírókkal együtt

$formátum = "%1$04d majom ül a %2$s-on";
echo sprintf ($formátum, $szám, $hely);
?>

A példa futtatásának eredménye:

0005 majom ül egy fán

Megjegyzés:

Kísérlet történt ennél nagyobb pozíciómeghatározó használatára PHP_INT_MAX, a funkció figyelmeztetést generál sprintf() .

Figyelem

A c A típusmeghatározó figyelmen kívül hagyja a kitöltést és a szélességet

Visszatérési értékek

A formátumnak megfelelően formázott karakterláncot ad vissza.

Példák

7. példa sprintf(): padding nullákkal

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

// vegye figyelembe, hogy a dupla %% egyetlen "%"-ként jelenik meg
printf ("%%b = "%b"\n" , $n ); // bináris reprezentáció
printf ("%%c = "%c"\n" , $c ); // kiír egy ascii karaktert, hasonlóan a chr() függvényhez
printf ("%%d = "%d"\n" , $n ); // szabályos egész
printf ("%%e = "%e"\n" , $n ); // tudományos jelöléssel
printf ("%%u = "%u"\n" , $n ); // pozitív szám előjel nélküli egész reprezentációja
printf ("%%u = "%u"\n" , $u ); // egy negatív szám előjel nélküli egész reprezentációja
printf ("%%f = "%f"\n" , $n ); // lebegőpontos szám ábrázolása
printf ("%%o = "%o"\n" , $n ); // oktális ábrázolás
printf ("%%s = "%s"\n" , $n ); // vonal
printf ("%%x = "%x"\n" , $n ); // hexadecimális ábrázolás (kisbetű)
printf ("%%X = "%X"\n" , $n ); // hexadecimális ábrázolás (nagybetűs)

Printf ("%%+d = "%+d"\n" , $n ); // jelleíró pozitív egész számmal
printf ("%%+d = "%+d"\n" , $u ); // jelleíró negatív egész számmal
?>

A példa futtatásának eredménye:

%b = "10100111010100110101101" %c = "a" %d = "43951789" %e = "4.39518e+7" %u = "43951789" %u = "4251015507" %f = "43951789.000000" %o = "2475232" 2475232 55 " %s = "43951789" %x = "29ea6ad" %X = "29EA6AD" %+d = "+43951789" %+d = "-43951789"

8. példa printf(): karakterlánc-leírók

$s = "majom" ;
$t = "sok majom" ;

Printf("[%s]\n" , $s ); // normál vonali kimenet
printf ("[%10s]\n" , $s ); // jobbra igazítás szóközökkel
printf ("[%-10s]\n" , $s ); // balra igazítás szóközökkel
printf ("[%010s]\n" , $s ); // a nulla padding karakterláncokkal is működik
printf ("[%"#10s]\n" , $s ); // használja a saját kiegészítő "#" karakterét
printf ("[%10.10s]\n" , $t ); // balra igazítás 10 karakteres levágással
?>