Go Standard Library

https://pkg.go.dev/*go1.25.3
Admin
Go's standard library is a comprehensive collection of packages providing built-in functionality for...
Tokens:1,479,870
Snippets:15,551
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### WaitGroup Example using Go

Source: https://pkg.go.dev/sync%40go1.25.3

Demonstrates starting tasks using WaitGroup.Go and waiting for their completion. This is the preferred method for managing goroutines with WaitGroup.

```go
var wg sync.WaitGroup
wg.Go(task1)
wg.Go(task2)
wg.Wait()
```

--------------------------------

### Image DecodeConfig Example

Source: https://pkg.go.dev/image%40go1.25.3

This example shows how to use DecodeConfig to get image header information before full decoding. This is crucial for security and resource management.

```go
Output:


```

--------------------------------

### Start Server

Source: https://pkg.go.dev/net/http/httptest%40go1.25.3

Starts a server that was created via NewUnstartedServer.

```go
func (s *Server) Start()
```

--------------------------------

### Benchmark with Expensive Setup

Source: https://pkg.go.dev/testing%40go1.25.3

Demonstrates performing setup outside the b.Loop to ensure it is not included in timing.

```go
func BenchmarkBigLen(b *testing.B) {
    big := NewBig()
    for b.Loop() {
        big.Len()
    }
}
```

--------------------------------

### Go Example Function with Standard Output

Source: https://pkg.go.dev/testing%40go1.25.3

Example functions can include a concluding line comment starting with 'Output:' which is compared against the function's standard output during testing. Leading and trailing spaces in the output are ignored during comparison.

```go
func ExampleHello() {
    fmt.Println("hello")
    // Output: hello
}
```

```go
func ExampleSalutations() {
    fmt.Println("hello, and")
    fmt.Println("goodbye")
    // Output:
    // hello, and
    // goodbye
}
```

--------------------------------

### Div32 Example Output

Source: https://pkg.go.dev/math/bits%40go1.25.3

Example output for Div32.

```text
Output:
[0 6] / 3 = [2 0]
[2 2147483648] / 2147483648 = [5 0]
```

--------------------------------

### LeadingZeros Example Outputs

Source: https://pkg.go.dev/math/bits%40go1.25.3

Example outputs for LeadingZeros functions.

```text
Output:
LeadingZeros8(00000001) = 7
```

```text
Output:
LeadingZeros16(0000000000000001) = 15
```

```text
Output:
LeadingZeros32(00000000000000000000000000000001) = 31
```

```text
Output:
LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63
```

--------------------------------

### Usage Example

Source: https://pkg.go.dev/internal/godebug%40go1.25.3

Example demonstrating how to use the godebug package to access and react to GODEBUG settings.

```APIDOC
## Usage Example

### Description
This example shows how to declare a global Setting and use its Value to conditionally alter program behavior. It also demonstrates calling IncNonDefault when non-default behavior is executed.

### Code
```go
import "go.googlesource.com/godebug/godebug"
import "net/http"

var http2server = godebug.New("http2server")

func ServeConn(c net.Conn) {
	if http2server.Value() == "0" {
		// Disallow HTTP/2
		// ... custom logic ...
		http2server.IncNonDefault() // Increment counter as non-default behavior is executed
	}
	// ... rest of the ServeConn logic ...
}
```

### Convention
Global variables representing godebugs should be named identically to the godebug name (e.g., `var gotypesalias = godebug.New("gotypesalias")`).
```

--------------------------------

### Go bits package: Add32 example

Source: https://pkg.go.dev/math/bits%40go1.25.3

Example demonstrating the Add32 function with different inputs, showing the sum and carry-out.

```go
Output:
[33 12] + [21 23] = [54 35] (carry bit was 0)
[1 2147483648] + [1 2147483648] = [3 0] (carry bit was 1)
```

--------------------------------

### Go bits package: Add64 example

Source: https://pkg.go.dev/math/bits%40go1.25.3

Example demonstrating the Add64 function with different inputs, showing the sum and carry-out.

```go
Output:
[33 12] + [21 23] = [54 35] (carry bit was 0)
[1 9223372036854775808] + [1 9223372036854775808] = [3 0] (carry bit was 1)
```

--------------------------------

### ParseFile Example Output

Source: https://pkg.go.dev/go/parser%40go1.25.3

Example output showing parsed imports.

```text
Output:

"fmt"
"time"
```

--------------------------------

### Div64 Example Output

Source: https://pkg.go.dev/math/bits%40go1.25.3

Example output for Div64.

```text
Output:
[0 6] / 3 = [2 0]
[2 9223372036854775808] / 9223372036854775808 = [5 0]
```

--------------------------------

### Create New Unstarted Server

Source: https://pkg.go.dev/net/http/httptest%40go1.25.3

Returns a new server instance without starting it, allowing for configuration changes before calling Start or StartTLS.

```go
func NewUnstartedServer(handler http.Handler) *Server
```

--------------------------------

### Examples

Source: https://pkg.go.dev/go/doc%40go1.25.3

The Examples function extracts all example functions from the provided Go AST files. It returns a slice of Example structs, sorted by the example's name.

