코드스피츠90 - 코틀린 1회차 정리

본 글은 코드스피츠90 - 코틀린을 보고 정리한 글입니다.

---

코틀린은 원시형의 개념을 사용하지 않고 기본형을 정의한다.

basic type - number, Boolean, character, string, array

코드에서는 무조건 래퍼형으로 표현하고, 컴파일러가 컨텍스트와 플랫폼에 따라 래퍼형 또는 원시형 중 유리한 것으로 변환한다.

• 코틀린에서는 복사냐 레퍼런스냐의 문제보다 불변성을 갖는 형이냐 아니냐가 중요하다.
  number, Boolean, character, string: 불변형으로 복사이든, 레퍼런스든 별 상관없음

-> 플랫폼 별 가장 효율적인 번역은 코틀린이 알아서 한다.

---

코틀린의 내장형(built-in type)

Any - 모든 형의 부모

Nothing - 모든 형의 자식이자 제어흐름의 종결을 형으로 표현함

Unit - 없음을 나타내는 형이자 싱글톤 객체

Throwable - 모든 예외의 부모

Function - 함수를 나타내는 형

KClass, KCallable Kproperty, KFunction, KType - 리플렉션 타입

---

코드 작성 시 유의사항

deny list보다 accept list로 짜기

val : 값(value)
var : 변수(variable)
const val : 상수(constant)

한 줄에 하나만 작성 가능

val a,b,c (x)
val a (o)

이름 : 타입 = 값

val a:Int = 3
var b:String = "abc"

리터럴

'...' : Char literal
"..." : String literal
"""...""" : no escaping, newlines (엔터를 쳐도 됨)

[...] : Character Class
[^...] : Exception Character Class
\d : 0,1,2,3,4,5,6,7,8,9

val trim = """[^.\d-+/]"""
except
. 0 1 2 3 4 5 6 7 8 9 - + * /

---

함수 작성 시 유의사항

• 서비스 레이어를 개발할때, 형 추론보다 반환형을 표시하는 게 좋다.

정규식

(...) : capture group
(?:...) : non-capture group
(..|..) : alternative
? : zero or one = {0,1}
+ : one or unlimited = {1,}

람다

fun delegate(a:Int, b:(Int)->Int):Int{
	return b(a)
}

Passing trailing lambdas: 람다 표현식( {}을 괄호 밖으로 꺼내는 방식)

delegate(3, {it * 3})
delegate(3){it*3}
# 둘은 같은 표현!

MatchResult.groupValues = 
List<String>(전체, 그룹1, 그룹2, 그룹3..)

Destructuring

내부에 N번째 반환할 값을 정의

when(대상){
  값1->
  값2->{...}
  ...
  else->
}
  
v:T = when(대상){
  값1->T
  값2->{
  ...
  T
 }
 ...
 else->T
}

---

계산기 코드

val trim = """[^.\d-+*/()]""".toRegex()

fun trim(v:String):String{
    return v.replace(trim, "")
}
fun repMtoPM(v:String) = v.replace("-", "+-")
val groupMD = """((?:\+|\+-)?[.\d]+)([*/])((?:\+|\+-)?[.\d]+)""".toRegex()

// 차원을 줄이는 행위는 fold
// findall 은 sequence를 리턴
// Passing Trail Lambdas

fun foldGroup(v:String):Double = groupMD.findAll(v).fold(0.0){ acc, curr->
    val (_, left, op, right) = curr.groupValues
    val leftValue = left.replace("+", "").toDouble()
    val rightValue = right.replace("+", "").toDouble()
    val result = when(op){
        "*"->leftValue * rightValue
        "/"->leftValue / rightValue
        else-> throw Throwable("invalid operator $op")
    }
    acc + result
}

fun calc(v:String) = foldGroup( repMtoPM(trim(v)))