Scala 変数

変数は、コンピュータのメモリアドレスを参照するための便利なプレースホルダーであり、変数が作成されると一定のメモリ空間を占有します。

変数のデータ型に基づいて、オペレーティングシステムはメモリを割り当て、予約されたメモリに何を格納するかを決定します。したがって、変数に異なるデータ型を割り当てることで、これらの変数に整数、小数、または文字を格納できます。

変数宣言

変数と定数の宣言方法を学ぶ前に、まず変数と定数について理解しましょう。

  • 変数:プログラムの実行中に値が変化する可能性がある量を変数と呼びます。例:時間、年齢。
  • 定数:プログラムの実行中に値が変化しない量を定数と呼びます。例:数値 3、文字 'A'。

Scala では、キーワード"var"を使用して変数を宣言し、キーワード"val"を使用して定数を宣言します。

不変変数 (val):

  • 使用valキーワードで宣言された変数は不変であり、一度値を代入すると、その値を変更することはできません。
  • Java のfinal変数に似ています。

可変変数 (var):

  • 使用varキーワードで宣言された変数は可変であり、その値はプログラムのライフサイクル内で何度も変更できます。
  • Java の通常の変数に似ています。

変数宣言の例は次のとおりです:

var myVar : String = "Foo"
var myVar : String = "Too"

上記は変数 myVar を定義しており、それを変更できます。

定数宣言の例は次のとおりです:

val myVal : String = "Foo"

上記は定数 myVal を定義しており、これは変更できません。プログラムが定数 myVal の値を変更しようとすると、コンパイル時にエラーが発生します。


変数型宣言

変数の型は、変数名の後、等号の前に宣言します。変数の型を定義する構文は次のとおりです:

var VariableName : DataType [=  Initial Value]

或

val VariableName : DataType [=  Initial Value]

例

object VariableExample {
  def main(args: Array[String]): Unit = {
    // 不変変数の宣言
    val immutableVariable: Int = 10
    println(s"Immutable Variable: $immutableVariable")

    // 可変変数の宣言
    var mutableVariable: Int = 20
    println(s"Mutable Variable: $mutableVariable")

    // 可変変数の値を変更
    mutableVariable = 30
    println(s"Updated Mutable Variable: $mutableVariable")

    // 不変変数は再代入できないため、コンパイルエラーになります
    // immutableVariable = 15 // Uncommenting this line will cause a compilation error
  }
}

上記のコードを実行した出力結果は次のとおりです:

Immutable Variable: 10
Mutable Variable: 20
Updated Mutable Variable: 30

変数命名規則

有効な文字:

  • 変数名は、英字(A-Z または a-z)またはアンダースコア(_)で始まる必要があります。
  • 後続の文字は、英字、数字(0-9)、またはアンダースコアにすることができます。
  • 変数名は Scala のキーワードにすることはできません。

キャメルケース命名法:

  • 変数名は通常キャメルケースを使用します。つまり、最初の単語は小文字で始まり、後続の単語の先頭文字は大文字にします。
  • 例:myVariableName, userAge, accountBalance。

単一文字の変数名を避ける:

  • 一般的なカウンタ変数(例:i, j, k)を除き、コードの可読性を高めるために、単一文字の変数名の使用はできるだけ避けるべきです。

意味のある変数名:

  • 変数名はその用途や意味を明確に表す必要があり、曖昧または無意味な名前の使用は避けるべきです。
  • 例:val age: Int = 25より優れているval a: Int = 25。

Scala 固有の命名規則:

  • アンダースコアで始まる変数名はできるだけ使用しないでください。これは通常、内部またはプライベート変数を示すために使用されます。
  • 関数やメソッドの命名には文字と記号の組み合わせを使用できますが、変数命名ではほとんど見られません。
  • 演算子のような記号の組み合わせ(例:++,--)を変数名として使用することは避けてください。これによりコードが読みにくく、理解しにくくなります。

変数型の参照

Scala では、変数と定数の宣言時にデータ型を指定する必要はありません。データ型を指定しない場合、そのデータ型は変数または定数の初期値から推論されます。

したがって、データ型を指定せずに変数または定数を宣言する場合は、初期値を指定する必要があります。指定しないとエラーになります。

  • 明示的な型宣言:変数の型を明示的に指定します。
  • 型推論:型宣言を省略し、コンパイラが型を推論します。

Scala の型推論メカニズムは変数の型を自動的に決定できるため、型宣言を省略できます:

