net

package
v1.21.8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 24, 2023 License: MIT Imports: 9 Imported by: 0

Documentation

Overview

Package netは、TCP/IP、UDP、ドメイン名の解決、およびUnixドメインソケットなど、ネットワークI/Oのためのポータブルなインターフェースを提供します。

このパッケージは、低レベルのネットワーキングプリミティブへのアクセスを提供していますが、ほとんどのクライアントは、Dial、Listen、Accept関数と関連するConnとListenerインターフェースが提供する基本的なインターフェースだけを必要とします。crypto/tlsパッケージは、同じインターフェースと似たようなDialとListen関数を使用します。

Dial関数はサーバーに接続します： 

conn, err := net.Dial("tcp", "golang.org:80")
if err != nil {
	// エラーを処理する
}
fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
status, err := bufio.NewReader(conn).ReadString('\n')
// ...

Listen関数はサーバーを作成します： 

ln, err := net.Listen("tcp", ":8080")
if err != nil {
	// エラーを処理する
}
for {
	conn, err := ln.Accept()
	if err != nil {
		// エラーを処理する
	}
	go handleConnection(conn)
}

ネーム解決

ネーム解決の方法は、間接的にDialのような関数を使うか、LookupHostやLookupAddrのような関数を直接使うかによって、オペレーティングシステムによって異なります。

Unixシステムでは、名前を解決するための2つのオプションがあります。 /etc/resolv.confにリストされているサーバーに直接DNSリクエストを送信する純粋なGoリゾルバを使用するか、 getaddrinfoやgetnameinfoなどのCライブラリのルーチンを呼び出すcgoベースのリゾルバを使用するか、です。

デフォルトでは、ブロックされたDNSリクエストはゴルーチンのみを消費するため、純粋なGoリゾルバが使用されますが、 ブロックされたC呼び出しはオペレーティングシステムのスレッドを消費します。 cgoが利用可能な場合、さまざまな条件下でcgoベースのリゾルバが代わりに使用されます： 直接DNSリクエストを行うことができないシステム（OS X）や、 LOCALDOMAIN環境変数が存在する（空であっても）、 RES_OPTIONSまたはHOSTALIASES環境変数が空でない、 ASR_CONFIG環境変数が空でない（OpenBSDのみ）、 /etc/resolv.confまたは/etc/nsswitch.confで、 Goリゾルバが実装していない機能の使用が指定されている場合、 検索対象となる名前が.localで終わるか、mDNS名である場合です。

リゾルバの判断は、GODEBUG環境変数（パッケージruntimeを参照）のnetdns値をgoまたはcgoに設定することで上書きすることもできます。例： 

export GODEBUG=netdns=go    # 純粋なGoリゾルバを強制する
export GODEBUG=netdns=cgo   # ネイティブリゾルバを強制する（cgo、win32）

この判断は、Goソースツリーをビルドする際にも、netgoまたはnetcgoビルドタグを設定することで強制することができます。

GODEBUG=netdns=1のような数値のnetdns設定は、リゾルバが自身の判断に関するデバッグ情報を出力します。 特定のリゾルバを強制すると同時にデバッグ情報を出力するには、 2つの設定をプラス記号で結合します。例：GODEBUG=netdns=go+1。

macOSでは、netパッケージを使用するGoコードが-buildmode=c-archiveでビルドされる場合、 生成されたアーカイブをCプログラムにリンクする際に、Cコードをリンクするときに-lresolvを渡す必要があります。

Plan 9では、リゾルバは常に/net/csと/net/dnsにアクセスします。

Windowsでは、Go 1.18.x以前では、GetAddrInfoやDnsQueryなどのCライブラリ関数をリゾルバが常に使用していました。

Index

Examples

Constants

View Source 
const (
	IPv4len = 4
	IPv6len = 16
)

IPアドレスの長さ（バイト単位）。

Variables

View Source 
var (
	IPv4bcast     = IPv4(255, 255, 255, 255)
	IPv4allsys    = IPv4(224, 0, 0, 1)
	IPv4allrouter = IPv4(224, 0, 0, 2)
	IPv4zero      = IPv4(0, 0, 0, 0)
)

有名なIPv4アドレス

View Source 
var (
	IPv6zero                   = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	IPv6unspecified            = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	IPv6loopback               = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
	IPv6interfacelocalallnodes = IP{0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
	IPv6linklocalallnodes      = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
	IPv6linklocalallrouters    = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x02}
)

有名なIPv6アドレス

View Source 
var DefaultResolver = &Resolver{}

DefaultResolverは、パッケージレベルのLookup関数と指定されていないResolverを持つDialersによって使用されるリゾルバです。

View Source 
var ErrClosed error = errClosed

ErrClosedは、既に閉じられたネットワーク接続またはI/Oが完了する前に他のゴルーチンによって閉じられたネットワーク接続上のI/O呼び出しによって返されるエラーです。これは他のエラーに包まれる場合があり、通常はerrors.Is(err, net.ErrClosed)を使用してテストする必要があります。

View Source 
var (
	ErrWriteToConnected = errors.New("use of WriteTo with pre-connected connection")
)

OpErrorに含まれる様々なエラー。

Functions

func JoinHostPort 

func JoinHostPort(host, port string) string

JoinHostPort はホストとポートを "ホスト:ポート" のネットワークアドレスに結合します。 ホストがコロンを含んでいる場合、リテラルIPv6アドレスで見つかるように、JoinHostPortは "[host]:port" を返します。

ホストとポートパラメータの説明については、func Dial を参照してください。

func LookupAddr 

func LookupAddr(addr string) (names []string, err error)

LookupAddrは与えられたアドレスに対して逆引きを行い、そのアドレスにマッピングされる名前のリストを返します。 返された名前は適切にフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。応答に無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーと一緒に残りの結果（ある場合）が返されます。 ホストCライブラリリゾルバを使用する場合、最大で1つの結果が返されます。ホストリゾルバをバイパスするには、カスタムリゾルバを使用してください。 LookupAddrは内部でcontext.Backgroundを使用します。コンテキストを指定するには、Resolver.LookupAddrを使用してください。

func LookupCNAME 

func LookupCNAME(host string) (cname string, err error)

LookupCNAMEは指定されたホストの正式な名前（カノニカル名）を返します。 カノニカル名に関心がない場合は、LookupHostまたはLookupIPを直接呼び出すことができます。 どちらも、ルックアップの一部としてカノニカル名の解決を行います。

カノニカル名は、ゼロまたは複数のCNAMEレコードを辿った後の最終的な名前です。 hostにDNSの"CNAME"レコードが含まれていない場合でも、hostがアドレスレコードに解決されている限り、LookupCNAMEはエラーを返しません。

返されるカノニカル名は、正しくフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。

LookupCNAMEは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、Resolver.LookupCNAMEを使用してください。

func LookupHost 

func LookupHost(host string) (addrs []string, err error)

LookupHostは、ローカルのリゾルバを使用して指定されたホストを検索します。 そのホストのアドレスのスライスを返します。

LookupHostは、内部的にcontext.Backgroundを使用します。コンテキストを指定するには、 Resolver.LookupHostを使用してください。

func LookupPort 

func LookupPort(network, service string) (port int, err error)

LookupPortは指定されたネットワークとサービスに対するポートを調べます。

LookupPortは内部でcontext.Backgroundを使用します。コンテキストを指定するには、 Resolver.LookupPortを使用してください。

func LookupTXT 

func LookupTXT(name string) ([]string, error)

LookupTXTは指定されたドメイン名のDNS TXTレコードを返します。

LookupTXTは内部でcontext.Backgroundを使用します。コンテキストを指定するには、 Resolver.LookupTXTを使用してください。

func ParseCIDR 

func ParseCIDR(s string) (IP, *IPNet, error)

ParseCIDRはCIDR表記のIPアドレスとプレフィックス長を含むsを解析します。 例えば、"192.0.2.0/24"や"2001:db8::/32"のようなものです。 RFC 4632とRFC 4291で定義されています。

IPアドレスとプレフィックス長によって暗示されるIPとネットワークを返します。 例えば、ParseCIDR("192.0.2.1/24")はIPアドレスが 192.0.2.1でネットワークが192.0.2.0/24を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv4Addr, ipv4Net, err := net.ParseCIDR("192.0.2.1/24")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ipv4Addr)
	fmt.Println(ipv4Net)

	ipv6Addr, ipv6Net, err := net.ParseCIDR("2001:db8:a0b:12f0::1/32")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ipv6Addr)
	fmt.Println(ipv6Net)

}

Output:

192.0.2.1
192.0.2.0/24
2001:db8:a0b:12f0::1
2001:db8::/32

func Pipe 

func Pipe() (Conn, Conn)

Pipeは同期的な、インメモリ、フルダプレックスのネットワーク接続を作成します。 両端はConnインターフェースを実装しています。 一方の端での読み取りは、もう一方の端での書き込みと一致し、データを直接コピーします。 内部バッファリングはありません。

func SplitHostPort 

func SplitHostPort(hostport string) (host, port string, err error)

SplitHostPortは、"host:port"、"host％zone:port"、"[host]:port"、または "[host%zone]:port" のネットワークアドレスをhostまたはhost％zoneとポートに分割します。

ホストポート内のリテラルIPv6アドレスは、"[::1]:80"、"[::1％lo0]:80"のように角括弧で囲む必要があります。

hostportパラメータ、およびhostとportの結果の詳細については、func Dialを参照してください。

Types

type Addr 

type Addr interface {
	Network() string
	String() string
}

Addrはネットワークのエンドポイントアドレスを表します。

2つのメソッドNetworkおよびStringは、通常、Dialの引数として渡すことができる文字列を返しますが、 その文字列の形式や意味については実装次第です。

func InterfaceAddrs 

func InterfaceAddrs() ([]Addr, error)

InterfaceAddrsはシステムのユニキャストインターフェースのアドレスのリストを返します。

返されたリストは関連するインターフェースを識別しません。詳細についてはInterfacesとInterface.Addrsを使用してください。

type AddrError 

type AddrError struct {
	Err  string
	Addr string
}

func (*AddrError) Error 

func (e *AddrError) Error() string

func (*AddrError) Temporary 

func (e *AddrError) Temporary() bool

func (*AddrError) Timeout 

func (e *AddrError) Timeout() bool

type Buffers added in v1.8.0 

type Buffers [][]byte

Buffersは、書き込むバイトのゼロ以上のランを含んでいます。

ある種の接続に対して、特定のマシンでは、これはOS固有のバッチ書き込み操作（"writev"など）に最適化されます。

func (*Buffers) Read added in v1.8.0 

func (v *Buffers) Read(p []byte) (n int, err error)

バッファから読み込む。

Read はバッファのために io.Reader を実装します。

Read はスライス v と v[i]（ただし、0 <= i < len(v)）を変更しますが、 v[i][j]（ただし、任意の i, j）は変更しません。

func (*Buffers) WriteTo added in v1.8.0 

func (v *Buffers) WriteTo(w io.Writer) (n int64, err error)

WriteTo はバッファの内容を w に書き込みます。

WriteTo は、Buffeers の io.WriterTo を実装します。

WriteTo は、0 <= i < len(v) の範囲の v[i] およびスライス v を変更しますが、v[i][j] (i, j は任意の値) は変更しません。

type Conn 

