Hello, world!
Hello, Golang!

package main

import (
	"fmt"
	"log"
	"os"
)

func main() {
	// open file
	f, err := os.Open("./test.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	// read file
	buf := make([]byte, 1024)
	count, err := f.Read(buf) // reader to buf
	if err != nil {
		log.Fatal(err)
	}

	// output
	str := string(buf[:count])
	fmt.Printf("read %d bytes: %q\n", count, buf[:count])
	fmt.Println(str)

	/*
	read 28 bytes: "Hello, world!\nHello, Golang!"
	Hello, world!
	Hello, Golang!
	*/
}

package main

import (
	"fmt"
	"log"
	"os"
)

func main() {
	// create file
	f, err := os.Create("./file_io_write.txt")
	// f, err := os.Open("./file_io_write.txt")
	/* os.Open だと書き込み権限がないため、以下のようなランタイムエラーが発生する
	error: write ./file_io_write.txt: bad file descriptor
	*/
	if err != nil {
		fmt.Println(err)
		return
	}
	// defer f.Close()
	defer func() {
		err := f.Close()
		if err != nil {
			fmt.Println(err)
		}
	}()

	// write file
	str := "Write this file by Golang!\nHello, world!\nHello, Golang!"
	data := []byte(str)
	count, err := f.Write(data) // buf to writer
	if err != nil {
		fmt.Println(err)
		return
	}

	// output
	fmt.Printf("write %d bytes\n", count)

	/* 出力結果
	write 55 bytes
	*/
}

func (f *File) Close() error

f, err := os.Create("write.txt")
if err != nil {
	fmt.Println("cannot open the file")
}
- defer f.Close()
+ defer func(){
+	err := f.Close()
+	if err != nil {
+		fmt.Println(err)
+	}
+ }()
// 以下write処理等を書く

// Close closes the File, rendering it unusable for I/O.
// On files that support SetDeadline, any pending I/O operations will
// be canceled and return immediately with an ErrClosed error.
// Close will return an error if it has already been called.
func (f *File) Close() error {
	if f == nil {
		return ErrInvalid
	}
	return f.file.close()
}

func (file *file) close() error {
        // file が nil ならエラーを返す
	if file == nil {
		return syscall.EINVAL // src/syscall/zerrors_darwin_arm64.go で定数で定義されている
	}

        // ディレクトリ情報のクローズ（ファイルがディレクトリの場合の特別な処理）
	if file.dirinfo != nil {
		file.dirinfo.close()
		file.dirinfo = nil
	}

        // ！！！！！ここがファイルを閉じるメインの処理！！！！！
        // ファイルディスクリプタのクローズ
	var err error
	if e := file.pfd.Close(); e != nil {
		if e == poll.ErrFileClosing {
			e = ErrClosed
		}
		err = &PathError{Op: "close", Path: file.name, Err: e}
	}

	// no need for a finalizer anymore
	runtime.SetFinalizer(file, nil)
	return err
}

// Close closes the FD. The underlying file descriptor is closed by the
// destroy method when there are no remaining references.
func (fd *FD) Close() error {
	if !fd.fdmu.increfAndClose() {
		return errClosing(fd.isFile)
	}

	// Unblock any I/O.  Once it all unblocks and returns,
	// so that it cannot be referring to fd.sysfd anymore,
	// the final decref will close fd.sysfd. This should happen
	// fairly quickly, since all the I/O is non-blocking, and any
	// attempts to block in the pollDesc will return errClosing(fd.isFile).
	fd.pd.evict()

	// The call to decref will call destroy if there are no other
	// references.
	err := fd.decref()

	// Wait until the descriptor is closed. If this was the only
	// reference, it is already closed. Only wait if the file has
	// not been set to blocking mode, as otherwise any current I/O
	// may be blocking, and that would block the Close.
	// No need for an atomic read of isBlocking, increfAndClose means
	// we have exclusive access to fd.
	if fd.isBlocking == 0 {
		runtime_Semacquire(&fd.csema)
	}

	return err
}

// src/os/types.go: os.File
type File struct {
	*file // os specific
}

// src/os/file_unix.go: os.file
type file struct {
	pfd         poll.FD
	name        string
	dirinfo     *dirInfo // nil unless directory being read
	nonblock    bool     // whether we set nonblocking mode
	stdoutOrErr bool     // whether this is stdout or stderr
	appendMode  bool     // whether file is opened for appending
}

// src/internal/poll/fd_unix.go: poll.FD
// FD is a file descriptor. The net and os packages use this type as a
// field of a larger type representing a network connection or OS file.
type FD struct {
	// Lock sysfd and serialize access to Read and Write methods.
	fdmu fdMutex

	// System file descriptor. Immutable until Close.
	Sysfd int

	// I/O poller.
	pd pollDesc

	// Writev cache.
	iovecs *[]syscall.Iovec

	// Semaphore signaled when file is closed.
	csema uint32

	// Non-zero if this file has been set to blocking mode.
	isBlocking uint32

	// Whether this is a streaming descriptor, as opposed to a
	// packet-based descriptor like a UDP socket. Immutable.
	IsStream bool

	// Whether a zero byte read indicates EOF. This is false for a
	// message based socket connection.
	ZeroReadIsEOF bool

	// Whether this is a file rather than a network socket.
	isFile bool
}

// src/internal/poll/fd_unix.go: FD.Read
// Read implements io.Reader.
func (fd *FD) Read(p []byte) (int, error) {
	if err := fd.readLock(); err != nil {
		return 0, err
	}
	defer fd.readUnlock()
	if len(p) == 0 {
		// If the caller wanted a zero byte read, return immediately
		// without trying (but after acquiring the readLock).
		// Otherwise syscall.Read returns 0, nil which looks like
		// io.EOF.
		// TODO(bradfitz): make it wait for readability? (Issue 15735)
		return 0, nil
	}
	if err := fd.pd.prepareRead(fd.isFile); err != nil {
		return 0, err
	}
	if fd.IsStream && len(p) > maxRW {
		p = p[:maxRW]
	}
	for {
		n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
		if err != nil {
			n = 0
			if err == syscall.EAGAIN && fd.pd.pollable() {
				if err = fd.pd.waitRead(fd.isFile); err == nil {
					continue
				}
			}
		}
		err = fd.eofError(n, err)
		return n, err
	}
}

// src/internal/poll/fd_unix.go: ignoringEINTRIO
// ignoringEINTRIO is like ignoringEINTR, but just for IO calls.
func ignoringEINTRIO(fn func(fd int, p []byte) (int, error), fd int, p []byte) (int, error) {
	for {
		n, err := fn(fd, p)
		if err != syscall.EINTR {
			return n, err
		}
	}
}