```APIDOC
## Examples

### Description
Examples returns the examples found in testFiles, sorted by Name field. The Order fields record the order in which the examples were encountered. The Suffix field is not populated when Examples is called directly, it is only populated by NewFromFiles for examples it finds in _test.go files.

Playable Examples must be in a package whose name ends in "_test". An Example is "playable" (the Play field is non-nil) in either of these circumstances:
  * The example function is self-contained: the function references only identifiers from other packages (or predeclared identifiers, such as "int") and the test file does not include a dot import.
  * The entire test file is the example: the file contains exactly one example function, zero test, fuzz test, or benchmark function, and at least one top-level function, type, variable, or constant declaration other than the example function.

### Method
func Examples(testFiles ...*ast.File) []*Example
```

--------------------------------

### Get Denominator of a Constant (Example)

Source: https://pkg.go.dev/go/constant%40go1.25.3

This example demonstrates how to get the denominator of a constant value. The output '6121026514868073/2251799813685248' suggests the input value was a fraction.

```go
Output:

6121026514868073/2251799813685248
```

--------------------------------

### Starting a Basic HTTP Server in Go

Source: https://pkg.go.dev/net/http%40go1.25.3

Demonstrates how to start an HTTP server using ListenAndServe, which binds to a given address and uses DefaultServeMux if no handler is provided. Handlers can be registered using Handle and HandleFunc.

```go
http.Handle("/foo", fooHandler)

http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
})

log.Fatal(http.ListenAndServe(":8080", nil))


```

--------------------------------

### Get Numerator of a Constant (Example)

Source: https://pkg.go.dev/go/constant%40go1.25.3

This example demonstrates how to get the numerator of a constant value. The output '9223372036854775807' suggests the input value was likely a large integer or fraction.

```go
Output:

9223372036854775807
```

--------------------------------

### Create Package Documentation with NewFromFiles

Source: https://pkg.go.dev/go/doc%40go1.25.3

Use NewFromFiles to compute package documentation, including examples from _test.go files. Ensure the provided files match the desired build context.

```go
func NewFromFiles(fset *token.FileSet, files []*ast.File, importPath string, opts ...any) (*Package, error)
```

--------------------------------

### Get SliceExpr Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the SliceExpr node.

```go
func (x *SliceExpr) Pos() token.Pos
```

--------------------------------

### Template Execution Example (Share)

Source: https://pkg.go.dev/text/template%40go1.25.3

Illustrates using one group of driver templates with distinct sets of helper templates, showing how template versions can be managed.

```text
Output:
T0 (second version) invokes T1: (T1 invokes T2: (T2, version B))
T0 (first version) invokes T1: (T1 invokes T2: (T2, version A))

```

--------------------------------

### Get SendStmt Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the SendStmt node.

```go
func (s *SendStmt) Pos() token.Pos
```

--------------------------------

### Example Struct Documentation

Source: https://pkg.go.dev/go/doc%40go1.25.3

Represents documentation for a type, including a sorted list of associated examples extracted from test files.

```go
type Type struct {
	// Examples is a sorted list of examples associated with
	// this type. Examples are extracted from _test.go files
	// provided to NewFromFiles.
	Examples []*Example
}
```

--------------------------------

### Get SelectorExpr Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the SelectorExpr node.

```go
func (x *SelectorExpr) Pos() token.Pos
```

--------------------------------

### Example: Sharing Templates and Helpers

Source: https://pkg.go.dev/html/template%40go1.25.3

Illustrates sharing templates and using them in different contexts by adding multiple driver templates.

```go
Output:
Driver 1 calls T1: (T1 invokes T2: (This is T2))
Driver 2 calls T2: (This is T2)
```

--------------------------------

### Get SelectStmt Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the SelectStmt node.

```go
func (s *SelectStmt) Pos() token.Pos
```

--------------------------------

### Example: Parsefiles Template Loading

Source: https://pkg.go.dev/html/template%40go1.25.3

Demonstrates loading templates from files located in different directories.

```go
Output:
T1 invokes T2: (This is T2)
```

--------------------------------

### Example: Glob Template Loading

Source: https://pkg.go.dev/html/template%40go1.25.3

Shows how to load a set of templates from a directory using glob patterns.

```go
Output:
T0 invokes T1: (T1 invokes T2: (This is T2))
```

--------------------------------

### Get ReturnStmt Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the ReturnStmt node.

```go
func (s *ReturnStmt) Pos() token.Pos
```

--------------------------------

### Get RangeStmt Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the RangeStmt node.

```go
func (s *RangeStmt) Pos() token.Pos
```

--------------------------------

### Init Method

Source: https://pkg.go.dev/text/tabwriter%40go1.25.3

Initializes a Writer with specific formatting parameters.

```go
func (b *Writer) Init(output io.Writer, minwidth, tabwidth, padding int, padchar byte, flags uint) *Writer
```

--------------------------------

### Find output example

Source: https://pkg.go.dev/sort%40go1.25.3

Expected output for the Find string example.

```text
Output:
found banana at index 1
orange not found, would insert at 4
```

--------------------------------

### Get ParenExpr Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the ParenExpr node.

```go
func (x *ParenExpr) Pos() token.Pos
```

--------------------------------

### Get Package Start Position

Source: https://pkg.go.dev/go/ast%40go1.25.3

Returns the starting position of the Package node.

```go
func (p *Package) Pos() token.Pos
```

--------------------------------

### Example Usage of FileServer with http.Dir

Source: https://pkg.go.dev/net/http%40go1.25.3