type Conn interface {
	// Read reads data from the connection.
	// Read can be made to time out and return an error after a fixed
	// time limit; see SetDeadline and SetReadDeadline.
	Read(b []byte) (n int, err error)

	// Write writes data to the connection.
	// Write can be made to time out and return an error after a fixed
	// time limit; see SetDeadline and SetWriteDeadline.
	Write(b []byte) (n int, err error)

	// Close closes the connection.
	// Any blocked Read or Write operations will be unblocked and return errors.
	Close() error

	// LocalAddr returns the local network address, if known.
	LocalAddr() Addr

	// RemoteAddr returns the remote network address, if known.
	RemoteAddr() Addr

	// SetDeadline sets the read and write deadlines associated
	// with the connection. It is equivalent to calling both
	// SetReadDeadline and SetWriteDeadline.
	//
	// A deadline is an absolute time after which I/O operations
	// fail instead of blocking. The deadline applies to all future
	// and pending I/O, not just the immediately following call to
	// Read or Write. After a deadline has been exceeded, the
	// connection can be refreshed by setting a deadline in the future.
	//
	// If the deadline is exceeded a call to Read or Write or to other
	// I/O methods will return an error that wraps os.ErrDeadlineExceeded.
	// This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
	// The error's Timeout method will return true, but note that there
	// are other possible errors for which the Timeout method will
	// return true even if the deadline has not been exceeded.
	//
	// An idle timeout can be implemented by repeatedly extending
	// the deadline after successful Read or Write calls.
	//
	// A zero value for t means I/O operations will not time out.
	SetDeadline(t time.Time) error

	// SetReadDeadline sets the deadline for future Read calls
	// and any currently-blocked Read call.
	// A zero value for t means Read will not time out.
	SetReadDeadline(t time.Time) error

	// SetWriteDeadline sets the deadline for future Write calls
	// and any currently-blocked Write call.
	// Even if write times out, it may return n > 0, indicating that
	// some of the data was successfully written.
	// A zero value for t means Write will not time out.
	SetWriteDeadline(t time.Time) error
}

Connは汎用のストリーム指向のネットワーク接続です。

複数のgoroutineがConn上のメソッドを同時に呼び出すことができます。

func Dial 

func Dial(network, address string) (Conn, error)

Dialは指定されたネットワークのアドレスに接続します。

知られているネットワークは "tcp", "tcp4" (IPv4のみ), "tcp6" (IPv6のみ), "udp", "udp4" (IPv4のみ), "udp6" (IPv6のみ), "ip", "ip4" (IPv4のみ), "ip6" (IPv6のみ), "unix", "unixgram" および "unixpacket" です。

TCPとUDPのネットワークの場合、アドレスは "ホスト:ポート" の形式で指定します。 ホストはリテラルのIPアドレスであるか、IPアドレスに解決できるホスト名である必要があります。 ポートはリテラルのポート番号またはサービス名である必要があります。 ホストがリテラルのIPv6アドレスの場合、"[2001:db8::1]:80" または "[fe80::1%zone]:80" のように角括弧で囲む必要があります。 ゾーンは、RFC 4007で定義されているリテラルのIPv6アドレスのスコープを指定します。 関数JoinHostPortとSplitHostPortは、この形式のホストとポートのペアを操作します。 TCPを使用し、ホストが複数のIPアドレスに解決される場合、Dialは順番に各IPアドレスを試し、成功したものを使用します。

例:

Dial("tcp", "golang.org:http") Dial("tcp", "192.0.2.1:http") Dial("tcp", "198.51.100.1:80") Dial("udp", "[2001:db8::1]:domain") Dial("udp", "[fe80::1%lo0]:53") Dial("tcp", ":80")

IPネットワークの場合、ネットワークは "ip", "ip4" または "ip6" の後にコロンとリテラルのプロトコル番号またはプロトコル名が続き、 アドレスは "ホスト" の形式となります。ホストはリテラルのIPアドレスまたはゾーン付きのリテラルのIPv6アドレスである必要があります。 "0" や "255" などの広く知られていないプロトコル番号の場合、各オペレーティングシステムによって動作が異なることによります。

例:

Dial("ip4:1", "192.0.2.1") Dial("ip6:ipv6-icmp", "2001:db8::1") Dial("ip6:58", "fe80::1%lo0")

TCP、UDP、およびIPネットワークの場合、ホストが空白またはリテラルの未指定IPアドレスの場合、 すなわち ":80", "0.0.0.0:80" または "[::]:80" などの場合、TCPおよびUDPでは、 ""、"0.0.0.0" または "::" などの場合、IPでは、ローカルシステムが仮定されます。

UNIXネットワークの場合、アドレスはファイルシステムのパスである必要があります。

func DialTimeout 

func DialTimeout(network, address string, timeout time.Duration) (Conn, error)

DialTimeoutは、タイムアウトを設定してDialと同様の動作をします。

必要に応じて名前解決も含まれたタイムアウト処理が行われます。 TCPを使用している場合、アドレスパラメータのホストが複数のIPアドレスに解決される場合は、 タイムアウトは各連続したダイヤルに均等に分散され、それぞれが適切な時間の一部を接続に割り当てます。

ネットワークとアドレスパラメータの詳細については、func Dialを参照してください。

func FileConn 

func FileConn(f *os.File) (c Conn, err error)

FileConnは、開いているファイルfに対応するネットワーク接続のコピーを返します。 使用が完了したら、呼び出し元の責任でfを閉じる必要があります。 cを閉じてもfには影響しませんし、fを閉じてもcには影響しません。

type DNSConfigError 

type DNSConfigError struct {
	Err error
}

DNSConfigErrorは、マシンのDNS設定を読み取る際のエラーを表します。 （使用されていませんが、互換性のために保持されています。）

func (*DNSConfigError) Error 

func (e *DNSConfigError) Error() string

func (*DNSConfigError) Temporary 

func (e *DNSConfigError) Temporary() bool

func (*DNSConfigError) Timeout 

func (e *DNSConfigError) Timeout() bool

func (*DNSConfigError) Unwrap added in v1.13.0 

func (e *DNSConfigError) Unwrap() error

type DNSError 

type DNSError struct {
	Err         string
	Name        string
	Server      string
	IsTimeout   bool
	IsTemporary bool
	IsNotFound  bool
}

DNSErrorはDNSの検索エラーを表します。

func (*DNSError) Error 

func (e *DNSError) Error() string

func (*DNSError) Temporary 

func (e *DNSError) Temporary() bool

Temporaryは、DNSエラーが一時的であるかどうかを示す。 これは常にわかるわけではない。一時的なエラーによりDNS検索が失敗し、Temporaryがfalseを返す場合がある。

func (*DNSError) Timeout 

func (e *DNSError) Timeout() bool

TimeoutはDNSの検索がタイムアウトしたかどうかを報告します。 これは常に正確にはわかりません。DNSの検索はタイムアウトにより失敗する場合があり、Timeoutがfalseを返すDNSErrorが返されることがあります。

type Dialer added in v1.1.0 

type Dialer struct {

	// Timeoutはダイヤルが接続の完了を待つ最大時間です。Deadlineも設定されている場合、より早く失敗する可能性があります。
	// デフォルトはタイムアウトなしです。
	// TCPを使用して複数のIPアドレスを持つホスト名にダイヤルする場合、タイムアウトはそれらの間で分割される場合があります。
	// タイムアウトの有無にかかわらず、オペレーティングシステムは独自の早期タイムアウトを課す場合があります。たとえば、TCPのタイムアウトは通常約3分です。
	Timeout time.Duration

	// Deadlineは、ダイヤルが失敗する絶対的な時間です。
	// Timeoutが設定されている場合、それよりも早く失敗することがあります。
	// ゼロは期限がないことを意味し、またはオペレーティングシステムに依存することもあります。
	// (Timeoutオプションと同様に)
	Deadline time.Time

	// LocalAddr is the local address to use when dialing an
	// address. The address must be of a compatible type for the
	// network being dialed.
	// If nil, a local address is automatically chosen.
	LocalAddr Addr

	// DualStackは以前からRFC 6555 Fast Fallback、または「Happy Eyeballs」として知られる機能をサポートしており、IPv6が誤設定されていて正しく動作していない場合にはIPv4がすぐに試されます。
	// 廃止予定：Fast Fallbackはデフォルトで有効になっています。無効にするには、FallbackDelayを負の値に設定してください。
	DualStack bool

	// FallbackDelayは、RFC 6555 Fast Fallback接続を作成する前に待機する時間の長さを指定します。つまり、IPv6が成功するまで待機する時間であり、IPv6の設定が誤っていると仮定し、IPv4に切り替える前に待機する時間です。
	// ゼロの場合、デフォルトの遅延時間は300msです。
	// 負の値はFast Fallbackサポートを無効にします。
	FallbackDelay time.Duration

	// KeepAliveはアクティブなネットワーク接続の間隔を示します。
	// ゼロの場合、keep-aliveプローブはデフォルト値（現在は15秒）で送信されます。
	// プロトコルやオペレーティングシステムがサポートしている場合、ネットワークプロトコルやオペレーティングシステムはkeep-aliveを無視します。
	// ネガティブの場合、keep-aliveプローブは無効になります。
	KeepAlive time.Duration

	// Resolverはオプションで、代替のリゾルバを指定することができます。
	Resolver *Resolver

	// Cancel is an optional channel whose closure indicates that
	// the dial should be canceled. Not all types of dials support
	// cancellation.
	//
	// Deprecated: Use DialContext instead.
	Cancel <-chan struct{}

	// Controlがnilでない場合、ネットワーク接続の作成後に、実際にダイアルする前に呼び出されます。
	//
	// Control関数に渡されるネットワークとアドレスのパラメータは、必ずしもDialに渡されるものとは限りません。たとえば、Dialに「tcp」を渡すと、Control関数は「tcp4」または「tcp6」で呼び出されます。
	//
	// ControlContextがnilでない場合、Controlは無視されます。
	Control func(network, address string, c syscall.RawConn) error

	// ControlContextがnilでない場合、ネットワークの接続を作成する前に呼び出されます。
	//
	// ControlContext関数に渡されるネットワークおよびアドレスのパラメータは、必ずしもDialに渡されたものではありません。
	// 例えば、Dialに"tcp"を渡すと、ControlContext関数は "tcp4" または "tcp6" とともに呼び出されます。
	//
	// ControlContextがnilでない場合、Controlは無視されます。
	ControlContext func(ctx context.Context, network, address string, c syscall.RawConn) error
	// contains filtered or unexported fields
}

Dialerはアドレスに接続するためのオプションを含んでいます。

各フィールドのゼロ値は、そのオプションなしでダイヤルすることと同等です。 Dialerのゼロ値でダイヤルすることは、単にDial関数を呼び出すのと同等です。

Dialerのメソッドを同時に呼び出しても安全です。

Example 
package main

import (
	"github.com/shogo82148/std/context"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
	"github.com/shogo82148/std/time"
)

func main() {
	var d net.Dialer
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	conn, err := d.DialContext(ctx, "tcp", "localhost:12345")
	if err != nil {
		log.Fatalf("Failed to dial: %v", err)
	}
	defer conn.Close()

	if _, err := conn.Write([]byte("Hello, World!")); err != nil {
		log.Fatal(err)
	}
}

Output:
Example (Unix) 
package main

import (
	"github.com/shogo82148/std/context"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
	"github.com/shogo82148/std/time"
)

func main() {
	// DialUnixはcontext.Contextパラメータを受け取りません。この例は、
	// Contextを使用してUnixソケットにダイヤルする方法を示しています。ただし、
	// Contextはダイヤル操作にのみ適用されます。接続が確立された後には適用されません。
	var d net.Dialer
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	d.LocalAddr = nil // もしローカルのアドレスがあれば、ここに追加してください。
	raddr := net.UnixAddr{Name: "/path/to/unix.sock", Net: "unix"}
	conn, err := d.DialContext(ctx, "unix", raddr.String())
	if err != nil {
		log.Fatalf("Failed to dial: %v", err)
	}
	defer conn.Close()
	if _, err := conn.Write([]byte("Hello, socket!")); err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Dialer) Dial added in v1.1.0 

