Go/uint8

Goのuint8について

Goにおけるuint8は8ビット符号なし整数型を表す組み込み型です。1バイトのサイズを持ち、0から255までの値を格納できます。

基本情報

uint8は8ビット（1バイト）の符号なし整数型
値の範囲: 0 から 255 (2^8-1)
byte型はuint8のエイリアスであり、同じ型として扱われる
メモリ上での表現: 8ビット

他のキーワードとの組み合わせ

変数宣言との組み合わせ

var age uint8 = 25
count := uint8(100) // 型推論による短縮形
b := byte(255)      // byte型（uint8のエイリアス）

定数定義との組み合わせ

const MAX_LEVEL uint8 = 99
const COLOR_RED uint8 = 255

関数パラメータと戻り値

func incrementByte(value uint8) uint8 {
    return value + 1
}

func getRedComponent() uint8 {
    return 240
}

型変換

i := 42
b := uint8(i) // int から uint8 への変換（値が範囲外の場合は切り捨て）

f := 250.99
b2 := uint8(f) // float から uint8 への変換（小数点以下切り捨て）

c := 'A'
b3 := uint8(c) // runeからuint8への変換（ASCII値）

配列とスライス

var pixels [100]uint8 // uint8型の固定長配列
buffer := make([]uint8, 1024) // uint8型のスライス（バイトバッファ）
bytes := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f} // byteはuint8のエイリアス

マップ

colorValues := make(map[string]uint8)
colorValues["red"] = 255
colorValues["green"] = 128
colorValues["blue"] = 64

構造体のフィールド

type Color struct {
    R uint8
    G uint8
    B uint8
    A uint8
}

type Flag struct {
    IsActive uint8 // 0または1の値を持つフラグ（Goではbool型を使うのが一般的）
}

ビット操作

var flags uint8 = 0
// ビットをセット
flags |= 1 << 3
// ビットをクリア
flags &^= 1 << 2
// ビットをチェック
if (flags & (1 << 3)) != 0 {
    fmt.Println("3番目のビットがセットされています")
}

一般的なユースケース

バイナリデータ処理

   data := []uint8{0x48, 0x65, 0x6c, 0x6c, 0x6f} // "Hello"のASCII値
   fmt.Println(string(data)) // バイト列を文字列に変換

カラー情報の格納（RGB値）

   type RGB struct {
       Red   uint8
       Green uint8
       Blue  uint8
   }
   
   purple := RGB{
       Red:   128,
       Green: 0,
       Blue:  128,
   }

ファイルI/O操作

   file, err := os.Open("example.txt")
   if err != nil {
       log.Fatal(err)
   }
   defer file.Close()
   
   buffer := make([]uint8, 1024)
   n, err := file.Read(buffer)

ネットワーク通信

   conn, err := net.Dial("tcp", "example.com:80")
   if err != nil {
       log.Fatal(err)
   }
   defer conn.Close()
   
   buffer := make([]uint8, 1024)
   n, err := conn.Read(buffer)

ビットマスクとフラグ

   const (
       FLAG_READ  uint8 = 1 << 0 // 0000 0001
       FLAG_WRITE uint8 = 1 << 1 // 0000 0010
       FLAG_EXEC  uint8 = 1 << 2 // 0000 0100
   )
   
   var permissions uint8 = FLAG_READ | FLAG_WRITE
   
   // 読み取り権限があるかチェック
   if permissions&FLAG_READ != 0 {
       fmt.Println("読み取り可能")
   }

ASCIIテキスト処理

   message := "Hello"
   for i := 0; i < len(message); i++ {
       char := message[i] // uint8型（byte型）
       if char >= 'a' && char <= 'z' {
           // 小文字を大文字に変換
           char = char - 32
       }
       fmt.Printf("%c", char)
   }

画像処理

   type GrayscaleImage struct {
       Width  int
       Height int
       Pixels []uint8
   }
   
   func createGrayscaleImage(w, h int) GrayscaleImage {
       return GrayscaleImage{
           Width:  w,
           Height: h,
           Pixels: make([]uint8, w*h),
       }
   }

ハッシュ計算とチェックサム

   package main
   
   import (
       "crypto/md5"
       "fmt"
   )
   
   func main() {
       data := []byte("Hello, World!")
       sum := md5.Sum(data)
       // sum は [16]byte 型（[16]uint8と同じ）
       fmt.Printf("%x\n", sum)
   }

uint8とbyte型の関係

// これらは同じ型として扱われる
var b1 byte = 100
var b2 uint8 = b1 // 型変換不要

注意点

オーバーフロー: 最大値（255）を超えると、0に戻ります（ラップアラウンド）
```
   var x uint8 = 255
   x++ // x は 0 になる
```
負の値: 負の値を代入しようとするとコンパイルエラーになります
```
   var b uint8 = -1 // コンパイルエラー
```

範囲外の値: 代入時に自動的に切り捨てられます

   var b uint8 = 300 // 300は255を超えるので、44になる（300 % 256 = 44）

文字列操作: 文字列はUTF-8エンコードされるため、非ASCII文字を扱う場合は注意が必要です

   s := "こんにちは"
   b := s[0] // 最初のバイトを取得（日本語はマルチバイト文字なので一文字ではない）

uint8（byte）型を適切に使用することで、バイナリデータ処理やメモリ効率の最適化が可能になりますが、値の範囲制限には常に注意が必要です。