Demonstrates how to use http.FileServer with http.Dir to serve files from the operating system's file system.

```go
http.Handle("/", http.FileServer(http.Dir("/tmp")))

```

--------------------------------

### Start HTTP server for pprof

Source: https://pkg.go.dev/net/http/pprof%40go1.25.3

Start a background HTTP server to serve profiling data if one is not already running.

```go
go func() {
	log.Println(http.ListenAndServe("localhost:6060", nil))
}()
```

--------------------------------

### CoverableUnit Example

Source: https://pkg.go.dev/internal/coverage%40go1.25.3

Illustrates how CoverableUnit describes simple and intraline units for coverage, using a code example with line numbers.

```go
L7:   q := 1
L8:   x := (y == 101 || launch() == false)
L9:   r := x * 2

```

--------------------------------

### Example Go Path Directory Layout

Source: https://pkg.go.dev/go/build%40go1.25.3

Illustrates the expected directory structure within a Go path, including src, bin, and pkg subdirectories.

```text
GOPATH=/home/user/gocode

/home/user/gocode/
    src/
        foo/
            bar/               (go code in package bar)
                x.go
            quux/              (go code in package main)
                y.go
    bin/
        quux                   (installed command)
    pkg/
        linux_amd64/
            foo/
                bar.a          (installed package object)


```

--------------------------------

### Get Numerator of a Constant (Example)

Source: https://pkg.go.dev/go/constant%40go1.25.3

This example demonstrates how to get the numerator of a constant value. The output '22' suggests the input value was likely a fraction or integer that resulted in 22 as its numerator.

```go
Output:
22
```

--------------------------------

### Get MMUCurve Examples

Source: https://pkg.go.dev/internal/trace%40go1.25.3

Retrieves specific examples of the lowest mutator utilization for a given window size. Returns disjoint windows.

```go
func (c *MMUCurve) Examples(window time.Duration, n int) (worst []UtilWindow)
```

--------------------------------

### Server Initialization

Source: https://pkg.go.dev/net/rpc%40go1.25.3

Creates and returns a new RPC server instance. No setup is required before calling this function.

```go
func NewServer() *Server {
	// ... implementation details ...
}
```

--------------------------------

### Selection String Examples

Source: https://pkg.go.dev/go/types%40go1.25.3

Examples demonstrating the string representations for different types of selections, including fields and methods.

```text
"field (T) f int"
"method (T) f(X) Y"
"method expr (T) f(X) Y"
```

--------------------------------

### Get Reader Version

Source: https://pkg.go.dev/internal/trace/raw%40go1.25.3

Returns the version of the trace being read. No setup required.

```go
func (r *Reader) Version() version.Version
```

--------------------------------

### Example: Share Template Groups

Source: https://pkg.go.dev/html/template%40go1.25.3

Shows how to use one group of driver templates with distinct sets of helper templates.

```go
Output:
T0 (second version) invokes T1: (T1 invokes T2: (T2, version B))
T0 (first version) invokes T1: (T1 invokes T2: (T2, version A))
```

--------------------------------

### Start Server TLS

Source: https://pkg.go.dev/net/http/httptest%40go1.25.3

Starts TLS on a server that was created via NewUnstartedServer.

```go
func (s *Server) StartTLS()
```

--------------------------------

### Get Boolean Value of a Constant (Example)

Source: https://pkg.go.dev/go/constant%40go1.25.3

This example demonstrates retrieving a boolean value from a constant. The output 'false' indicates the constant represented the boolean value false.

```go
Output:
false
```

--------------------------------

### Example GoVersion Usage

Source: https://pkg.go.dev/go/build/constraint%40go1.25.3

Illustrates how GoVersion determines the minimum Go version from various build expressions.

```go
GoVersion(linux && go1.22) = "go1.22"
GoVersion((linux && go1.22) || (windows && go1.20)) = "go1.20" => go1.20
GoVersion(linux) = ""
GoVersion(linux || (windows && go1.22)) = ""
GoVersion(!go1.22) = ""
```

--------------------------------

### Get Boolean Value of a Constant (Example)

Source: https://pkg.go.dev/go/constant%40go1.25.3

This example demonstrates retrieving a boolean value from a constant. The output 'true' indicates the constant represented the boolean value true.

```go
Output:
true
```

--------------------------------

### Example Delims Usage

Source: https://pkg.go.dev/html/template%40go1.25.3

Demonstrates setting custom delimiters for template actions.

```html
Hello {{.Name}}

```

--------------------------------

### Starting an HTTP Server

Source: https://pkg.go.dev/net/http%40go1.25.3

ListenAndServe starts an HTTP server with a given address and handler. DefaultServeMux is used if handler is nil.

```APIDOC
## Starting an HTTP Server

### Description
`http.ListenAndServe` initiates an HTTP server on the specified address, utilizing the provided handler. If no handler is specified (nil), `http.DefaultServeMux` is employed.

### Usage
```go
http.Handle("/foo", fooHandler)

http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
})

log.Fatal(http.ListenAndServe(":8080", nil))
```
```

--------------------------------

### GetOption Example

Source: https://pkg.go.dev/encoding/json/v2%40go1.25.3

Illustrates how to retrieve a specific option's value from a set of Options using the GetOption function.

```go
v, ok := json.GetOption(opts, json.Deterministic)
```

--------------------------------

### Get Line Start Position