func (d *Dialer) Dial(network, address string) (Conn, error)

Dialは指定されたネットワーク上のアドレスに接続します。

ネットワークとアドレスの詳細は、func Dialの説明を参照してください。

Dialは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、DialContextを使用してください。

func (*Dialer) DialContext added in v1.7.0 

func (d *Dialer) DialContext(ctx context.Context, network, address string) (Conn, error)

DialContextは、指定されたコンテキストを使用して、指定されたネットワーク上のアドレスに接続します。

提供されたコンテキストは、nilでない必要があります。接続が完了する前にコンテキストが期限切れになると、エラーが返されます。接続が成功した後、コンテキストの期限切れは接続に影響しません。

TCPを使用し、アドレスパラメータのホストが複数のネットワークアドレスに解決される場合、ダイヤルタイムアウト（d.Timeoutまたはctxから）は、各連続したダイヤルに均等に分散されます。それぞれのダイヤルには、適切な接続時間の割合が与えられます。 例えば、ホストが4つのIPアドレスを持ち、タイムアウトが1分の場合、次のアドレスを試す前に、各単一のアドレスへの接続には15秒の時間が与えられます。

ネットワークやアドレスパラメータの説明については、func Dialを参照してください。

func (*Dialer) MultipathTCP added in v1.21.0 

func (d *Dialer) MultipathTCP() bool

MultipathTCPはMPTCPを使用するかどうかを報告します。

このメソッドは、オペレーティングシステムがMPTCPをサポートしているかどうかをチェックしません。

func (*Dialer) SetMultipathTCP added in v1.21.0 

func (d *Dialer) SetMultipathTCP(use bool)

SetMultipathTCPは、オペレーティングシステムでサポートされている場合、DialメソッドがMPTCPを使用するかどうかを指示します。 このメソッドは、システムのデフォルトとGODEBUG=multipathtcp=...の設定を上書きします。

ホストでMPTCPが利用できない場合やサーバーでサポートされていない場合、DialメソッドはTCPにフォールバックします。

type Error 

type Error interface {
	error
	Timeout() bool

	// Deprecated: Temporary errors are not well-defined.
	// Most "temporary" errors are timeouts, and the few exceptions are surprising.
	// Do not use this method.
	Temporary() bool
}

Errorはネットワークエラーを表します。

type Flags 

type Flags uint
const (
	FlagUp Flags = 1 << iota
	FlagBroadcast
	FlagLoopback
	FlagPointToPoint
	FlagMulticast
	FlagRunning
)

func (Flags) String 

func (f Flags) String() string

type HardwareAddr 

type HardwareAddr []byte

HardwareAddrは物理的なハードウェアアドレスを表します。

func ParseMAC 

func ParseMAC(s string) (hw HardwareAddr, err error)

ParseMACは、次のいずれかの形式で定義されたIEEE 802 MAC-48、EUI-48、EUI-64、または20オクテットのIP over InfiniBandリンク層アドレスとしてsを解析します： 

00:00:5e:00:53:01
02:00:5e:10:00:00:00:01
00:00:00:00:fe:80:00:00:00:00:00:00:02:00:5e:10:00:00:00:01
00-00-5e-00-53-01
02-00-5e-10-00-00-00-01
00-00-00-00-fe-80-00-00-00-00-00-00-02-00-5e-10-00-00-00-01
0000.5e00.5301
0200.5e10.0000.0001
0000.0000.fe80.0000.0000.0000.0200.5e10.0000.0001

func (HardwareAddr) String 

func (a HardwareAddr) String() string

type IP 

type IP []byte

IPは単一のIPアドレス、バイトのスライスです。 このパッケージの関数は、4バイト（IPv4）または16バイト（IPv6）のスライスを入力として受け付けます。

このドキュメントでは、IPアドレスをIPv4アドレスまたはIPv6アドレスと呼ぶことは、アドレスの意味的な属性であり、単にバイトスライスの長さだけではありません：16バイトスライスもIPv4アドレスである可能性があります。

Example (To4) 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	ipv4 := net.IPv4(10, 255, 0, 0)

	fmt.Println(ipv6.To4())
	fmt.Println(ipv4.To4())

}

Output:

<nil>
10.255.0.0

func IPv4 

func IPv4(a, b, c, d byte) IP

IPv4は、IPv4アドレスa.b.c.dのIPアドレス（16バイト形式）を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	fmt.Println(net.IPv4(8, 8, 8, 8))

}

Output:

8.8.8.8

func LookupIP 

func LookupIP(host string) ([]IP, error)

LookupIPはローカルリゾルバを使用してホストを検索します。 それはそのホストのIPv4およびIPv6アドレスのスライスを返します。

func ParseIP 

func ParseIP(s string) IP

ParseIPは文字列sをIPアドレスと解釈し、結果を返します。 文字列sはIPv4点区切りの10進法（「192.0.2.1」）、IPv6（「2001:db8::68」）、またはIPv4-mapped IPv6形式（「::ffff:192.0.2.1」）で書かれている必要があります。 もしsが有効なIPアドレスのテキスト表現ではない場合、ParseIPはnilを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	fmt.Println(net.ParseIP("192.0.2.1"))
	fmt.Println(net.ParseIP("2001:db8::68"))
	fmt.Println(net.ParseIP("192.0.2"))

}

Output:

192.0.2.1
2001:db8::68
<nil>

func (IP) DefaultMask 

func (ip IP) DefaultMask() IPMask

DefaultMaskはIPアドレスipのデフォルトのマスクを返します。 IPv4アドレスのみがデフォルトマスクを持ちます。ipが有効なIPv4アドレスでない場合、DefaultMaskは nilを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ip := net.ParseIP("192.0.2.1")
	fmt.Println(ip.DefaultMask())

}

Output:

ffffff00

func (IP) Equal 

func (ip IP) Equal(x IP) bool

Equalは、ipとxが同じIPアドレスであるかどうかを報告します。 IPv4アドレスと同じアドレスを持つIPv6形式は 同じものと見なされます。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv4DNS := net.ParseIP("8.8.8.8")
	ipv4Lo := net.ParseIP("127.0.0.1")
	ipv6DNS := net.ParseIP("0:0:0:0:0:FFFF:0808:0808")

	fmt.Println(ipv4DNS.Equal(ipv4DNS))
	fmt.Println(ipv4DNS.Equal(ipv4Lo))
	fmt.Println(ipv4DNS.Equal(ipv6DNS))

}

Output:

true
false
true

func (IP) IsGlobalUnicast 

func (ip IP) IsGlobalUnicast() bool

IsGlobalUnicastは、ipがグローバルユニキャストアドレスであるかどうかを報告します。

グローバルユニキャストアドレスの識別は、RFC 1122、RFC 4632、RFC 4291で定義されたアドレスタイプの識別を使用しますが、 IPv4の指示ブロードキャストアドレスは除外します。 ipがIPv4のプライベートアドレススペースまたはローカルIPv6ユニキャストアドレススペースにある場合でも、trueを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Global := net.ParseIP("2000::")
	ipv6UniqLocal := net.ParseIP("2000::")
	ipv6Multi := net.ParseIP("FF00::")

	ipv4Private := net.ParseIP("10.255.0.0")
	ipv4Public := net.ParseIP("8.8.8.8")
	ipv4Broadcast := net.ParseIP("255.255.255.255")

	fmt.Println(ipv6Global.IsGlobalUnicast())
	fmt.Println(ipv6UniqLocal.IsGlobalUnicast())
	fmt.Println(ipv6Multi.IsGlobalUnicast())

	fmt.Println(ipv4Private.IsGlobalUnicast())
	fmt.Println(ipv4Public.IsGlobalUnicast())
	fmt.Println(ipv4Broadcast.IsGlobalUnicast())

}

Output:

true
true
false
true
true
false

func (IP) IsInterfaceLocalMulticast 

func (ip IP) IsInterfaceLocalMulticast() bool

IsInterfaceLocalMulticastは、ipがインターフェースローカルなマルチキャストアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6InterfaceLocalMulti := net.ParseIP("ff01::1")
	ipv6Global := net.ParseIP("2000::")
	ipv4 := net.ParseIP("255.0.0.0")

	fmt.Println(ipv6InterfaceLocalMulti.IsInterfaceLocalMulticast())
	fmt.Println(ipv6Global.IsInterfaceLocalMulticast())
	fmt.Println(ipv4.IsInterfaceLocalMulticast())

}

Output:

true
false
false

func (IP) IsLinkLocalMulticast 

func (ip IP) IsLinkLocalMulticast() bool

IsLinkLocalMulticast は、与えられた IP アドレスがリンクローカルマルチキャストアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6LinkLocalMulti := net.ParseIP("ff02::2")
	ipv6LinkLocalUni := net.ParseIP("fe80::")
	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
	ipv4LinkLocalUni := net.ParseIP("169.254.0.0")

	fmt.Println(ipv6LinkLocalMulti.IsLinkLocalMulticast())
	fmt.Println(ipv6LinkLocalUni.IsLinkLocalMulticast())
	fmt.Println(ipv4LinkLocalMulti.IsLinkLocalMulticast())
	fmt.Println(ipv4LinkLocalUni.IsLinkLocalMulticast())

}

Output:

true
false
true
false

func (IP) IsLinkLocalUnicast 

func (ip IP) IsLinkLocalUnicast() bool

IsLinkLocalUnicast は、ip がリンクローカルユニキャストアドレスであるかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6LinkLocalUni := net.ParseIP("fe80::")
	ipv6Global := net.ParseIP("2000::")
	ipv4LinkLocalUni := net.ParseIP("169.254.0.0")
	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")

	fmt.Println(ipv6LinkLocalUni.IsLinkLocalUnicast())
	fmt.Println(ipv6Global.IsLinkLocalUnicast())
	fmt.Println(ipv4LinkLocalUni.IsLinkLocalUnicast())
	fmt.Println(ipv4LinkLocalMulti.IsLinkLocalUnicast())

}

Output:

true
false
true
false

func (IP) IsLoopback 

func (ip IP) IsLoopback() bool

IsLoopbackはipがループバックアドレスであるかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Lo := net.ParseIP("::1")
	ipv6 := net.ParseIP("ff02::1")
	ipv4Lo := net.ParseIP("127.0.0.0")
	ipv4 := net.ParseIP("128.0.0.0")

	fmt.Println(ipv6Lo.IsLoopback())
	fmt.Println(ipv6.IsLoopback())
	fmt.Println(ipv4Lo.IsLoopback())
	fmt.Println(ipv4.IsLoopback())

}

Output:

true
false
true
false

func (IP) IsMulticast 

func (ip IP) IsMulticast() bool

IsMulticastは、ipがマルチキャストアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Multi := net.ParseIP("FF00::")
	ipv6LinkLocalMulti := net.ParseIP("ff02::1")
	ipv6Lo := net.ParseIP("::1")
	ipv4Multi := net.ParseIP("239.0.0.0")
	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
	ipv4Lo := net.ParseIP("127.0.0.0")

	fmt.Println(ipv6Multi.IsMulticast())
	fmt.Println(ipv6LinkLocalMulti.IsMulticast())
	fmt.Println(ipv6Lo.IsMulticast())
	fmt.Println(ipv4Multi.IsMulticast())
	fmt.Println(ipv4LinkLocalMulti.IsMulticast())
	fmt.Println(ipv4Lo.IsMulticast())

}

Output:

true
true
false
true
true
false

func (IP) IsPrivate added in v1.17.0 

func (ip IP) IsPrivate() bool

