ბეჭდავს სტრიქონს, ცვლადის მნიშვნელობას ან გამონათქვამს.
Სინტაქსი:

ბეჭდვა (სტრიქონი არგ)

print() ფუნქცია ბეჭდავს arg არგუმენტს, რომელიც შეიძლება იყოს ცვლადი ან გამოხატულება.

vsprintf ()

აბრუნებს ფორმატირებულ სტრიქონს (PHP 4 >= 4.1.0, PHP 5)

აღწერა:

სიმებიანი vsprintf (სტრიქონის ფორმატი, მასივის არგები)

ეს ფუნქცია sprintf()-ის მსგავსია, მაგრამ მას სჭირდება არგუმენტების ცვლადი რაოდენობის ნაცვლად მასივი.

ბეჭდავს ერთ ან მეტ მნიშვნელობას.
Სინტაქსი:

ექო (სტრიქონი arg1, სიმებიანი ...)

echo() ფუნქცია აჩვენებს ჩამოთვლილი პარამეტრების მნიშვნელობებს.
echo() რეალურად არის ენის კონსტრუქცია, ამიტომ მას არ სჭირდება ფრჩხილები, თუნდაც მრავალი არგუმენტის გამოყენება.
echo "კოდში არსებული ხაზების შეფერხებები ინახება და გამოიყენება გამომავალში."
"ამ გამოყენების თავიდან ასაცილებლად."
"შეერთების ოპერატორი";

გამოიტანეთ ფორმატირებული სტრიქონი.
Სინტაქსი:

Int printf(string format [, mixed args, ...]);

აკეთებს იგივეს, რაც sprintf(), მხოლოდ მიღებული სტრიქონი არ ბრუნდება, არამედ იგზავნება მომხმარებლის ბრაუზერში.

ასრულებს სტრიქონების ფორმატირებას ცვლადის ჩანაცვლებით.
Სინტაქსი:

Sprintf ($ფორმატი [,args, ...])

ეს ფუნქცია აბრუნებს სტრიქონს, რომელიც დაფუძნებულია ფორმატის სტრიქონზე, რომელიც შეიცავს ზოგიერთს სპეციალური სიმბოლოები, რომელიც შემდგომში შეიცვლება არგუმენტების სიიდან შესაბამისი ცვლადების მნიშვნელობებით.
$format ფორმატის სტრიქონი შეიძლება შეიცავდეს ფორმატირების ბრძანებებს, რომლებსაც წინ უძღვის % სიმბოლო.
ყველა სხვა სიმბოლო კოპირებულია გამომავალ სტრიქონში, როგორც არის. თითოეული ფორმატის სპეციფიკატორი (ანუ % სიმბოლო და შემდეგი ბრძანებები) ემთხვევა მხოლოდ ერთ და მხოლოდ ერთ პარამეტრს, რომელიც მითითებულია $format პარამეტრის შემდეგ. თუ თქვენ გჭირდებათ % განათავსოთ ტექსტში, როგორც ჩვეულებრივი სიმბოლო, თქვენ უნდა გააორმაგოთ იგი:

Echo sprintf("პროცენტი იყო %d%%",$percentage);

თითოეული ფორმატის სპეციფიკატორი შეიცავს მაქსიმუმ ხუთ ელემენტს (იმ თანმიმდევრობით, რომლებიც ისინი გამოჩნდება %) სიმბოლოს შემდეგ:

არჩევითი ველის ზომის დამაზუსტებელი, რომელიც განსაზღვრავს რამდენი სიმბოლო იქნება გამოყოფილი გამომავალი მნიშვნელობისთვის.
როგორც ჩანაცვლების სიმბოლოები (თუ მნიშვნელობა უფრო მცირეა, ვიდრე ველის ზომა, რათა გამოჩნდეს)
შეიძლება გამოყენებულ იქნას ინტერვალი ან 0, ნაგულისხმევი არის ინტერვალი. თქვენ შეგიძლიათ მიუთითოთ შემავსებლის ნებისმიერი სხვა სიმბოლო, თუ მას მიუთითებთ ფორმატის სტრიქონში, რომელსაც წინ უძღვის აპოსტროფი.
არჩევითი გასწორების დამახასიათებელი, რომელიც განსაზღვრავს, შედეგი იქნება გასწორებული ველის მარჯვნივ ან მარცხნივ. ნაგულისხმევი არის მარჯვენა გასწორება, მაგრამ შეგიძლიათ მიუთითოთ მარცხნივ გასწორება - (მინუს) სიმბოლოს მითითებით.

არასავალდებულო ნომერი, რომელიც განსაზღვრავს ველის ზომას მნიშვნელობის ჩვენებისთვის. თუ შედეგი არ არის ველში, მაშინ ის „გავრცელდება“ ამ ველის კიდეებს მიღმა, მაგრამ არ შეიკვეცება.
არასავალდებულო რიცხვი, რომელსაც წინ უძღვის წერტილი ".", რომელიც განსაზღვრავს რამდენი ათობითი ადგილი იქნება მიღებული სტრიქონში.
ეს მახასიათებელი მხედველობაში მიიღება მხოლოდ იმ შემთხვევაში, თუ გამოდის მცურავი წერტილის ნომერი, წინააღმდეგ შემთხვევაში ის იგნორირებულია.
და ბოლოს, მნიშვნელობის ტიპის საჭირო (შენიშვნა - ერთადერთი საჭირო!) სპეციფიკატორი, რომელიც განთავსდება გამომავალ სტრიქონში:

b - სიიდან შემდეგი არგუმენტი გამოდის ბინარული რიცხვის სახით
c - გამოსახულია არგუმენტში მითითებული კოდის სიმბოლო
d - მთელი რიცხვი
ვ - მცურავი წერტილის ნომერი
o - რვიანი მთელი რიცხვი
s - სიმბოლოების სტრიქონი
x - თექვსმეტობითი მთელი რიცხვი პატარებით ასო ა-ზ
X არის თექვსმეტობითი რიცხვი დიდი ასოებით A-Z

აი, როგორ უნდა დააკონკრეტოთ მცურავი წერტილის რიცხვების სიზუსტე:

$ ფული1 = 68,75;
$ ფული2 = 54,35;
$money = $money1 + $money2;
// echo $money გამოვა "123.1"...
$formatted = sprintf("%01.2f", $money);
// echo $formatted გამოვა "123.10"!

აქ მოცემულია მთელი რიცხვის გამოტანის მაგალითი, რომელსაც წინ უძღვის ნულების საჭირო რაოდენობა:

$isodate=sprintf("%04d-%02d-%02d",$year,$month,$day);

ახდენს სტრიქონის ინტერპრეტაციას ფორმატის მიხედვით და შეაქვს მნიშვნელობებს ცვლადებში.

Სინტაქსი:

შერეული sscanf (სტრიქონის str, სტრიქონის ფორმატი [, string var1 ...])

sscanf() ფუნქცია არის printf() ფუნქციის საპირისპირო.

ის განმარტავს string str-ს ფორმატის მიხედვით, printf() სპეციფიკაციის მსგავსი.

როდესაც მითითებულია მხოლოდ ორი არგუმენტი, მიღებული მნიშვნელობები ბრუნდება მასივში.

// სერიული ნომრის მიღება$serial = sscanf("SN/235-0001", "SN/%3d-%4d");
echo $serial*10000+$serial; // გამომავალი: 2350001
// და წარმოების თარიღი$date = "იანვარი 01 2000";
სია ($თვე, $დღე, $წელი) = sscanf($თარიღი, "%s %d %d");
echo "თარიღი: $year-".substr($month,0,3)."-$dayn";
// გამომავალი: 2000-იან-01

დამატებითი არჩევითი პარამეტრების მითითებისას (ისინი უნდა გადაეცეს მითითებით)