Source: https://pkg.go.dev/go/token%40go1.25.3

Returns the Pos value for the start of a specified line. Ignores alternative positions set by AddLineColumnInfo. Panics if the 1-based line number is invalid.

```go
func (f *File) LineStart(line int) Pos
```

--------------------------------

### Get start conditions

Source: https://pkg.go.dev/regexp/syntax%40go1.25.3

Returns the leading empty-width conditions that must be true in any match.

```go
func (p *Prog) StartCond() EmptyOp
```

--------------------------------

### Create New Server

Source: https://pkg.go.dev/net/http/httptest%40go1.25.3

Starts and returns a new test server. The caller should invoke Close when finished.

```go
func NewServer(handler http.Handler) *Server
```

--------------------------------

### Example QueryRow Usage

Source: https://pkg.go.dev/database/sql%40go1.25.3

Example of how to use QueryRow to fetch a single value and scan it into a variable.

```go
var name string
err := nameByUseridStmt.QueryRow(id).Scan(&name)
```

--------------------------------

### Example: Block Template Execution

Source: https://pkg.go.dev/html/template%40go1.25.3

Demonstrates the output of a template using block functionality.

```go
Output:
Names:
- Gamora
- Groot
- Nebula
- Rocket
- Star-Lord
Names: Gamora, Groot, Nebula, Rocket, Star-Lord
```

--------------------------------

### Get program prefix

Source: https://pkg.go.dev/regexp/syntax%40go1.25.3

Returns a literal string that all matches for the regexp must start with.

```go
func (p *Prog) Prefix() (prefix string, complete bool)
```

--------------------------------

### Get Current Local Time

Source: https://pkg.go.dev/time%40go1.25.3

Now returns the current local time. No setup is required.

```go
func Now() Time
```

--------------------------------

### Example Usage of FileServerFS

Source: https://pkg.go.dev/net/http%40go1.25.3

Demonstrates how to use http.FileServerFS with an fs.FS implementation.

```go
http.Handle("/", http.FileServerFS(fsys))

```

--------------------------------

### Go Example Function Naming Conventions with Suffix

Source: https://pkg.go.dev/testing%40go1.25.3

Multiple example functions for a package, type, function, or method can be provided by appending a distinct suffix starting with a lower-case letter to the name.

```go
func Example_suffix() { ... }
```

```go
func ExampleF_suffix() { ... }
```

```go
func ExampleT_suffix() { ... }
```

```go
func ExampleT_M_suffix() { ... }
```

--------------------------------

### Get TextReader Version

Source: https://pkg.go.dev/internal/trace/raw%40go1.25.3

Returns the version of the trace being read by the TextReader. No additional setup needed.

```go
func (r *TextReader) Version() version.Version
```

--------------------------------

### FuncType Node Position Methods

Source: https://pkg.go.dev/go/ast%40go1.25.3

Provides methods to get the start and end positions of a FuncType AST node.

```go
func (x *FuncType) End() token.Pos
```

```go
func (x *FuncType) Pos() token.Pos
```

--------------------------------

### Template Execution Example (Glob)

Source: https://pkg.go.dev/text/template%40go1.25.3

Illustrates loading a set of templates from a directory using glob patterns, showing nested template invocation.

```text
Output:
T0 invokes T1: (T1 invokes T2: (This is T2))

```

--------------------------------

### FuncLit Node Position Methods

Source: https://pkg.go.dev/go/ast%40go1.25.3

Provides methods to get the start and end positions of a FuncLit AST node.

```go
func (x *FuncLit) End() token.Pos
```

```go
func (x *FuncLit) Pos() token.Pos
```

--------------------------------

### Example of Context Value Usage

Source: https://pkg.go.dev/context%40go1.25.3

Demonstrates how to add a value to a context and retrieve it. Shows successful retrieval and handling of missing keys.

```text
found value: Go
key not found: color
```

--------------------------------

### FuncDecl Node Position Methods

Source: https://pkg.go.dev/go/ast%40go1.25.3

Provides methods to get the start and end positions of a FuncDecl AST node.

```go
func (d *FuncDecl) End() token.Pos
```

```go
func (d *FuncDecl) Pos() token.Pos
```

--------------------------------

### pprof.StartCPUProfile

Source: https://pkg.go.dev/runtime/pprof%40go1.25.3

Starts CPU profiling, writing the profile data to the given `io.Writer`.

```APIDOC
## func StartCPUProfile

### Description
Starts CPU profiling, writing the profile data to the given `io.Writer`. This function should be called before the code to be profiled.

### Method
`pprof.StartCPUProfile`

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```go
import (
	"os"
	"runtime/pprof"
)

f, err := os.Create("cpu.prof")
if err != nil {
	// handle error
}
defer f.Close()
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
```

### Response
#### Success Response (200)
Returns `nil` if CPU profiling started successfully.

#### Response Example
`nil`
```

--------------------------------

### ForStmt Node Position Methods

Source: https://pkg.go.dev/go/ast%40go1.25.3

Provides methods to get the start and end positions of a ForStmt AST node.

```go
func (s *ForStmt) End() token.Pos
```

```go
func (s *ForStmt) Pos() token.Pos
```

--------------------------------

### Profiling with go test

Source: https://pkg.go.dev/runtime/pprof%40go1.25.3

