perl-5.34.0
sprintf FORMAT, LIST

Returns a string formatted by the usual printf conventions of the C library function sprintf. See below for more details and see sprintf(3) or printf(3) on your system for an explanation of the general principles.

C ��í�ゃ����í�ʒ�∽�� sprintf �� ��勰����� printf 荐�羈��� ��翫就������������絖�������菴������障����� 筝���㋜����ɱ�������勤ą�����˨�ゃ����⓾�壚札筝���勤ą�����������激�鴻������� sprintf(3) ��障����� printf(3) ��勤ą�����������с����⓾��������������

For example:

箴�������:

        # Format number with up to 8 leading zeroes
        my $result = sprintf("%08d", $number);

        # Round number to 3 digits after decimal point
        my $rounded = sprintf("%.3f", $number);

Perl does its own sprintf formatting: it emulates the C function sprintf(3), but doesn't use it except for floating-point numbers, and even then only standard modifiers are allowed. Non-standard extensions in your local sprintf(3) are therefore unavailable from Perl.

Perl ��� sprintf �����í�若����������☎�������ɱ����ц�������障��: ��������� C ��� sprintf(3) ��∽�違����������ャ�㋘�若�������障��������C ��勰�∽�違�壚戎�����障����� (羌勐��絨���亥�鴻����ゃ����障����������������с��罔�羣���勤��菴医����勉�帥����ñ����с����障��)��� 緇���c�⓾����㏍�若�˨�˨�ʒ��罔�羣���� sprintf(3) ��≦宍罘���純�� Perl ��с�壚戎�����障��������

Unlike printf, sprintf does not do what you probably mean when you pass it an array as your first argument. The array is given scalar context, and instead of using the 0th element of the array as the format, Perl will use the count of elements in the array as the format, which is almost never useful.

printf ��◒����c�⓾�� sprintf ��勖�������勐����違�̹��������羝<����⓾�� �����ŝ�����紊���������������������˨�壠��篏������障�������� ��������壔�鴻�˨�í�潟�潟����㏍�鴻����ф検�����������勉�с����������� 0 ��ɾ�勉�勤��膣���с�壔�ŝ����� ��������勤��膣���違�������í�若����������������〠�宴����障��; ��������壔�祉�������ï醜��̥����<�障��������

Perl's sprintf permits the following universally-known conversions:

Perl ��� sprintf ��壚札筝���勌����㋘�̥�ャ�������⓾�����紊������ 絲上�������⓾����障��:

   %%    a percent sign
   %c    a character with the given number
   %s    a string
   %d    a signed integer, in decimal
   %u    an unsigned integer, in decimal
   %o    an unsigned integer, in octal
   %x    an unsigned integer, in hexadecimal
   %e    a floating-point number, in scientific notation
   %f    a floating-point number, in fixed decimal notation
   %g    a floating-point number, in %e or %f notation
   %%    �����若�祉�潟�������若�
   %c    筝���������������ɱ垩�勖��絖�
   %s    ���絖����
   %d    膃☗垬����� 10 ��我�
   %u    膃☗垩�ŝ�� 10 ��我�
   %o    膃☗垩�ŝ�� 8 ��我�
   %x    膃☗垩�ŝ�� 16 ��我�
   %e    腱�絖☎��茵◑����勖貴���絨���亥�号�
   %f    ��阪�� 10 ��我�域;荐���勖貴���絨���亥�号�
   %g    %e ��� %f ��勤;荐���勖貴���絨���亥�号�

In addition, Perl permits the following widely-supported conversions:

