2018 년 46 주차 - 스칼라 입문 - 패턴 매 칭

패턴 매 칭 은 scala 에서 매우 특색 이 있 고 매우 강 한 작업 입 니 다. 패턴 매 칭 은 자바 의 switch 문법 과 유사 합 니 다. 즉, 하나의 값 을 판단 한 다음 에 서로 다른 조건 에 따라 서로 다른 처 리 를 합 니 다. 그러나 scala 의 모델 매 칭 기능 은 자바 의 switch 문법 보다 훨씬 강하 고 자바 의 값 만 매 칭 할 수 있 습 니 다.int 와 매 거 진 값 만 일치 할 수 있 습 니 다. 그러나 scala 의 패턴 은 값 을 일치 시 킬 수 있 을 뿐만 아니 라 다음 과 같은 일치 도 할 수 있 습 니 다.

유형 매 칭

Array 와 List 의 요소 상황 을 일치 시 킵 니 다

case class 매 칭

값 이 있 거나 없 거나 (Option) 일치 합 니 다.

간단 한 예
scala 는 자바 가 없 는 switch 문법 이지 만 더 강력 한 match 문법, 즉 패턴 매 칭 을 제공 합 니 다. match 문법 은 다음 과 같 습 니 다. 변수 명 match {case 값 = > 표현 식} 값 이 밑줄 이 라면 상기 모든 상황 에 만족 하지 않 는 기본 적 인 상황 처 리 를 표시 합 니 다. match 문법 에 서 는 하나의 case 분기 만 만족 하면 다음 case 가 지 를 계속 판단 하지 않 습 니 다. 이 점 은 자바 와 다 릅 니 다.break 로 인 한 bug 를 쓰 는 것 도 피 할 수 있 습 니 다.
예: 성적 평가

def judgeGrade(grade: String){
   grade match{
       case "A" => println("Excellent")
       case "B" => println("Good")
       case "C" => println("Just so so")
       case _ => println("you need work harder")
   }
}

패턴 매 칭 중 if 수위 사용
scala 의 패턴 매 칭 문법 은 케이스 후의 조건 판단 에서 하나의 값 만 제공 하 는 것 이 아니 라 값 뒤에 if 수 비 를 추가 하여 이중 여과 할 수 있다 는 특징 이 있 습 니 다. 예: 성적 평가 (업그레이드 버 전, 이름 에 따라 서로 다른 힌트 를 줄 수 있 습 니 다)

def judgeGrade(name:String, grade:String){
  grade match{
    case "A" => println(name+", you are excellent")
    case "B" => println(name+", you are good")
    case "C" if name == "jc" => println(name+", you are a good boy, come on")
    case "C" => println(name+", you are just so so") //            ,          jc
    case _ => println("you need to work harder")
  }
}

패턴 일치 에서 변수 할당
scala 의 패턴 매 칭 문법 은 패턴 이 일치 하 는 기본 상황, 밑줄 을 그 어 하나의 변수 이름 으로 바 꿀 수 있 습 니 다. 이때 패턴 매 칭 문법 은 일치 하 는 값 을 이 변수 에 부여 하여 뒤의 처리 문 에서 일치 하 는 값 을 사용 할 수 있 습 니 다. 예: 성적 평가 (업그레이드 판, 이름 에 따라 서로 다른 힌트 를 주 고 성적 을 가 져 올 수 있 습 니 다)

def judgeGrade(name:String, grade:String){
  grade match{
    case "A" => println(name+", you are excellent")
    case "B" => println(name+", you are good")
    case "C" => println(name+", you are just so so")
    case _actualGrade if name == "jc" => println(name+", you are a good boy, come on, your grade is "+_actualGrade)
    case _actualGrade => println("you need to work harder, your grade is"+_actualGrade)
  }
}

형식 일치
scala 의 패턴 이 일치 하 는 강력 한 기능 중 하 나 는 바로 유형 을 직접 일치 시 킬 수 있다 는 것 이다.
예외 처리

import java.io_
def processException(){
  e match{
     case e1: IllegalArgumentException=> println("that has illegal arguments! exception is: "+e1)
     case e2: FileNotFoundException=> println("can not find the file! exception is: "+e2)  
     case e3: IOException=> println("you got an IOException")
     case _: Exception=>println("I have not idea what exception is")
  }
}

