7장 built in control structures

스칼라의 제어구문(syntax) : if, while, for, try, match, 함수호출
Scala의 대부분의 제어 구문은 값을 반환함. <- functional language들이 이렇게 동작한다고 함.
Java의 ternary operator인 ? 의 경우, Scala의 if로 대체 가능함. 이는 if나 else블럭의 마지막 평가값이 return되기 때문으로 이해했음. 이런 형태를 취함으로써 임시 변수의 필요성을 줄일 수 있다고 함.

int a = 1 > 10 ? 1 : 0; //java
val a:Int = if( 1 > 10 ) 1 else 0 //scala

scala> val k = try { val a = 1; }  
k: Unit = () 

scala> val a = 1 match { case 1 => 1; case 2 => 2; }
a: Int = 1

7.1 If expressions

일반적인 if문의 기능을 수행한다.

val filename = 
  if (!args.isEmpty) args(0)
  else "default.txt"

var보다 val을 사용하면 좋은점.
- 자바의 final변수처럼 사용할 수 있다.
- 등식추론에 더 도움이 된다. "equational reasoning"
- 읽기도 쉽고 리팩토링하기도 쉽다.

7.2 While loops

일반적인 while문의 기능을 수행한다.

def gcdLoop(x: Long, y: Long): Long = {
  var a = x
  var b = y
  while (a != 0) {
    val temp = a
    a = b % a
    b = temp
  }
  b
}

do-while문도 있다.

var line = ""
do {
  line = readLine()
  println("Read: " + line)
} while (line != "")

while과 do-while은 반환형이 Unit이기 때문에 표현식이 아니라 루프라고 한다.

scala> val a = while( false) { }
a: Unit = ()

Unit타입이 반환하는 값은 unit value라고 하며 ()로 표기한다.
- 자바와는 다르다.
- 자바의 void와는 다르게 함수의 값을 비교할 수 있다.
- 대입식을 비교하는 구문으로 사용하면 루프를 쓰지 말아야 한다.
  (대입하면 스칼라에서는 결과가 unit value, ()라서 ""이 될 수 없다. > 무한루프로 빠진다. pg.118)
while문 대신 함수형으로 재귀호출을 쓸 수 있다.
java의 할당문은 할당된 값을 반환하지만, Scala의 할당문은 Unit 값을 반환함.

//java
public class A {
  public static void main(String[] args)
  {
    String a = null;
    System.out.println( a= "a");
    }
  }
// a //실행결과

//scala
scala> val a = { val b = 3; }
a: Unit = ()

7.3 For expressions

scala의 for문은 상당히 강력하다.
collection iteration

val filesHere = (new java.io.File(".")).istFiles
for (file <- filesHere)
  println(file)

* `file <- filesHere`부분을 generator라보 부르고 콜렉션 요소로 반복문을 수행한다.
* `Range`를 사용해서 `for`문을 사용할 수 있다.

scala> for (i <- 1 to 4) println("Iteration " + i)
Iteration 1
Iteration 2
Iteration 3
Iteration 4
scala> for (i <- 1 until 4) println("Iteration " + i)
Iteration 1
Iteration 2
Iteration 3

스칼라에서 정수를 반복하는 일반적인 방법.

// Not common in Scala....
for (i <- 0 to filesHere.length - 1)
  println(filesHere(i))

스칼라에서는 켈럭션에서 직접 반복을 할 수 있기 때문에 거의 사용되지 않는 방법
Filtering
- for문 안에 if절을 넣어 필터링을 할 수 있다.
- for문은 표현식.(타입을 가진 콜렉션이 결과값으로 나오기 때문)

val filesHere = (new java.io.File(".")).istFiles
for (file <- filesHere if file.getName.endsWith(".scala"))
  println(file)
// 다음과 동일하다.
for (file <- filesHere)
  if (file.getName.endsWith(".scala"))
    println(file)

* 필터링이 여러개 필요하면 필요한 만큼 쭉 if 를 붙이면 됨. && 로 덧붙이는 게 아님.

for (
  file <- filesHere
  if file.isFile
  if file.getName.endsWith(".scala")
) println(file)

* _질문:  && 로 덧붙이는 것이랑 if 를 여러개 붙이는 것이랑 차이가 있을까?_ -> 별 차이 없는 듯 한데.

scala> val a = for( i <- 1 to 10 ; if i %2 == 0 ;  if i %3 == 0 ) yield i
a: scala.collection.immutable.IndexedSeq[Int] = Vector(6)
scala> val a = for( i <- 1 to 10 ; if i %2 == 0 && i %3 == 0 ) yield i
a: scala.collection.immutable.IndexedSeq[Int] = Vector(6)

Nested iteration
- <-절을 추가하여 중첩루프로 쓸 수 있다.

def fileLines(file: java.io.File) = scala.io.Source.fromFile(file).getLines().toList
def grep(pattern: String) =
  for (
    file <- filesHere
    if file.getName.endsWith(".scala");;
    line <- fileLines(file)
    if line.trim.matches(pattern)
  ) println(file + ": " + line.trim)
grep(".*gcd.*")

* `{}`를 `()`대신 쓸 수도 있다.(`{}`를 쓰면 `;`을 안써도 된다.)

Mid-stream variable bindings
- 반복되는 표현식이의 계산을 한번만 하고 싶다면 =를 사용해서 새로운 변수에 바인딩할 수 있다. 여기서 바인딩된 변수는 val은 없지만 val처럼 사용한다.

def fileLines(file: java.io.File) = scala.io.Source.fromFile(file).getLines().toList
def grep(pattern: String) =
  for (
    file <- filesHere
    if file.getName.endsWith(".scala");;
    line <- fileLines(file)
    trimmed = line.trim
    if trimmed.matches(pattern)
  ) println(file + ": " + trimmed)