This example demonstrates how to generate CPU and memory profiles for benchmarks using the `go test` command.

```APIDOC
## Profiling with go test

### Description
This command runs benchmarks and writes CPU and memory profiles to specified files.

### Method
`go test`

### Endpoint
N/A

### Parameters
#### Query Parameters
- **-cpuprofile** (string) - Optional - Write CPU profile to `file`.
- **-memprofile** (string) - Optional - Write memory profile to `file`.
- **-bench** (string) - Required - Run benchmarks matching the regular expression.

### Request Example
```bash
go test -cpuprofile cpu.prof -memprofile mem.prof -bench .
```

### Response
#### Success Response (200)
N/A (generates profile files)

#### Response Example
N/A
```

--------------------------------

### Example of Time.Format layouts

Source: https://pkg.go.dev/time%40go1.25.3

Demonstrates various layout strings for formatting time values, including different date and time representations, AM/PM, and fractional seconds.

```go
Output:
default format: 2015-02-25 11:06:39 -0800 PST
Unix format: Wed Feb 25 11:06:39 PST 2015
Same, in UTC: Wed Feb 25 19:06:39 UTC 2015
in Shanghai with seconds: 2015-02-26T03:06:39 +080000
in Shanghai with colon seconds: 2015-02-26T03:06:39 +08:00:00

Formats:

Basic full date  "Mon Jan 2 15:04:05 MST 2006" gives "Wed Feb 25 11:06:39 PST 2015"
Basic short date "2006/01/02" gives "2015/02/25"
AM/PM            "3PM==3pm==15h" gives "11AM==11am==11h"
No fraction      "Mon Jan _2 15:04:05 MST 2006" gives "Wed Feb 25 11:06:39 PST 2015"
0s for fraction  "15:04:05.00000" gives "11:06:39.12340"
9s for fraction  "15:04:05.99999999" gives "11:06:39.1234"

```

--------------------------------

### Get Offset from Position

Source: https://pkg.go.dev/go/token%40go1.25.3

Returns the offset for a given file position. Adjusts out-of-bounds positions to the file's start or end.

```go
func (f *File) Offset(p Pos) int
```

--------------------------------

### Get JSON Value Kind

Source: https://pkg.go.dev/encoding/json/jsontext%40go1.25.3

Kind returns the starting token kind of a JSON Value. For a valid value, this will never include '}' or ']'.

```go
func (v Value) Kind() Kind
```

--------------------------------

### Open and Prepare Plan 9 File

Source: https://pkg.go.dev/debug/plan9obj%40go1.25.3

Opens the named file using os.Open and prepares it for use as a Plan 9 a.out binary.

```go
func Open(name string) (*File, error)
```

--------------------------------

### Get Position from Offset

Source: https://pkg.go.dev/go/token%40go1.25.3

Returns the Pos value for a given file offset. Adjusts out-of-bounds offsets to the file's start or end.

```go
func (f *File) Pos(offset int) Pos
```

--------------------------------

### Get Field Offset in Go Structs

Source: https://pkg.go.dev/unsafe%40go1.25.3

Offsetof returns the byte offset of a struct field from the start of the struct. Requires the argument to be of the form structValue.field.

```go
func Offsetof(x ArbitraryType) uintptr
```

--------------------------------

### Example output showing token positions

Source: https://pkg.go.dev/go/token%40go1.25.3

Demonstrates the output format for retrieving position information for lexical tokens within Go source files.

```text
main.go:3:1: import
main.go:5:1: import
main.go:1:5[main.go:8:1]: type
main.go:3:1[main.go:10:1]: const
fake.go:42:11[main.go:13:1]: func
fake.go:7:9[main.go:17:14]: func
```

--------------------------------

### Inspect AST Example

Source: https://pkg.go.dev/go/ast%40go1.25.3

Demonstrates inspecting the AST of a Go program, showing the output of visited nodes and their associated information.

```text
Output:
src.go:2:9:	p
src.go:3:7:	c
src.go:3:11:	1.0
src.go:4:5:	X
src.go:4:9:	f
src.go:4:11:	3.14
src.go:4:17:	2
src.go:4:21:	c


```

--------------------------------

### Getting the expvar HTTP Handler

Source: https://pkg.go.dev/expvar%40go1.25.3

The Handler function returns the expvar HTTP handler. This is useful for installing the handler at a non-standard URL path. Added in go1.8.

```go
func Handler() http.Handler

```

--------------------------------

### Load and Use Plugin Symbols

Source: https://pkg.go.dev/plugin%40go1.25.3

Example demonstrating how to open a plugin, look up exported symbols (a variable 'V' and a function 'F'), modify the variable, and call the function. Ensure the plugin and host application are compiled with compatible toolchains.

```go
package main

import "fmt"

var V int

func F() { fmt.Printf("Hello, number %d\n", V) }

```

```go
p, err := plugin.Open("plugin_name.so")
if err != nil {
	panic(err)
}
v, err := p.Lookup("V")
if err != nil {
	panic(err)
}
f, err := p.Lookup("F")
if err != nil {
	panic(err)
}
*v.(*int) = 7
f.(func())() // prints "Hello, number 7"

```

--------------------------------

### Encoder AvailableBuffer Example

Source: https://pkg.go.dev/encoding/json/jsontext%40go1.25.3