IsPrivateは、RFC 1918（IPv4アドレス）およびRFC 4193（IPv6アドレス）に基づいて、IPがプライベートアドレスかどうかを報告します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Private := net.ParseIP("fc00::")
	ipv6Public := net.ParseIP("fe00::")
	ipv4Private := net.ParseIP("10.255.0.0")
	ipv4Public := net.ParseIP("11.0.0.0")

	fmt.Println(ipv6Private.IsPrivate())
	fmt.Println(ipv6Public.IsPrivate())
	fmt.Println(ipv4Private.IsPrivate())
	fmt.Println(ipv4Public.IsPrivate())

}

Output:

true
false
true
false

func (IP) IsUnspecified 

func (ip IP) IsUnspecified() bool

IsUnspecified は、ipが特定されていないアドレスであるかどうかを報告します。 つまり、IPv4アドレスの "0.0.0.0" またはIPv6アドレス "::" です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6Unspecified := net.ParseIP("::")
	ipv6Specified := net.ParseIP("fe00::")
	ipv4Unspecified := net.ParseIP("0.0.0.0")
	ipv4Specified := net.ParseIP("8.8.8.8")

	fmt.Println(ipv6Unspecified.IsUnspecified())
	fmt.Println(ipv6Specified.IsUnspecified())
	fmt.Println(ipv4Unspecified.IsUnspecified())
	fmt.Println(ipv4Specified.IsUnspecified())

}

Output:

true
false
true
false

func (IP) MarshalText added in v1.2.0 

func (ip IP) MarshalText() ([]byte, error)

MarshalTextはencoding.TextMarshalerインターフェースを実装します。 エンコードはStringで返されるものと同じですが、1つ例外があります： len(ip)がゼロの場合、空のスライスを返します。

func (IP) Mask 

func (ip IP) Mask(mask IPMask) IP

MaskはIPアドレスipをmaskでマスクした結果を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv4Addr := net.ParseIP("192.0.2.1")
	// このマスクはIPv4の/24サブネットに対応しています。
	ipv4Mask := net.CIDRMask(24, 32)
	fmt.Println(ipv4Addr.Mask(ipv4Mask))

	ipv6Addr := net.ParseIP("2001:db8:a0b:12f0::1")
	// このマスクはIPv6の/32サブネットに対応しています。
	ipv6Mask := net.CIDRMask(32, 128)
	fmt.Println(ipv6Addr.Mask(ipv6Mask))

}

Output:

192.0.2.0
2001:db8::

func (IP) String 

func (ip IP) String() string

StringはIPアドレスipの文字列形式を返します。 それは以下の4つの形式のいずれかを返します:

  • "<nil>", ipの長さが0の場合
  • ドット付きの10進表現 ("192.0.2.1"), ipがIPv4またはIP4-mapped IPv6アドレスの場合
  • RFC 5952に準拠したIPv6形式 ("2001:db8::1"), ipが有効なIPv6アドレスの場合
  • 上記の条件に当てはまらない場合は、ipの句読点を除いた16進数形式
Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	ipv4 := net.IPv4(10, 255, 0, 0)

	fmt.Println(ipv6.String())
	fmt.Println(ipv4.String())

}

Output:

fc00::
10.255.0.0

func (IP) To16 

func (ip IP) To16() IP

To16はIPアドレスipを16バイトの表現に変換します。 ipがIPアドレスでない場合（長さが正しくない場合）、To16はnilを返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
	ipv4 := net.IPv4(10, 255, 0, 0)

	fmt.Println(ipv6.To16())
	fmt.Println(ipv4.To16())

}

Output:

fc00::
10.255.0.0

func (IP) To4 

func (ip IP) To4() IP

To4はIPv4アドレスを4バイトの表現に変換します。 もしipがIPv4アドレスでない場合、To4はnilを返します。

func (*IP) UnmarshalText added in v1.2.0 

func (ip *IP) UnmarshalText(text []byte) error

UnmarshalTextはencoding.TextUnmarshalerインターフェースを実装します。 IPアドレスはParseIPで受け入れられる形式で指定することが期待されています。

type IPAddr 

type IPAddr struct {
	IP   IP
	Zone string
}

IPAddrはIPエンドポイントのアドレスを表します。

func ResolveIPAddr 

func ResolveIPAddr(network, address string) (*IPAddr, error)

ResolveIPAddrはIPエンドポイントのアドレスを返します。

ネットワークはIPネットワーク名である必要があります。

アドレスパラメーターのホストがリテラルIPアドレスではない場合、 ResolveIPAddrはIPエンドポイントのアドレスに解決します。 そうでなければ、アドレスをリテラルのIPアドレスとして解析します。 アドレスパラメーターはホスト名を使用することもできますが、 これは推奨されません。なぜなら、ホスト名のIPアドレスのうち最大で1つしか返さないからです。

ネットワークとアドレスパラメーターの説明については、func Dialを参照してください。

func (*IPAddr) Network 

func (a *IPAddr) Network() string

Networkはアドレスのネットワーク名を返します。"ip"。

func (*IPAddr) String 

func (a *IPAddr) String() string

type IPConn 

type IPConn struct {
	// contains filtered or unexported fields
}

IPConnはIPネットワーク接続のConnおよびPacketConnインターフェースの実装です。

func DialIP 

func DialIP(network string, laddr, raddr *IPAddr) (*IPConn, error)

DialIPはIPネットワークに対してDialのように機能します。

ネットワークはIPネットワーク名である必要があります。詳細はfunc Dialを参照してください。

もしladdrがnilであれば、ローカルアドレスが自動的に選択されます。 もしraddrのIPフィールドがnilであるか、未指定のIPアドレスである場合、 ローカルシステムが仮定されます。

func ListenIP 

func ListenIP(network string, laddr *IPAddr) (*IPConn, error)

ListenIPはIPネットワーク用のListenPacketと同様に機能します。

ネットワークはIPネットワーク名である必要があります。詳細についてはfunc Dialを参照してください。

もしladdrのIPフィールドがnilまたは指定されていないIPアドレスである場合、 ListenIPはローカルシステムの利用可能なすべてのIPアドレスでリッスンします マルチキャストIPアドレスを除く。

func (*IPConn) ReadFrom 

func (c *IPConn) ReadFrom(b []byte) (int, Addr, error)

ReadFromはPacketConnのReadFromメソッドを実装します。

func (*IPConn) ReadFromIP 

func (c *IPConn) ReadFromIP(b []byte) (int, *IPAddr, error)

ReadFromIPはReadFromと同様に動作しますが、IPAddrを返します。

func (*IPConn) ReadMsgIP added in v1.1.0 

func (c *IPConn) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error)

ReadMsgIPはcからメッセージを読み取り、ペイロードをbにコピーし、 関連する帯域外データをoobにコピーします。bにコピーされたバイト数、oobにコピーされたバイト数、 メッセージに設定されたフラグ、およびメッセージの送信元アドレスを返します。

パッケージgolang.org/x/net/ipv4とgolang.org/x/net/ipv6を使用して、oobに対してIPレベルのソケットオプションを操作できます。

func (*IPConn) SyscallConn added in v1.9.0 

func (c *IPConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは、生のネットワーク接続を返します。 これはsyscall.Connインターフェースを実装しています。

func (*IPConn) WriteMsgIP added in v1.1.0 

func (c *IPConn) WriteMsgIP(b, oob []byte, addr *IPAddr) (n, oobn int, err error)

WriteMsgIPは、bからペイロードを、oobから関連のオフドーバンドータをコピーし、cを経由してaddrにメッセージを送信します。送信されたペイロードとオフドーバンドズダのバイト数を返します。

golang.org/x/net/ipv4とgolang.org/x/net/ipv6のパッケージを使用して、oob内のIPレベルのソケットオプションを操作することができます。

func (*IPConn) WriteTo 

func (c *IPConn) WriteTo(b []byte, addr Addr) (int, error)

WriteToはPacketConnのWriteToメソッドを実装します。

func (*IPConn) WriteToIP 

func (c *IPConn) WriteToIP(b []byte, addr *IPAddr) (int, error)

WriteToIPはWriteToと同様の動作をするが、IPAddrを取ります。

type IPMask 

type IPMask []byte

IPMaskは、IPアドレスのアドレッシングとルーティングに使用できる ビットマスクです。

詳細については、型IPNetと関数ParseCIDRを参照してください。

func CIDRMask 

func CIDRMask(ones, bits int) IPMask

CIDRMaskは、'ones'個の1ビットで構成されたIPMaskを返します。 その後、0ビットが 'bits'ビットの総長になるまで続きます。 この形式のマスクに対して、CIDRMaskはIPMask.Sizeの逆です。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	// このマスクはIPv4の/31サブネットに対応しています。
	fmt.Println(net.CIDRMask(31, 32))

	// このマスクはIPv6の/64サブネットに対応しています。
	fmt.Println(net.CIDRMask(64, 128))

}

Output:

fffffffe
ffffffffffffffff0000000000000000

func IPv4Mask 

func IPv4Mask(a, b, c, d byte) IPMask

IPv4Maskは、IPv4マスクa.b.c.dのIPマスク（4バイト形式）を返します。

Example 
package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/net"
)

func main() {
	fmt.Println(net.IPv4Mask(255, 255, 255, 0))

}

Output:

ffffff00

func (IPMask) Size 

func (m IPMask) Size() (ones, bits int)

Sizeはマスクの先頭の1の数と合計のビット数を返します。 マスクが正規の形式でない場合、つまり、1が0に続く形式でない場合は、 Sizeは0, 0を返します。

func (IPMask) String 

func (m IPMask) String() string

Stringは、句読点なしのmの16進数形式を返します。

type IPNet 

type IPNet struct {
	IP   IP
	Mask IPMask
}

IPNetはIPネットワークを表します。

func (*IPNet) Contains 

func (n *IPNet) Contains(ip IP) bool

Containsは、ネットワークが指定したIPを含んでいるかどうかを報告します。

func (*IPNet) Network 

func (n *IPNet) Network() string

Networkはアドレスのネットワーク名、"ip+net"を返します。

func (*IPNet) String 

func (n *IPNet) String() string

Stringは、CIDR表記であるnの文字列を返します。例えば「192.0.2.0/24」やRFC 4632およびRFC 4291で定義されている「2001:db8::/48」です。 もしマスクが正規形式でない場合、IPアドレスに続いてスラッシュ文字とパンクチュエーションを含まない16進形式のマスクで表された文字列を返します。例えば「198.51.100.0/c000ff00」。

type Interface 

type Interface struct {
	Index        int
	MTU          int
	Name         string
	HardwareAddr HardwareAddr
	Flags        Flags
}

インターフェースはネットワークインタフェースの名前とインデックスのマッピングを表します。また、ネットワークインタフェースの機能情報も表します。

func InterfaceByIndex 

func InterfaceByIndex(index int) (*Interface, error)

InterfaceByIndex は、インデックスで指定されたインターフェースを返します。

Solarisでは、論理データリンクを共有する論理ネットワークインターフェースのうちの1つを返しますが、より正確な情報が必要な場合は、 InterfaceByName を使用してください。

func InterfaceByName 

func InterfaceByName(name string) (*Interface, error)

InterfaceByNameは、指定された名前で指定されたインターフェースを返します。

func Interfaces 

func Interfaces() ([]Interface, error)

インタフェースはシステムのネットワークインタフェースのリストを返します。

func (*Interface) Addrs 

func (ifi *Interface) Addrs() ([]Addr, error)

Addrsは特定のインターフェースのユニキャストインターフェースアドレスのリストを返します。

func (*Interface) MulticastAddrs 

func (ifi *Interface) MulticastAddrs() ([]Addr, error)

MulticastAddrsは特定のインターフェースに結合されたマルチキャストグループアドレスのリストを返します。