ფუნქცია აბრუნებს მათ რიცხვს. ის ცვლადები, რომლებიც არ იღებენ მნიშვნელობებს, არ არის გათვალისწინებული დაბრუნების მნიშვნელობაში.

// XML ჩანაწერის გენერირება $auth = "765tLewis Carroll" სტრიქონიდან;
$n = სკანირება ($auth,"%dt%s %s", &$id, &$first, &$last);
ექო"
$ პირველი
$ ბოლო
n";

fprintf ()

აღწერა:

Int fprintf (რესურსის სახელური, სიმებიანი ფორმატი [, შერეული არგები])

ფორმატის სტრიქონის გამოყენებით შექმნილ სტრიქონს წერს ნაკადს, რომლის სახელურიც გადაეცემა სახელურს. ფორმატის არგუმენტი დეტალურად არის განხილული sprintf() ფუნქციის აღწერაში.

fprintf(): ავსება ნულებით

დაბრუნების;

fprintf($fp, "%04d-%02d-%02d", $year, $month, $day);
// წერს ფორმატირებულ თარიღს ფაილის date.txt-ზე
?>

fprintf(): ფულადი მნიშვნელობების ფორმატირება

if (!($fp = fopen("currency.txt", "w")))
დაბრუნების;

$ ფული1 = 68,75;
$ ფული2 = 54,35;
$money = $money1 + $money2;
// echo $money გამოვა "123.1";
$len = fprintf ($fp, "%01.2f", $money);
// სტრიქონი "123.10" იწერება ფაილში currency.txt

echo "$len bytes ჩაწერილი ფაილში currency.txt";
?>

vfprintf ()

წერს ფორმატირებულ სტრიქონს ნაკადში (PHP 5)

აღწერა:

Int vfprintf (რესურსის სახელური, სიმებიანი ფორმატი, მასივის არგები)

სახელურით მითითებულ ნაკადის რესურსზე წერს სტრიქონს, ფორმატირებულ ფორმატის მიხედვით. ფორმატირება ხდება ისევე, როგორც sprintf().

მუშაობს ისევე, როგორც fprintf(), მაგრამ იღებს არგუმენტების მასივს და არა არგუმენტების ცვლადი რაოდენობას.

აბრუნებს გამომავალი სტრიქონის სიგრძეს.

აგრეთვე იხილეთ: printf(), sprintf(), sscanf(), fscanf(), vsprintf() და number_format().
მაგალითები

vfprintf(): ნულოვანი მთელი რიცხვები

if (!($fp = fopen("date.txt", "w")))
დაბრუნების;

vfprintf($fp, "%04d-%02d-%02d", მასივი ($წელი, $თვე, $დღე));
// ჩაწერს ISO ფორმატირებულ თარიღს date.txt
?>

vprintf ()

გამოაქვს ფორმატირებული სტრიქონი (PHP 4 >= 4.1.0, PHP 5)

აღწერა:

Int vprintf (სტრიქონის ფორმატი, მასივის არგები)

ბეჭდავს args მასივის მნიშვნელობებს, ფორმატირებული ფორმატის არგუმენტის მიხედვით, რომელიც აღწერილია sprintf() ფუნქციის დოკუმენტაციაში.

ეს ფუნქცია მსგავსია printf(), მაგრამ მას არგუმენტების ცვლადი რაოდენობის ნაცვლად, მასივი სჭირდება.

აბრუნებს გამომავალი სტრიქონის სიგრძეს

ნომერი_ფორმატი()

აფორმებს რიცხვს ჯგუფური გამოყოფით (PHP 3, PHP 4, PHP 5)

აღწერა:

სტრიქონის ნომერი_ფორმატი (მოძრავი ნომერი [, ათწილადებში])

სტრიქონის ნომერი_ფორმატი (float number, int ათწილადები, სტრიქონის dec_point, string ათასობით_სექ.)

number_format() აბრუნებს ფორმატირებულ ნომერს. ფუნქცია იღებს ერთ, ორ ან ოთხ არგუმენტს (და არა სამს):

თუ მხოლოდ ერთი არგუმენტი გაიცემა, რიცხვი ფორმატირდება წილადი ნაწილის გარეშე, მაგრამ მძიმით ("") 3 ციფრიან ჯგუფს შორის.

თუ ორი არგუმენტი გადაიცემა, რიცხვი დაფორმირდება ათწილადებით წერტილების (".") და მძიმეებით ("") 3-იანი რიცხვების ჯგუფებს შორის.

თუ ოთხივე არგუმენტი ჩაბარებულია, რიცხვი დაფორმატდება ათწილადებით წერტილის შემდეგ და გამყოფი 3-იანი რიცხვების ჯგუფებს შორის, დეკ_პუნქტის გამოყენებით, როგორც ათობითი წერტილი და ათასობით_სეპ, როგორც ჯგუფის გამყოფი.

გამოიყენება ათასობით_სეპ ხაზის მხოლოდ პირველი სიმბოლო. მაგალითად, თუ 1000 რიცხვის დასაფორმებლად foo-ს გადასცემთ ათასობით_სეპ-ს, number_format() აბრუნებს 1f000-ს.

ნომერი_format() გამოყენების მაგალითი

საფრანგეთში ჩვეულებრივია გამოიყენონ 2 ათობითი ადგილი ("") და სივრცე (""), როგორც ჯგუფის გამყოფი. ეს ფორმატირება მიიღება შემდეგი კოდის გამოყენებით:

$ნომერი = 1234.56;

// ინგლისური ფორმატი (ნაგულისხმევი)
$english_format_number = ნომერი_ფორმატი ($number);
// 1,234