위 에 있 는 '패턴 일치 값 일치' 와 비교 해 야 합 니 다. 차이 점 을 알 고 있 습 니 다. 일치 값 은 case 값 = > 표현 식 이 고 일치 하 는 유형 은 case 변수: 형식 = > 표현 식 입 니 다. 따라서 일치 하 는 유형 은 기본 값 으로 변 수 를 할당 할 수 있 습 니 다. 일치 하 는 값 은 밑줄 로 새로운 변 수 를 정의 해 야 합 니 다.
Array 와 List 모드 일치
Array 를 패턴 매 칭 합 니 다. 지정 한 요 소 를 가 진 배열 과 일치 할 수 있 습 니 다. 지정 한 요소 의 개 수 를 가 진 배열 입 니 다. 특정한 요소 로 시작 하 는 배열 을 지정 하여 List 를 패턴 매 칭 할 수 있 습 니 다. Array 와 유사 하지만 List 특유 의: 연산 자 가 필요 합 니 다.
예: 친구 에 게 인사

def greeting(peoples: Array[String]){
  peoples match{
     case Array("jc")=> println("Hi, jc!")
     case Array(girl1, girl2, girl3)=> println("Hi, girls, nice to meet you. "+girl1+" and "+girl2+" and "+ girl3) 
     case Array("jc",_*)=> println("Hi, jc, please introduce your friends to me.")
     case _=> println("hey guys, who are you!")
  }
}

var a = Array("jc")
greeting(a)
a = Array("jc","jay","jack")
greeting(a)
a = Array("jc","jay","jack","john")
greeting(a)
a = Array("jay","jack","john","johnny")
greeting(a)


def greeting(peoples: List[String]){
  peoples match{
     case "jc"::Nil=> println("Hi, jc!")
     case girl1::girl2::girl3::Nil=> println("Hi, girls, nice to meet you. "+girl1+" and "+girl2+" and "+girl3) 
     case "jc"::tail=> println("Hi, jc, please introduce your friends to me.")
     case _=> println("hey guys, who are you!")
  }
}


var a = List("jc")
greeting(a)
a = List("jc","jay","jack")
greeting(a)
a = List("jc","jay","jack","john")
greeting(a)
a = List("jay","jack","john","johnny")
greeting(a)

위의 두 가지 기능 은 모두 같 습 니 다. 케이스 문 구 는 각각 하나의 기능 입 니 다. jc 요소 만 있 고 3 개의 요소 의 집합, jc 요소 의 선두, 다른 상황 입 니 다.
case class 가 패턴 과 일치 합 니 다.
scala 는 특별한 피 로 를 제공 합 니 다. 바로 case class 의 클래스 를 사용 하 는 것 입 니 다. 이러한 종 류 를 샘플 류 라 고 합 니 다. 샘플 류 는 엄격 한 정의 의 자바 빈 과 유사 합 니 다. field 만 정의 하고 scala 에서 컴 파일 할 때 getter 와 setter 방법 을 자동 으로 제공 하지만 다른 방법 이 없습니다. 그 밖 에 scala 는 샘플 류 에 동반 대상, 즉 object 를 자동 으로 정의 하고 apply 방법 을 정의 합 니 다.이 apply 방법의 매개 변 수 는 주 구조 함수 의 매개 변수 와 마찬가지 로 병 은 사례 류 로 되 돌아 갑 니 다. 쉽게 말 하면 사례 류 는 정의 류 와 예화 류 의 문법 을 간소화 합 니 다.
학교 방송

class Person
case class Teacher(name:String, subject:String) extends Person
case class Student(name:String, classroom:String) extends Person

def broadcast(p: Person){
  p match{
   case Teacher(name, subject)=> println(" "+subject+" "+name+"         ")
   case Student(name, classroom)=> println(classroom+name+"       ")
   case _=>println("    ")
  }
}

val t = Teacher("   ","  ")
val s = Student("   ","   ")
broadcast(t)
broadcast(s)

옵션 과 패턴 일치
scala 는 Option 이 라 고 하 는 특수 한 유형 이 있 습 니 다. Option 은 두 개의 값 이 있 습 니 다. 하 나 는 Some 이 고 값 이 있 는 것 을 의미 하 며 하 나 는 None 이 고 값 이 없 는 것 을 의미 합 니 다.
option 은 보통 패턴 매 칭 에 사 용 됩 니 다. 특정한 변수 가 값 이 있 는 지 없 는 지 판단 하 는 데 사 용 됩 니 다. 이것 은 null 에서 온 것 보다 더욱 의미 화 됩 니 다. 예: 성적 조회

val  grades = Map("jc"->"A","jay"->"B","jack"->"M")
def getGrade(name:String){
   var grade = grades.get(name)
   grade match{
     case Some(grade)=> println("Hi "+name+", your grade is "+grade)
     case None=> println("Sorry "+name+", your grade is not in the system.")
   }
}  
getGrade("jc")
getGrade("jay")
getGrade("jack")
getGrade("john")