324 }

325

326 func builtinFormat(args ...Object) (Object, error) {

327 numArgs := len(args)

328 if numArgs == 0 {

99

100 // Format N number of arguments for logging, and limit the length of each formatted arg.

101 func Format(args ...interface{}) string {

102 parts := make([]string, len(args))

103 for i, arg := range args {

185 func execmTimeFormat(_ int, p *gop.Context) {

186 args := p.GetArgs(2)

187 ret0 := args[0].(time.Time).Format(args[1].(string))

188 p.Ret(2, ret0)

189 }

191 func execmTimeAppendFormat(_ int, p *gop.Context) {

192 args := p.GetArgs(3)

193 ret0 := args[0].(time.Time).AppendFormat(args[1].([]byte), args[2].(string))

194 p.Ret(3, ret0)

195 }

33 }

34 args[0] = types.Float64(args[0])

35 return FuncFormat(args...)

36 }

37

73 // 格式化

74 // format('%.2f')

75 func FuncFormat(args ...interface{}) interface{} {

76 if len(args) == 0 {

77 return ""

147 // Call appends a command to the write buffer or returns an error.

148 func (ac *AsyncClient) Call(args ...interface{}) (err error) {

149 _, err = ac.buf.Write(format(args...))

150 ac.queued++

151 return err

195 }

196

197 func (u *Unicode) Format(args *Tuple) (*Unicode, error) {

198 ret := C.PyUnicode_Format(c(u), c(args))

199 if ret == nil {

81

82 //还可以自定义结构体解析实体,如json,gorm,xml

83 func (c *commands) CustomFormat(args []string) int {

84 formats = c._setFormat()

85 return 0

163 func (e Error) Panicf(args ...interface{}) {

164 _, fn, line, _ := runtime.Caller(1)

165 errMsg := e.Format(args...).Error()

166 errMsg += "\nCaller was: " + fmt.Sprintf("%s:%d", fn, line)

167 panic(errMsg)

55 Gen(args []string, dryRun bool) error

56 Lint(args []string, listAllLinters bool, listLinters bool, listAllLintGroups bool, listLintGroup string, diffLintGroups string, generateIgnores bool) error

57 Format(args []string, overwrite, diffMode, lintMode, fix bool) error

58 All(args []string, disableFormat, disableLint, fix bool) error

59 GRPC(args, headers []string, address, method, data, callTimeout, connectTimeout, keepaliveTime string, stdin bool, details bool, tls bool, insecure bool, cacert string, cert string, key string, serverName string) error

28 }

29

30 formatted, err := format(args[0].String(), args[1:])

31 if err != nil {

32 return values.None, err

66 var validationErrors []validationError

67

68 namedArgs, parsingErrors := validateArgFormat(args)

69 validationErrors = append(validationErrors, parsingErrors...)

70 if validateArgs {

94 }

95

96 func validateArgFormat(args []string) (map[string]string, []validationError) {

97 var validationErrors []validationError

98 namedArgs := map[string]string{}

74 * of strings which create a redis command.

75 * Returns a byte array */

76 func format(args ...interface{}) []byte {

77 buf := make([][]byte, len(args))

78

93 // Write might return a net.Conn.Write error

94 func (c *Conn) Write(args ...interface{}) error {

95 _, e := c.c.Write(format(args...))

96

97 if e != nil {

41 engineConfig.SetBundlePath(absBundle)

42 engineConfig.SetLogPath(args.LogPath)

43 engineConfig.SetLogFormat(args.LogFormat)

44 engineConfig.SetPidFile(args.PidFile)

45

36 }

37

38 func CheckFormat(args []interface{}) (format string, hasFormat bool) {

39 if len(args) < 1 { return }

40 switch arg := args[0].(type){

54

55 func Print(args ...interface{}) {

56 if format, hasFormat := CheckFormat(args); hasFormat {

57 fmt.Printf(format, args[1:]...)

58 } else {

62

63 func Log(args ...interface{}) {

64 if format, hasFormat := CheckFormat(args); hasFormat {

65 log.Printf(format, args[1:]...)

66 } else {

87 // SetFormat changes format properties of a page. Valid values are:

88 // page_full_width (bool), page_small_text (bool)

89 func (p *Page) SetFormat(args map[string]interface{}) error {

90 if len(args) == 0 {

91 return errors.New("args can't be empty")

82

83 // ReInitFormat - re-init 'format.json'

84 func (receiver *adminRPCReceiver) ReInitFormat(args *ReInitFormatArgs, reply *VoidReply) error {

85 return receiver.local.ReInitFormat(args.DryRun)

130 // {format str args...}

131 // just like fmt.Sprintf

132 func kfFormat(args []KeyBuilderStage) KeyBuilderStage {

133 if len(args) < 1 {

134 return stageError(ErrorArgCount)

46 }

47

48 func (t *template) Format(args ...string) string {

49 s := ""

50 for i := range t.Fragments {

21

22 // Format ...

23 func (fm Formatter) Format(args ...interface{}) string {

24 return fmt.Sprintf(string(fm), args...)

25 }

19

20 // Format returns a formatted new error based on the arguments

21 func (e *Error) Format(args ...interface{}) error {

22 return fmt.Errorf(e.message, args...)

23 }

54 }

55 _, fn, line, _ := runtime.Caller(1)

56 errMsg := e.Format(args...).Error()

57 errMsg = "\nCaller was: " + fmt.Sprintf("%s:%d", fn, line)

58 panic(errMsg)

28 }

29 logf(" updating format to %v\n", args)

30 err := page.SetFormat(args)

31 if err != nil {

32 logf("updateFormatIfNeeded: page.SetFormat() failed with '%s'\n", err)

9 Name() string

10 Alias() string

11 Format(args ...interface{}) string

12 FormatMap(params H) string

13 RegExp() *regexp.Regexp

31 }

32

33 func (h *host) Format(args ...interface{}) string {

34 if len(args) > 0 {

35 return fmt.Sprintf(h.format, args...)

125 }

126

127 func kfTimeFormat(args []KeyBuilderStage) KeyBuilderStage {

128 if len(args) < 1 {

129 return stageError(ErrorArgCount)

97 func (e Error) Panicf(args ...interface{}) {

98 _, fn, line, _ := runtime.Caller(1)

99 errMsg := e.Format(args...).Error()

100 errMsg = "\nCaller was: " + fmt.Sprintf("%s:%d", fn, line)

101 panic(errMsg)

44 // write args to socket

45 func (c *Conn) Write(args ...interface{}) error {

46 _, e := c.c.Write(format(args...))

47

48 if e != nil {

48 }

49

50 func (s *String) Format(args *Tuple) (*String, error) {

51 ret := C.PyString_Format(c(s), c(args))

52 if ret == nil {

29 r.router = h.Router

30 if len(args) != 1 {

31 r.prefix = h.group.host.Format(args...)

32 return

33 }

38 r.prefix = h.group.host.FormatMap(v)

39 default:

40 r.prefix = h.group.host.Format(args...)

41 }

42 return

80

81 func (ac *AsyncClient) Call(args ...interface{}) (err error) {

82 _, err = ac.buf.Write(format(args...))

83 ac.queued++

84 return err

18 // Function Format runs fmt.Sprintf using the format string specified during creation and the specified

19 // arguments, then returns the created error.

20 func (et ErrorTemplate) Format(args ...interface{}) (err error) {

21 return errors.New(fmt.Sprintf(string(et), args...))

22 }