grep(".*gcd.*")

Producing a new collection
- 지금까지는 반복문만 순회했지만 각 반복에서 생성된 값을 yield를 사용해서 생성할 수 있다.

for clauses yield body

def scalaFiles =
  for {
    file <- filesHere
    if file.getName.endsWith(".scala")
  } yield file

* [yield에 대한 토론](http://stackoverflow.com/questions/1052476/can-someone-explain-scalas-yield)

7.4 Exception handling with try expressions

예외를 던지는 것은 자바와 동일하다.

throw new IllegalArgumentException

throw도 결과값을 가지는 표현식이고 기술적으로는 throw는 Nothing타입이 된다. 어떤 타입도 될 수 있으며 이 반환값을 사용할 수는 없다. --> 이건 126pg 에서 else 문에 throw가 들어가도 문법에 어긋나지 않음을 설명하기 위함이라고 봄.
catch절은 패턴매칭을 이용해서 예외를 처리한다.

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

try {
  val f = new FileReader("imput.txt")
} catch {
  case ex: FileNotFoundException => // handle missing file
  case ex: IOException => //Handle other I/O error
}

* 스칼라는 throws 절에서 checked exception를 잡거나 선언하도록 하지 않는다. 필요하다면 `@throws` 어노테이션으러 선언할 수 있다.

filnally로 구문이 종료되는 것과 상관없이 항상 수행되어야 하는 코드를 처리한다. 자바랑 다를 바 없는 듯. 9.4절에 나오는 loan pattern을 고려할 수 있다고 함.
예외가 던져졌는데 catch되지 앟으면 표현식의 결과값은 없다.
try, catch, finally도 value를 반환함. (java랑 다름!) 다만 finally의 평가 결과는 무시됨. 따라서 finally에서 명시적으로 return을 하지 않는 이상 finally의 평가 값은 버려짐.

7.5 Match expressions

switch문처럼 여러 대안을 선택할 수 있다.(int, enum만 쓸 수 있는 java의 switch 보다 훨씬 강력)
default는 _
자바의 switch문과는 다르다.
- 다양한 종류의 타입을 쓸 수 있다.
- break가 없다.(case 뒤에 break;를 붙일 필요 없음. 무조건 break.)
- 값이 도출된다.

대상 match {
  case 1 => expr1
  case 2 => expr2 ...
  case _ => default
}

match 표현식도 값을 반환함.

###7.6 Living without break and continue

스칼라에는 break와 continue가 없다.
boolean 타입의 필드를 사용하면 break, continue를 쓰지 않을 수 있음.
모든 continue는 if문으로 break문은 boolean값으로 바꿀 수 있다.

// This is Java
int i = 0;
boolean foundIt = false;
while (i < args.length) {
  if (args[i].startsWith("-")) {
    i = i + 1;
    continue;
  }
  if (args[i].endsWith(".scala"")) {
    foundIt = true;
    break;
  }
  i = i + 1;
}

// looping without break or continue
var i = 0
var foundIt = false

while (i < args.length && !foundIt) {
  if (!args(i).startsWith("-")) {
    if (args(i).endsWith(".scala"))
      foundIt = true
  }
  i = i + 1
}

// 재귀로 다시 구현
def searchFrom(i: Int): Int =
  if (i >= args.length) -1
  else if (args(i).startsWith("-")) searchFrom(i + 1)
  else if (args(i).endsWith(".scala")) i
  else searchFrom(i + 1)

val i = searchFrom(0)

필요하다면 scala.util.control패키지에 있는 Breaks클래스에서 break메소드를 제공한다.
Breaks클래스는, breakable메소드에서 처리하는 예외를 던져서 break를 구현한다.

import scala.util.control.Breaks._
breakable {
  while (true) {
    if () break
  }
}

Breaks

###7.7 Variable scope

변수를 선언하면 변수는 scope를 가지며 일반적으로 {}가 새로운 범위를 갖는다.
같은 scope에서는 동일한 이름의 변수를 쓸 수 없다. 단, 하위 scope에 상위 scope에 이미 선언된 변수를 선언할 수 있음(java에선 안됨).
repl 에서 중복 선언이 가능한 것도 이런 특성에 기인함. repl에선 매 문장마다 nested scope를 만들기 때문이라 함

val a = 1;
{
  val a = 2;
  {
    // ...
  }
}

외부의 변수와 같은 이름인 내부변수를 shadow라고 부른다.
변수는 새 이름으로 의미있게!

7.8 Refactoring imperative-style code

imperative 코드를 functional하게 바꿔보자.

// imperative style
def printMultiTable() {
  var i = 1
  while (i <= 10) {
    var j = 1
    while (j <= 10) {
      val prod = (i * j).toString
      var k = prod.length
      while (k < 4) {
        println(" ")
        k += 1
      }
      print(prod)
      j += 1
    }
    println()
    i += 1
  }
}

// funtinal style
def makeRowSeq(row: Int) =
  for (col <- 1 to 10) yield {
    val prod = (row * col).toString
    val padding = " " * (4 - prod.length)
    padding + prod
  }

def makeRow(row: Int) = makeRowSeq(row).mkString

def multiTable() = {
  val tableSeq =
    for (row <- 1 to 10)
    yield makeRow(row)
  tableSeq.mkString("\n")
}

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

7장 built in control structures

7.1 If expressions

7.2 While loops

7.3 For expressions

7.4 Exception handling with try expressions

7.5 Match expressions

7.8 Refactoring imperative-style code

Clone this wiki locally