qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-15 06:30:32 -07:00
Code Releases Activity

fmt: add available godoc link

Browse Source 
Change-Id: Ia7eaa654b44625983d09284d906a7b67ef589696
Reviewed-on: https://go-review.googlesource.com/c/go/+/535082
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Auto-Submit: Ian Lance Taylor <iant@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Ian Lance Taylor <iant@google.com>
This commit is contained in:
cui fliter 2023-10-13 23:14:30 +08:00 committed by Gopher Robot
parent cf8010d221
commit d8e47e257e
3 changed files with 36 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
src/fmt/doc.go
View File

@ -128,7 +128,7 @@ to 1.2+3.4i produces (1.200000+3.400000i).
When formatting a single integer code point or a rune string (type []rune) When formatting a single integer code point or a rune string (type []rune)
with %q, invalid Unicode code points are changed to the Unicode replacement with %q, invalid Unicode code points are changed to the Unicode replacement
character, U+FFFD, as in strconv.QuoteRune. character, U+FFFD, as in [strconv.QuoteRune].
Other flags: Other flags:
@ -137,7 +137,7 @@ Other flags:
'-' pad with spaces on the right rather than the left (left-justify the field) '-' pad with spaces on the right rather than the left (left-justify the field)
'#' alternate format: add leading 0b for binary (%#b), 0 for octal (%#o), '#' alternate format: add leading 0b for binary (%#b), 0 for octal (%#o),
0x or 0X for hex (%#x or %#X); suppress 0x for %p (%#p); 0x or 0X for hex (%#x or %#X); suppress 0x for %p (%#p);
for %q, print a raw (backquoted) string if strconv.CanBackquote for %q, print a raw (backquoted) string if [strconv.CanBackquote]
returns true; returns true;
always print a decimal point for %e, %E, %f, %F, %g and %G; always print a decimal point for %e, %E, %f, %F, %g and %G;
do not remove trailing zeros for %g and %G; do not remove trailing zeros for %g and %G;
@ -169,17 +169,17 @@ Except when printed using the verbs %T and %p, special
formatting considerations apply for operands that implement formatting considerations apply for operands that implement
certain interfaces. In order of application: certain interfaces. In order of application:
1. If the operand is a reflect.Value, the operand is replaced by the 1. If the operand is a [reflect.Value], the operand is replaced by the
concrete value that it holds, and printing continues with the next rule. concrete value that it holds, and printing continues with the next rule.
2. If an operand implements the Formatter interface, it will 2. If an operand implements the [Formatter] interface, it will
be invoked. In this case the interpretation of verbs and flags is be invoked. In this case the interpretation of verbs and flags is
controlled by that implementation. controlled by that implementation.
3. If the %v verb is used with the # flag (%#v) and the operand 3. If the %v verb is used with the # flag (%#v) and the operand
implements the GoStringer interface, that will be invoked. implements the [GoStringer] interface, that will be invoked.
If the format (which is implicitly %v for Println etc.) is valid If the format (which is implicitly %v for [Println] etc.) is valid
for a string (%s %q %x %X), or is %v but not %#v, for a string (%s %q %x %X), or is %v but not %#v,
the following two rules apply: the following two rules apply:
@ -219,7 +219,7 @@ formatting methods such as Error or String on unexported fields.
# Explicit argument indexes # Explicit argument indexes
In Printf, Sprintf, and Fprintf, the default behavior is for each In [Printf], [Sprintf], and [Fprintf], the default behavior is for each
formatting verb to format successive arguments passed in the call. formatting verb to format successive arguments passed in the call.
However, the notation [n] immediately before the verb indicates that the However, the notation [n] immediately before the verb indicates that the
nth one-indexed argument is to be formatted instead. The same notation nth one-indexed argument is to be formatted instead. The same notation
@ -287,17 +287,17 @@ string, "<nil>".
# Scanning # Scanning
An analogous set of functions scans formatted text to yield An analogous set of functions scans formatted text to yield
values. Scan, Scanf and Scanln read from os.Stdin; Fscan, values. [Scan], [Scanf] and [Scanln] read from [os.Stdin]; [Fscan],
Fscanf and Fscanln read from a specified io.Reader; Sscan, [Fscanf] and [Fscanln] read from a specified [io.Reader]; [Sscan],
Sscanf and Sscanln read from an argument string. [Sscanf] and [Sscanln] read from an argument string.
Scan, Fscan, Sscan treat newlines in the input as spaces. [Scan], [Fscan], [Sscan] treat newlines in the input as spaces.
Scanln, Fscanln and Sscanln stop scanning at a newline and [Scanln], [Fscanln] and [Sscanln] stop scanning at a newline and
require that the items be followed by a newline or EOF. require that the items be followed by a newline or EOF.
Scanf, Fscanf, and Sscanf parse the arguments according to a [Scanf], [Fscanf], and [Sscanf] parse the arguments according to a
format string, analogous to that of Printf. In the text that format string, analogous to that of [Printf]. In the text that
follows, 'space' means any Unicode whitespace character follows, 'space' means any Unicode whitespace character
except newline. except newline.
@ -320,10 +320,10 @@ scanf family: in C, newlines are treated as any other space,
and it is never an error when a run of spaces in the format and it is never an error when a run of spaces in the format
string finds no spaces to consume in the input. string finds no spaces to consume in the input.
The verbs behave analogously to those of Printf. The verbs behave analogously to those of [Printf].
For example, %x will scan an integer as a hexadecimal number, For example, %x will scan an integer as a hexadecimal number,
and %v will scan the default representation format for the value. and %v will scan the default representation format for the value.
The Printf verbs %p and %T and the flags # and + are not implemented. The [Printf] verbs %p and %T and the flags # and + are not implemented.
For floating-point and complex values, all valid formatting verbs For floating-point and complex values, all valid formatting verbs
(%b %e %E %f %F %g %G %x %X and %v) are equivalent and accept (%b %e %E %f %F %g %G %x %X and %v) are equivalent and accept
both decimal and hexadecimal notation (for example: "2.3e+7", "0x4.5p-8") both decimal and hexadecimal notation (for example: "2.3e+7", "0x4.5p-8")
@ -359,26 +359,26 @@ immediately by a newline is treated as a plain newline
(\r\n means the same as \n). (\r\n means the same as \n).
In all the scanning functions, if an operand implements method In all the scanning functions, if an operand implements method
Scan (that is, it implements the Scanner interface) that [Scan] (that is, it implements the [Scanner] interface) that
method will be used to scan the text for that operand. Also, method will be used to scan the text for that operand. Also,
if the number of arguments scanned is less than the number of if the number of arguments scanned is less than the number of
arguments provided, an error is returned. arguments provided, an error is returned.
All arguments to be scanned must be either pointers to basic All arguments to be scanned must be either pointers to basic
types or implementations of the Scanner interface. types or implementations of the [Scanner] interface.
Like Scanf and Fscanf, Sscanf need not consume its entire input. Like [Scanf] and [Fscanf], [Sscanf] need not consume its entire input.
There is no way to recover how much of the input string Sscanf used. There is no way to recover how much of the input string [Sscanf] used.
Note: Fscan etc. can read one character (rune) past the input Note: [Fscan] etc. can read one character (rune) past the input
they return, which means that a loop calling a scan routine they return, which means that a loop calling a scan routine
may skip some of the input. This is usually a problem only may skip some of the input. This is usually a problem only
when there is no space between input values. If the reader when there is no space between input values. If the reader
provided to Fscan implements ReadRune, that method will be used provided to [Fscan] implements ReadRune, that method will be used
to read characters. If the reader also implements UnreadRune, to read characters. If the reader also implements UnreadRune,
that method will be used to save the character and successive that method will be used to save the character and successive
calls will not lose data. To attach ReadRune and UnreadRune calls will not lose data. To attach ReadRune and UnreadRune
methods to a reader without that capability, use methods to a reader without that capability, use
bufio.NewReader. [bufio.NewReader].
*/ */
package fmt package fmt

16
src/fmt/print.go
View File

@ -34,7 +34,7 @@ const (
) )
// State represents the printer state passed to custom formatters. // State represents the printer state passed to custom formatters.
// It provides access to the io.Writer interface plus information about // It provides access to the [io.Writer] interface plus information about
// the flags and options for the operand's format specifier. // the flags and options for the operand's format specifier.
type State interface { type State interface {
// Write is the function to call to emit formatted output to be printed. // Write is the function to call to emit formatted output to be printed.
@ -49,8 +49,8 @@ type State interface {
} }
// Formatter is implemented by any value that has a Format method. // Formatter is implemented by any value that has a Format method.
// The implementation controls how State and rune are interpreted, // The implementation controls how [State] and rune are interpreted,
// and may call Sprint() or Fprint(f) etc. to generate its output. // and may call [Sprint] or [Fprint](f) etc. to generate its output.
type Formatter interface { type Formatter interface {
Format(f State, verb rune) Format(f State, verb rune)
} }
@ -59,7 +59,7 @@ type Formatter interface {
// which defines the “native” format for that value. // which defines the “native” format for that value.
// The String method is used to print values passed as an operand // The String method is used to print values passed as an operand
// to any format that accepts a string or to an unformatted printer // to any format that accepts a string or to an unformatted printer
// such as Print. // such as [Print].
type Stringer interface { type Stringer interface {
String() string String() string
} }
@ -73,10 +73,10 @@ type GoStringer interface {
} }
// FormatString returns a string representing the fully qualified formatting // FormatString returns a string representing the fully qualified formatting
// directive captured by the State, followed by the argument verb. (State does not // directive captured by the [State], followed by the argument verb. ([State] does not
// itself contain the verb.) The result has a leading percent sign followed by any // itself contain the verb.) The result has a leading percent sign followed by any
// flags, the width, and the precision. Missing flags, width, and precision are // flags, the width, and the precision. Missing flags, width, and precision are
// omitted. This function allows a Formatter to reconstruct the original // omitted. This function allows a [Formatter] to reconstruct the original
// directive triggering the call to Format. // directive triggering the call to Format.
func FormatString(state State, verb rune) string { func FormatString(state State, verb rune) string {
var tmp [16]byte // Use a local buffer. var tmp [16]byte // Use a local buffer.
@ -201,14 +201,14 @@ func (p *pp) Flag(b int) bool {
return false return false
} }
// Implement Write so we can call Fprintf on a pp (through State), for // Implement Write so we can call [Fprintf] on a pp (through [State]), for
// recursive use in custom verbs. // recursive use in custom verbs.
func (p *pp) Write(b []byte) (ret int, err error) { func (p *pp) Write(b []byte) (ret int, err error) {
p.buf.write(b) p.buf.write(b)
return len(b), nil return len(b), nil
} }
// Implement WriteString so that we can call io.WriteString // Implement WriteString so that we can call [io.WriteString]
// on a pp (through state), for efficiency. // on a pp (through state), for efficiency.
func (p *pp) WriteString(s string) (ret int, err error) { func (p *pp) WriteString(s string) (ret int, err error) {
p.buf.writeString(s) p.buf.writeString(s)

10
src/fmt/scan.go
View File

@ -51,7 +51,7 @@ type ScanState interface {
// Scanner is implemented by any value that has a Scan method, which scans // Scanner is implemented by any value that has a Scan method, which scans
// the input for the representation of a value and stores the result in the // the input for the representation of a value and stores the result in the
// receiver, which must be a pointer to be useful. The Scan method is called // receiver, which must be a pointer to be useful. The Scan method is called
// for any argument to Scan, Scanf, or Scanln that implements it. // for any argument to [Scan], [Scanf], or [Scanln] that implements it.
type Scanner interface { type Scanner interface {
Scan(state ScanState, verb rune) error Scan(state ScanState, verb rune) error
} }
@ -64,7 +64,7 @@ func Scan(a ...any) (n int, err error) {
return Fscan(os.Stdin, a...) return Fscan(os.Stdin, a...)
} }
// Scanln is similar to Scan, but stops scanning at a newline and // Scanln is similar to [Scan], but stops scanning at a newline and
// after the final item there must be a newline or EOF. // after the final item there must be a newline or EOF.
func Scanln(a ...any) (n int, err error) { func Scanln(a ...any) (n int, err error) {
return Fscanln(os.Stdin, a...) return Fscanln(os.Stdin, a...)
@ -100,7 +100,7 @@ func Sscan(str string, a ...any) (n int, err error) {
return Fscan((*stringReader)(&str), a...) return Fscan((*stringReader)(&str), a...)
} }
// Sscanln is similar to Sscan, but stops scanning at a newline and // Sscanln is similar to [Sscan], but stops scanning at a newline and
// after the final item there must be a newline or EOF. // after the final item there must be a newline or EOF.
func Sscanln(str string, a ...any) (n int, err error) { func Sscanln(str string, a ...any) (n int, err error) {
return Fscanln((*stringReader)(&str), a...) return Fscanln((*stringReader)(&str), a...)
@ -125,7 +125,7 @@ func Fscan(r io.Reader, a ...any) (n int, err error) {
return return
} }
// Fscanln is similar to Fscan, but stops scanning at a newline and // Fscanln is similar to [Fscan], but stops scanning at a newline and
// after the final item there must be a newline or EOF. // after the final item there must be a newline or EOF.
func Fscanln(r io.Reader, a ...any) (n int, err error) { func Fscanln(r io.Reader, a ...any) (n int, err error) {
s, old := newScanState(r, false, true) s, old := newScanState(r, false, true)
@ -416,7 +416,7 @@ func (s *ss) free(old ssave) {
// SkipSpace provides Scan methods the ability to skip space and newline // SkipSpace provides Scan methods the ability to skip space and newline
// characters in keeping with the current scanning mode set by format strings // characters in keeping with the current scanning mode set by format strings
// and Scan/Scanln. // and [Scan]/[Scanln].
func (s *ss) SkipSpace() { func (s *ss) SkipSpace() {
for { for {
r := s.getRune() r := s.getRune()