type InvalidAddrError 

type InvalidAddrError string

func (InvalidAddrError) Error 

func (e InvalidAddrError) Error() string

func (InvalidAddrError) Temporary 

func (e InvalidAddrError) Temporary() bool

func (InvalidAddrError) Timeout 

func (e InvalidAddrError) Timeout() bool

type ListenConfig added in v1.11.0 

type ListenConfig struct {

	// Controlがnilでない場合、ネットワーク接続を作成した後、
	// オペレーティングシステムにバインドする前に呼び出されます。
	//
	// Controlメソッドに渡されるネットワークとアドレスのパラメータは、
	// 必ずしもListenに渡されるものとは限りません。例えば、"tcp"を
	// Listenに渡すと、Control関数へは"tcp4"または"tcp6"が渡されます。
	Control func(network, address string, c syscall.RawConn) error

	// KeepAliveは、このリスナーによって受け入れられたネットワーク接続のキープアライブ期間を指定します。
	// ゼロの場合、プロトコルとオペレーティングシステムがサポートしている場合にキープアライブが有効になります。
	// キープアライブをサポートしていないネットワークプロトコルやオペレーティングシステムは、このフィールドを無視します。
	// マイナスの値の場合、キープアライブは無効になります。
	KeepAlive time.Duration
	// contains filtered or unexported fields
}

ListenConfig はアドレスのリッスンに関するオプションを含んでいます。

func (*ListenConfig) Listen added in v1.11.0 

func (lc *ListenConfig) Listen(ctx context.Context, network, address string) (Listener, error)

Listenはローカルネットワークアドレスでアナウンスします。

ネットワークおよびアドレスの詳細については、func Listenを参照してください。

func (*ListenConfig) ListenPacket added in v1.11.0 

func (lc *ListenConfig) ListenPacket(ctx context.Context, network, address string) (PacketConn, error)

ListenPacketはローカルネットワークアドレスでアナウンスします。

ネットワークとアドレスのパラメーターの説明については、func ListenPacketを参照してください。

func (*ListenConfig) MultipathTCP added in v1.21.0 

func (lc *ListenConfig) MultipathTCP() bool

MultipathTCPはMPTCPが使用されるかどうかを報告します。

このメソッドはオペレーティングシステムがMPTCPをサポートしているかどうかを確認しません。

func (*ListenConfig) SetMultipathTCP added in v1.21.0 

func (lc *ListenConfig) SetMultipathTCP(use bool)

SetMultipathTCPは、オペレーティングシステムがサポートしている場合、ListenメソッドがMPTCPを使用するかどうかを指示します。 このメソッドは、システムのデフォルトおよびGODEBUG=multipathtcp=...の設定を上書きします。

ホスト上でMPTCPが利用できない場合、またはクライアントがサポートしていない場合、 ListenメソッドはTCPにフォールバックします。

type Listener 

type Listener interface {
	// Accept waits for and returns the next connection to the listener.
	Accept() (Conn, error)

	// Close closes the listener.
	// Any blocked Accept operations will be unblocked and return errors.
	Close() error

	// Addr returns the listener's network address.
	Addr() Addr
}

リスナーはストリーム指向のプロトコルのための汎用のネットワークリスナーです。

複数のゴルーチンが同時にリスナーのメソッドを呼び出すことができます。

Example 
package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
)

func main() {
	// ローカルシステムの利用可能なすべてのユニキャストおよび
	// IPv4マルチキャストアドレス上のTCPポート2000でリッスンします。
	l, err := net.Listen("tcp", ":2000")
	if err != nil {
		log.Fatal(err)
	}
	defer l.Close()
	for {
		// Wait for a connection.
		conn, err := l.Accept()
		if err != nil {
			log.Fatal(err)
		}
		// 新しいgoroutineで接続を処理する。
		// ループはその後、受け付けを再開するため、
		// 複数の接続を同時に処理することが可能です。
		go func(c net.Conn) {
			// すべての受信データをエコーします。
			io.Copy(c, c)
			// 接続をシャットダウンします。
			c.Close()
		}(conn)
	}
}

Output:

func FileListener 

func FileListener(f *os.File) (ln Listener, err error)

FileListenerは、開いたファイルfに対応するネットワークリスナーのコピーを返します。 lnを使用後に閉じる責任は呼び出し元にあります。 lnを閉じるとfには影響しませんし、fを閉じるとlnにも影響しません。

func Listen 

func Listen(network, address string) (Listener, error)

Listenはローカルネットワークアドレスでアナウンスします。

ネットワークは"tcp"、"tcp4"、"tcp6"、"unix"、または"unixpacket"である必要があります。

TCPネットワークの場合、アドレスパラメータのホストが空または明示的に指定されていないIPアドレスの場合、Listenは利用可能なすべてのユニキャストおよびエニーキャストIPアドレスでリッスンします。 IPv4のみを使用する場合は、ネットワークに"tcp4"を使用します。 アドレスにはホスト名を使用できますが、これは推奨されないため、ホストのIPアドレスの最大1つのリスナーが作成されます。 アドレスパラメータのポートが空または"0"の場合、例えば"127.0.0.1:"や"[::1]:0"のように、ポート番号が自動的に選択されます。 ListenerのAddrメソッドを使用して、選択されたポートを取得できます。

ネットワークおよびアドレスパラメータの説明については、func Dialを参照してください。

Listenは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、ListenConfig.Listenを使用してください。

type MX 

type MX struct {
	Host string
	Pref uint16
}

MXは単一のDNS MXレコードを表します。

func LookupMX 

func LookupMX(name string) ([]*MX, error)

LookupMXは指定されたドメイン名のDNS MXレコードを優先度に従ってソートして返します。

返されるメールサーバー名は、正しくフォーマットされた表示形式のドメイン名であることが検証されます。 レスポンスに無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーと共に残りの結果が返されます（もしあれば）。

LookupMXは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、Resolver.LookupMXを使用してください。

type NS added in v1.1.0 

type NS struct {
	Host string
}

NSは単一のDNS NSレコードを表します。

func LookupNS added in v1.1.0 

func LookupNS(name string) ([]*NS, error)

LookupNSは指定されたドメイン名のDNS NSレコードを返します。

返されるネームサーバ名は、正しくフォーマットされた表示形式のドメイン名であることが検証されます。 応答に無効な名前が含まれている場合、これらのレコードはフィルタリングされ、エラーが残りの結果と共に返されます。

LookupNSは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、Resolver.LookupNSを使用します。

type OpError 

type OpError struct {

	// Opはエラーの原因となった操作であり、
	// "read"または"write"などの操作です。
	Op string

	// Netはこのエラーが発生したネットワークの種類です。
	// 例えば、"tcp"や"udp6"などがあります。
	Net string

	// リモートネットワーク接続に関する操作（Dial、Read、またはWriteなど）において、ソースは対応するローカルネットワークアドレスです。
	Source Addr

	// Addrはこのエラーが発生したネットワークアドレスです。
	// ListenやSetDeadlineなどのローカルな操作の場合、Addrは操作されるローカルエンドポイントのアドレスです。
	// Dial、Read、またはWriteなどのリモートネットワーク接続に関する操作の場合、Addrはその接続のリモートアドレスです。
	Addr Addr

	// Errは操作中に発生したエラーです。
	// Errorメソッドはエラーがnilの場合にパニックを起こします。
	Err error
}

OpErrorは通常、netパッケージの関数によって返されるエラータイプです。これは操作、ネットワークタイプ、およびエラーのアドレスを説明します。

func (*OpError) Error 

func (e *OpError) Error() string

func (*OpError) Temporary 

func (e *OpError) Temporary() bool

func (*OpError) Timeout 

func (e *OpError) Timeout() bool

func (*OpError) Unwrap added in v1.13.0 

func (e *OpError) Unwrap() error

type PacketConn 

type PacketConn interface {
	// ReadFrom reads a packet from the connection,
	// copying the payload into p. It returns the number of
	// bytes copied into p and the return address that
	// was on the packet.
	// It returns the number of bytes read (0 <= n <= len(p))
	// and any error encountered. Callers should always process
	// the n > 0 bytes returned before considering the error err.
	// ReadFrom can be made to time out and return an error after a
	// fixed time limit; see SetDeadline and SetReadDeadline.
	ReadFrom(p []byte) (n int, addr Addr, err error)

	// WriteTo writes a packet with payload p to addr.
	// WriteTo can be made to time out and return an Error after a
	// fixed time limit; see SetDeadline and SetWriteDeadline.
	// On packet-oriented connections, write timeouts are rare.
	WriteTo(p []byte, addr Addr) (n int, err error)

	// Close closes the connection.
	// Any blocked ReadFrom or WriteTo operations will be unblocked and return errors.
	Close() error

	// LocalAddr returns the local network address, if known.
	LocalAddr() Addr

	// SetDeadline sets the read and write deadlines associated
	// with the connection. It is equivalent to calling both
	// SetReadDeadline and SetWriteDeadline.
	//
	// A deadline is an absolute time after which I/O operations
	// fail instead of blocking. The deadline applies to all future
	// and pending I/O, not just the immediately following call to
	// Read or Write. After a deadline has been exceeded, the
	// connection can be refreshed by setting a deadline in the future.
	//
	// If the deadline is exceeded a call to Read or Write or to other
	// I/O methods will return an error that wraps os.ErrDeadlineExceeded.
	// This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
	// The error's Timeout method will return true, but note that there
	// are other possible errors for which the Timeout method will
	// return true even if the deadline has not been exceeded.
	//
	// An idle timeout can be implemented by repeatedly extending
	// the deadline after successful ReadFrom or WriteTo calls.
	//
	// A zero value for t means I/O operations will not time out.
	SetDeadline(t time.Time) error

	// SetReadDeadline sets the deadline for future ReadFrom calls
	// and any currently-blocked ReadFrom call.
	// A zero value for t means ReadFrom will not time out.
	SetReadDeadline(t time.Time) error

	// SetWriteDeadline sets the deadline for future WriteTo calls
	// and any currently-blocked WriteTo call.
	// Even if write times out, it may return n > 0, indicating that
	// some of the data was successfully written.
	// A zero value for t means WriteTo will not time out.
	SetWriteDeadline(t time.Time) error
}

PacketConnは汎用のパケット指向のネットワーク接続です。

複数のゴルーチンは同時にPacketConnのメソッドを呼び出すことができます。

func FilePacketConn 

func FilePacketConn(f *os.File) (c PacketConn, err error)

FilePacketConn は、開いているファイル f に対応するパケットネットワーク接続のコピーを返します。 使用が終わったら f を閉じるのは呼び出し元の責任です。 c を閉じても f には影響しませんし、f を閉じても c には影響しません。

func ListenPacket 

func ListenPacket(network, address string) (PacketConn, error)

ListenPacketはローカルネットワークアドレスでの通知を行います。

ネットワークは「udp」「udp4」「udp6」「unixgram」またはIPトランスポートである必要があります。 IPトランスポートは、次の形式で「ip」「ip4」、「ip6」のいずれかの後に「:」とリテラルのプロトコル番号またはプロトコル名が続きます。 例：「ip:1」または「ip:icmp」。

UDPとIPネットワークの場合、アドレスパラメータのホストが空白またはリテラルの未指定のIPアドレスの場合、 ListenPacketはマルチキャストIPアドレス以外のすべての利用可能なローカルシステムのIPアドレスでリスンします。 IPv4のみを使用する場合は、ネットワークに「udp4」または「ip4:proto」を使用します。 アドレスはホスト名を使用することもできますが、これは推奨されません。 なぜなら、それによってホストのIPアドレスのうちの最大で1つのリスナが作成されるからです。 アドレスパラメータのポートが空または「0」の場合、「127.0.0.1:」や「[::1]:0」といった形式で、ポート番号は自動的に選択されます。 PacketConnのLocalAddrメソッドを使用して選択されたポートを特定することができます。