Shows how to use AvailableBuffer to get a buffer for populating a Value, which is then passed to an immediately succeeding Encoder.WriteValue call. This is useful for efficiently building values.

```go
b := d.AvailableBuffer()
b = append(b, '"')
b = appendString(b, v) // append the string formatting of v
b = append(b, '"')
... := d.WriteValue(b)

```

--------------------------------

### Calculate Units in a Duration in Go

Source: https://pkg.go.dev/time%40go1.25.3

To find the number of smaller units within a Duration, divide the Duration by the smaller unit. This example shows how to get the number of milliseconds in a second.

```go
second := time.Second
fmt.Print(int64(second/time.Millisecond)) // prints 1000
```

--------------------------------

### Initialize ResponseRecorder

Source: https://pkg.go.dev/net/http/httptest%40go1.25.3

Creates and returns an initialized ResponseRecorder instance.

```go
func NewRecorder() *ResponseRecorder
```

--------------------------------

### Event.Goroutine

Source: https://pkg.go.dev/internal/trace%40go1.25.3

Goroutine returns the ID of the goroutine that was executing when this event happened. It describes part of the execution context for this event. Note that for goroutine state transitions this always refers to the state before the transition. For example, if a goroutine is just starting to run on this thread and/or proc, then this will return NoGoroutine. In this case, the goroutine starting to run will be can be found at Event.StateTransition().Resource.

```APIDOC
## func (Event) Goroutine ¶ added in go1.23.0
```
func (e Event) Goroutine() GoID
```

### Description
Goroutine returns the ID of the goroutine that was executing when this event happened. It describes part of the execution context for this event. 
Note that for goroutine state transitions this always refers to the state before the transition. For example, if a goroutine is just starting to run on this thread and/or proc, then this will return NoGoroutine. In this case, the goroutine starting to run will be can be found at Event.StateTransition().Resource.
```

--------------------------------

### Get Current Position

Source: https://pkg.go.dev/text/scanner%40go1.25.3

Pos returns the position of the character immediately after the last character or token returned by Scanner.Next or Scanner.Scan. Use the Position field for the start position of the most recently scanned token.

```go
func (s *Scanner) Pos() (pos Position)
```

--------------------------------

### Event.Proc

Source: https://pkg.go.dev/internal/trace%40go1.25.3

Proc returns the ID of the proc this event event pertains to. Note that for proc state transitions this always refers to the state before the transition. For example, if a proc is just starting to run on this thread, then this will return NoProc.

```APIDOC
## func (Event) Proc ¶ added in go1.23.0
```
func (e Event) Proc() ProcID
```

### Description
Proc returns the ID of the proc this event event pertains to. 
Note that for proc state transitions this always refers to the state before the transition. For example, if a proc is just starting to run on this thread, then this will return NoProc.
```

--------------------------------

### Base64 Encoding and Decoding Example

Source: https://pkg.go.dev/encoding/base64%40go1.25.3

Demonstrates basic base64 encoding and decoding operations.

```go
Output:
SGVsbG8sIOS4lueVjA==
Hello, 世界

```

--------------------------------

### Get GOARCH Name and Value

Source: https://pkg.go.dev/internal/buildcfg%40go1.25.3

GOGOARCH returns the name and value of the GO$GOARCH setting. For example, if GOARCH is "amd64" it might return "GOAMD64", "v2".

```go
func GOGOARCH() (name, value string)

```

--------------------------------

### Search Example (Ascending Order)

Source: https://pkg.go.dev/sort%40go1.25.3

Demonstrates searching a list sorted in ascending order using the Search function.

```text
Output:
found 6 at index 2 in [1 3 6 10 15 21 28 36 45 55]
```

--------------------------------

### ErrSlashAmbig Example: Division vs. Regexp Ambiguity

Source: https://pkg.go.dev/html/template%40go1.25.3

Demonstrates how '/' can be ambiguous in JavaScript, potentially being interpreted as division or the start of a regular expression. This can lead to unexpected behavior, especially with missing semicolons or unclarified intent.

```html
<script>
  {{if .C}}var x = 1{{end}}
  /-{{.N}}/i.test(x) ? doThis : doThat();
</script>
```

--------------------------------

### Image Decoding Example

Source: https://pkg.go.dev/image%40go1.25.3

This example demonstrates decoding an image. It's recommended to call DecodeConfig before Decode to check image dimensions and prevent resource exhaustion.

```go
Output:
bin               red  green   blue  alpha
0x0000-0x0fff:    364    790   7242      0
0x1000-0x1fff:    645   2967   1039      0
0x2000-0x2fff:   1072   2299    979      0
0x3000-0x3fff:    820   2266    980      0
0x4000-0x4fff:    537   1305    541      0
0x5000-0x5fff:    319    962    261      0
0x6000-0x6fff:    322    375    177      0
0x7000-0x7fff:    601    279    214      0
0x8000-0x8fff:   3478    227    273      0
0x9000-0x9fff:   2260    234    329      0
0xa000-0xafff:    921    282    373      0
0xb000-0xbfff:    321    335    397      0
0xc000-0xcfff:    229    388    298      0
0xd000-0xdfff:    260    414    277      0
0xe000-0xefff:    516    428    298      0
0xf000-0xffff:   2785   1899   1772  15450


```

--------------------------------

### Get Time Zone Bounds

Source: https://pkg.go.dev/time%40go1.25.3

