NAME

       gofmt - format Go programs

SYNOPSIS

       gofmt [flags] [path ...]

DESCRIPTION

       Gofmt  formats Go programs. It uses tabs for indentation and blanks for alignment. Alignment assumes that
       an editor is using a fixed-width font.

       Without an explicit path, it processes the standard input. Given a file, it operates on that file;  given
       a  directory,  it operates on all .go files in that directory, recursively. (Files starting with a period
       are ignored.) By default, gofmt prints the reformatted sources to standard output.

OPTIONS

       -d     Do not print reformatted sources to standard output.  If a file's  formatting  is  different  than
              gofmt's, print diffs to standard output.

       -e     Print all (including spurious) errors.

       -l     Do  not  print  reformatted  sources to standard output.  If a file's formatting is different from
              gofmt's, print its name to standard output.

       -r rule
              Apply the rewrite rule to the source before reformatting.

       -s     Try to simplify code (after applying the rewrite rule, if any).

       -w     Do not print reformatted sources to standard output.  If a file's  formatting  is  different  from
              gofmt's,  overwrite it with gofmt's version. If an error occurred during overwriting, the original
              file is restored from an automatic backup.

       Debugging support:

       -cpuprofile filename
              Write cpu profile to the specified file.

       The rewrite rule specified with the -r flag must be a string of the form:

             pattern -> replacement

       Both pattern and replacement must be valid Go expressions. In  the  pattern,  single-character  lowercase
       identifiers  serve as wildcards matching arbitrary sub-expressions; those expressions will be substituted
       for the same identifiers in the replacement.

       When gofmt reads from standard input, it accepts either a full  Go  program  or  a  program  fragment.  A
       program  fragment  must  be  a  syntactically valid declaration list, statement list, or expression. When
       formatting such a fragment, gofmt preserves leading indentation as well as leading and  trailing  spaces,
       so that individual sections of a Go program can be formatted by piping them through gofmt.

EXAMPLES

       To check files for unnecessary parentheses:

             gofmt -r '(a) -> a' -l *.go

       To remove the parentheses:

             gofmt -r '(a) -> a' -w *.go

       To convert the package tree from explicit slice upper bounds to implicit ones:

             gofmt -r 'α[β:len(α)] -> α[β:]' -w $GOROOT/src/pkg

   The simplify command
       When invoked with -s gofmt will make the following source transformations where possible.

           An array, slice, or map composite literal of the form:
               []T{T{}, T{}}
           will be simplified to:
               []T{{}, {}}

           A slice expression of the form:
               s[a:len(s)]
           will be simplified to:
               s[a:]

           A range of the form:
               for x, _ = range v {...}
           will be simplified to:
               for x = range v {...}

           A range of the form:
               for _ = range v {...}
           will be simplified to:
               for range v {...}

       This may result in changes that are incompatible with earlier versions of Go.

AUTHOR

       This  manual  page  was  written  by  Michael Stapelberg <stapelberg@debian.org> and is maintained by the
       Debian Go Compiler Team <team+go-compiler@tracker.debian.org> based on the output of 'go  doc  cmd/gofmt'
       for the Debian project (and may be used by others).

                                                   2021-09-06                                           GOFMT(1)