ネットワークおよびアドレスパラメータの説明については、func Dialを参照してください。

ListenPacketは内部的にcontext.Backgroundを使用します。コンテキストを指定するには、 ListenConfig.ListenPacketを使用してください。

type ParseError 

type ParseError struct {

	// Typeは期待される文字列のタイプです。例えば、「IPアドレス」、「CIDRアドレス」などです。
	Type string

	// Textは不正なテキスト文字列です。
	Text string
}

ParseErrorは文字列形式のネットワークアドレスパーサーのエラータイプです。

func (*ParseError) Error 

func (e *ParseError) Error() string

func (*ParseError) Temporary added in v1.17.0 

func (e *ParseError) Temporary() bool

func (*ParseError) Timeout added in v1.17.0 

func (e *ParseError) Timeout() bool

type Resolver added in v1.8.0 

type Resolver struct {

	// PreferGoは、利用可能なプラットフォーム上でGoの組み込みDNSリゾルバーを優先するかどうかを制御します。これはGODEBUG=netdns=goを設定するのと同等ですが、このリゾルバーにのみスコープされます。
	PreferGo bool

	// StrictErrorsは、一時的なエラー（タイムアウト、ソケットエラー、およびSERVFAILを含む）の動作を制御します。Goの組み込みリゾルバを使用する場合、このオプションは複数のサブクエリからなるクエリ（A+AAAAアドレスの検索やDNS検索リストの走査など）に対して、部分的な結果を返す代わりに、エラーが発生した場合にクエリ全体を中止させます。これはデフォルトでは有効にされていませんが、AAAAクエリを正しく処理しないリゾルバとの互換性に影響を与える可能性があるためです。
	StrictErrors bool

	// Dialは、Go言語の組み込みDNSリゾルバがTCPおよびUDP接続を作成するために使用する代替ダイラーをオプションで指定します。アドレスパラメーターのホストは常にリテラルIPアドレスであり、ホスト名ではありません。また、アドレスパラメーターのポートはリテラルポート番号であり、サービス名ではありません。
	// 返されたConnがPacketConnでもある場合、送信および受信されるDNSメッセージはRFC 1035セクション4.2.1「UDP使用」に準拠する必要があります。
	Dial func(ctx context.Context, network, address string) (Conn, error)
	// contains filtered or unexported fields
}

Resolverは名前や数値を検索します。

nil *ResolverはゼロのResolverと同等です。

func (*Resolver) LookupAddr added in v1.8.0 

func (r *Resolver) LookupAddr(ctx context.Context, addr string) ([]string, error)

LookupAddrは指定されたアドレスの逆引きを行い、そのアドレスにマッピングされる名前のリストを返します。

返された名前は適切なフォーマットのプレゼンテーション形式のドメイン名であることが検証されます。 もし回答に無効な名前が含まれている場合、それらのレコードはフィルタリングされ、 残りの結果がある場合はエラーが返されます。

func (*Resolver) LookupCNAME added in v1.8.0 

func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error)

LookupCNAMEは指定されたホストの正規名を返します。 正規名に関心を持たない呼び出し元は、 LookupHostまたはLookupIPを直接呼び出すことができます。 両者は名前解決の一環として正規名を処理します。

正規名は、ゼロ個以上のCNAMEレコードをたどった後の最終名です。 LookupCNAMEは、ホストがDNSの"CNAME"レコードを含まない場合でも、 ホストがアドレスレコードに解決されている限り、エラーを返しません。

返される正規名は、適切な形式のドメイン名であることが検証されます。

func (*Resolver) LookupHost added in v1.8.0 

func (r *Resolver) LookupHost(ctx context.Context, host string) (addrs []string, err error)

LookupHostは、ローカルのリゾルバを使用して指定されたホストを検索します。 そのホストのアドレスのスライスを返します。

func (*Resolver) LookupIP added in v1.15.0 

func (r *Resolver) LookupIP(ctx context.Context, network, host string) ([]IP, error)

LookupIPは、ローカルリゾルバーを使用して指定されたネットワークのホストを検索します。 networkによって指定されたタイプのホストのIPアドレスのスライスを返します。 networkは"ip"、"ip4"、または"ip6"のいずれかでなければなりません。

func (*Resolver) LookupIPAddr added in v1.8.0 

func (r *Resolver) LookupIPAddr(ctx context.Context, host string) ([]IPAddr, error)

LookupIPAddrは、ローカルのリゾルバを使用してホストを検索します。 そのホストのIPv4およびIPv6アドレスのスライスを返します。

func (*Resolver) LookupMX added in v1.8.0 

func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error)

LookupMXは、指定されたドメイン名のDNS MXレコードを優先度に基づいてソートして返します。 返されるメールサーバー名は正しくフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。 レスポンスに無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーが返されます。 残りの結果がある場合、それらとともにエラーが返されます。

func (*Resolver) LookupNS added in v1.8.0 

func (r *Resolver) LookupNS(ctx context.Context, name string) ([]*NS, error)

LookupNSは指定されたドメイン名のDNS NSレコードを返します。

返されたネームサーバの名前は、正しくフォーマットされた プレゼンテーション形式のドメイン名であることが検証されます。 もしレスポンスに無効な名前が含まれている場合、それらのレコードは フィルタリングされ、エラーが返されます。 残りの結果がある場合、それらとともにエラーが返されます。

func (*Resolver) LookupNetIP added in v1.18.0 

func (r *Resolver) LookupNetIP(ctx context.Context, network, host string) ([]netip.Addr, error)

LookupNetIPはローカルリゾルバを使用してホストを検索します。 それは、ネットワークで指定されたタイプのそのホストのIPアドレスのスライスを返します。 ネットワークは、"ip"、"ip4"、または "ip6"のいずれかでなければなりません。

func (*Resolver) LookupPort added in v1.8.0 

func (r *Resolver) LookupPort(ctx context.Context, network, service string) (port int, err error)

LookupPortは、指定されたネットワークとサービスのポートを検索します。

func (*Resolver) LookupSRV added in v1.8.0 

func (r *Resolver) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error)

LookupSRVは、指定されたサービス、プロトコル、ドメイン名のSRVクエリを解決しようとします。 プロトコルは「tcp」または「udp」です。 返されるレコードは優先度でソートされ、優先度内でのウェイトによってランダムになります。

LookupSRVは、RFC 2782に従ってルックアップするためのDNS名を構築します。 つまり、_service._proto.nameをルックアップします。非標準の名前の下にSRVレコードを公開するサービスを収容するために、 serviceとprotoの両方が空の文字列の場合、LookupSRVは直接nameをルックアップします。

返されるサービス名は、正しくフォーマットされたプレゼンテーション形式のドメイン名であることが検証されます。 レスポンスに無効な名前が含まれている場合、それらのレコードはフィルタリングされ、エラーが返されます。 残りの結果がある場合、それらと一緒にエラーが返されます。

func (*Resolver) LookupTXT added in v1.8.0 

func (r *Resolver) LookupTXT(ctx context.Context, name string) ([]string, error)

LookupTXTは指定されたドメイン名のDNSのTXTレコードを返します。

type SRV 

type SRV struct {
	Target   string
	Port     uint16
	Priority uint16
	Weight   uint16
}

SRVは単一のDNS SRVレコードを表します。

func LookupSRV 

func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error)

LookupSRVは、指定されたサービス、プロトコル、およびドメイン名のSRVクエリを解決しようとします。 protoは「tcp」または「udp」です。 返されるレコードは優先度に従ってソートされ、各優先度内で重みによってランダムになります。

LookupSRVはRFC 2782に従って調べるDNS名を構築します。 つまり、_service._proto.nameを検索します。非標準の名前でSRVレコードを公開するサービスに対応するために、 serviceとprotoの両方が空の文字列の場合、LookupSRVは直接nameを検索します。

返されたサービス名は、適切な形式のプレゼンテーション形式のドメイン名であることが検証されます。 応答に無効な名前が含まれている場合、これらのレコードはフィルタリングされ、エラーが返されます。 残りの結果がある場合は、これらのエラーと一緒に返されます。

type TCPAddr 

type TCPAddr struct {
	IP   IP
	Port int
	Zone string
}

TCPAddrはTCPエンドポイントのアドレスを表します。

func ResolveTCPAddr 

func ResolveTCPAddr(network, address string) (*TCPAddr, error)

ResolveTCPAddrはTCPエンドポイントのアドレスを返します。

ネットワークはTCPのネットワーク名である必要があります。

アドレスパラメータのホストがリテラルIPアドレスでない場合や、 ポートがリテラルのポート番号でない場合、ResolveTCPAddrは TCPエンドポイントのアドレスに解決します。 そうでなければ、アドレスをリテラルのIPアドレスとポート番号のペアとして解析します。 アドレスパラメータはホスト名を使用することもできますが、 ホスト名のIPアドレスの一つを最大で返すため、推奨されていません。

ネットワークとアドレスパラメータの詳細については、 func Dialの説明を参照してください。

func TCPAddrFromAddrPort added in v1.18.0 

func TCPAddrFromAddrPort(addr netip.AddrPort) *TCPAddr

TCPAddrFromAddrPortはaddrをTCPAddrとして返します。もしaddrがIsValid()がfalseである場合、 返されるTCPAddrにはnilのIPフィールドが含まれ、アドレスファミリーに依存しない未指定のアドレスを示します。

func (*TCPAddr) AddrPort added in v1.18.0 

func (a *TCPAddr) AddrPort() netip.AddrPort

AddrPortはTCPAddr aをnetip.AddrPortとして返します。

もしa.Portがuint16に収まらない場合、静かに切り捨てられます。

もしaがnilの場合、ゼロ値が返されます。

func (*TCPAddr) Network 

func (a *TCPAddr) Network() string

Networkはアドレスのネットワーク名「tcp」を返します。

func (*TCPAddr) String 

func (a *TCPAddr) String() string

type TCPConn 

type TCPConn struct {
	// contains filtered or unexported fields
}

TCPConnはTCPネットワーク接続のConnインターフェースの実装です。

func DialTCP 

func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)

DialTCPはTCPネットワークのためのDialのように振る舞います。

ネットワークはTCPネットワーク名でなければなりません。詳細についてはfunc Dialを参照してください。

laddrがnilの場合、自動的にローカルアドレスが選択されます。 raddrのIPフィールドがnilまたは未指定のIPアドレスの場合、ローカルシステムが使用されます。

func (*TCPConn) CloseRead 

func (c *TCPConn) CloseRead() error

CloseReadはTCP接続の読み込み側をシャットダウンします。 ほとんどの呼び出し元は、単にCloseを使用するだけで十分です。

func (*TCPConn) CloseWrite 

func (c *TCPConn) CloseWrite() error

CloseWrite は TCP 接続の書き込み側をシャットダウンします。 ほとんどの呼び出し元は Close を使用すべきです。

func (*TCPConn) MultipathTCP added in v1.21.0 

func (c *TCPConn) MultipathTCP() (bool, error)

MultipathTCPは、現在の接続がMPTCPを使用しているかどうかを報告します。

ホスト、他のピア、またはその間にあるデバイスによってMultipath TCPがサポートされていない場合、 意図的に/意図せずにフィルタリングされた場合、TCPへのフォールバックが行われます。 このメソッドは、MPTCPが使用されているかどうかを確認するために最善を尽くします。

Linuxでは、カーネルのバージョンがv5.16以上の場合、さらに条件が検証され、結果が改善されます。

func (*TCPConn) ReadFrom 