Returns the bounds of the time zone in effect at time t. The zone begins at start and the next zone begins at end. Zero Time indicates the beginning of time or an infinite duration.

```go
func (t Time) ZoneBounds() (start, end Time)
```

--------------------------------

### File Node Position Methods

Source: https://pkg.go.dev/go/ast%40go1.25.3

Provides methods to get the end position of the last declaration or the start position of the package declaration within a File AST node. Use FileEnd for the end of the entire file, which is always valid.

```go
func (f *File) End() token.Pos
```

```go
func (f *File) Pos() token.Pos
```

--------------------------------

### Custom HTTP Server Configuration in Go

Source: https://pkg.go.dev/net/http%40go1.25.3

Illustrates creating a custom HTTP server with specific configurations for address, timeouts, and header limits. This offers more control than ListenAndServe.

```go
s := &http.Server{
	Addr:           ":8080",
	Handler:        myHandler,
	ReadTimeout:    10 * time.Second,
	WriteTimeout:   10 * time.Second,
	MaxHeaderBytes: 1 << 20,
}
log.Fatal(s.ListenAndServe())


```

--------------------------------

### Get Importer with FileSet

Source: https://pkg.go.dev/go/importer%40go1.25.3

Returns an Importer for importing from installed packages for the compilers "gc" and "gccgo", or for importing directly from the source if the compiler argument is "source". A lookup function must be provided for correct module-aware operation.

```go
func ForCompiler(fset *token.FileSet, compiler string, lookup Lookup) types.Importer
```

--------------------------------

### Measure elapsed time with monotonic clock

Source: https://pkg.go.dev/time%40go1.25.3

Use time.Now() to get a time value that includes a monotonic clock reading. Subsequent subtractions using t.Sub(start) will use this monotonic reading, ensuring accurate elapsed time measurement even if the system's wall clock is reset.

```go
start := time.Now()
... operation that takes 20 milliseconds ...
t := time.Now()
elapsed := t.Sub(start)
```

--------------------------------

### Custom HTTP Client Configuration in Go

Source: https://pkg.go.dev/net/http%40go1.25.3

Illustrates creating a custom HTTP client with specific redirect policies. Clients should be created once and reused.

```go
client := &http.Client{
	CheckRedirect: redirectPolicyFunc,
}

resp, err := client.Get("http://example.com")
// ...

```

--------------------------------

### Visualizing Profiles with go tool pprof

Source: https://pkg.go.dev/runtime/pprof%40go1.25.3

This example shows how to use the `go tool pprof` command to visualize collected profile data.

```APIDOC
## Visualizing Profiles with go tool pprof

### Description
This command-line tool is used to analyze and visualize profiling data collected by the `pprof` package.

### Method
`go tool pprof`

### Endpoint
N/A

### Parameters
#### Path Parameters
- **profile_file** (string) - Required - The path to the profile file (e.g., `cpu.prof`, `mem.prof`).

### Request Example
```bash
go tool pprof cpu.prof
```

### Response
#### Success Response (200)
Opens an interactive command-line interface for analyzing the profile.

#### Response Example
```
Type 'help' for commands.
(pprof) top
```
```

--------------------------------

### MMUCurve.Examples

Source: https://pkg.go.dev/internal/trace%40go1.25.3

Examples returns a slice of UtilWindow representing the worst-case utilization windows.

```APIDOC
## func (c *MMUCurve) Examples

### Description
Examples returns a slice of UtilWindow representing the worst-case utilization windows for a given duration and number of examples.

### Signature
```go
func (c *MMUCurve) Examples(window time.Duration, n int) (worst []UtilWindow)
```
```

--------------------------------

### Get Method for GET Requests

Source: https://pkg.go.dev/net/http%40go1.25.3

Get issues a GET to the specified URL. If the response is a redirect code, Get follows the redirect after calling the Client.CheckRedirect function.

```go
func (c *Client) Get(url string) (resp *Response, err error) {
}
```

--------------------------------

### WSAID_WSASENDMSG GUID

Source: https://pkg.go.dev/internal/syscall/windows%40go1.25.3

GUID for the WSASENDMSG function.

```go
var WSAID_WSASENDMSG = syscall.GUID{
	Data1: 0xa441e712,
	Data2: 0x754f,
	Data3: 0x43ca,
	Data4: [8]byte{0x84, 0xa7, 0x0d, 0xee, 0x44, 0xcf, 0x60, 0x6d},
}
```

--------------------------------

### Base32 Encoding Example

Source: https://pkg.go.dev/encoding/base32%40go1.25.3

Demonstrates base32 encoding. The output will be the base32 encoded string of the input data.

```go
Output:
MZXW6ADCMFZA====

```

--------------------------------

### WSAID_WSARECVMSG GUID

Source: https://pkg.go.dev/internal/syscall/windows%40go1.25.3

GUID for the WSARECVMSG function.

```go
var WSAID_WSARECVMSG = syscall.GUID{
	Data1: 0xf689d7c8,
	Data2: 0x6f1f,
	Data3: 0x436b,
	Data4: [8]byte{0x8a, 0x53, 0xe5, 0x4f, 0xe3, 0x51, 0xc3, 0x22},
}
```

--------------------------------

### Create new Setting instance

Source: https://pkg.go.dev/crypto/internal/fips140deps/godebug%40go1.25.3

