V/クイックツアー

Hello, World!

Vでの最もシンプルなプログラムから始めましょう。

fn main() {
    println('Hello, World!')
}

変数と基本型

Vでは変数はデフォルトでイミュータブルです。変更可能な変数にはmutキーワードが必要です。

name := 'V'            // イミュータブル文字列
mut age := 25             // ミュータブル整数
is_compiled := true       // 真偽値
height := 1.75           // 浮動小数点数
large_number := i64(123)  // 明示的な型指定

配列

配列は同じ型の要素を格納するデータ構造です。

numbers := [1, 2, 3, 4, 5]
mut fruits := ['りんご', 'みかん']
fruits << 'バナナ'  // 要素の追加

// 配列の反復
for fruit in fruits {
    println(fruit)
}

// インデックスも使用可能
for i, value in numbers {
    println('${i}: ${value}')
}

構造体

構造体は関連するデータをまとめる方法を提供します。

struct Point {
    x int
    y int
}

struct Rectangle {
mut:
    width  int    // 変更可能フィールド
    height int
pub:
    color  string // 公開フィールド
}

// 構造体の使用
point := Point{
    x: 10
    y: 20
}

mut rect := Rectangle{
    width: 100
    height: 200
    color: 'red'
}

rect.width = 150  // 変更可能

関数

関数はデフォルトで純粋関数として扱われます。

fn add(x int, y int) int {
    return x + y
}

// 複数の戻り値
fn divide(x int, y int) (int, int) {
    return x / y, x % y
}

// メソッド
fn (p Point) distance_from_origin() f64 {
    return math.sqrt(p.x * p.x + p.y * p.y)
}

// 使用例
sum := add(5, 3)
quotient, remainder := divide(10, 3)
dist := point.distance_from_origin()

オプション型

Vではnullの代わりにオプション型を使用します。

fn find_user(id int) ?User {
    if id == 0 {
        return none
    }
    return User{id: id}
}

// オプション型の使用
user := find_user(1) or {
    println('ユーザーが見つかりません')
    return
}

エラーハンドリング

エラーハンドリングはorブロックを使用します。

fn read_file(path string) !string {
    if !os.exists(path) {
        return error('ファイルが存在しません')
    }
    return os.read_file(path)!
}

// エラーハンドリング
content := read_file('config.txt') or {
    println('エラー: ${err}')
    return
}

並行処理

goキーワードで簡単に並行処理を実装できます。

fn expensive_task() int {
    time.sleep(2 * time.second)
    return 42
}

fn main() {
    handle := go expensive_task()
    println('他の処理を実行中...')
    result := handle.wait()
    println('結果: ${result}')
}

チャネルによる通信

スレッド間の通信にはチャネルを使用します。

fn sender(ch chan int) {
    for i in 0 .. 5 {
        ch <- i  // データ送信
    }
}

fn main() {
    ch := chan int{}
    go sender(ch)
    
    for i in 0 .. 5 {
        value := <-ch  // データ受信
        println(value)
    }
}

モジュールとインポート

コードは論理的な単位でモジュールに分割できます。

// math_utils.v
module math_utils

pub fn square(x int) int {
    return x * x
}

// main.v
import math_utils

fn main() {
    result := math_utils.square(5)
    println(result)
}

ジェネリクス

型パラメータを使用して汎用的なコードを書くことができます。

fn swap[mut a T, mut b T T] {
    temp := a
    a = b
    b = temp
}

mut x := 5
mut y := 10
swap(mut x, mut y)

インターフェース

インターフェースを使用して抽象化を実現できます。

interface Animal {
mut:
    speak() string
}

struct Dog {
mut:
    name string
}

fn (d Dog) speak() string {
    return 'わんわん'
}

struct Cat {
mut:
    name string
}

fn (c Cat) speak() string {
    return 'にゃーん'
}

// インターフェースの使用
fn make_noise(animal Animal) {
    println(animal.speak())
}

dog := Dog{'ポチ'}
cat := Cat{'タマ'}
make_noise(dog)
make_noise(cat)