��������˨��Perl ��с�壚札筝���勉����鋎帥�������⓾�����紊�������絲上�������⓾����障��:

   %X    like %x, but using upper-case letters
   %E    like %e, but using an upper-case "E"
   %G    like %g, but with an upper-case "E" (if applicable)
   %b    an unsigned integer, in binary
   %B    like %b, but using an upper-case "B" with the # flag
   %p    a pointer (outputs the Perl value's address in hexadecimal)
   %n    special: *stores* the number of characters output so far
         into the next argument in the parameter list
   %a    hexadecimal floating point
   %A    like %a, but using upper-case letters
   %X    %x ������罕�������紊ф��絖����篏帥��
   %E    %e ������罕�������紊ф��絖���� "E" ���篏帥��
   %G    %g ������罕�������(��ï����ŝ��)紊ф��絖���� "E" ���篏帥��
   %b    膃☗垩�ŝ�� 2 ��我�
   %B    %b ������罕����������# �����í�違�уぇ���絖���� "B" ���篏帥��
   %p    �����ゃ�潟�� (Perl ��勐�ゃ�勉�≪����㋘�鴻�� 16 ��我�違�у�阪��������)
   %n    ��号��: ��阪�����絖���違��綣���違�ŝ�鴻����勖❶��勐����違�˨����主�����������
   %a    16 ��我貴���絨���亥�
   %A    %a ������罕����������紊ф��絖����篏帥��

Finally, for backward (and we do mean "backward") compatibility, Perl permits these unnecessary but widely-supported conversions:

���緇���˨������サ�����勌��������(��������壔������サ��������◑�������⓾����障��)��勉�������˨�� Perl ��壚札筝���勌��荀���с�壔�������������í��綺���鋎帥�������⓾�����紊�������絲上�������⓾����障�����

   %i    a synonym for %d
   %D    a synonym for %ld
   %U    a synonym for %lu
   %O    a synonym for %lo
   %F    a synonym for %f
   %i    %d ��勐��臂ò��
   %D    %ld ��勐��臂ò��
   %U    %lu ��勐��臂ò��
   %O    %lo ��勐��臂ò��
   %F    %f ��勐��臂ò��

Note that the number of exponent digits in the scientific notation produced by %e, %E, %g and %G for numbers with the modulus of the exponent less than 100 is system-dependent: it may be three or less (zero-padded as necessary). In other words, 1.23 times ten to the 99th may be either "1.23e99" or "1.23e099". Similarly for %a and %A: the exponent or the hexadecimal digits may float: especially the "long doubles" Perl configuration option may cause surprises.

%e, %E, %g, %G ��˨�������⓾�������育����� 100 ��ʋ����勐�翫���� �����育����勛��絖☎����ʃ;荐�羈���壔�激�鴻�����箴�絖���с��������������羈���������⓾�����������: 3 罅���������������障�����������������篁ヤ����������������障�����(綽�荀����綽������� 0 �� �����������c�潟�違�������障��)��� 荐������������������� 1.23 ��������� 10 ��� 99 箙���� "1.23e99" ��������������障�������� "1.23e099" ��������������障�������� ���罕���� %a ��� %A ��勐�翫��: �����育����� 16 ��我�違��羌勐��絨���亥�鴻�������������障�����: ��鴻�� "long doubles" Perl 荐㊤����ŝ����激�с�潟��薊�������綣����莎激�������������������障��������

Between the % and the format letter, you may specify several additional attributes controlling the interpretation of the format. In order, these are:

% ��������í�若�����������絖���勰����˨�������í�若����������勤В��������九勝��������������勉�� ��������ゃ����勤申�����勐����с�����絎���с����障����� �����ŝ�˨��篁ヤ����勉����勉����������障��:

format parameter index

(�����í�若�������������í�<�若�帥�ゃ�潟�������壔��)

An explicit format parameter index, such as 2$. By default sprintf will format the next unused argument in the list, but this allows you to take the arguments out of order:

2$ ��勉�������ʋ��腓榊����ŝ����í�若�������������í�<�若�帥�ゃ�潟�������壔�鴻�� ��������í�˨����с�� sprintf ��壔�ŝ�鴻����勖❶��勌戎��������⓾����ŝ��綣���違�� �����í�若�������������障����������������˨����c�☎�違�ŝ�c�������ŝ�勐����違��篏帥�������������˨����障��:

  printf '%2$d %1$d', 12, 34;      # prints "34 12"
  printf '%3$d %d %1$d', 1, 2, 3;  # prints "3 1 1"
flags

(������)

one or more of:

篁ヤ����勉����<�勌����ゃ�障����虁����井��絎���с����障��:

   space   prefix non-negative number with a space
   +       prefix non-negative number with a plus sign
   -       left-justify within the field
   0       use zeros, not spaces, to right-justify
   #       ensure the leading "0" for any octal,
           prefix non-zero hexadecimal with "0x" or "0X",
           prefix non-zero binary with "0b" or "0B"
   space   ���莢���違�勐����̥Ã��純����ゃ�����
   +       ���莢���違�勐����˨����í�壕���垩����ゃ�����
   -       �����c�若�˨�������у窪荅違��������
   0       �勈¹�����̥Ã��純�с�壔�ŝ����若�㏍��篏帥��
   #       8 ��我�違�с�夌∈絎���������㏍�� "0" �����ゃ�����;
           ��� 0 ��� 16 ��我�違�с�� "0x" ��� "0X" �����ゃ�����;
           ��� 0 ��� 2 ��我�違�с�� "0b" ��� "0B" �����ゃ�����

For example:

箴�������:

  printf '<% d>',  12;   # prints "< 12>"
  printf '<% d>',   0;   # prints "< 0>"
  printf '<% d>', -12;   # prints "<-12>"
  printf '<%+d>',  12;   # prints "<+12>"
  printf '<%+d>',   0;   # prints "<+0>"
  printf '<%+d>', -12;   # prints "<-12>"
  printf '<%6s>',  12;   # prints "<    12>"
  printf '<%-6s>', 12;   # prints "<12    >"
  printf '<%06s>', 12;   # prints "<000012>"
  printf '<%#o>',  12;   # prints "<014>"
  printf '<%#x>',  12;   # prints "<0xc>"
  printf '<%#X>',  12;   # prints "<0XC>"
  printf '<%#b>',  12;   # prints "<0b1100>"
  printf '<%#B>',  12;   # prints "<0B1100>"

When a space and a plus sign are given as the flags at once, the space is ignored.

腥榊�純�������í�壕���垩�������í�違�������☗�������˩�������������������� 腥榊�純�夌�∴����������障�����

  printf '<%+ d>', 12;   # prints "<+12>"
  printf '<% +d>', 12;   # prints "<+12>"

When the # flag and a precision are given in the %o conversion, the precision is incremented if it's necessary for the leading "0".

%o 紊������� # �����í�違�◐仮綺⓾��筝������������������������㏍�� "0" ���綽�荀���ɱ�翫���� 膕上墾��� 1 �����������������障�����

  printf '<%#.5o>', 012;      # prints "<00012>"
  printf '<%#.5o>', 012345;   # prints "<012345>"
  printf '<%#.0o>', 0;        # prints "<0>"
vector flag

(�����壔�帥����í��)

This flag tells Perl to interpret the supplied string as a vector of integers, one for each character in the string. Perl applies the format to each integer in turn, then joins the resulting strings with a separator (a dot . by default). This can be useful for displaying ordinal values of characters in arbitrary strings:

�����勉����í�違�� Perl ��˨��筝����������������絖�������������絖�罸���˩����ゃ�勖�贋�違�勉����壔�帥������� 茹i����������障����� Perl ��壠����医�ゃ�������í�若��������������������������腟������勖��絖���������祉����㋘�若� (��������í�˨����с�� .)��ч�g�������障����� ��������壚算�����勖��絖������勖��絖�������綺鋌������勐�ゃ�������☀;腓冴�������勉�˩梢��í�с��:

  printf "%vd", "AB\x{100}";           # prints "65.66.256"
  printf "version is v%vd\n", $^V;     # Perl's version

Put an asterisk * before the v to override the string to use to separate the numbers:

��≪�鴻�帥�ŝ�鴻�� * ��� v ��勐����̥舟�����������医�ゃ�������������������˩戎������������絖������� 筝���吾�������障��:

  printf "address is %*vX\n", ":", $addr;   # IPv6 address
  printf "bits are %0*v8b\n", " ", $bits;   # random bitstring

You can also explicitly specify the argument number to use for the join string using something like *2$v; for example:

��障�����*2$v ��勉�������˨����g�����������絖������������☖戎���綣���違�勛�ɱ垩�����腓榊���� ���絎���с����障��; 箴�������:

  printf '%*4$vX %*4$vX %*4$vX',       # 3 IPv6 addresses
          @addr[1..3], ":";
(minimum) width

((���絨�)綛�)

Arguments are usually formatted to be only as wide as required to display the given value. You can override the width by putting a number here, or get the width from the next argument (with *) or from a specified argument (e.g., with *2$):

綣���違�壔����勰����壠�ゃ��茵◐ず��������勉��綽�荀���ŝ�<�������í�勐����с����í�若����������������障����� �����������医�ゃ��臀勉��������(* ���)罨<�勐����違��(*2$ ���)���腓榊��������絎�������綣���違� 綛����筝���吾����с����障�����

 printf "<%s>", "a";       # prints "<a>"
 printf "<%6s>", "a";      # prints "<     a>"
 printf "<%*s>", 6, "a";   # prints "<     a>"
 printf '<%*2$s>', "a", 6; # prints "<     a>"
 printf "<%2s>", "long";   # prints "<long>" (does not truncate)

If a field width obtained through * is negative, it has the same effect as the - flag: left-justification.

* �����������☗����������������c�若�˨����勐�ゃ��莢���違�勐�翫�����- �����í�違� ���罕���勐�号�� (綏☀¹���) �����������障�����

precision, or maximum width

(膕上墾�����������壩��紊у��)

You can specify a precision (for numeric conversions) or a maximum width (for string conversions) by specifying a . followed by a number. For floating-point formats except g and G, this specifies how many places right of the decimal point to show (the default being 6). For example:

. ��勐�������医�ゃ�����絎���������������с��(��医�ゅ�������勐�翫��)膕上墾���(���絖����紊������勐�翫��) ���紊у��������絎���с����障����� 絨���亥�号�違����í�若����������勐�翫�����g ��� G �����ゃ����⓾��茵◐ず������絨���亥�剛札筝��� 罅���違�����絎������障��(��������í�˨����� 6 ��с��)��� 箴�������:

  # these examples are subject to system-specific variation
  printf '<%f>', 1;    # prints "<1.000000>"
  printf '<%.1f>', 1;  # prints "<1.0>"
  printf '<%.0f>', 1;  # prints "<1>"
  printf '<%e>', 10;   # prints "<1.000000e+01>"
  printf '<%.1e>', 10; # prints "<1.0e+01>"

For "g" and "G", this specifies the maximum number of significant digits to show; for example:

"g" ��� "G" ��勐�翫�������������壩��紊ф����号�医��������絎������障��; 箴�������:

  # These examples are subject to system-specific variation.
  printf '<%g>', 1;        # prints "<1>"
  printf '<%.10g>', 1;     # prints "<1>"
  printf '<%g>', 100;      # prints "<100>"
  printf '<%.1g>', 100;    # prints "<1e+02>"
  printf '<%.2g>', 100.01; # prints "<1e+02>"
  printf '<%.5g>', 100.01; # prints "<100.01>"
  printf '<%.4g>', 100.01; # prints "<100>"
  printf '<%.1g>', 0.0111; # prints "<0.01>"
  printf '<%.2g>', 0.0111; # prints "<0.011>"
  printf '<%.3g>', 0.0111; # prints "<0.0111>"

For integer conversions, specifying a precision implies that the output of the number itself should be zero-padded to this width, where the 0 flag is ignored:

��贋�医�������勐�翫�����膕上墾������絎���������������医�よ�ŭ����勐�阪����壔����勐����� 0 �� �����������c�潟�違�������鴻����с�������������������̥ず�����������˨�ŝ�����0 �����í�違� ��∴����������障��:

  printf '<%.6d>', 1;      # prints "<000001>"
  printf '<%+.6d>', 1;     # prints "<+000001>"
  printf '<%-10.6d>', 1;   # prints "<000001    >"
  printf '<%10.6d>', 1;    # prints "<    000001>"
  printf '<%010.6d>', 1;   # prints "<    000001>"
  printf '<%+10.6d>', 1;   # prints "<   +000001>"

  printf '<%.6x>', 1;      # prints "<000001>"
  printf '<%#.6x>', 1;     # prints "<0x000001>"
  printf '<%-10.6x>', 1;   # prints "<000001    >"
  printf '<%10.6x>', 1;    # prints "<    000001>"
  printf '<%010.6x>', 1;   # prints "<    000001>"
  printf '<%#10.6x>', 1;   # prints "<  0x000001>"

For string conversions, specifying a precision truncates the string to fit the specified width:

���絖����紊������勐�翫�����膕上墾������絎����������������絎����������綛���������障��������������絖������� ������荅違����障��:

  printf '<%.5s>', "truncated";   # prints "<trunc>"
  printf '<%10.5s>', "truncated"; # prints "<     trunc>"

You can also get the precision from the next argument using .*, or from a specified argument (e.g., with .*2$):

.* ���篏帥�c�☎仮綺⓾��罨<�勐����違����������c�������� (.*2$ ��勉��������) ���絎�������綣���違����������c����������������������с����障��:

  printf '<%.6x>', 1;       # prints "<000001>"
  printf '<%.*x>', 6, 1;    # prints "<000001>"

  printf '<%.*2$x>', 1, 6;  # prints "<000001>"

  printf '<%6.*2$x>', 1, 4; # prints "<  0001>"

If a precision obtained through * is negative, it counts as having no precision at all.

* ��˨����c�☗�����������膕上墾���莢���違�勐�翫�����膕上墾������絎���������ŝ����c����翫���� ��������号�������ŝ����障�����

  printf '<%.*s>',  7, "string";   # prints "<string>"
  printf '<%.*s>',  3, "string";   # prints "<str>"
  printf '<%.*s>',  0, "string";   # prints "<>"
  printf '<%.*s>', -1, "string";   # prints "<string>"

  printf '<%.*d>',  1, 0;   # prints "<0>"
  printf '<%.*d>',  0, 0;   # prints "<>"
  printf '<%.*d>', -1, 0;   # prints "<0>"