Initializes a new Setting object for a given name.

```go
func New(name string) *Setting
```

--------------------------------

### Get Function Signature

Source: https://pkg.go.dev/net/http%40go1.25.3

Signature for the Get function. It issues an HTTP GET request to the specified URL and follows redirects up to a maximum of 10.

```go
func Get(url string) (resp *Response, err error)
```

--------------------------------

### Client.Get

Source: https://pkg.go.dev/net/http%40go1.25.3

Get issues a GET to the specified URL. If the response is one of the redirect codes, Get follows the redirect after calling the Client.CheckRedirect function.

```APIDOC
## Client.Get

### Description
Issues an HTTP GET request to the specified URL and follows redirects according to the client's policy.

### Method
func (c *Client) Get(url string) (resp *Response, err error)

### Endpoint
GET [url]

### Parameters
#### Path Parameters
- **url** (string) - Required - The URL to fetch.

### Response
#### Success Response
- **resp** (*Response) - The HTTP response.
- **err** (error) - Nil on success, or an error if the request failed or redirects were not permitted.

### Request Example
```go
// Assuming 'client' is an initialized *http.Client
resp, err := client.Get("http://example.com")
if err != nil {
    // Handle error
}
defer resp.Body.Close()
// Process response
```

### Response Example
```go
// Successful response structure (simplified)
{
  "StatusCode": 200,
  "Header": {
    "Content-Type": "text/html"
  },
  "Body": "<html>...</html>"
}
```
```

--------------------------------

### Marshal Example

Source: https://pkg.go.dev/encoding/json%40go1.25.3

Demonstrates the output of the Marshal function for a given data structure.

```Go
Output:
{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
```

--------------------------------

### OnesCount Example Output

Source: https://pkg.go.dev/math/bits%40go1.25.3

Example output for OnesCount.

```text
Output:
OnesCount(1110) = 3
```

--------------------------------

### Dir Open Method Go

Source: https://pkg.go.dev/net/http%40go1.25.3

Implements FileSystem.Open using os.Open, opening files for reading rooted and relative to the directory d. Handles '/'-separated paths.

```go
func (d Dir) Open(name string) (File, error)
```

--------------------------------

### Open

Source: https://pkg.go.dev/debug/elf%40go1.25.3

Opens a named file and prepares it for use as an ELF binary.

```APIDOC
## Open

### Description
Opens the named file using os.Open and prepares it for use as an ELF binary.

### Signature
```go
func Open(name string) (*File, error)
```
```

--------------------------------

### Example Output

Source: https://pkg.go.dev/hash/crc32%40go1.25.3

Example output for a CRC-32 operation.

```text
Output:
2964d064
```

--------------------------------

### Command execution

Source: https://pkg.go.dev/os/exec%40go1.25.3

Demonstrates running an external command.

```go
cmd := exec.Command("prog")
if err := cmd.Run(); err != nil {
	log.Fatal(err)
}
```

--------------------------------

### Scanner Example Output

Source: https://pkg.go.dev/text/scanner%40go1.25.3

This output demonstrates the tokenization of a sample text, showing the line, column, and token type for each identified element.

```text
example:3:1: if
example:3:4: a
example:3:6: >
example:3:8: 10
example:3:11: {
example:4:2: someParsable
example:4:15: =
example:4:17: text
example:5:1: }

```

--------------------------------

### Get

Source: https://pkg.go.dev/net/http%40go1.25.3

Get issues a GET request to the specified URL. It automatically follows redirects (301, 302, 303, 307, 308) up to a maximum of 10.

```APIDOC
## Get

### Description
Get issues a GET to the specified URL. If the response is one of the following redirect codes, Get follows the redirect, up to a maximum of 10 redirects:
301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

### Method
func Get(url string) (resp *Response, err error)
```

--------------------------------

### Go Example Function Naming Conventions

Source: https://pkg.go.dev/testing%40go1.25.3

Standard naming conventions for example functions in Go packages. Examples without output comments are compiled but not executed.

```go
func Example() { ... }
```

```go
func ExampleF() { ... }
```

```go
func ExampleT() { ... }
```

```go
func ExampleT_M() { ... }
```

--------------------------------

### Plugin Example Usage

Source: https://pkg.go.dev/plugin%40go1.25.3

Demonstrates how to load a plugin and access its exported symbols.

```APIDOC
### Request Example
```go
package main

import (
	"fmt"
	"plugin"
)

var V int

func F() {
	fmt.Printf("Hello, number %d\n", V)
}
```

### Response Example
```go
p, err := plugin.Open("plugin_name.so")
if err != nil {
	panic(err)
}
v, err := p.Lookup("V")
if err != nil {
	panic(err)
}
f, err := p.Lookup("F")
if err != nil {
	panic(err)
}
*v.(*int) = 7
f.(func())()
```
```

--------------------------------

### StartProcess function

Source: https://pkg.go.dev/os%40go1.25.3

Starts a new process with specified program, arguments, and attributes.

```go
func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)
```

--------------------------------

### Mul Example Outputs

Source: https://pkg.go.dev/math/bits%40go1.25.3

Example outputs for Mul functions.

```text
Output:
12 * 12 = [0 144]
2147483648 * 2 = [1 0]
```

```text
Output:
12 * 12 = [0 144]
9223372036854775808 * 2 = [1 0]
```
Tokens:
Raw