Go言語で実現する可変戻り値の使い方について解説

package main
import (
	"fmt"
)
// add は2つの整数を受け取り、合計とエラーを返すサンプル関数です。
// エラーは、入力に負の値が含まれる場合に返します。
func add(a int, b int) (int, error) {
	if a < 0 || b < 0 {
		// 負の値が入力された場合、エラーを返す
		return 0, fmt.Errorf("負の値は受け付けません")
	}
	return a + b, nil
}
func main() {
	sum, err := add(10, 20)
	if err != nil {
		fmt.Println("エラー:", err)
	} else {
		fmt.Println("合計は", sum, "です。")
	}
}

合計は 30 です。

package main
import "fmt"
// multiply は2つの整数を掛け合わせた結果を返すサンプル関数です。
func multiply(a int, b int) (int, error) {
	// エラーがない場合はnilを返すのが一般的です
	return a * b, nil
}
func main() {
	// エラーは無視して積だけを使用する例です
	product, _ := multiply(5, 4)
	fmt.Println("積は", product, "です。")
}

積は 20 です。

package main
import "fmt"
// generateNumbers は引数 count に応じて整数のスライスを返す関数です。
func generateNumbers(count int) []int {
	numbers := make([]int, 0, count)
	for i := 1; i <= count; i++ {
		numbers = append(numbers, i)
	}
	return numbers
}
func main() {
	nums := generateNumbers(5)
	fmt.Println("生成された数字:", nums)
}

生成された数字: [1 2 3 4 5]

package main
import "fmt"
// Result は計算結果を表す構造体です。
type Result struct {
	Value int    // 計算結果の値
	Info  string // 補足情報
}
// compute は2つの整数を足し合わせ、結果を構造体で返す関数です。
func compute(a int, b int) Result {
	return Result{
		Value: a + b,
		Info:  "加算結果",
	}
}
func main() {
	res := compute(12, 18)
	fmt.Printf("結果: %d, 詳細: %s\n", res.Value, res.Info)
}

結果: 30, 詳細: 加算結果

package main
import "fmt"
// getValues は条件に応じて動的な整数値のスライスとエラーを返す関数です。
func getValues(param int) ([]int, error) {
	// param が負の場合、エラーを返す
	if param < 0 {
		return nil, fmt.Errorf("パラメータは正の値である必要があります")
	}
	// param の数だけの整数をスライスに追加する
	result := make([]int, param)
	for i := 0; i < param; i++ {
		result[i] = i * 2
	}
	return result, nil
}
func main() {
	values, err := getValues(4)
	if err != nil {
		fmt.Println("エラー:", err)
	} else {
		fmt.Println("生成された値:", values)
	}
}

生成された値: [0 2 4 6]

package main
import "fmt"
// processData は入力値が負の場合にエラーを返す関数です。
// 正常な場合は、計算結果をスライスとして返します。
func processData(value int) ([]int, error) {
	if value < 0 {
		return nil, fmt.Errorf("入力値は負の値ではありません")
	}
	// 複数の計算結果をスライスで返す
	results := []int{value, value * 2, value * 3}
	return results, nil
}
func main() {
	// 負の値を渡してエラーケースを確認する例です
	results, err := processData(-5)
	if err != nil {
		fmt.Println("エラー発生:", err)
		return
	}
	fmt.Println("処理結果:", results)
}

エラー発生: 入力値は負の値ではありません

package main
import "fmt"
// safeCompute は計算結果とエラーを返す関数です。
// 両方の入力が0の場合は、計算不可としてエラーを返します。
func safeCompute(a int, b int) (int, error) {
	if a == 0 && b == 0 {
		return 0, fmt.Errorf("両方の値が0の場合は計算不可です")
	}
	return a - b, nil
}
func main() {
	result, err := safeCompute(0, 0)
	if err != nil {
		fmt.Println("計算エラー:", err)
		return
	}
	fmt.Println("計算結果は", result, "です。")
}

計算エラー: 両方の値が0の場合は計算不可です

package main
import "fmt"
// optimizedValues は効率的に整数スライスを作成する関数です。
// 予め容量を設定することで、再アロケーションを最小限に抑えます。
func optimizedValues(count int) []int {
	values := make([]int, 0, count) // 予め容量を指定
	for i := 1; i <= count; i++ {
		values = append(values, i*i) // 平方値を計算して追加
	}
	return values
}
func main() {
	vals := optimizedValues(5)
	fmt.Println("最適化された値:", vals)
}

最適化された値: [1 4 9 16 25]

package main
import "fmt"
// checkBoundary は入力値に応じて異なる結果を返す関数です。
// 境界値として特別な処理を行っています。
func checkBoundary(value int) []int {
	if value <= 0 {
		return []int{0}
	}
	results := make([]int, 0, value)
	for i := 1; i <= value; i++ {
		results = append(results, i+10)
	}
	return results
}
func main() {
	// 境界値として0を入力した場合
	resZero := checkBoundary(0)
	fmt.Println("境界テスト (0):", resZero)
	// 通常の入力例
	resNormal := checkBoundary(3)
	fmt.Println("境界テスト (3):", resNormal)
}

境界テスト (0): [0]
境界テスト (3): [11 12 13]

package main
import "fmt"
// calculateResult は、2つの整数の平均値を計算して返す関数です。
// 変数名は、意味が明確になるように命名しています。
func calculateResult(a int, b int) float64 {
	sum := a + b
	average := float64(sum) / 2.0
	return average
}
func main() {
	avg := calculateResult(10, 20)
	fmt.Println("平均値は", avg, "です。")
}

平均値は 15 です。

package main
import (
	"fmt"
	"reflect"
)
// fetchData は、入力した数値に応じた文字列のスライスを返すサンプル関数です。
func fetchData(count int) []string {
	if count < 1 {
		return []string{"default"}
	}
	data := make([]string, count)
	for i := 0; i < count; i++ {
		data[i] = "データ" + fmt.Sprintf("%d", i+1)
	}
	return data
}
// simpleTest は、fetchData 関数の簡単なテストを行う関数です。
func simpleTest() {
	expected := []string{"データ1", "データ2"}
	result := fetchData(2)
	if reflect.DeepEqual(result, expected) {
		fmt.Println("ユニットテスト成功")
	} else {
		fmt.Println("ユニットテスト失敗")
	}
}
func main() {
	simpleTest()
}

ユニットテスト成功

package main
import "fmt"
// performOperation は、入力値が0の場合にエラーを返す関数です。
// 正常な場合は、計算結果を返します。
func performOperation(value int) (int, error) {
	if value == 0 {
		return 0, fmt.Errorf("ゼロは不正な入力です")
	}
	return 100 / value, nil
}
func main() {
	result, err := performOperation(0)
	if err != nil {
		fmt.Println("エラー対応:", err)
	} else {
		fmt.Println("オペレーション結果は", result, "です。")
	}
}

エラー対応: ゼロは不正な入力です