func (c *TCPConn) ReadFrom(r io.Reader) (int64, error)

ReadFrom は io.ReaderFrom の ReadFrom メソッドを実装します。

func (*TCPConn) SetKeepAlive 

func (c *TCPConn) SetKeepAlive(keepalive bool) error

SetKeepAliveは、オペレーティングシステムが接続に対して keep-aliveメッセージを送信するかどうかを設定します。

func (*TCPConn) SetKeepAlivePeriod added in v1.2.0 

func (c *TCPConn) SetKeepAlivePeriod(d time.Duration) error

SetKeepAlivePeriodは、Keep-Alive間の期間を設定します。

func (*TCPConn) SetLinger 

func (c *TCPConn) SetLinger(sec int) error

SetLingerは、まだ送信または確認待ちのデータがある接続に対してCloseの振る舞いを設定します。 sec < 0（デフォルト）の場合、オペレーティングシステムはバックグラウンドでデータの送信を完了します。 sec == 0の場合、オペレーティングシステムは未送信または確認待ちのデータを破棄します。 sec > 0の場合、データはsec < 0と同様にバックグラウンドで送信されます。 Linuxを含む一部のオペレーティングシステムでは、これによりCloseが全てのデータの送信または破棄が完了するまでブロックする場合があります。 sec秒経過後、未送信のデータは破棄される可能性があります。

func (*TCPConn) SetNoDelay 

func (c *TCPConn) SetNoDelay(noDelay bool) error

SetNoDelayは、パケットの送信を遅延させるかどうかを制御します。これにより、より少ないパケットで送信することが期待されます（Nagleのアルゴリズム）。デフォルト値はtrue（遅延なし）であり、Writeの後で可能な限りすぐにデータが送信されます。

func (*TCPConn) SyscallConn added in v1.9.0 

func (c *TCPConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは生のネットワーク接続を返します。 これはsyscall.Connインターフェースを実装しています。

type TCPListener 

type TCPListener struct {
	// contains filtered or unexported fields
}

TCPListenerはTCPネットワークリスナーです。クライアントは通常、TCPを仮定する代わりにListener型の変数を使用するべきです。

func ListenTCP 

func ListenTCP(network string, laddr *TCPAddr) (*TCPListener, error)

ListenTCPはTCPネットワーク用のListenのように機能します。

ネットワークはTCPネットワーク名でなければなりません。詳細はfunc Dialを参照してください。

laddrのIPフィールドがnilまたは未指定のIPアドレスの場合、ListenTCPはローカルシステムの利用可能なユニキャストおよびエニーキャストIPアドレスすべてでリスンします。 laddrのPortフィールドが0の場合、ポート番号は自動的に選択されます。

func (*TCPListener) Accept 

func (l *TCPListener) Accept() (Conn, error)

Accept implements the Accept method in the Listener interface; it waits for the next call and returns a generic Conn.

func (*TCPListener) AcceptTCP 

func (l *TCPListener) AcceptTCP() (*TCPConn, error)

AcceptTCPは次の着信呼び出しを受け入れ、新しい接続を返します。

func (*TCPListener) Addr 

func (l *TCPListener) Addr() Addr

Addrはリスナーのネットワークアドレス、*TCPAddrを返します。 返されるAddrはAddrのすべての呼び出しで共有されるため、 変更しないでください。

func (*TCPListener) Close 

func (l *TCPListener) Close() error

Close は TCP アドレスのリスニングを停止します。 既に受け入れられた接続は閉じられません。

func (*TCPListener) File 

func (l *TCPListener) File() (f *os.File, err error)

File は元の os.File のコピーを返します。 終了した後、f を閉じる責任は呼び出し元にあります。 l を閉じても f には影響を与えませんし、f を閉じても l には影響を与えません。

返された os.File のファイルディスクリプタは、接続のものとは異なります。 この複製を使用して元のもののプロパティを変更しようとすると、 望ましい効果が現れるかどうかは不明です。

func (*TCPListener) SetDeadline 

func (l *TCPListener) SetDeadline(t time.Time) error

SetDeadlineはリスナーに関連付けられた締め切りを設定します。 ゼロの時刻値は締め切りを無効にします。

func (*TCPListener) SyscallConn added in v1.10.0 

func (l *TCPListener) SyscallConn() (syscall.RawConn, error)

SyscallConn は生のネットワーク接続を返します。 これは syscall.Conn インターフェースを実装しています。

返された RawConn は Control の呼び出しのみをサポートします。 Read と Write はエラーを返します。

type UDPAddr 

type UDPAddr struct {
	IP   IP
	Port int
	Zone string
}

UDPAddrはUDPエンドポイントのアドレスを表します。

func ResolveUDPAddr 

func ResolveUDPAddr(network, address string) (*UDPAddr, error)

ResolveUDPAddr はUDPのエンドポイントのアドレスを返します。

ネットワークはUDPのネットワーク名である必要があります。

アドレスパラメータのホストがIPアドレスのリテラルでない場合、または ポート番号がリテラルのポート番号でない場合、ResolveUDPAddrは UDPエンドポイントのアドレスに解決します。 それ以外の場合は、アドレスをリテラルのIPアドレスとポート番号のペアとして解析します。 アドレスパラメータはホスト名を使用することもできますが、これは 推奨されません。なぜなら、ホスト名のIPアドレスのいずれか一つしか返さないからです。

ネットワークおよびアドレスパラメータの説明については、func Dialを参照してください。

func UDPAddrFromAddrPort added in v1.18.0 

func UDPAddrFromAddrPort(addr netip.AddrPort) *UDPAddr

UDPAddrFromAddrPortはaddrをUDPAddrとして返します。もしaddr.IsValid()がfalseであれば、返されるUDPAddrにはnilのIPフィールドが含まれ、アドレスファミリーに依存しない未指定のアドレスを示します。

func (*UDPAddr) AddrPort added in v1.18.0 

func (a *UDPAddr) AddrPort() netip.AddrPort

AddrPortはUDPAddr aをnetip.AddrPortとして返します。

もしa.Portがuint16に収まらない場合、静かに切り捨てられます。

もしaがnilの場合、ゼロ値が返されます。

func (*UDPAddr) Network 

func (a *UDPAddr) Network() string

Networkはアドレスのネットワーク名、"udp"を返します。

func (*UDPAddr) String 

func (a *UDPAddr) String() string

type UDPConn 

type UDPConn struct {
	// contains filtered or unexported fields
}

UDPConnはUDPネットワーク接続のConnおよびPacketConnインターフェースの実装です。

func DialUDP 

func DialUDP(network string, laddr, raddr *UDPAddr) (*UDPConn, error)

DialUDPはUDPネットワークのためにDialと同様の機能を提供します。

ネットワークはUDPネットワークの名前でなければならず、詳細についてはfunc Dialを参照してください。

もしladdrがnilの場合、自動的にローカルアドレスが選択されます。 もしraddrのIPフィールドがnilまたは未指定のIPアドレスの場合、ローカルシステムが仮定されます。

func ListenMulticastUDP 

func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)

ListenMulticastUDPは、グループアドレスを指定したネットワークインターフェース上でのUDPネットワーク用のListenPacketのように動作します。 ネットワークはUDPネットワーク名である必要があります。詳細については、func Dialを参照してください。 ListenMulticastUDPは、グループのマルチキャストIPアドレスを含む、ローカルシステムの利用可能なすべてのIPアドレスでリッスンします。 ifiがnilの場合、ListenMulticastUDPはシステムが割り当てたマルチキャストインターフェースを使用しますが、これは推奨されません。割り当てはプラットフォームに依存し、時にはルーティングの設定が必要になる場合があります。 gaddrのPortフィールドが0の場合、ポート番号が自動的に選択されます。 ListenMulticastUDPは、単純で小規模なアプリケーションのための便利さのために提供されています。一般的な目的にはgolang.org/x/net/ipv4とgolang.org/x/net/ipv6パッケージがあります。 ListenMulticastUDPは、IPPROTO_IPのIP_MULTICAST_LOOPソケットオプションを0に設定して、マルチキャストパケットのループバックを無効にします。

func ListenUDP 

func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)

ListenUDPは、UDPネットワークに対してListenPacketと同様の機能を提供します。

ネットワークはUDPネットワーク名でなければなりません。詳細については、func Dialを参照してください。

laddrのIPフィールドがnilまたは未指定のIPアドレスである場合、 ListenUDPは、マルチキャストIPアドレスを除く、ローカルシステムのすべての利用可能なIPアドレスでリスンします。 laddrのPortフィールドが0の場合、ポート番号が自動的に選択されます。

func (*UDPConn) ReadFrom 

func (c *UDPConn) ReadFrom(b []byte) (int, Addr, error)

ReadFrom は PacketConn の ReadFrom メソッドを実装します。

func (*UDPConn) ReadFromUDP 

func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)

ReadFromUDPはReadFromと同様の動作をしますが、UDPAddrを返します。

func (*UDPConn) ReadFromUDPAddrPort added in v1.18.0 

func (c *UDPConn) ReadFromUDPAddrPort(b []byte) (n int, addr netip.AddrPort, err error)

ReadFromUDPAddrPortはReadFromと同様の機能を提供しますが、netip.AddrPortを返します。

cが指定されていないアドレスにバインドされている場合、返される netip.AddrPortのアドレスは、IPv4-mapped IPv6アドレスの可能性があります。 IPv6のプレフィックスなしのアドレスを取得するには、netip.Addr.Unmapを使用してください。

func (*UDPConn) ReadMsgUDP added in v1.1.0 

func (c *UDPConn) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)

ReadMsgUDPは、cからメッセージを読み込み、ペイロードをbにコピーし、サイドバンドデータをoobにコピーします。bにコピーされたバイト数、oobにコピーされたバイト数、メッセージに設定されたフラグ、およびメッセージのソースアドレスを返します。

パッケージgolang.org/x/net/ipv4およびgolang.org/x/net/ipv6は、oob内のIPレベルのソケットオプションを操作するために使用できます。

func (*UDPConn) ReadMsgUDPAddrPort added in v1.18.0 

func (c *UDPConn) ReadMsgUDPAddrPort(b, oob []byte) (n, oobn, flags int, addr netip.AddrPort, err error)

ReadMsgUDPAddrPortは、UDPAddrではなくnetip.AddrPortを返すReadMsgUDPと同様の機能です。

func (*UDPConn) SyscallConn added in v1.9.0 