val inferredInt = 42  // 编译器推断为 Int
val inferredDouble = 3.14  // 编译器推断为 Double
val inferredString = "Hello, Scala!"  // 编译器推断为 String
val inferredBoolean = true  // 编译器推断为 Boolean

型推論によりコードはより簡潔になりますが、複雑なシナリオでは、型を明示的に宣言することで混乱を避けることができます。

型を明示的に宣言する場合、変数名の後にコロンとデータ型を続けます:

val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true

明示的な宣言は、コードの可読性と保守性を向上させるのに役立ちます。特に、型が推論しにくい場合や混乱しやすい場合に有効です。

例

object VariableTypesExample {
  def main(args: Array[String]): Unit = {
    // 明示的な型宣言
    val explicitInt: Int = 42
    val explicitDouble: Double = 3.14
    val explicitString: String = "Hello, Scala!"
    val explicitBoolean: Boolean = true

    // 型推論
    val inferredInt = 42  // コンパイラは Int と推論
    val inferredDouble = 3.14  // コンパイラは Double と推論
    val inferredString = "Hello, Scala!"  // コンパイラは String と推論
    val inferredBoolean = true  // コンパイラは Boolean と推論

    // 可変変数
    var mutableInt: Int = 10
    println(s"Initial mutableInt: $mutableInt")
    mutableInt = 20  // 変数の値を変更
    println(s"Updated mutableInt: $mutableInt")

    // すべての変数を出力
    println(s"Explicit Int: $explicitInt")
    println(s"Explicit Double: $explicitDouble")
    println(s"Explicit String: $explicitString")
    println(s"Explicit Boolean: $explicitBoolean")

    println(s"Inferred Int: $inferredInt")
    println(s"Inferred Double: $inferredDouble")
    println(s"Inferred String: $inferredString")
    println(s"Inferred Boolean: $inferredBoolean")
  }
}

上記のコードを実行した出力結果は次のとおりです:

Initial mutableInt: 10
Updated mutableInt: 20
Explicit Int: 42
Explicit Double: 3.14
Explicit String: Hello, Scala!
Explicit Boolean: true
Inferred Int: 42
Inferred Double: 3.14
Inferred String: Hello, Scala!
Inferred Boolean: true

Scala 複数変数の宣言

Scala では、複数の変数を同時に宣言できます。これによりコードがより簡潔になるだけでなく、複数の変数を同じ行で宣言する際の関連性も保証されます。

Scala では、カンマ区切り、タプル分解、for 内包表記などの方法を使用して、複数の変数を同時に宣言できます。

1 行でカンマ区切りを使用して複数の変数を宣言できます:

val xmax, ymax = 100  // xmax, ymax都声明为100

例

object MultipleVariables {
  def main(args: Array[String]): Unit = {
    // 複数の不変変数を同時に宣言
    val a, b, c: Int = 5
    println(s"a: $a, b: $b, c: $c")

    // 複数の可変変数を同時に宣言
    var x, y, z: Int = 10
    println(s"x: $x, y: $y, z: $z")

    // 可変変数の値を変更
    x = 20
    y = 30
    z = 40
    println(s"Updated x: $x, y: $y, z: $z")
  }
}

メソッドの戻り値がタプルの場合、val を使用してタプルを宣言できます:

scala> val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)

例

object TupleDestructuring {
  def main(args: Array[String]): Unit = {
    // タプル分解を使用して複数の変数を同時に宣言
    val (a, b, c) = (1, 2, "hello")
    println(s"a: $a, b: $b, c: $c")

    // タプル分解を使用して複数の可変変数を同時に宣言
    var (x, y, z) = (10, 20, "world")
    println(s"x: $x, y: $y, z: $z")

    // 可変変数の値を変更
    x = 30
    y = 40
    z = "Scala"
    println(s"Updated x: $x, y: $y, z: $z")
  }
}

for 内包表記を使用した複数変数の宣言

for 内包表記では、複数の変数を同時に宣言して、反復処理や新しいコレクションの生成に使用できます。

例

object ForComprehension {
  def main(args: Array[String]): Unit = {
    // 反復処理に使用する複数の変数を同時に宣言
    val numbers = List((1, "one"), (2, "two"), (3, "three"))
    for ((number, word) <- numbers) {
      println(s"Number: $number, Word: $word")
    }

    // for 内包表記を使用して新しいコレクションを生成
    val newNumbers = for {
      (number, word) <- numbers
    } yield (number * 2, word.toUpperCase)

    println(s"New Numbers: $newNumbers")
  }
}
その他の拡張