// ფრანგული ფორმატი
$nombre_format_francais = ნომერი_ფორმატი ($ნომერი, 2, ","", " ");
// 1 234,56

$ნომერი = 1234.5678;

// ინგლისური ფორმატი ჯგუფური გამყოფების გარეშე
$english_format_number = ნომერი_ფორმატი ($number, 2, ".", "");
// 1234.57

PHP sprintf ფუნქცია საშუალებას გაძლევთ დააკონვერტიროთ და მოათავსოთ რამდენიმე არგუმენტი ერთი სიმბოლოს სტრიქონში. ფორმატირების სპეციფიკატორები საშუალებას გაძლევთ იმუშაოთ სიმბოლოებთან, სტრიქონებთან, მთელ რიცხვებთან და რეალურ რიცხვებთან.

ფუნქცია გამოიყენება ცხრილის ინფორმაციის ფორმატირებისთვის და შაბლონების შესაქმნელად. ის შეიძლება გამოყენებულ იქნას წყაროს მონაცემების წინასწარი ფორმალიზაციისთვის გარკვეულ სტრუქტურაში, შეცვალოს მათი შინაარსი ან თანმიმდევრობა.

PHP sprintf() ფუნქციის სინტაქსი

ფუნქციის შედეგი არის სიმბოლოების სტრიქონი, რომელიც ჩამოყალიბებულია გარკვეული თანმიმდევრობით კონკრეტული მონაცემებისგან, ფუნქციის პარამეტრებისგან:

• ფორმატის სტრიქონი;
• არგუმენტების სია.

ფორმატირებისთვის შეგიძლიათ გამოიყენოთ ნებისმიერი დიზაინი და ლოგიკა, HTML ტეგების ჩათვლით. მიუხედავად იმისა, რომ არ არსებობს შეზღუდვები sprintf-ის გამოყენებასთან დაკავშირებით, PHP სახელმძღვანელო უფრო მეტად განსაზღვრავს კონვერტაციის მახასიათებლებს ციფრული ინფორმაციის მიმართ.

ფორმატის ელემენტი იწყება % სიმბოლოთი და მთავრდება კვალიფიკაციის სიმბოლოთი. ფორმატირების შესაძლებლობების უმეტესობა ციფრული ინფორმაციის არეალშია. რიცხვის ორობით და თექვსმეტობით ფორმატში გადაქცევის შესაძლებლობა ძალიან პრაქტიკულია. აქ PHP-ში sprintf ფუნქცია ძნელად ღირს ჩანაცვლების დაწერა.

ზემოთ მოყვანილი მაგალითი ხაზს უსვამს არგუმენტების დასახელების წესებს და განმასხვავებელ x-ს X-დან. მითითებების სწორად გამოყენება ფორმატირებული არგუმენტების თანმიმდევრობისთვის მნიშვნელოვანია სწორი შედეგისთვის. ნუმერაცია ყოველთვის იწყება 1-დან.

ბმულების გამოყენების თანმიმდევრობას მნიშვნელობა არ აქვს, მაგრამ მნიშვნელოვანია გვახსოვდეს: PHP sprintf ფუნქცია განიხილავს ყველა % ელემენტს (არგუმენტის ნომრის მითითების გარეშე) თანმიმდევრობით ზოგად სიაში. არც რიცხვს და არც % ელემენტების თანმიმდევრობას, რომლებიც მითითებულია კონკრეტული პარამეტრის ნომრებით, საერთო სიის ნუმერაციასთან არ არის დაკავშირებული.

PHP-ში sprintf-ის გამოყენების მაგალითის აღწერა

თუ პირდაპირ შეუძლებელია არგუმენტის სტრიქონის სახით მართვა, მაშინ ფორმატის სტრიქონის მართვა და ციფრული ინფორმაციის შედეგის სტრიქონზე გამოტანა პრობლემა არ არის.

მაგალითის პირველ ორ სტრიქონში (არგუმენტების გამომავალი Arg1, Arg2c და Arg2p), პირველი არგუმენტი - სტრიქონი (პოზიციის სახელი) გამოდის როგორც არის. მესამე არგუმენტი იღებს 12 (14) სიმბოლოს გამოსავალში. პირველი ხაზი ამართლებს მარცხნივ რიცხვს ნულებით 12 სიმბოლოს საერთო სიგრძით. წერტილის შემდეგ ოთხი სიმბოლოა. მეორე სტრიქონი ამართლებს რიცხვს მარჯვნივ (წილადი ნაწილი) 14 სიმბოლოთი. ნიშანი იმისა, რომ თქვენ უნდა გაასწოროთ მარჯვნივ არის - სიმბოლო.

ფორმატის სტრიქონი სიმბოლოების ჩვეულებრივი სტრიქონია. შეგიძლიათ მასში ჩასვათ გამოთვლილი გამონათქვამები. ამ შემთხვევაში, ჩანართები ($cL) და ($cR) გამოიყენება სხვა რიცხვის ხაზგასასმელად. ამან გახადა ფორმატის სტრიქონი უფრო ნათელი და ადვილი დასაწერი ყველა მაგალითში.

ფორმატის სტრიქონის გენერირება

რუსულ ენაზე PHP-ის მუშაობა, ანუ sprintf ფუნქცია, არის თარჯიმანის მუშაობა ბუნებრივ და მოსახერხებელ გარემოში. სინამდვილეში, HTML გვერდი PHP კოდის ჩანართებით წარმოადგენს ნებისმიერ კონტექსტს ნებისმიერ ენაზე. ეს არ არის თავისუფლება, რომელსაც JavaScript უზრუნველყოფს ბრაუზერის გარემოში.

რუსული შინაარსის PHP-ში საჩვენებლად, თქვენ არ გჭირდებათ კირიული ანბანის კოდირება, მაგრამ ზოგჯერ უნდა გამოიყენოთ iconv() კონვერტაციის ფუნქცია. ნებისმიერ შემთხვევაში, ყველაფერი ხელმისაწვდომი და წასაკითხია.

PHP კოდის HTML გვერდზე ჩასმის ტექსტი ნათელი და შესაბამისია. გამოყენება სიმბოლოების სტრიქონში:

ცვლადი მნიშვნელობა ABC=($ABC) ერთეული

ჩანართი ($ABC) მნიშვნელოვანია მხოლოდ ერთხელ და შესრულებულია მხოლოდ ერთხელ.

გვერდზე PHP კოდის შესრულების მახასიათებლები

თარჯიმანი მხოლოდ ერთხელნახულობს გვერდს და მხოლოდ ერთხელცვლის ჩანართებს ($ABC) მათი მნიშვნელობებით. პროგრამისტს შეუძლია თავისი შეხედულებისამებრ გამოიყენოს ფრაზა "მხოლოდ ერთხელ",აიძულეთ PHP არაერთხელ მიუახლოვდეს სასურველ შედეგს.

ნებისმიერ შემთხვევაში, როგორც კი HTML გვერდი ბრაუზერში გაიგზავნება, მასში PHP კოდი არ არის.

თუ ბრაუზერის გვერდის ელემენტი იწყებს კონტაქტს სერვერთან, მას შეუძლია ახალი PHP სკრიპტის გაშვება. აქ ჩასმა ($ABC) ძალიან შედარებითია და არ არსებობს სწორი შედეგის გარანტია. მაგრამ PHP-ში sprintf-ის გამოყენება ასეთი შესაძლებლობის დინამიკაა.

დეველოპერს შეუძლია არა მხოლოდ მიიღოს ასეთი ჩასმის სასურველი შესრულება, არამედ შეცვალოს ხაზი, რომელზეც ის გადასცემს სასურველ მნიშვნელობას.

შინაარსის ფორმირების მომენტი

PHP-ის პოტენციალის გამოყენება, როგორც HTML გვერდზე ჩანართების გენერირების საშუალება, როგორც მთელი გვერდის გენერირების ინსტრუმენტი, ბუნებრივია. აქედან იწყება საიტი. როგორც კი გვერდი ჩამოყალიბდება და ვიზიტორი რეალურად მოვა საიტზე, მაშინ თანამედროვე იდეების მიხედვით:

• გვერდის შეცვლა შეუძლებელია;
• მენატრება მომხმარებელი იგივეაკრძალულია.

ფაქტობრივად, ვიზიტორი მოვიდა საიტზე და მიიღო პირველი პასუხი HTML კოდის სახით. ამ პასუხის შეცვლა სრულიად არასწორია - ეს ნიშნავს ვიზიტორს უთხრას, რომ გვერდი ცვლის მას. მაგრამ გვერდი უნდა უპასუხოს ვიზიტორის ქმედებებს ადეკვატურად და მისი ინიციატივით.

სტუმრის ჩამოსვლა პირველი პასუხია. ვიზიტორის მოქმედება არის გვერდის ადეკვატური რეაქცია და მისი მომზადება ვიზიტორის ყველა მოსალოდნელი შემდეგი მოქმედებისთვის.

გვერდის დინამიკაზე პასუხისმგებლობის მნიშვნელოვანი წილი ვიზიტორის ინიციატივით ეკისრება JavaScript-ს, მაგრამ ის მხოლოდ ბრაუზერში ფუნქციონირებს და მხოლოდ AJAX მოთხოვნების გაგზავნას შეუძლია სერვერზე. სერვერზე თითოეულ ზარს შეუძლია PHP სკრიპტის გაშვება. მაგრამ გვერდის ფორმირების მომენტი და მოთხოვნაზე პასუხის მომენტი მნიშვნელოვნად განსხვავდება.

PHP sprintf ფუნქცია იდეალური ინსტრუმენტია პასუხის შაბლონის დინამიურად გენერირებისთვის და სასურველი მნიშვნელობით შევსებისთვის.

PHP კოდის შეცვლა გაშვების დროს

კოდის დინამიკის იდეა დაიბადა პირველ პროგრამირების ენასთან ერთად და დღეს არის ყველა თანამედროვე პროგრამირების ენაში.

კოდის შესრულება eval-ის საშუალებით (კოდის ხაზი) ​​დღეს უსაფრთხოების ხვრელად ითვლება, მაგრამ ის ისეთივე პოპულარულია, რამდენადაც საშიში.

გაშვების დროს კოდის შესაცვლელად, დღეს არ გჭირდებათ eval() ფუნქციის გამოყენება. ეს უფრო სწრაფი საუზმეა, ერთი ან ორი ბრძანების შესრულება, ვიდრე სასურველი დინამიკის ასაშენებლად პრაქტიკული საფუძველი.

PHP sprintf() ფუნქცია საშუალებას გაძლევთ შექმნათ სკრიპტის შაბლონი, მაგალითად, ობიექტის კოდი, რომელიც გამოიძახება კონკრეტული ვიზიტორის მოქმედების დროს. ობიექტების სხეულების დამოუკიდებელი ფაილების სახით ჩაწერის დამკვიდრებული პრაქტიკა იდეალური გადაწყვეტაა მათი შეცვლისთვის საიტის მუშაობის დროს.

ინსტრუმენტების გამოყენება, რომლებიც ავსებენ sprintf()-ის ფუნქციონირებას, საშუალებას გაძლევთ არა მხოლოდ შეცვალოთ კონკრეტული ვიზიტორის მოქმედებების შედეგად გამოყენებული ობიექტები, არამედ გადაიტანოთ ეს დინამიკა სხვა ვიზიტორებთან მუშაობაში: ეს არის საიტის განვითარება, მისი ფუნქციონირების დინამიკა, სამუშაო გამოცდილების და ცოდნის დაგროვება.

სტანდარტული კონსოლის გამომავალი ფუნქცია C-ში არის printf. მისი აღწერა მოცემულია stdio.h სათაურის ფაილში. ამ ფუნქციის გამოყენებით შეგიძლიათ კონსოლში მონაცემების ან მომხმარებლის შეტყობინებების გამოტანა. C ენა არის რეგისტრის მგრძნობიარე. მაგალითად, ორი ფუნქცია printf და scanf განსხვავდება მათი მსგავსი ფუნქციებისგან Printf და Scanf. printf და scanf ფუნქციებში ყველა სიმბოლო ასევე უნდა იყოს დაწერილი პატარა ასოებით. C printf-ის ერთ-ერთი უმარტივესი მაგალითი, რომელიც ბეჭდავს ნაცნობ Hello World მისალმებას, არის:

printf ჯგუფის ფუნქციების განსაზღვრა ფაილში "stdio.h"

ფაილი "stdio.h" ეხება სტანდარტული შეყვანის/გამოსვლის ბიბლიოთეკას C ენაზე. printf და მსგავსი ფუნქციების აღწერა მოცემულია შემდეგნაირად:

ჩამოთვლილი ფუნქციები ატვირთავს მონაცემებს გარკვეული მდებარეობიდან, გარდაქმნის მათ სიმბოლოების სტრიქონად და აგზავნის მითითებულ გამომავალ ნაკადებში.

printf ფუნქციების ოჯახი

printf ჯგუფის ფუნქციები C ენაზე გამოიყენება სტანდარტულ ნაკადზე მონაცემების დასამუშავებლად და ფორმატირებისთვის. უფრო მეტიც, printf და vprintf ფუნქციები ჩაწერენ სტანდარტულ stdout ნაკადს, fprintf და vfprintf ფუნქციები აგზავნიან გამომავალი არგუმენტების მნიშვნელობებს ზოგიერთ მითითებულ გამომავალ ნაკადზე, ხოლო snprintf, sprintf, vsnprintf და vsprintf წერენ მონაცემებს სიმბოლოების სტრიქონში. ჩამოთვლილი ყველა ფუნქცია მუშაობს ფორმატის სტრიქონის გამოყენებით, რომელიც განსაზღვრავს გამოსავალისთვის საჭირო არგუმენტების კონვერტაციას.

fprintf ფუნქცია წერს შედეგს გამომავალი ნაკადის ნაკადში. sprintf ფუნქცია გამოაქვს შედეგი ბუფერში, რომელიც არის სიმბოლოების სტრიქონი. ფუნქციის ქცევა განუსაზღვრელია, თუ გამოსატანი სტრიქონი აღემატება ბუფერული მასივის ზომას.

snprintf ფუნქცია, ისევე როგორც წინა, წერს მონაცემებს სიმებიანი ბუფერში. შედეგად მიღებული სიმბოლოს სტრიქონი ნულდება, თუ bufsz (ბუფერის ზომა) ნულოვანია. წინააღმდეგ შემთხვევაში, თუ bufsz არის ნულოვანი, მაშინ ბუფერში არაფერი გამოვა და ბუფერი თავად შეიძლება იყოს ნულოვანი მაჩვენებელი, მაგრამ დაბრუნებული მნიშვნელობა (ბაიტების რაოდენობა, რომელიც უნდა დაეწერა) მაინც გამოითვლება.

printf_s ფუნქცია ძირითადად მუშაობს ისევე, როგორც printf, ერთი რამის გარდა. მთავარი განსხვავება printf_s-ის აღწერილობაში C-სა და printf-ში შემდეგია: printf_s ფუნქცია ამოწმებს ფორმატის სტრიქონს მოქმედ სიმბოლოებზე, განსხვავებით printf-ისგან, რომელიც მხოლოდ ამოწმებს ფორმატის სტრიქონს null მაჩვენებელზე.

მოდით უფრო ახლოს მივხედოთ printf ფუნქციას.

ზოგადი აღწერა

C-ში, სიმბოლოების დაბეჭდვა სტანდარტულ გამომავალზე ხდება printf ფუნქციის გამოძახებით. printf ბრძანება C-ში აფორმატებს გამომავალი მონაცემების ერთობლიობას და აგზავნის მას stdout-ში. ფუნქციის არგუმენტებად გადაცემული მნიშვნელობები გამოდის კონსოლში მითითებული ფორმატის სტრიქონის მიხედვით, რომელიც თავის მხრივ შეიცავს ორი ტიპის ელემენტს. პირველი ტიპი არის ეკრანზე გამოსახული სიმბოლოები, ხოლო ელემენტები, რომლებიც განსაზღვრავენ მონაცემთა ფორმატის მახასიათებლებს და პასუხისმგებელნი არიან არგუმენტების წარმოდგენის მეთოდზე გამოტანის დროს, ეკუთვნის მეორე ტიპს.

C-ში printf-ით ცვლადების გამოტანისას, არგუმენტის სტრიქონში სიმბოლოების კონკრეტული კომბინაციები იცვლება ამ სიმბოლოების მიხედვით გარდაქმნილი მონაცემებით და მონაცემთა თითოეულ ტიპს აქვს საკუთარი გამომავალი ფორმატის სპეციფიკაციები.

ფუნქციის ტიპი და დაბრუნების მნიშვნელობა

printf ფუნქციას აქვს მთელი რიცხვი, რომელიც მიუთითებს ეკრანზე დაბეჭდილი სიმბოლოების რაოდენობაზე. მაგალითად, შეგიძლიათ დანიშნოთ:

int k = printf("გამარჯობა %c %d %s", "a", 11, "ყველას!"),

და შემდეგ k ცვლადის მნიშვნელობა ადვილად შეუძლია განსაზღვროს, მოხდა თუ არა შეცდომა გამოსვლისას. თუ დაბრუნდა უარყოფითი მნიშვნელობა (თუ ფუნქციამ დააბრუნა "-1"), შეგვიძლია დავასკვნათ, რომ მოხდა შეცდომა მისი შესრულებისას.

სინტაქსი და დამოკიდებულებები

printf ფუნქციის გამოსაყენებლად, თქვენ უნდა შეიტანოთ სათაურის ფაილი "stdio.h" შემდეგნაირად:

#შეიცავს

ფუნქციის შაბლონი ასე გამოიყურება:

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

ელიფსისი ეხება არგუმენტების ჩამონათვალს, რომლებიც უნდა გამოვიდეს. printf ფუნქცია შეიძლება გამოვიყენოთ სხვადასხვა რაოდენობის არგუმენტებით, მაგრამ პირველი ყოველთვის შემოიფარგლება ორმაგი ბრჭყალებით ორივე მხრიდან და ყოველი მომდევნო უნდა გამოიყოს წინადან მძიმით. ის, რაც წერია ორმაგ ბრჭყალებში და არ არის ფორმატის სპეციფიკაცია, იბეჭდება ცვლილებების გარეშე, წინააღმდეგ შემთხვევაში, თუ სპეფიკატორს შეხვდებით, მისი მნიშვნელობის ტიპი კოპირდება.

ფორმატის სპეციფიკაციების მითითების ფორმა:

%[flags][width][.position][length]ტიპი

ფორმატირება printf-ით C გამომავალი მნიშვნელობებით

გამოძახებული ფუნქციის სახელის შემდეგ ფრჩხილებში მითითებული ფორმატის სტრიქონი იკითხება მხოლოდ ერთი მიმართულებით: მარცხნიდან მარჯვნივ და თავად ამ სტრიქონის შემდეგ მითითებული პირველი არგუმენტი იბეჭდება მხოლოდ იმ შემთხვევაში, თუ შეგხვდებათ პირველი სპეციფიკაცია. ფორმატის სტრიქონის დასრულებამდე მასში მითითებული სპეციფიკაციები დაიწყებს შემდგომი არგუმენტების კონვერტაციას და ბეჭდვას. ფორმატის სტრიქონში, ინტერვალის სიმბოლო განიხილება, როგორც ნორმალური სიმბოლო და გამოდის, როდესაც ის არ გამოიყენება ფორმატის სპეციფიკაციის გამოხატულებაში.

სიმბოლო "%" მიუთითებს გამომავალი ფორმატის სპეციფიკაციის დასაწყისს, რასაც მოჰყვება ფორმატის კოდი. სპეციფიკაციის ყველა ველი არის ინდივიდუალური რიცხვები ან სიმბოლოები, რომლებიც განსაზღვრავენ ფორმატირების პირობებს.

ფორმატირებულ printf გამომავალს C-ში აქვს თავისი თავისებურებები. თუ ჩამოთვლილი არგუმენტების რაოდენობა აღემატება ფორმატის სპეციფიკაციების რაოდენობას, ისინი გამოტოვებულია და არ იბეჭდება. წინააღმდეგ შემთხვევაში, თუ დასაბეჭდი არგუმენტების სიაში მნიშვნელობებზე მეტი ფორმატის სპეციფიკაციებია, ფუნქციის გამოძახების შედეგი არ არის განსაზღვრული.

მკაფიოდ რომ მიუთითოთ რომელი არგუმენტი გამოვიყენოთ, შესაძლებელია გამოვიყენოთ „%m$“ „%“-ის ნაცვლად და „*m$“ „*“-ის ნაცვლად, m, მთელი ათობითი მნიშვნელობით, სასურველი არგუმენტის პოზიციის მითითებით. (ინდექსირება იწყება ერთიდან) .

Პარამეტრები

დროშები გამოიყენება ფორმატის სტრიქონში

დროშა	აღწერა
-	შედეგის გასწორება გამომავალი ველში მარცხნივ
+	რიცხვითი მნიშვნელობის დაბეჭდვისას, რომელსაც აქვს ნიშანი, ის იძულებულია დაბეჭდოს "+" დადებით მნიშვნელობამდე (ნაგულისხმევად, მხოლოდ "-" იბეჭდება უარყოფით მნიშვნელობამდე).
0	მთელი და მცურავი წერტილის რიცხვებისთვის, წინა ნულები გამოიყენება ინტერვალის სიმბოლოების ნაცვლად მარცხენა ციფრების შესავსებად, როდესაც ველის სიგანე მითითებულია რიცხვის სიგრძეზე მეტი. მთელი რიცხვებისთვის, დროშა იგნორირებულია, თუ სიზუსტე ცალსახად არის მითითებული. სხვა კონვერტაციებისთვის ამ დროშის გამოყენებით, ფუნქციის ქცევა განუსაზღვრელია. "0" დროშა იგნორირებულია, თუ "-" დროშა არსებობს
სივრცე	თუ ხელმოწერილი გამოხატვის გამომავალი შედეგი არ იწყება ამ ნიშნით ან ცარიელია, მაშინ შედეგს ემატება სივრცე. "სივრცის" დროშა იგნორირებულია, თუ "+" დროშა არსებობს
#	შესრულებულია კონვერტაციის ალტერნატიული ფორმა

სხვადასხვა ფორმატის სპეციფიკატორები

ფორმატის დამახასიათებელი	გამოყენება და აღწერა printf C-სთვის	არგუმენტის ტიპი
%	სიტყვასიტყვით "%"-ის დაწერა
გ	ერთი სიმბოლოს გამომავალი. არგუმენტი გარდაიქმნება სიმბოლოს ხელმოუწერელ ტიპად. "l" მოდიფიკატორის გამოყენებისას არგუმენტი გარდაიქმნება სიმბოლოების სტრიქონად	ხელმოუწერელი სიმბოლო
ს	დაბეჭდეთ სიმბოლოების სტრიქონი. არგუმენტი უნდა იყოს char მასივის საწყისი ელემენტის მაჩვენებელი	char *
დ მე	ხელმოწერილი მთელი მნიშვნელობის ათობითი გამოსახულების დაბეჭდვა	ინტ
ო	მთელი მნიშვნელობის რვავიანი გამოსახულების გამოტანა	ხელმოუწერელი ინტ
x X	გამომავალი თექვსმეტობითი წარმოდგენა დაუწერელი მთელი რიცხვის. სიმბოლოები "a", "b", "c", "d", "e", "f" გამოიყენება "x"-ის გადასაყვანად. და გარდაქმნას "X" - "A", "B", "C", "D", "E", "F"	ხელმოუწერელი ინტ
u	გამომავალი ათობითი კონვერტაცია ხელმოწერილი მთელი მნიშვნელობის გარეშე. თუ გარდაქმნილი მნიშვნელობა და სიზუსტე ორივეა 0, მაშინ სიმბოლოები არ გამოდის	ხელმოუწერელი ინტ
ვ ფ	ხელმოწერილი მცურავი წერტილის ათწილადის ბეჭდვა	ორმაგი
ე ე	გამოაქვს ათობითი სამეცნიერო აღნიშვნა, დამრგვალებული და გარდაქმნილი ისე, რომ იყოს ერთი ციფრი ათწილადის წერტილის წინ, ხოლო ციფრების რაოდენობა ათწილადის შემდეგ შეესაბამება წარმოდგენის სიზუსტეს (ნაგულისხმევი სიზუსტე არის 6 და თუ მითითებულია 0, მაშინ ათობითი სიმბოლო საერთოდ არ გამოდის). "e" სიმბოლო ნაჩვენებია დიდი ან პატარა ასოებით, კონვერტაციის მიხედვით	ორმაგი
ა ა	გამომავალი თექვსმეტობითი წარმოდგენა მცურავი პუნქტის რიცხვის	ორმაგი
გ გ	გამოიტანეთ მცურავი წერტილის რიცხვის ათობითი გამოსახულება ან მისი ათწილადი ექსპონენციალური წარმოდგენა მნიშვნელობისა და სიზუსტის მიხედვით	ორმაგი
ნ	დააბრუნეთ printf-ით დაბეჭდილი ელემენტების რაოდენობა. შედეგი იწერება არგუმენტით მითითებულ ცვლადზე. სპეციფიკაცია არ შეიძლება შეიცავდეს დროშებს, ველის სიგანეს ან სიზუსტეს	int *
გვ	პოინტერის გამომავალი	ბათილად *

ველის სიგანის მოდიფიკატორი

ფორმატის ხაზს printf C-ში შეუძლია დაწეროს მთელი რიცხვი პროცენტის ნიშნის შემდეგ და ფორმატის ბრძანებამდე. ეს არის ველის სიგანის მოდიფიკატორი და გავლენას ახდენს ნაჩვენები მონაცემების პრეზენტაციაზე. მნიშვნელობისთვის განკუთვნილი ველის უმცირესი სიგანე განისაზღვრება ამ რიცხვით და ასეთი მოდიფიკატორის არსებობა, თუ არგუმენტი მასზე გამოყოფილ ველზე მცირეა, იწვევს შედეგს შორისების ან ნულების დამატებას. ნაგულისხმევი ჩანაცვლება არის ინტერვალის სიმბოლო, მაგრამ თქვენ შეგიძლიათ დააყენოთ ის ნულზე სიგანის სპეციფიკაციის პრეფიქსით. მოდიფიკატორი განსაზღვრავს მინიმალურ სიგანეს და ამ მინიმუმზე მეტი მნიშვნელობა დაიბეჭდება ჩარევის გარეშე. რიცხვი, მაგალითად, რომელიც შედგება რვაზე ნაკლები სიმბოლოსგან და დაბეჭდილი სპეციფიკაციებით „%08d“ შეივსება საჭირო რვა სიმბოლოზე ნულებით.

მსგავს მოდიფიკატორებს შეუძლიათ ასევე მიუთითონ სიზუსტის ან გასწორების პარამეტრები.

სიზუსტის მოდიფიკატორი

სიზუსტის მოდიფიკატორი გამოიყენება ათწილადების რაოდენობის დასადგენად რიცხვების წარმომადგენლობაში დასაბეჭდად. ზუსტი მოდიფიკატორის დასამატებლად, თქვენ უნდა დააყენოთ წერტილი ველის სიგანის სპეციფიკაციის შემდეგ და მიუთითოთ სასურველი სიზუსტის მნიშვნელობა მის შემდეგ. სიზუსტის მოდიფიკატორი განისაზღვრება "e", "f", "a", "E", "A" და "F" ფორმატებისთვის. მთელი რიცხვებისთვის მოდიფიკატორი ადგენს გამოსახულ ციფრთა რაოდენობას, აუცილებლობის შემთხვევაში უმატებს ნულებს მარცხენა ციფრზე და რაციონალური რიცხვების ჩვენებისას ადგენს ათწილადების საჭირო რაოდენობას. სიმებიანი ცვლადებისთვის, სიზუსტის მოდიფიკატორში წერტილის შემდეგ რიცხვი განსაზღვრავს გამომავალი ველის მაქსიმალურ სიგრძეს. მაგალითად, "%4.8s" ფორმატის სპეციფიკაციის გათვალისწინებით, გამოვა სტრიქონი, რომლის სიგრძე ოთხიდან რვა სიმბოლოს ფარგლებშია, თუ გადააჭარბებს, ყველაზე გარე სიმბოლოები გამოტოვებული იქნება.

სხვა ფორმატის მოდიფიკატორები

ნაგულისხმევი გასწორება არის მარჯვნივ გასწორებული, მაგრამ ეს შეიძლება შეიცვალოს "-" ნიშნის დაყენებით "%"-ის შემდეგ. ეს ფორმატის სპეციფიკაცია ადგენს მარცხნივ გასწორებას.

გარდა ამისა, printf ფუნქციას შეუძლია განასხვავოს დასაბეჭდი მნიშვნელობების მოკლე და გრძელი ტიპები. სწორი სპეციფიკაციებია "o", "d", "u", "i", "x" და "X". გრძელი მნიშვნელობის ტიპი მითითებულია "l" მოდიფიკატორით, ხოლო მოკლე მნიშვნელობის ტიპი "h" მოდიფიკატორით. მაგალითად, გრძელი მთელი და მოკლე ხელმოუწერელი int მნიშვნელობის გამოტანისას, ფორმატის სპეციფიკაციები არის "%ld" და "%hu", შესაბამისად.

მაგალითები

1. printf C-ის აღწერა და თითოეული ფუნქციის გამოძახების შედეგები:

2. მარტივი დიალოგური შეტყობინების ჩვენება:

printf ("მესიჯი");

3. პროგრამის კოდი:

ფორმატის სპეციფიკაციების დაწყებამდე მითითებული გამონათქვამები იბეჭდება ეკრანზე, ისევე როგორც არგუმენტები ფორმატის სტრიქონის შემდეგ. ზემოაღნიშნული printf C ფუნქციების შესრულების შედეგი, გამოსავლის აღწერა:

ეს მაგალითი ასახავს ჩვენებას სხვადასხვა ფორმატების გამოყენებით სტრიქონების, მთელი რიცხვების ცვლადების, სიმბოლოების და მცურავი წერტილის ნომრებისთვის.

სტანდარტული შეყვანის ფუნქციის სკანირება და მისი გამოყენების მაგალითები

Scanf ფუნქცია გამოიყენება კლავიატურის შეყვანის წასაკითხად. printf-ისა და scanf-ის აღწერა C-ში მოცემულია სათაურის ფაილში "stdio.h".

scanf("ფორმატის სპეციფიკატორები",&მნიშვნელობა1,&მნიშვნელობა2, ...);

scanf ფუნქციასთან მუშაობის მარტივი მაგალითი:

#შეიცავს

printf("როგორ დავაფორმოთ", parameter1, parameter2, ...) -- აჩვენებს შედეგს ეკრანზე

$result= sprintf("..", .., .., ...) - იგივეა, მხოლოდ ხაზი არ გამოდის, მაგრამ მოთავსებულია $result-ში

ციტატა სახელმძღვანელოს თარგმანიდან ( მაგალითებიქვევით:-):

sprintf

sprintf -- აბრუნებს ფორმატირებულ სტრიქონს

აღწერა

sprintf (სტრინგის ფორმატი, შერეული ...);

აბრუნებს ფორმატის სტრიქონის მიხედვით დამუშავებულ სტრიქონს ფორმატი .

ფორმატის სტრიქონი, რომელიც შეიცავს ნულოვან ან მეტ დირექტივას: რეგულარული სიმბოლოები (გარდა %), რომლებიც კოპირებულია პირდაპირ შედეგზე, და რომლებიც კოპირებულია პირდაპირ შედეგზე, და ცვლილებების აღწერა, რომელთაგან თითოეული ასრულებს კონკრეტულ მოქმედებებს. ეს ასევე ეხება sprintf ()და რომ printf ()

თითოეული ცვლილების განცხადება შედგება შემდეგი ელემენტებისაგან, თანმიმდევრობით:

დამატებითი padding სპეციფიკატორი, რომელიც გვიჩვენებს, თუ რა სიმბოლოები იქნება გამოყენებული შედეგის სწორ ზომამდე. ეს შეიძლება იყოს სივრცეები ან 0 (ნულოვანი სიმბოლო). ნაგულისხმევად ის ივსება სივრცეებით. ალტერნატიული შიგთავსის სიმბოლო შეიძლება მიეთითოს ერთი ციტატით ("). იხილეთ მაგალითები ქვემოთ.

დამატებითი განლაგების აღმწერი, რომელიც ამბობს, რომ შედეგი უნდა იყოს გასწორებული მარცხნივ ან მარჯვნივ. ნაგულისხმევად, გასწორება არის მარჯვნივ გასწორებული; - სიმბოლო გამოიწვევს მარცხნივ გასწორებას.

დამატებითი სიგანის დამახასიათებელი, რომელიც ამბობს, რამდენი სიმბოლოთი (მინიმუმ) შეიძლება გაკეთდეს ეს ჩანაცვლება.

დამატებითი სიზუსტის აღმწერი, რომელიც გვიჩვენებს, რამდენი ათობითი ადგილი უნდა იყოს ნაჩვენები მცურავი წერტილის რიცხვებისთვის. ეს დესკრიპტორი არ მოქმედებს სხვა ტიპებზე, გარდა ორმაგი. (სხვა სასარგებლო ფუნქცია რიცხვების ფორმატირებისთვის არის ნომერი_ფორმატი() .)

1. ტიპის დამახასიათებელი, რომელიც გვიჩვენებს, თუ როგორ უნდა დამუშავდეს არგუმენტის მონაცემთა ტიპი. შესაძლო ტიპები:

   % არის პროცენტის სიმბოლო. არ არის საჭირო არგუმენტი.

   b - არგუმენტი განიხილება როგორც მთელი რიცხვი და წარმოდგენილია როგორც ორობითი რიცხვი.

   c - არგუმენტი განიხილება როგორც მთელი რიცხვი და წარმოდგენილია როგორც სიმბოლო ASCII მნიშვნელობით.

   d - არგუმენტი განიხილება როგორც მთელი რიცხვი და წარმოდგენილია როგორც ათობითი რიცხვი.

   f - არგუმენტი განიხილება როგორც ორმაგი და წარმოდგენილია როგორც მცურავი პუნქტიანი რიცხვი.

   o - არგუმენტი განიხილება როგორც მთელი რიცხვი და წარმოდგენილია როგორც რვადი რიცხვი.

   s - არგუმენტი ინტერპრეტირებულია და წარმოდგენილია როგორც სტრიქონი.

   x - არგუმენტი განიხილება როგორც მთელი რიცხვი და წარმოდგენილია როგორც თექვსმეტობითი რიცხვი (ასოებით პატარა რეგისტრით).

   X - არგუმენტი განიხილება როგორც მთელი რიცხვი და წარმოდგენილია როგორც თექვსმეტობითი რიცხვი (ზედა ასოებით).

მაგალითები

მაგალითი 2. sprintf: ვალუტის ფორმატირება $ ფული1 = 68,75; $ ფული2 = 54,35; $money = $money1 + $money2; // echo $money გამოვა "123.1"; $formatted = sprintf("%01.2f", $money); // echo $formatted გამოვა "123.10" მაგალითები ყველაფერი რაც ჩაწერილია >>> ასეთ ფრჩხილებს შორის <<< არის ფუნქციის შედეგი (ე.ი. ეკრანზე გამოტანის მაგალითი) $s="MyString"; -> ხაზი %s $f=12345.6789; -> წილადი %f $d=12345; -> მთელი რიცხვი %d მე-10 სისტემა: 0123456789 16 რიცხვები %x მე-16 სისტემა: 0123456789abcdef 16 რიცხვები %X მე-16 სისტემა: 0123456789ABCDEF 8numbers %o 23number4 ნომრის %601 : printf("%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); >>> აუტსაიდერი12345ტექსტი<<< вывод нескольких переменных - последовательное перечисление printf("%d-%f-%s",$d,$f,$s); >>> 12345-12345.678900-MyString<<< выравнивание (ширина 20 символов) по правому краю, пустоту заполняем "_": printf("%"_20s",MyString); >>> ____________MyString<<< выравнивание по левому краю, пустоту заполняем "x": printf("%-"x20s",MyString); >>> MyStringxxxxxxxxxxxxx<<< იხილეთ სხვა მაგალითები აქ:

(PHP 4, PHP 5, PHP 7)

სპრინტი - აბრუნებს ფორმატირებულ სტრიქონს

პარამეტრების სია

ფორმატის სტრიქონი შედგება ნული ან მეტი დირექტივისგან: რეგულარული სიმბოლოები (გარდა % ), რომლებიც კოპირებულია პირდაპირ მიღებულ სტრიქონში და ტრანსფორმაციის აღმწერები, რომელთაგან თითოეული იცვლება ერთ-ერთი პარამეტრით. ეს ორივეს ეხება sprintf (), და printf ().

თითოეული კონვერტაციის სპეციფიკატორი შედგება პროცენტის ნიშნისგან ( % ), რასაც მოჰყვება ერთი ან მეტი დამატებითი ელემენტი (მიმდევრობით, რომლებიც აქ არის ჩამოთვლილი):

1. სურვილისამებრ პერსონაჟის აღმწერი, სადაც მითითებულია, თუ როგორ იქნება გამოყენებული რიცხვზე ნიშანი (- ან +). ნაგულისხმევად, მხოლოდ მინუს ნიშანი გამოიყენება, თუ ნომერი უარყოფითია. ეს დამახასიათებელი იწვევს დადებით რიცხვებს ასევე პლუს ნიშნის ჩვენებას და დაემატა PHP 4.3.0-ში.
2. სურვილისამებრ padding სპეციფიკატორი, რომელიც განსაზღვრავს, რომელი სიმბოლო იქნება გამოყენებული შედეგის საჭირო სიგრძეზე დასაყენებლად. ეს შეიძლება იყოს სივრცე ან 0 . ნაგულისხმევი არის სივრცე. ალტერნატიული სიმბოლო შეიძლება განისაზღვროს ერთი ციტატის გამოყენებით ( " ). იხილეთ მაგალითები ქვემოთ.
3. სურვილისამებრ განლაგების აღმწერი, რომელიც განსაზღვრავს მარცხნივ ან მარჯვნივ გასწორებას. ნაგულისხმევად, ის გასწორებულია მარჯვნივ, - გამოიყენება მარცხნივ გასწორებისთვის.
4. არჩევითი ნომერი სიგანის დამახასიათებელი, რომელიც განსაზღვრავს სიმბოლოების მინიმალურ რაოდენობას, რომელსაც ამ კონვერტაციის შედეგი შეიცავს.
5. სურვილისამებრ სიზუსტის აღმწერი, მითითებულია, როგორც წერტილი ("."), რასაც მოჰყვება არჩევითი ათობითი სტრიქონი, რომელიც განსაზღვრავს ათწილადის რამდენი ადგილის ჩვენებას მცურავი წერტილიანი რიცხვებისთვის. სტრიქონებთან გამოყენებისას, ეს სპეციფიკატორი მოქმედებს როგორც ჭრის წერტილი, რომელიც ადგენს სიმბოლოების მაქსიმალურ ლიმიტს. თქვენ ასევე შეგიძლიათ მიუთითოთ სიმბოლო, რომელიც გამოიყენება ნომრის დასასრულებლად წერტილსა და რიცხვს შორის.

6. ტიპის დამახასიათებელი, რომელიც განსაზღვრავს, თუ როგორ უნდა მოექცეთ არგუმენტის მონაცემთა ტიპს. მოქმედი ტიპები:

   • % - პროცენტული სიმბოლო. არგუმენტი არ გამოიყენება.
   • ბ- არგუმენტი განიხილება როგორც მთელი რიცხვი და გამომავალი, როგორც ორობითი რიცხვი.
   • გ- არგუმენტი განიხილება, როგორც მთელი რიცხვი და გამომავალი, როგორც სიმბოლო შესაბამისი ASCII კოდით.
   • დ- არგუმენტი განიხილება, როგორც მთელი რიცხვი და გამომავალი, როგორც ხელმოწერილი ათობითი რიცხვი.
   • ე- არგუმენტი განმარტებულია, როგორც რიცხვი სამეცნიერო აღნიშვნით (მაგალითად, 1.2e+2). სიზუსტის დამახასიათებელი მიუთითებს ათწილადების რაოდენობას PHP 5.2.1-დან. ადრინდელ ვერსიებში იგი მიუთითებდა მნიშვნელოვანი ფიგურების რაოდენობაზე (ერთი ნაკლები ნიშანი).
   • ე- მსგავსი %e, მაგრამ იყენებს დიდ ასოს (მაგალითად, 1.2E+2).
   • ვ- არგუმენტი განიხილება როგორც მცურავი წერტილის რიცხვი და ასევე გამოდის ლოკალის მიხედვით.
   • ფ- არგუმენტი განიხილება როგორც მცურავი წერტილის რიცხვი და ასევე გამოდის, მაგრამ ლოკალზე დამოკიდებულების გარეშე. ხელმისაწვდომია PHP 4.3.10 და PHP 5.0.3-დან დაწყებული.
   • გ %eდა %f.
   • გ- ირჩევს უმოკლეს ჩანაწერს %Eდა %f.
   • ო- არგუმენტი განიხილება როგორც მთელი რიცხვი და გამომავალი, როგორც რვა რიცხვი.
   • ს- არგუმენტი განიხილება, როგორც სტრიქონი.
   • u- არგუმენტი განიხილება, როგორც მთელი რიცხვი და გამომავალი, როგორც ხელმოუწერელი ათობითი რიცხვი.
   • x- არგუმენტი განიხილება, როგორც მთელი რიცხვი და გამომავალი, როგორც თექვსმეტობითი რიცხვი (პატარა).
   • X- არგუმენტი განიხილება როგორც მთელი რიცხვი და გამომავალი, როგორც თექვსმეტობითი რიცხვი (ზედა შემთხვევაში).

ცვლადები გარდაიქმნება სპეციფიკატორის შესაბამის ტიპად:

ტიპი Handling

ტიპი	სპეციფიკატორი
სიმებიანი	ს
მთელი რიცხვი	დ, u, გ, ო, x, X, ბ
ორმაგი	გ, გ, ე, ე, ვ, ფ

ყურადღება

სტრიქონების და სიგანის სპეციფიკატორების კომბინაციის გამოყენების მცდელობა კოდირებით, რომლებიც საჭიროებენ ერთ ბაიტზე მეტ სიმბოლოს, შეიძლება გამოიწვიოს მოულოდნელი შედეგები.

ფორმატის სტრიქონი მხარს უჭერს ნუმერაციას და პარამეტრების გადალაგებას. Მაგალითად:

მაგალითი #1 პარამეტრების რიგის შეცვლა

$num = 5 ;
$location = "ხე" ;

$ფორმატი = "%d მაიმუნი ზის %s-ზე";

?>

ეს კოდი გამოვა "5 მაიმუნი ზის ხეზე". ახლა წარმოიდგინეთ, რომ ფორმატის სტრიქონი მოთავსებულია ცალკეულ ფაილში, რომელიც შემდეგ სხვა ენაზე ითარგმნება და ჩვენ მას ასე გადავწერთ:

მაგალითი #2 პარამეტრების რიგის შეცვლა

$ფორმატი = "%d მაიმუნი ზის %s-ზე";
echo sprintf ($format, $num, $location);
?>

არის პრობლემა: კონვერტაციის დამახასიათებელთა თანმიმდევრობა არ ემთხვევა არგუმენტების თანმიმდევრობას. ჩვენ არ გვინდა კოდის შეცვლა და უნდა დავაზუსტოთ, რომელი არგუმენტი შეესაბამება კონვერტაციის რომელ მახასიათებელს.

მაგალითი #3 პარამეტრების რიგის შეცვლა

$ფორმატი = "%1$d მაიმუნი ზის %2$s-ზე";
echo sprintf ($format, $num, $location);
?>

არგუმენტის ნუმერაციას სხვა გამოყენება აქვს: ის საშუალებას გაძლევთ დაბეჭდოთ ერთი და იგივე არგუმენტი რამდენჯერმე ფუნქციისთვის დამატებითი პარამეტრების გადაცემის გარეშე.

მაგალითი #4 პარამეტრების რიგის შეცვლა

$ფორმატი = %2$s-ზე %1$d მაიმუნი ზის.
მშვენიერია, როცა %2$s ზის %1$d მაიმუნზე.";
echo sprintf ($format, $num, $location);
?>

პარამეტრების რიგის შეცვლისას პოზიციის აღმწერი n$უნდა მოვიდეს დაუყოვნებლივ პროცენტის ნიშნის შემდეგ ( % ) ყველა სხვა დესკრიპტორამდე, როგორც ნაჩვენებია ქვემოთ მოცემულ მაგალითში.

მაგალითი #5 კომპლემენტის სიმბოლოს მითითება

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

123 000000123

მაგალითი #6 პოზიციის დამახასიათებლის გამოყენება და სხვა აღმწერებთან ერთად

$ფორმატი = "%1$04d მაიმუნი ზის %2$s-ზე";
echo sprintf ($format, $num, $location);
?>

ამ მაგალითის გაშვების შედეგი:

0005 მაიმუნი იჯდა ხეზე

კომენტარი:

გაკეთდა მცდელობა, გამოეყენებინათ პოზიციის აღმნიშვნელი მეტი PHP_INT_MAX, გამოიწვევს ფუნქციის გაფრთხილების გენერირებას sprintf () .

ყურადღება

The გტიპის დამახასიათებელი უგულებელყოფს ბალიშს და სიგანეს

ღირებულებების დაბრუნება

აბრუნებს ფორმატის მიხედვით დაფორმატებულ სტრიქონს.

მაგალითები

მაგალითი #7 sprintf (): ავსება ნულებით

$n = 43951789 ;
$u = - 43951789 ;
$c = 65 ; // ASCII 65 არის "A"

// გაითვალისწინეთ, რომ ორმაგი %% გამოდის როგორც ერთჯერადი „%“
printf ("%%b = "%b"\n" , $n ); // ბინარული წარმოდგენა
printf ("%%c = "%c"\n" , $c ); // ბეჭდავს ascii სიმბოლოს, chr() ფუნქციის მსგავსი
printf ("%%d = "%d"\n" , $n ); // რეგულარული მთელი რიცხვი
printf ("%%e = "%e"\n" , $n ); // მეცნიერული ნოტაცია
printf ("%%u = "%u"\n" , $n ); // დადებითი რიცხვის უსაზღვრო მთელი რიცხვი
printf ("%%u = "%u"\n" , $u ); // უარყოფითი რიცხვის უსაზღვრო მთელი რიცხვი
printf ("%%f = "%f"\n" , $n ); // მცურავი წერტილის ნომრის წარმოდგენა
printf ("%%o = "%o"\n" , $n ); //რვავიანი წარმოდგენა
printf ("%%s = "%s"\n" , $n ); // ხაზი
printf ("%%x = "%x"\n" , $n ); // თექვსმეტობითი გამოსახულება (პატარა)
printf ("%%X = "%X"\n" , $n ); //თექვსმეტობითი გამოსახულება (ზედა)

Printf ("%%+d = "%+d"\n" , $n); // ნიშანი აღმწერი დადებითი მთელი რიცხვით
printf ("%%+d = "%+d"\n" , $u ); // აღწერის ნიშანი უარყოფითი მთელი რიცხვით
?>

ამ მაგალითის გაშვების შედეგი:

%b = "101001111010010011010101101" %C = "A" %D = "43951789" %E = "4.39518E+7" %U = "43951789" %u = "4251015507" %F = "43951789.000000" %O = " 255 " %s = "43951789" %x = "29ea6ad" %X = "29EA6AD" %+d = "+43951789" %+d = "-43951789"

მაგალითი #8 printf (): სიმებიანი აღწერები

$s = "მაიმუნი" ;
$t = "ბევრი მაიმუნი" ;

Printf("[%s]\n" , $s ); // ნორმალური ხაზის გამომავალი
printf ("[%10s]\n" , $s ); // მარჯვნივ გასწორება სივრცეებთან
printf ("[%-10s]\n" , $s ); // მარცხნივ გასწორება სივრცეებით
printf ("[%010s]\n" , $s ); // zero padding ასევე მუშაობს სტრიქონებთან
printf ("[%"#10s]\n" , $s ); // გამოიყენეთ თქვენი საკუთარი დამატებითი სიმბოლო "#".
printf ("[%10.10s]\n" , $t ); // მარცხნივ გასწორება 10 სიმბოლოს მორთვით
?>