func (c *UDPConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは生のネットワーク接続を返します。 これはsyscall.Connインターフェースを実装しています。

func (*UDPConn) WriteMsgUDP added in v1.1.0 

func (c *UDPConn) WriteMsgUDP(b, oob []byte, addr *UDPAddr) (n, oobn int, err error)

WriteMsgUDPは、cが接続されていない場合はcを介してaddrにメッセージを書き込み、 cが接続されている場合はcのリモートアドレスにメッセージを書き込みます（その場合、 addrはnilでなければなりません）。ペイロードはbからコピーされ、関連する フラグデータはoobからコピーされます。ペイロードとフラグデータの書き込まれた バイト数を返します。

パッケージgolang.org/x/net/ipv4およびgolang.org/x/net/ipv6を使用して、 oob内のIPレベルのソケットオプションを操作することができます。

func (*UDPConn) WriteMsgUDPAddrPort added in v1.18.0 

func (c *UDPConn) WriteMsgUDPAddrPort(b, oob []byte, addr netip.AddrPort) (n, oobn int, err error)

WriteMsgUDPAddrPortはUDPAddrではなく、netip.AddrPortを受け取るWriteMsgUDPと同様のものです。

func (*UDPConn) WriteTo 

func (c *UDPConn) WriteTo(b []byte, addr Addr) (int, error)

WriteToはPacketConnのWriteToメソッドを実装します。

Example 
package main

import (
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net"
)

func main() {
	// Dialとは異なり、ListenPacketはピアとの関連付けなしで
	// 接続を作成します。
	conn, err := net.ListenPacket("udp", ":0")
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	dst, err := net.ResolveUDPAddr("udp", "192.0.2.1:2000")
	if err != nil {
		log.Fatal(err)
	}

	// この接続は、指定したアドレスにデータを書き込むことができます。
	_, err = conn.WriteTo([]byte("data"), dst)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*UDPConn) WriteToUDP 

func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

WriteToUDPはWriteToと同様の動作をしますが、UDPAddrを引数に取ります。

func (*UDPConn) WriteToUDPAddrPort added in v1.18.0 

func (c *UDPConn) WriteToUDPAddrPort(b []byte, addr netip.AddrPort) (int, error)

WriteToUDPAddrPortは、WriteToと同様に動作しますが、netip.AddrPortを受け取ります。

type UnixAddr 

type UnixAddr struct {
	Name string
	Net  string
}

UnixAddrはUnixドメインソケットエンドポイントのアドレスを表します。

func ResolveUnixAddr 

func ResolveUnixAddr(network, address string) (*UnixAddr, error)

ResolveUnixAddrは、Unixドメインソケットエンドポイントのアドレスを返します。

ネットワークはUnixのネットワーク名である必要があります。

ネットワークとアドレスのパラメータについての説明は、 func Dialを参照してください。

func (*UnixAddr) Network 

func (a *UnixAddr) Network() string

Networkはアドレスのネットワーク名を返します。"unix"、"unixgram"、または"unixpacket"です。

func (*UnixAddr) String 

func (a *UnixAddr) String() string

type UnixConn 

type UnixConn struct {
	// contains filtered or unexported fields
}

UnixConnは、Unixドメインソケットへの接続のためのConnインターフェースの実装です。

func DialUnix 

func DialUnix(network string, laddr, raddr *UnixAddr) (*UnixConn, error)

DialUnixは、UnixネットワークにおけるDialと同様の動作をします。

ネットワークはUnixネットワーク名でなければなりません。詳細についてはfunc Dialを参照してください。

laddrがnilでない場合、それは接続のローカルアドレスとして使用されます。

func ListenUnixgram 

func ListenUnixgram(network string, laddr *UnixAddr) (*UnixConn, error)

ListenUnixgramはUnixネットワーク用のListenPacketのように動作します。

ネットワークは"unixgram"である必要があります。

func (*UnixConn) CloseRead added in v1.1.0 

func (c *UnixConn) CloseRead() error

CloseReadは、Unixドメイン接続の読み込み側をシャットダウンします。 ほとんどの呼び出し元は、単にCloseを使用すべきです。

func (*UnixConn) CloseWrite added in v1.1.0 

func (c *UnixConn) CloseWrite() error

CloseWriteはUnixドメイン接続の書き込み側をシャットダウンします。 ほとんどの呼び出し元は、単にCloseを使用するだけで十分です。

func (*UnixConn) ReadFrom 

func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error)

ReadFromはPacketConnのReadFromメソッドを実装します。

func (*UnixConn) ReadFromUnix 

func (c *UnixConn) ReadFromUnix(b []byte) (int, *UnixAddr, error)

ReadFromUnixは、ReadFromと同様に動作しますが、UnixAddrを返します。

func (*UnixConn) ReadMsgUnix 

func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error)

ReadMsgUnix はcからメッセージを読み取り、そのペイロードをbに、 関連する帯域外データをoobにコピーします。bにコピーされたバイト数、oobに コピーされたバイト数、メッセージに設定されたフラグ、およびメッセージの 送信元アドレスを返します。

なお、len(b) == 0 かつ len(oob) > 0 の場合、この関数は依然として接続から 1バイトを読み取り(および破棄)ます。

func (*UnixConn) SyscallConn added in v1.9.0 

func (c *UnixConn) SyscallConn() (syscall.RawConn, error)

SyscallConnは生のネットワーク接続を返します。 これはsyscall.Connインターフェースを実装しています。

func (*UnixConn) WriteMsgUnix 

func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error)

WriteMsgUnixは、ペイロードのbと関連するオーバンドデータのoobから、cを介してaddrにメッセージを書き込みます。書き込まれたペイロードとオーバンドバイトの数を返します。 注意：len(b) == 0かつlen(oob) > 0の場合、この関数は依然として接続に1バイトを書き込みます。

func (*UnixConn) WriteTo 

func (c *UnixConn) WriteTo(b []byte, addr Addr) (int, error)

WriteToはPacketConnのWriteToメソッドを実装します。

func (*UnixConn) WriteToUnix 

func (c *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (int, error)

WriteToUnixはWriteToと同様に動作しますが、UnixAddrを取ります。

type UnixListener 

type UnixListener struct {
	// contains filtered or unexported fields
}

UnixListenerはUnixドメインソケットのリスナーです。クライアントは通常、Unixドメインソケットを想定せずに、Listenerの型の変数を使用するべきです。

func ListenUnix 

func ListenUnix(network string, laddr *UnixAddr) (*UnixListener, error)

ListenUnixはUnixネットワーク向けのListenのように機能します。

ネットワークは「unix」または「unixpacket」である必要があります。

func (*UnixListener) Accept 

func (l *UnixListener) Accept() (Conn, error)

AcceptはListenerインターフェースのAcceptメソッドを実装します。 返される接続は*UnixConn型です。

func (*UnixListener) AcceptUnix 

func (l *UnixListener) AcceptUnix() (*UnixConn, error)

AcceptUnixは次の着信呼び出しを受け入れ、新しい接続を返します。

func (*UnixListener) Addr 

func (l *UnixListener) Addr() Addr

Addrはリスナーのネットワークアドレスを返します。 返されるAddrは、Addrのすべての呼び出しで共有されるため、 変更しないでください。

func (*UnixListener) Close 

func (l *UnixListener) Close() error

CloseはUnixアドレス上でのリスニングを停止します。既に受け付けた接続は閉じません。

func (*UnixListener) File 

func (l *UnixListener) File() (f *os.File, err error)

File は基になる os.File のコピーを返します。 終了時には、f を閉じるのは呼び出し元の責任です。 l を閉じても f に影響を与えず、f を閉じても l に影響を与えません。

返された os.File のファイルディスクリプタは、接続のものとは異なります。 この複製を使用して元のもののプロパティを変更しようとしても、望ましい効果があるかどうかはわかりません。

func (*UnixListener) SetDeadline 

func (l *UnixListener) SetDeadline(t time.Time) error

SetDeadlineはリスナーと関連付けられた締め切りを設定します。 ゼロの時間値は締め切りを無効にします。

func (*UnixListener) SetUnlinkOnClose added in v1.8.0 

func (l *UnixListener) SetUnlinkOnClose(unlink bool)

SetUnlinkOnCloseは、リスナーがクローズされたときに基礎となるソケットファイルを ファイルシステムから削除するかどうかを設定します。

デフォルトの動作では、ソケットファイルは、package netによって作成された場合にのみ アンリンクされます。つまり、リスナーや基礎となるソケットファイルが ListenまたはListenUnixの呼び出しによって作成された場合、デフォルトでは リスナーをクローズするとソケットファイルが削除されます。 ただし、リスナーが既存のソケットファイルを使用するためにFileListenerを呼び出して作成された場合、 デフォルトではリスナーをクローズしてもソケットファイルは削除されません。

func (*UnixListener) SyscallConn added in v1.10.0 

func (l *UnixListener) SyscallConn() (syscall.RawConn, error)

SyscallConnは、生のネットワーク接続を返します。 これはsyscall.Connインターフェースを実装します。

返されるRawConnは、Controlの呼び出しのみをサポートします。 ReadとWriteはエラーを返します。

type UnknownNetworkError 

type UnknownNetworkError string

func (UnknownNetworkError) Error 

func (e UnknownNetworkError) Error() string

func (UnknownNetworkError) Temporary 

func (e UnknownNetworkError) Temporary() bool

func (UnknownNetworkError) Timeout 

func (e UnknownNetworkError) Timeout() bool

Source Files

View all Source files

Directories

Path Synopsis
Package http は HTTP クライアントとサーバーの実装を提供します。
 Package http は HTTP クライアントとサーバーの実装を提供します。
cgi
パッケージcgiは、RFC 3875で指定されているCGI（Common Gateway Interface）を実装しています。
 パッケージcgiは、RFC 3875で指定されているCGI（Common Gateway Interface）を実装しています。
cookiejar
Package cookiejar はメモリ内で RFC 6265 に準拠した http.CookieJar を実装します。
 Package cookiejar はメモリ内で RFC 6265 に準拠した http.CookieJar を実装します。
fcgi
Package fcgiはFastCGIプロトコルを実装します。
 Package fcgiはFastCGIプロトコルを実装します。
httptest
パッケージhttptestは、HTTPテストのためのユーティリティを提供します。
 パッケージhttptestは、HTTPテストのためのユーティリティを提供します。
httptrace
パッケージhttptraceは、HTTPクライアントリクエスト内のイベントをトレースするメカニズムを提供します。
 パッケージhttptraceは、HTTPクライアントリクエスト内のイベントをトレースするメカニズムを提供します。
httputil
Package httputilは、net/httpパッケージにある一般的なものと補完するHTTPユーティリティ関数を提供します。
 Package httputilは、net/httpパッケージにある一般的なものと補完するHTTPユーティリティ関数を提供します。
internal
Package internal contains HTTP internals shared by net/http and net/http/httputil.
 Package internal contains HTTP internals shared by net/http and net/http/httputil.
internal/ascii
internal/testcert
Package testcert contains a test-only localhost certificate.
 Package testcert contains a test-only localhost certificate.
pprof
パッケージpprofは、pprof可視化ツールが期待する形式で実行時プロファイリングデータをHTTPサーバー経由で提供します。
 パッケージpprofは、pprof可視化ツールが期待する形式で実行時プロファイリングデータをHTTPサーバー経由で提供します。
internal
socktest
Package socktest provides utilities for socket testing.
 Package socktest provides utilities for socket testing.
パッケージメールは、メールメッセージの解析を実装しています。
 パッケージメールは、メールメッセージの解析を実装しています。
パッケージnetipは、小さな値型であるIPアドレス型を定義します。
 パッケージnetipは、小さな値型であるIPアドレス型を定義します。
internal/intern
rpc
Package rpcは、オブジェクトのエクスポートされたメソッドに、ネットワークやその他のI/O接続を通じてアクセスする機能を提供します。
 Package rpcは、オブジェクトのエクスポートされたメソッドに、ネットワークやその他のI/O接続を通じてアクセスする機能を提供します。
jsonrpc
Package jsonrpc はRPCパッケージのためのJSON-RPC 1.0のClientCodecとServerCodecを実装します。
 Package jsonrpc はRPCパッケージのためのJSON-RPC 1.0のClientCodecとServerCodecを実装します。
smtp パッケージは RFC 5321 で定義されている Simple Mail Transfer Protocol を実装しています。
 smtp パッケージは RFC 5321 で定義されている Simple Mail Transfer Protocol を実装しています。
パッケージtextprotoは、HTTP、NNTP、およびSMTPのスタイルでテキストベースのリクエスト/レスポンスプロトコルの汎用サポートを実装します。
 パッケージtextprotoは、HTTP、NNTP、およびSMTPのスタイルでテキストベースのリクエスト/レスポンスプロトコルの汎用サポートを実装します。
Package urlはURLを解析し、クエリのエスケープを実装します。
 Package urlはURLを解析し、クエリのエスケープを実装します。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.