Binary World

유용한 윈도우 단축키 모음집.zip

모쿠 — Wed, 6 Jan 2021 10:22:54 +0900

- 윈도우키 + 숫자키 : 작업 표시줄 프로그램을 숫자 번호대로 실행

- 윈도우키 + R : 실행창 열기

- 윈도우키 + E : 탐색기창 열기

- 윈도우키 + D : 모든 화면 내리기

- 윈도우키 + 방향키 : 현재 프로그램 창 위치 조정

- 윈도우키 + TAB : 모든 창 한 번에 보기

- 윈도우키 + X : 각종 기능 빠르게 보기

클래스와 상속(Classes and Inheritance)

모쿠 — Fri, 31 May 2019 16:33:06 +0900

<클래스(Classes)>

코틀린에서 클래스는 class 키워드를 사용한다.

class Invoice {...}

클래스 선언은 클래스 이름, 클래스 헤더(타입 매개 변수, 기본 생성자 등), 클래스 본문, 괄호로 구성된다. 헤더와 본문은 선택적이다. 클래스가 본문이 없다면 괄호는 제거된다.

class Empty

생성자(Constructors)

코틀린에서 클래스는 기본 생성자와 하나 이상의 보조 생성자를 가질 수 있다. 기본 생성자는 클래스 헤더의 일부다 : 클래스 이름 뒤에 위치.

class Person constructor(firstName: String) { ... }

만약 기본 생성자에 특정 어노테이션 또는 접근 제한자가 없으면, constructor 키워드는 제거된다.

class Person(firstName: String) { ... }

기본 생성자는 어떤 코드도 포함하지 않는다. 초기화 코드는 초기화 블록에 놓을 수 있고, 이 접두사에는 init 키워드가 붙는다.

인스턴스 초기화 중에, 초기화 블록이 실행된다. 초기화 블록은 클래스 본문에 나타내는 순서와 동일하게 실행되고, 속성 초기화 값을 인터리브한다.

class InitOrderDemo(name: String) {
    val firstProperty = "First property: $name".also(::println)
    
    init {
        println("First initializer block that prints ${name}")
    }
    
    val secondProperty = "Second property: ${name.length}".also(::println)
    
    init {
        println("Second initializer block that prints ${name.length}")
    }
}

fun main() {
    InitOrderDemo("hello")
}

/* 출력 결과 */
First property: hello
First initializer block that prints hello
Second property: 5
Second initializer block that prints 5

기본 생성자의 매개 변수는 초기화 블록에서 사용될 수 있다. 또한, 클래스 본문에 선언된 속성 초기화 변수에 사용될 수 있다.

class Customer(name: String) {
    val customerKey = name.toUpperCase()
}

사실, 코틀린에서는, 기본 생성자로부터 속성 선언과 초기화를 위해 간결한 문구를 사용할 수 있다.

class Person(val firstName: String, val lastName: String, var age: Int) { ... }

정규 속성들과 거의 같은 방식으로, 기본 생성자에서 속성 선언은 var(변수) 또는 val(읽기 전용)으로 한다.

생성자가 어노테이션 또는 접근 제한자를 갖는다면, constructor 키워드가 필요하다.

class Customer public @Inject constructor(name: String) { ... }

보조 생성자(Secondary Constructors)

contstructor 접두사를 사용하여, 보조 생성자를 선언할 수 있다.

class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}

클래스가 기본 생성자를 갖는다면, 다른 보조 생성자(들)을 통해 직접 또는 간접적으로, 각 보조 생성자가 기본 생성자에 위임을 해야 한다. 같은 클래스의 다른 생성자로 위임은 this 키워드를 사용한다.

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

초기화 블록의 코드는 효과적으로 기본 생성자의 일부가 된다. 기본 생성자에 대한 위임은 보조 생성자의 첫 번째 상태로 발생하므로, 초기화 블록의 코드는 보조 생성자의 본문보다 먼저 실행된다. 기본 생성자가 없더라도, 위임은 여전히 발생되며, 초기화 블록 역시 실행된다.

class Constructors {
    init {
        println("Init block")
    }

    constructor(i: Int) {
        println("Constructor")
    }
}

fun main() {
    Constructors(1)
}

/* 출력 결과 */
Init block
Constructor

추상화 클래스가 아닌 클래스가 어떤 생성자도 생성하지 않으면, 매개 변수가 없는 기본 생성자를 생성한다. 생성자의 접근 상태는 public으로 된다. 클래스가 public 생성자를 갖는 것을 원치 않는다면, 기본 접근 제한자 외에 제한자를 갖는 빈 기본 생성자를 선언해야 한다.

class DontCreateMe private constructor () { ... }

클래스의 인스턴스 생성(Creating instance of classes)

클래스의 인스턴스를 생성하기 위해, 정규 함수의 생성자를 호출해 보자.

val invoice = Invoice()

val customer = Customer("Joe Smith")

참고 : new 키워드를 사용하지 않는다.

클래스 멤버(Class Members)

클래스는 아래 항목들을 포함한다.

생성자와 초기화 블록
함수
속성들
중복 클래스와 내부 클래스
객체 선언

<상속(Inheritance)>

코틀린에서 모든 클래스는 공통의 상위클래스 any를 갖는다. 이것은 상위타입 선언이 되지 않은 기본 슈퍼클래스다.

class Example // Any로 부터 암묵적인 상속

명시적으로 상위 타입을 선언하려면, 클래스 헤더에 콜론을 사용한 후 타입을 명시한다.

open class Base(p: Int)

class Derived(p: Int) : Base(p)

클래스가 기본 생성자를 갖지 않는다면, 각 보조 생성자들은 super 키워드를 사용하여 초기화되거나, 다른 생성자로 위임된다. 서로 다른 보조 생성자들은 기본 타입의 다른 생성자들을 호출할 수 있다.

class MyView : View {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

오버라이딩 메소드(Overriding Methods)

자바와 다르게, 코틀린은 오버라이드될 멤버와 오버라이드에 명시적 수식어를 요구한다.

open class Base {
    open fun v() { ... }
    fun nv() { ... }
}
class Derived() : Base() {
    override fun v() { ... }
}

override로 표시된 멤버는 열린 형태가 된다. 이 멤버는 하위클래스에서도 오버라이드 가능하다. 만약 오버라이딩을 금지하려면 final을 사용한다.

open class AnotherDerived() : Base() {
    final override fun v() { ... }
}

속성 오버라이딩(Overriding Properties)

속성 오버라이딩은 메소드 오버라이딩과 비슷하게 작동된다. 파생된 클래스에서 재정의된 상위클래스에서 선언된 속성은 overrride로 우선 적용되어야 하며, 호환 가능한 타입이어야 한다.

open class Foo {
    open val x: Int get() { ... }
}

class Bar1 : Foo() {
    override val x: Int = ...
}

var 속성으로 val 속성을 오버라이드 할 수 있다. val 속성이 기본적으로 getter 메소드를 선언하고, 이를 var로 오버라이드하면 setter 메소드를 추가로 선언하기 때문이다.

참고 : override 키워드는 기본 생성자에서도 사용이 가능하다.

interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}

파생 클래스 초기화 순서(Derived class initialization order)

파생된 클래스의 새로운 인스턴스의 구성 중에, 기본 클래스 초기화는 첫 단계로 수행된다. 따라서, 파생된 클래스의 초기화 논리가 실행되기 전에 수행된다.

open class Base(val name: String) {

    init { println("Initializing Base") }

    open val size: Int = 
        name.length.also { println("Initializing size in Base: $it") }
}

class Derived(
    name: String,
    val lastName: String
) : Base(name.capitalize().also { println("Argument for Base: $it") }) {

    init { println("Initializing Derived") }

    override val size: Int =
        (super.size + lastName.length).also { println("Initializing size in Derived: $it") }
}

fun main() {
    println("Constructing Derived(\"hello\", \"world\")")
    val d = Derived("hello", "world")
}

/* 출력 결과 */
Constructing Derived("hello", "world")
Argument for Base: Hello
Initializing Base
Initializing size in Base: 5
Initializing Derived
Initializing size in Derived: 10

상위 클래스 구현 호출(Calling the superclass implementation)

파생 클래스의 코드는 super 키워드를 사용하여 상위 클래스 함수 및 속성 접근자를 구현할 수 있다.

open class Foo {
    open fun f() { println("Foo.f()") }
    open val x: Int get() = 1
}

class Bar : Foo() {
    override fun f() { 
        super.f()
        println("Bar.f()") 
    }
    
    override val x: Int get() = super.x + 1
}

내부 클래스 안에서는, 외부 클래스의 상위 클래스 접근은 외부 클래스 이름으로 지정된 super 키워드를 사용한다: super@Outer

class Bar : Foo() {
    override fun f() { /* ... */ }
    override val x: Int get() = 0
    
    inner class Baz {
        fun g() {
            super@Bar.f() // Foo의 f() 실행 호출
            println(super@Bar.x) // Foo의 x getter 실행 호출
        }
    }
}

오버라이딩 규칙(Overriding Rules)

다양한 클래스에서 상속 할 때, 멤버 이름이 동일한 경우에는 이 멤버를 재정의하는 방법을 제공한다. 상속된 구현으로부터 상위타입을 나타내려면, 다음과 같은 표현을 사용한다 : super<Base>

open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // 인터페이스 멤버는 open이 기본 상태이다.
    fun b() { print("b") }
}

class C() : A(), B {
    // f() 함수 오버라이드가 필요하다.
    override fun f() {
        super<A>.f() // call to A.f()
        super<B>.f() // call to B.f()
    }
}

추상 클래스(Abstract Classes)

일부 클래스와 멤버들은 abstract로 선언될 수 있다. 추상 멤버는 해당 클래스에 구현되지 않는다.

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

함수(Functions)

모쿠 — Thu, 30 May 2019 16:30:11 +0900

함수 선언(Function Declarations)

fun 키워드를 사용해서 함수를 선언한다.

fun double(x: Int): Int {
    return 2 * x
}

함수 사용(Function Usage)

함수 호출은 일반적인 방법을 사용한다.

val result = double(2)

멤버 함수 호출은 점(.) 표기법을 사용한다.

Sample().foo() // 클래스의 인스턴스를 생성하고 foo()를 호출

매개 변수(Parameters)

함수 매개 변수 파스칼 표기법(이름 : 타입)을 사용하여 정의된다. 매개 변수는 쉼표(,)를 이용하여 구분된다. 각 매개 변수는 명시적 타입으로 선언되어야 한다.

fun powerOf(number: Int, exponent: Int) { ... }

기본 인자 값(Default Arguments)

함수 매개 변수는 기본 값을 가질 수 있고, 인자 값이 생략될 때 사용된다. 다른 언어와 비교해서 과부하를 더 줄일 수 있다.

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) { ... }

기본 값은 '= after 타입'을 사용하여 정의된다.

오버라이딩 메소드는 항상 기초 메소드와 같은 기본 매개 변수 값을 사용한다. 오버라이딩 메소드가 기본 매개 변수 값을 가질 때, 기본 매개 변수 값은 제거된다.

open class A {
    open fun foo(i: Int = 10) { ... }
}

class B : A() {
    override fun foo(i: Int) { ... }  // 기본 값을 허용하지 않는다.
}

기본 값이 없는 매개 변수 앞에 기본 값이 있는 매개 변수가 있는 경우, 기본 값은 명명된 매개 변수를 포함한 함수에서만 사용된다.

fun foo(bar: Int = 0, baz: Int) { ... }

foo(baz = 1) // 기본 값 bar = 0이 사용된다.

기본 매개 변수 뒤에 마지막 매개 변수가 람다 표현식인 경우, 명명된 인자 값 또는 괄호 외부로 전달될 수 있다.

fun foo(bar: Int = 0, baz: Int = 1, qux: () -> Unit) { ... }

foo(1) { println("hello") }     // 기본 값 baz = 1 사용
foo(qux = { println("hello") }) // 기본 값 bar = 0 와 baz = 1 둘 다 사용 
foo { println("hello") }

명명된 인자 값(Named Arguments)

함수를 호출할 때, 매개 변수의 이름을 지정할 수 있다. 함수에 많은 수의 매개 변수 또는 기본 매개 변수가 있는 경우 매우 편리하다.

fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
...
}

기본 인자 값을 사용해서 다음과 같이 호출할 수 있다.

reformat(str)

기본 값이 아닌 값으로 호출 할 때, 다음과 같이 사용한다.

reformat(str, true, true, false, '_')

명명된 인수를 사용하면 코드를 훨씬 쉽게 읽을 수 있다.

reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
)

일부 인자 값만 사용하는 방법은 다음과 같다.

reformat(str, wordSeparator = '_')

호출 f(1, y = 2) 허용되고, f(x = 1, 2)는 허용되지 않는다. 즉, 명명된 인자 값 앞에 위치 인자 값이 있어야 한다.

가변 인자(vararg)는 스프레드(spread) 연산자를 사용한 명명된 형식으로 전달될 수 있다.

fun foo(vararg strings: String) { ... }

foo(strings = *arrayOf("a", "b", "c"))

참고 : 명명된 인자 값은 자바 함수 호출에서 사용할 수 없다. 자바 바이트 코드는 함수 매개 변수의 이름을 항상 유지하지 않기 때문이다.

단위 반환 함수(Unit-returning functions)

함수가 유용한 값을 반환하지 않으면, 리턴 타입은 Unit이 된다. Unit은 하나의 값만 있는 유형이다. 이 값을 명시적으로 반환할 필요는 없다.

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` 또는 `return` 선택이다.
}

Unit 리턴 타입 또한 선택이다. 아래 코드는 위와 같다.

fun printHello(name: String?) { ... }

단일 표현식 함수(Single-Expression functions)

함수가 단일 표현을 리턴할 때, 중괄호는 생략할 수 있고 본문은 =기호에 저장된다.

fun double(x: Int): Int = x * 2

리턴 타입이 컴파일러에 의해 추정되면, 명시적 리턴 타입 선언은 선택이다.

fun double(x: Int) = x * 2

명시적 리턴 타입(Explicit return types)

블록 본문을 갖는 함수는 항상 특정 리턴 타입을 명시해야 한다. 코틀린은 블록 본문이 있는 함수의 반환 형식을 추정하지 않는다. 이러한 함수는 본문에서 복잡한 제어 흐름을 가질 수 있고, 반환 형식이 명확하지 않기 때문이다.

가변 인자(Variable number of arguments : varargs)

함수의 매개 변수(보통 마지막 매개 변수)는 varargs 수식어로 표시된다.

fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts는 배열이다.
        result.add(t)
    return result
}

가변 인자가 함수에 전달되도록 허용된다.

val list = asList(1, 2, 3)

함수 내에서 T타입의 vararg-매개 변수는 T의 배열로 볼 수 있다. 위 코드에서, ts 변수는 Array<out T> 타입을 갖는다.

오직 하나의 매개 변수만 vararg로 표시될 수 있다. vararg 매개 변수가 목록의 마지막 매개 변수가 아니면, 다음 매개 변수의 값은 명명된 인자 값 구문을 사용하거나, 매개 변수가 함수 타입이거나, 괄호 밖에서 람다 표현식을 통과시킴으로써 전달할 수 있다.

vararg 함수를 호출할 때, 인자를 하나씩 전달할 수 있다. 예) asList(1, 2, 3). 이미 배열이 있고, 그 내용을 함수에 전달하려면, 스프레드 연산자(배열 접두사 *)를 사용한다.

val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

중위 표기법(Infix notation)

infix 키워드로 표시되는 함수는 중위 표기법 사용으로 호출할 수 있다. (호출을 위해 점과 괄호를 생략)

중위 표기법은 아래 요구사항을 만족해야 한다.

멤버 함수나 확장 함수이다.
단일 매개 변수이다.
매개 변수가 가변 인자(varargs)를 허용하지 않고, 기본 값을 갖지 않는다.

infix fun Int.shl(x: Int): Int { ... }

// 중위 표기법을 사용한 함수 호출
1 shl 2

// 위와 같은 방법
1.shl(2)

* 중위 함수의 우선순위

중위 함수는 산술 연산자, 형 변환, rangeTo 연산자 보다 우선순위가 낮다. 예시는 아래와 같다.

1 shl 2 + 3 and 1 shl (2 + 3)
0 until n * 2 and 0 until (n * 2)
xs union ys as Set<*> and xs union (ys as Set<*>)

논리 연산자보다는 우선순위가 높다. 예시는 아래와 같다.

a && b xor c and a && (b xor c)
a xor b in c and (a xor b) in c

참고 : 중위 함수는 항상 수신자와 매개 변수를 지정해줘야 한다. 중위 표기법을 사용해서 현재 수신자를 메소드를 부를 경우, this를 사용해야 한다. 정규 표현식과는 다르게 this는 제거될 수 없다.

class MyStringCollection {
    infix fun add(s: String) { ... }
    
    fun build() {
        this add "abc"   // 정확
        add("abc")       // 정확
        add "abc"        // 부정확 : 수신자를 명식해야한다.
    }
}

지역 함수(Local Functions)

코틀린은 지역 함수를 지원한다. 지역 함수는 다른 함수 안에 함수가 들어가는 형태다.

fun dfs(graph: Graph) {
    fun dfs(current: Vertex, visited: Set<Vertex>) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v, visited)
    }

    dfs(graph.vertices[0], HashSet())
}

지역 함수는 외부 함수의 지역 변수(즉, 클로저)에 액세스 할 수 있다.

fun dfs(graph: Graph) {
    val visited = HashSet<Vertex>()
    fun dfs(current: Vertex) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v)
    }

    dfs(graph.vertices[0])
}

멤버 함수(Member Functions)

멤버 함수는 클래스 또는 객체 내부에 정의되는 함수이다.

class Sample() {
    fun foo() { print("Foo") }
}

점 표기법을 사용해서 호출한다.

Sample().foo() // Sample 클래스의 인스턴스를 생성하고 foo를 호출

제네릭 함수(Generic Functions)

함수는 함수 이름 앞에 단일 꺽쇠 괄호(<>)를 사용하여 지정된 제네릭 매개 변수를 가질 수 있다.

fun <T> singletonList(item: T): List<T> { ... }

인라인 함수(Inline Functions)

- 다른 챕터에서 작성

확장 함수(Extension Functions)

- 다른 챕터에서 작성

고차 함수와 람다 함수(Higher-Order Functions and Lambdas)

- 다른 챕터에서 작성

리턴과 점프(Returns and Jumps)

모쿠 — Wed, 29 May 2019 17:19:17 +0900

코틀린은 세 개의 구조적 점프 표현식이 있다:

return. 기본적으로, 가장 인접한 둘러싸인 함수 또는 익명 함수로부터 반환된다.
break. 가장 인접한 둘러싸인 반복을 종료한다.
continue. 가장 인접한 둘러싸인 반복의 다음 단계를 진행한다.

모든 표현식은 더 큰 표현식의 일부로 사용 가능하다.

val s = person.name ?: return

Break와 Continue 라벨(Labels)

코틀린에서 label로 표시되는 표현들이 있다. 레이블은 식별자로 @를 사용한다. 예시: abc@, fooBar@. 표현식에 라벨을 추가하려면, 표현식의 앞에 사용한다.

loop@ for (i in 1..100) {
    // ...
}

break 또는 continue에 라벨을 붙일 수 있다.

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (...) break@loop
    }
}

라벨이 붙여진 break는 loop@가 표시된 곳으로 이동한 후에 실행된다. continue는 해당 루프의 다음 반복으로 진행된다.

라벨에서 리턴(Return at Labels)

코틀린에서, 함수 리터럴, 지역 함수, 객체 표현식, 함수는 중복될 수 있다. return은 외부 함수에서 반환할 수 있도록 허용한다. 가장 중요한 사용하는 경우는 람다 표현식에서 리턴하는 것이다.

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return // foo()의 호출자에 직접적으로 리턴
        print(it)
    }
    println("this point is unreachable")
}

fun main() {
    foo()
}

/* 출력 결과 */
12

람다 표현식에서 리턴을 하고 싶다면, 아래와 같이 라벨을 붙인다.

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        if (it == 3) return@lit // local return to the caller of the lambda, i.e. the forEach loop
        print(it)
    }
    print(" done with explicit label")
}

/* 출력 결과 */
1245 done with explicit label

람다 표현식 내에 함수를 라벨 이름으로 사용할 수 있다.

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // local return to the caller of the lambda, i.e. the forEach loop
        print(it)
    }
    print(" done with implicit label")
}

fun main() {
    foo()
}

/* 출력 결과 */
1245 done with implicit label

다음과 같은 방법도 가능하다.

fun foo() {
    run loop@{
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@loop // 람다 표현식을 지나서 run 위치에서 리턴
            print(it)
        }
    }
    print(" done with nested loop")
}

fun main() {
    foo()
}

/* 출력 결과 */
12 done with nested loop

값을 리턴할 때, 파서(parser)는 자격이 있는 리턴에 우선권을 부여한다.

return@a 1

"라벨 @a에 1을 리턴"한다는 의미

제어 흐름(Control Flow)

모쿠 — Tue, 28 May 2019 22:12:19 +0900

If 표현식

Kotlin에서 if는 표현식이다. 즉, 값을 반환한다. 그러므로 삼중 연산자 (condition? then : else)가 없다. 왜냐하면 if가이 역할을 잘 수행하기 때문이다.

// 기존 사용법
var max = a 
if (a < b) max = b

// else를 사용하여 
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}
 
// 표현식으로
val max = if (a > b) a else b

if분기가 블록 일 수 있고, 마지막 표현식이 블록의 값인 경우

val max = if (a > b) {
    print("Choose a")
    a
} else {
    print("Choose b")
    b
}

When 표현식

when은 C언어 계열의 스위치 연산자를 대신한다. 가장 간단한 형태로 보면 다음과 같다.

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> {
        print("x is neither 1 nor 2")
    }
}

when은 분기 조건이 충족될 때까지 모든 분기에 대한 인수 값을 순차적으로 찾는다. when은 표현식이나 명령문으로 사용될 수 있다. 표현식으로 사용되면 만족 된 분기의 값이 전체 표현식의 값이 된다. 명령문으로 사용되면 개별 분기의 값은 무시된다.

다른 분기 조건이 충족되지 않으면 else 분기가 평가된다. 컴파일러가 가능한 모든 경우가 분기 조건으로 덮여 있다는 것을 증명할 수 없다면, 표현식으로 when을 사용하면 else 분기는 필수 조건이다.

많은 경우가 동일한 방식으로 처리되어야하는 경우, 분기 조건은 쉼표로 결합할 수 있다.

when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

분기 조건으로 임의의 표현식 (상수뿐만 아니라)을 사용할 수 있다.

when (x) {
    parseInt(s) -> print("s encodes x")
    else -> print("s does not encode x")
}

범위의 in 또는 !in 또는 컬렉션에 존재하는 값을 확인할 수 있다.

when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

is 또는 !is를 이용하여 값이 특정 유형인지 확인이 가능하다. 스마트 캐스트(Smart cast) 덕분에, 추가 검사 없이 타입의 메소드 및 속성에 접근할 수 있다.

fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}

when은 if-else 체인의 대체용으로도 사용할 수 있다. 인수 값이 제공되지 않으면 분기 조건은 단순히 논리식이 되고, 조건이 참일 때 분기가 실행된다.

when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

Kotlin 1.3 이후, 다음과 같은 구문을 사용하여 when의 주체 변수를 얻을 수 있다.

fun Request.getBody() =
        when (val response = executeRequest()) {
            is Success -> response.body
            is HttpError -> throw HttpException(response.status)
        }

변수의 범위에서, when의 주체는 when 몸체로 제한된다.

For 반복

for 반복은 반복자를 제공하는 모든 것을 반복한다. 이것은 C# 같은 언어의 foreach 루프와 동일하다. 구문은 다음과 같다.

for (item in collection) print(item)

몸체는 블록화 될 수 있다.

for (item: Int in ints) {
    // ...
}

앞서 언급했듯이, for는 반복자를 제공하는 모든 것들을 통해 반복된다. 아래 예시가 있다.

iterator() 멤버 또는 확장 함수를 갖고 있고, 이는 리턴 타입이 존재
- next() 멤버 또는 확장 함수를 갖고 있고,
- 부울을 리턴하는 hasNext() 멤버 또는 확장 함수를 갖고 있다.

위의 세 가지 함수는 operator로 표시되어야 한다.

범위 표현을 사용하여, 숫자의 범위 내에 반복하기:

fun main() {
    for (i in 1..3) {
        println(i)
    }
    for (i in 6 downTo 0 step 2) {
        println(i)
    }
}

/* 출력 결과 */
1
2
3
6
4
2
0

범위 또는 배열에 대한 for 반복은 반복자 객체를 만들지 않는 인덱스 기반 반복으로 컴파일된다.

인덱스가 있는 배열이나 목록을 반복 할 경우 다음과 같이 할 수 있다.:

fun main() {
val array = arrayOf("a", "b", "c")
    for (i in array.indices) {
        println(array[i])
    }
}

/* 출력 결과 */
a
b
c

또는, withIndex 라이브러리 함수를 사용할 수 있다.

fun main() {
    val array = arrayOf("a", "b", "c")
    for ((index, value) in array.withIndex()) {
        println("the element at $index is $value")
    }
}

/* 출력 결과 */
the element at 0 is a
the element at 1 is b
the element at 2 is c

While 반복

while 과 do..while 다른 언어와 같이 동작한다.

while (x > 0) {
    x--
}

do {
    val y = retrieveData()
} while (y != null) // y는 여기서 보인다!

패키지와 임포트(Packages and Imports)

모쿠 — Tue, 28 May 2019 20:50:44 +0900

패키지(Packages)

소스 파일은 패키지 선언으로 시작할 수 있다.

package foo.bar

fun baz() { ... }
class Goo { ... }

// ...

소스 파일의 모든 내용들(클래스와 함수 같은)은 선언된 패키지에 포함된다. 따라서, 위의 예제에서 baz()의 전체 이름은 foo.bar.baz이고, Goo()의 전체 이름은 foo.bar.Goo

패키지가 명시되지 않았다면, 파일의 내용들은 "default" 패키지에 속해있는 것이다.

디폴트 임포트(Default Import)

다수의 패키지가 모든 코틀린 파일에 기본적으로 포함되어 있다.

kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.* (since 1.1)
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*

추가적인 패키지는 타깃 플랫폼에 따라 임포트 한다.

VM:
- java.lang.*
- kotlin.jvm.*
JS:
- kotlin.js.*

임포트(Imports)

디폴트 임포트와 별개로, 각 파일들은 자신의 임포트 경로를 갖고 있다. 임포트를 위한 구문은 문법에서 표현된다.

단일 이름으로 임포트 하거나,

import foo.Bar // Bar는 현재 자격에 상관없이 모두 접근 가능

범위의 모든 접근 가능한 내용(package, class, object etc)을 임포트 할 수 있다.

import foo.* // 'foo'에 모든 것들을 접근 가능

이름이 충돌한다면, as 키워드를 이용해 지역 내에 새로 이름을 생성하여 모호성을 제거한다.

import foo.Bar // Bar는 접근 가능
import bar.Bar as bBar // bBar는 'bar.Bar'를 나타냄

import 키워드는 클래스 임포트만 국한되지 않는다. 다른 선언을 가져오는데도 사용 가능하다.

최상위 함수와 속성들;
객체 선언에서 선언된 함수와 속성들;
enum 상수.

자바와 다르게, 코틀린은 별도의 "import static" 구문을 갖고 있지 않다. 모든 선언들은 정규 import 키워드를 사용하여 임포트 된다.

최상위 선언의 가시성(Visibility of Top-Level Declarations)

최상위 선언이 private로 표시되면, 선언된 파일은 비공개가 된다.

기본 타입(Basic Type)

모쿠 — Tue, 28 May 2019 18:09:31 +0900

코틀린에서 모든 것은 객체다. 변수에 대한 멤버 함수와 호출할 수 있다는 의미에서 모든 것은 객체다.

일부 유형은 특수한 내부 표현을 할 수 있다. 예를 들어, 숫자, 문자, 논리(boolean)는 런타임에서 기본 값(primitive value)으로 나타낼 수 있다. 하지만, 사용자에게는 보통의 클래스로 보인다. 이 섹션에서는 숫자, 문자, 부울, 배열 및 문자열과 같은 Kotlin에서 사용되는 기본 유형을 설명한다.

숫자(Numbers)

코틀린에서 숫자는 자바와 유사하게 다뤄지지만, 완벽히 같지는 않다. 예를 들어, 숫자에 대한 암묵적인 확장 변환이 없고, 상수가 같은 케이스에서 약간 다르다.

코틀린은 다음과 같은 타입 표현을 갖는다.(자바랑 같음):

Type	Bit width
Double	64
Float	32
Long	64
Int	32
Short	16
Byte	8

참고) 코틀린에서 문자는 숫자가 아니다.

리터럴 상수(Literal Constants)

리터럴은 자료를 알 수 있는 표기 형식을 말한다. 아래는 정수 값에 대한 리터럴 상수의 종류다:

십진법: 123
- Long타입은 끝에 문자L을 붙임 : 123L
16진법: 0x0F
Binaries: 0b00001011

참고: 8진법은 지원하지 않음.

부동 소수점을 위한 기존 표기법도 지원한다:

Doubles by default: 123.5, 123.5e10
Floats은 끝에 문자 f 또는 F를 붙임: 123.5f

숫자 리터럴에서 밑줄(Underscore)

밑줄을 사용하여 숫자 상수를 더 쉽게 읽을 수 있다.:

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

표현법(Representation)

자바 플랫폼에서, null 가능한 정수 참조 (예 : Int?)가 필요하지 않거나, generics이 포함되지 않는다면, 숫자는 JVM 기본 타입으로 물리적으로 저장된다. 후자의 경우, 숫자는 박싱 된다.

박싱 된 숫자는 특징을 보존할 필요가 없음을 참고:

fun main() {
    val a: Int = 10000
    println(a === a) 
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a
    println(boxedA === anotherBoxedA)
}

/* 출력 */
true
false

반면에, 아래 표현은 같음을 표기한다.:

fun main() {
    val a: Int = 10000
    println(a === a) // 'true' 출력
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a
    println(boxedA === anotherBoxedA) // 'false' 출력
}

/* 출력 결과 */
true
true

명시적 전환(Explicit Conversions)

서로 다른 표현법 때문에, 작은 타입은 큰 타입의 서브타입이 아니다.:

// 가상의 코드. 실제로 컴파일 하지 않음:
val a: Int? = 1 // 박싱된 Int (java.lang.Integer)
val b: Long? = a // 명시적 형변환 산출. 박싱된 Long (java.lang.Long)
print(b == a) // 이 출력은 "false"가 된다. Integer와 Long은 갖지 않다.

결과적으로, 더 작은 타입을 더 큰 타입으로 암묵적으로 변경할 수 없다. 즉, 명시적 변환 없이 Int 변수에 Byte 타입의 값을 할당할 수 없다.

fun main() {
    val b: Byte = 1 // 리터럴 상수 체크됨
    val i: Int = b // 에러
}

숫자를 확장하기 위해 명시적 형 변환을 사용 가능하다.

fun main() {
    val b: Byte = 1
    val i: Int = b.toInt() // 명식적으로 확대되었기 때문에 가능
    print(i)
}

/* 출력 결과 */
1

모든 숫자 타입은 아래 변환을 지원한다.

toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

암시적 변환은 문맥상에서 유추된 타입으로 인해 자동으로 실행되고, 적절한 변환을 위한 산술적 연산이 오버로드 된다.:

val l = 1L + 3 // Long + Int => Long

연산(Operations)

코틀린은 숫자에 대한 산술적 연산자 표준 세트를 지원한다.

비트 연산의 경우, 특별한 문자가 제공되진 않는다. 그러나, infix form이라 불리는 명명된 함수를 사용할 수 있다.

val x = (1 shl 2) and 0x000FF000

비트 연산 종류는 아래와 같다.(Int와 Long만 사용 가능)

shl(bits) – 왼쪽으로 비트 이동 (Java's <<)
shr(bits) – 오른쪽으로 비트 이동 (Java's >>)
ushr(bits) – 양수(unsigned) 오른쪽으로 비트 이동 (Java's >>>)
and(bits) – 비트 단위 and
or(bits) – 비트 단위 or
xor(bits) – 비트 단위 xor
inv() – 비트 단위 inversion(반전)

부동 소수점 숫자 비교

부동 소수점 비교 연산은 다음과 같다.:

대등 체크: a == b and a != b
비교 연산자: a < b, a > b, a <= b, a >= b
범위 인스턴스화 및 범위 체크: a..b, x in a..b, x !in a..b

피연산자가 정적 부동 소수점 숫자 타입으로 선언되지 않은 경우(e.g Any, Comparable<...>), Float 및 Double에 대해, 표준에 동의하지 않은 equals 와 compareTo 구현을 사용한다. 따라서 아래와 같은 함수를 사용한다.

NaN은 스스로 동일한 것으로 간주된다.
NaN 은 POSITIVE_INFINITY을 포함한 어느 요소보다 큰 값으로 간주된다.
-0.0은 0.0보다 작은 것으로 간주된다.

문자(Characters)

문자는 Char 타입으로 표현된다. 숫자로 직접 대치할 수 없다.

fun check(c: Char) {
    if (c == 1) { // 양립할 수 없는 타입들
        // ...
    }
}

문자 리터럴은 작은따옴표로 구성된다: '1'. 특수 문자는 백슬래쉬(\)를 이용해서 표현한다.

아래의 Escape sequence가 지원된다.:

\t, \b, \n, \r, \', \", \\, \$

다른 문자로 인코딩하기 위해선 유니코드 Escape sequence를 사용한다.: '\uFF00'

문자를 Int 숫자로 변경할 수 있다.:

fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // 숫자에 대한 명시적 변환
}

숫자와 마찬가지로, Null 가능 참조가 필요할 때, 문자가 박싱 된다. 원형태는 박싱 연산에 의해 보호받지 못한다.

부울(Boolean)

Boolean 타입은 논리를 나타내고, 두 개의 값을 갖는다: true, false

Null 가능 참조가 필요하면 박싱된다.

아래와 같은 빌트인(Built-in) 연산이 포함

|| – 둘 중 하나만 참이면 참
&& – 둘 다 참일 때 참
! - 부정

배열(Arrays)

코틀린에서 배열은 Array 클래스로 표현된다. get과 set 함수(연산자 오버로딩 변환으로 인해 []로 변경된)와 size 속성 등, 유용한 멤버 함수를 갖고있다.:

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ...
}

배열을 만들기 위해, arrayOf() 함수를 사용한다. arrayOf(1, 2, 3)으로 생성하면 배열 [1, 2, 3]이 생성된다. arrayOfNulls()은 null 요소들로 채워진 배열을 생성할 수 있다.

배열 크기를 얻는 Array 생성자를 이용할 수 있다. 또한, 인덱스를 가지는 각 배열 요소들의 초기 값을 리턴하는 함수를 이용할 수 있다.:

fun main() {
    // ["0", "1", "4", "9", "16"]을 요소로 갖는 문자열 배열 생성
    val asc = Array(5) { i -> (i * i).toString() }
    asc.forEach { println(it) }
}

/* 출력 결과 */
0
1
4
9
16

위에서 언급했듯이, [] 연산자는 get()과 set() 멤버 함수에 대한 호출을 의미한다.

참고 : 자바와 다르게, 코틀린에서 배열은 불변이다. 이것은 코틀린이 가능한 런타임 에러들을 방지하기 위해, Array <String>에서 Array <Any>로 할당할 수 없다는 의미이다.

코틀린은 박싱 오버헤드가 없는 기본 타입 배열을 표현하는 특별한 클래스가 존재한다. ByteArray, ShortArray, IntArray 기타 등등이다. 이 클래스들은 Array 클래스와 상속관계는 없지만, 메서드와 속성들은 동일하다. 또한, 각각에 상응하는 팩토리 함수를 갖고 있다.:

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

부호 없는 정수(Unsigned Integer)

코틀린은 다음과 같은 Unsigned 타입을 제공한다.:

kotlin.UByte: Unsigned 8-bit 정수, 0 ~ 255 범위
kotlin.UShort: Unsigned 16-bit 정수, 0 ~ 65535 범위
kotlin.UInt: Unsigned 32-bit 정수, 0 ~ 2^32 - 1 범위
kotlin.ULong: Unsigned 64-bit 정수, 0 to 2^64 - 1 범위

특별한 클래스(Specialized classes)

기본 타입과 마찬가지로, Unsigned 타입도 배열 표현에 상응하는 타입이 존재한다.:

kotlin.UByteArray: unsigned bytes 배열
kotlin.UShortArray: unsigned shorts 배열
kotlin.UIntArray: unsigned ints 배열
kotlin.ULongArray: unsigned longs 배열

리터럴(Literals)

Unsigned 정수를 사용하기 쉽게 하기 위해, 정수 리터럴에 특정 Unsigned 타입을 나타내는 접미사로 태그를 지정하는 기능을 제공한다.

접미사 u 와 U는 unsigned 태그 리터럴이다. 정확한 타입은 예상 타입에 의해 결정된다. 만약 예상 유형이 제공되지 않는다면, UInt or ULong은 리터럴 크기에 따라 결정된다.

val b: UByte = 1u  // UByte, 예상 타입 제공
val s: UShort = 1u // UShort, 예상 타입 제공
val l: ULong = 1u  // ULong, 예상 타입 제공

val a1 = 42u // UInt: 예상 타입 제공안됨, UInt로 맞춰짐
val a2 = 0xFFFF_FFFF_FFFFu // ULong: 예상 타입 제공안됨, UInt에 맞출 수 없음

문자열(Strings)

문자열은 String 타입으로 표현된다. 문자열은 불변성을 지닌다. 문자열 요소들은 인덱스 연산으로 접근할 수 있는 문자들이다: s[i]. 문자열은 for-loop로 반복할 수 있다.

fun main() {
val str = "abcd"
    for (c in str) {
        println(c)
    }
}

/* 출력 결과 */
a
b
c
d

+ 연산자를 사용해서 문자열을 연결할 수 있다. 문자열에 다른 타입을 연결하기 위해서는, 첫 번째 요소가 문자열로 표현되어야 한다.:

fun main() {
    val s = "abc" + 1
    println(s + "def")
}

/* 출력 결과 */
abc1def

문자열 리터럴(String Literals)

문자열 리터럴은 두 가지 유형이 있음:

Escaped 문자열은 escaped 문자를 포함한 문자열이고, raw 문자열은 개행 문자와 임의의 문자를 포함할 수 있는 문자열이다. Escaped 문자열은 자바와 매우 흡사하다.

val s = "Hello, world!\n"

Escaping은 백 슬러쉬(\)를 사용하여 쉽게 사용 가능하다.

raw 문자열은 삼 따옴표(""")를 사용하는 것으로 정해진다. 개행 등 다른 escaping 문자들은 포함되지 않아야 한다.

val text = """
    for (c in "foo")
        print(c)
"""

trimMargin() 함수를 이용하여 공백을 제거

val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()

문자열 템플릿(String Templates)

문자열은 템플릿 표현을 포함할 수 있다. 템플릿 표현은 달러 모양($)으로 시작하고 변수 이름으로 구성된다.:

fun main() {
    val i = 10
    println("i = $i") 
}

/* 출력 결과 */
i = 10

중괄호 안에 임의의 표현도 가능:

fun main() {
    val s = "abc"
    println("$s.length is ${s.length}") 
}

/* 출력 결과 */
"abc.length is 3"

템플릿은 raw 문자열과 escaped 문자열을 동시에 지원한다. 리터럴 $ 문자를 raw 문자열에 포함한다면, 아래와 같이 표현한다.

val price = """
${'$'}9.99
"""

기본 구문(Basic Syntax)

모쿠 — Tue, 28 May 2019 13:45:57 +0900

패키지 정의(Defining packages)

패키지 명시는 가장 위에 줄에 해야한다.

package my.demo

import java.util.*

// ...

함수 정의(Defining functions)

Int를 리턴 타입으로 갖는 'Int' 매개 변수 값이 두 개인 함수:

fun sum(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    print("sum of 3 and 5 is ")
    println(sum(3, 5))
}

/* 출력 결과 */
sum of 3 and 5 is 8

표현식 본문과 유추된 리턴 타입을 갖는 함수:

fun sum(a: Int, b: Int) = a + b

fun main() {
    println("sum of 19 and 23 is ${sum(19, 23)}")
}

/* 출력 결과 */
sum of 19 and 23 is 42

의미없는 값(void)을 리턴하는 함수:

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

fun main() {
    printSum(-1, 8)
}

/* 출력 결과 */
sum of -1 and 8 is 7

Unit 리턴 타입은 생략이 가능:

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

fun main() {
    printSum(-1, 8)
}

/* 출력 결과 */
sum of -1 and 8 is 7

변수 정의(Defining variables)

읽기 전용 지역변수는 val 키워드를 사용해서 정의된다.:

fun main() {
    val a: Int = 1  // 즉시 할당
    val b = 2   // `Int` 타입으로 추론됨
    val c: Int  // 초기화자(initializer)가 없을 때 요구되는 타입이 제공됨
    c = 3       // 후에 할당
    println("a = $a, b = $b, c = $c")
}

/* 출력 결과 */
a = 1, b = 2, c = 3

변수는 var 키워드를 사용해서 정의된다.:

fun main() {
    var x = 5 // `Int` 타입이 추론됨
    x += 1
    println("x = $x")
}

/* 출력 결과 */
x = 6

최상위 변수들

val PI = 3.14 // 전역 읽기 전용 변수
var x = 0 // 전역 변수

fun incrementX() { 
    x += 1 
}

fun main() {
    println("x = $x; PI = $PI")
    incrementX()
    println("incrementX()")
    println("x = $x; PI = $PI")
}

/* 출력 결과 */
x = 0; PI = 3.14
incrementX()
x = 1; PI = 3.14

주석(Comments)

자바와 자바 스크립트와 같이 줄의 끝과 블럭 주석을 제공한다.:

// This is an end-of-line comment

/* This is a block comment
   on multiple lines. */

자바와 다르게 중첩될 수 있다.

문자열 템플릿 사용(Using string templates)

fun main() {
    var a = 1
    // 템플릿에서 기본 이름
    val s1 = "a is $a" 

    a = 2
    // 템플릿에서 임의의 표현
    val s2 = "${s1.replace("is", "was")}, but now is $a"
    // replace(a, b) : a를 b로 재배치한다.
    println(s2)
}

/* 출력 결과 */
a was 1, but now is 2

조건 표현식 사용(Using conditional expressions)

// 기본 표현식
fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

// 간단한 표현식
fun maxOf(a: Int, b: Int) = if (a > b) a else b

fun main() {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}

/* 출력 결과 */
max of 0 and 42 is 42

Null가능한 변수 사용과 Null 체킹(Using nullable values and checking for null)

Null값이 가능할 때 nullable을 명시적으로 표시해야 한다.

null 리턴 표현 함수:

fun parseInt(str: String): Int? {
    // ...
}

nullable 변수 리턴하는 함수 사용:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // `x * y` 사용은 산출 에러 발생. null로 고정되어 있기 때문에
    if (x != null && y != null) {
        // x, y 는 null 체크 후에 자동적으로 non-nullable로 변경된다.
        println(x * y)
    }
    else {
        println("either '$arg1' or '$arg2' is not a number")
    }    
}


fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("a", "b")
}

/* 출력 결과 */
42
either 'a' or '7' is not a number
either 'a' or 'b' is not a number

위의 방법 또는:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    
    // ...
    if (x == null) {
        println("Wrong number format in arg1: '$arg1'")
        return
    }
    if (y == null) {
        println("Wrong number format in arg2: '$arg2'")
        return
    }

    // x, y 는 null 체크 후에 자동적으로 non-nullable로 변경된다.
    println(x * y)
}

fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("99", "b")
}

/* 출력 결과 */
42
Wrong number format in arg1: 'a'
Wrong number format in arg2: 'b'

타입 체크와 자동 형변환 사용(Using type checks and automatic casts)

is 연산자는 표현식이 인스턴스 타입인지 아닌지 체크한다. 만약 변경 가능한 지역 변수 또는 속성이 특정 타입으로 체크되면, 명시적으로 형변환시킬 필요가 없다.:

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // 이 위치에서 `obj` 는 자동으로 'String'으로 형변환된다.
        return obj.length
    }

    // 타입 체크 부분 바깥에서 'obj'는 여전히 'Any' 타입이다.
    return null
}


fun main() {
    fun printLength(obj: Any) {
        println("'$obj' string length is ${getStringLength(obj) ?: "... err, not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

/* 출력 결과 */
'Incomprehensibilities' string length is 21 
'1000' string length is ... err, not a string 
'[java.lang.Object@3af49f1c]' string length is ... err, not a string

위 방법 외에:

fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null

    // `obj` is automatically cast to `String` in this branch
    return obj.length
}


fun main() {
    fun printLength(obj: Any) {
        println("'$obj' string length is ${getStringLength(obj) ?: "... err, not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

/* 출력 결과 */
'Incomprehensibilities' string length is 21 
'1000' string length is ... err, not a string 
'[java.lang.Object@3af49f1c]' string length is ... err, not a string

또는 :

fun getStringLength(obj: Any): Int? {
    // `obj` is automatically cast to `String` on the right-hand side of `&&`
    if (obj is String && obj.length > 0) {
        return obj.length
    }

    return null
}


fun main() {
    fun printLength(obj: Any) {
        println("'$obj' string length is ${getStringLength(obj) ?: "... err, is empty or not a string at all"} ")
    }
    printLength("Incomprehensibilities")
    printLength("")
    printLength(1000)
}

/* 출력 결과 */
'Incomprehensibilities' string length is 21 
'' string length is ... err, is empty or not a string at all 
'1000' string length is ... err, is empty or not a string at all

For 반복(Loop) 사용(Using a for loop)

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    for (item in items) {
        println(item)
    }
}

/* 출력 결과 */
apple
banana
kiwifruit

또는:

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}

/* 출력 결과 */
item at 0 is apple
item at 1 is banana
item at 2 is kiwifruit

While 반복(Loop) 사용(Using a while loops)

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    var index = 0
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
}

/* 출력 결과 */
item at 0 is apple
item at 1 is banana
item at 2 is kiwifruit

When 조건식 사용(Using a when expressions)

fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long"
        !is String -> "Not a string"
        else       -> "Unknown"
    }

fun main() {
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}

/* 출력 결과 */
One
Greeting
Long
Not a string
Unknown

범위 사용(Using ranges)

in 연사자를 사용, 숫자가 범위 내에 있는지 확인:

fun main() {
    val x = 10
    val y = 9
    if (x in 1..y+1) {
        println("fits in range")
    }
}

/* 출력 결과 */
fits in range

숫자가 범위 밖에 있는지 확인:

fun main() {
    val list = listOf("a", "b", "c")

    if (-1 !in 0..list.lastIndex) {
        println("-1 is out of range")
    }
    if (list.size !in list.indices) {
        println("list size is out of valid list indices range, too")
    }
}

/* 출력 결과 */
-1 is out of range
list size is out of valid list indices range, too

범위 내에 반복:

fun main() {
    for (x in 1..5) {
        print(x)
    }
}

/* 출력 결과 */
12345

오름 또는 내림차순으로 특정 값 차이 반복:

fun main() {
    for (x in 1..10 step 2) {
        print(x)
    }
    println()
    for (x in 9 downTo 0 step 3) {
        print(x)
    }
}

/* 출력 결과 */
13579
9630

컬렉션(Collections) 사용

컬렉션 내에 반복:

fun main() {
    val items = listOf("apple", "banana", "kiwifruit")
    for (item in items) {
        println(item)
    }
}

/* 출력 결과 */
apple
banana
kiwifruit

in 연산자를 사용해서, 컬렉션이 객체를 포함하고 있는 지 체크:

fun main() {
    val items = setOf("apple", "banana", "kiwifruit")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
}

/* 출력 결과 */
apple is fine too

람다 표현식(lambda expressions)을 사용한 필터링과 맵 컬렉션:

fun main() {
  val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
  fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { println(it) }
}

/* 출력 결과 */
APPLE
AVOCADO

기본 클래스와 인스턴스 생성(Creating basic classes and their instances)

fun main() {
    val rectangle = Rectangle(5.0, 2.0) //'new' 키워드를 사용하지 않음
    val triangle = Triangle(3.0, 4.0, 5.0)
    println("Area of rectangle is ${rectangle.calculateArea()}, its perimeter is ${rectangle.perimeter}")
    println("Area of triangle is ${triangle.calculateArea()}, its perimeter is ${triangle.perimeter}")
}

abstract class Shape(val sides: List<Double>) {
    val perimeter: Double get() = sides.sum()
    abstract fun calculateArea(): Double
}

interface RectangleProperties {
    val isSquare: Boolean
}

class Rectangle(
    var height: Double,
    var length: Double
) : Shape(listOf(height, length, height, length)), RectangleProperties {
    override val isSquare: Boolean get() = length == height
    override fun calculateArea(): Double = height * length
}

class Triangle(
    var sideA: Double,
    var sideB: Double,
    var sideC: Double
) : Shape(listOf(sideA, sideB, sideC)) {
    override fun calculateArea(): Double {
        val s = perimeter / 2
        return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC))
    }
}

/* 출력 결과 */
Area of rectangle is 10.0, its perimeter is 14.0
Area of triangle is 6.0, its perimeter is 12.0

코틀린 개발환경 구축 및 출력

모쿠 — Mon, 27 May 2019 15:36:03 +0900

코틀린 통합개발환경인 IntelliJ IDE를 설치하고 문자를 출력하도록 하자.

코틀린은, 앞서 설명한 것처럼 다양한 개발 환경에서 사용이 가능하고 온라인으로 실행이 가능하니 목적에 맞게 사용하면 된다.

온라인 사이트 : https://play.kotlinlang.org/

Kotlin Playground: Edit, Run, Share Kotlin Code Online

play.kotlinlang.org

1. www.jetbrains.com 접속 후 Download 클릭

2. 본인이 사용하는 운영 체제 선택(필자는 Windows선택) 후, Community 항목에 Download를 클릭

3. 다운로드 된 idealC-2019.1.2.exe 파일을 실행하여 설치 진행(Next만 눌러도 된다.)

4. 설치가 완료되고 아이콘을 클릭하여 실행. Creat New Project 클릭

5. Creat New Project를 클릭하면 다음과 같은 화면이 나타난다.

Kotlin/JVM을 선택한 후 Next 클릭

* 참고 : Project SDK가 No SDK로 뜬다면 JDK 설치가 되지 않은 것이다. 따라서 JDK를 설치한 뒤 폴더 경로를 지정해주어야 한다.(JDK 설치는 자바 설치 부분에서 참조)

6. Next를 클릭하여 Project Name을 입력하고 Finish 클릭한다.

7. 약간의 로딩 후 다음과 같은 화면이 나타나면 성공이다.

Hello Kotlin > src 폴더에 코트를 생성할 예정이다.

8. src 폴더를 선택한 후 마우스 오른쪽 클릭 -> New Kotlin File/Class 선택

9. 제목을 Hello으로 작성하고 다음과 같이 코드 작성 후 Alt+Shift+F10(실행 단축키)를 누른다.

println()안에 문자가 잘 출력되었다.

Kotlin이란 무엇인가

모쿠 — Mon, 27 May 2019 14:05:49 +0900

1. 코틀린(Kotiln)?

IntelliJ IDEA의 개발사 JetBrains에서 2011년에 공개한 프로그래밍 언어.

JVM(Java Virtual Mechine) 기반의 언어이며, Java와의 상호 운용이 100% 가능.

안드로이드, 스프링 프레임워크, 톰캣, JavaScript, Java EE, HTML5, iOS, 라즈베리 파이 등을 개발할 때 사용 가능.

2017년 구글이 안드로이드 공식 언어로 채택함으로써 관심이 증가하게 되었음.

2. 왜 코틀린을 사용하는가?

- 간결함 : 상용구 코드의 양을 대폭적으로 줄여줌

getters, setters, equals(), hashCode(), toString(), copy() 함수들을 포함한 POJO(Plain Old Java Object)를 한 줄에 생성:

data class Customer(val name: String, val email: String, val company: String)

람다식을 사용하여 목록 필터링:

val positiveNumbers = list.filter { it > 0 }

싱글톤 객채를 생성:

object ThisIsASingleton { val companyName: String = "JetBrains" }

- 안전함 : 'null pointer exceptions'와 같은 전체 클래스의 에러를 방지

NullPointerExceptions 제거하여, 실수를 방지

var output: String
output = null   // Compilation error

null 입력 가능 타입에서 실수로 실행되는 것을 방지

val name: String? = null    // Nullable type
println(name.length())      // Compilation error

타입이 올바른지 확인하면, 컴파일러가 자동 캐스팅을 실행

fun calculateTotal(obj: Any) {
    if (obj is Invoice)
        obj.calculateTotal()
}

- 상호 운용성 : JVM, Android, Browser 등을 위한 라이브러리에 강점이 존재

JVM에 존재하는 라이브러리를 사용하면, 100% 호환 가능:

import io.reactivex.Flowable
import io.reactivex.schedulers.Schedulers

Flowable
    .fromCallable {
        Thread.sleep(1000) //  imitate expensive computation
        "Done"
    }
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.single())
    .subscribe(::println, Throwable::printStackTrace)

JVM 또는 JavaScript을 대상으로 가능. 코틀린으로 작성하고 게재할 곳을 결정 가능

import kotlin.browser.window

fun onLoad() {
    window.document.body!!.innerHTML += "<br/>Hello, Kotlin!"
}

- 도구 친화적 : JAVA IDE 또는 Build를 Command Line에서 선택 가능

JetBrain에서 언어의 Tooling에 도움을 줌

[Eclipse-GitHub 연동] GitHub 가입하기

모쿠 — Mon, 23 Jul 2018 15:44:57 +0900

보통 프로젝트 개발을 하다보면 여러사람과 함께 진행하거나 다름 사람들과 코드를 공유하는 경우가 많다.

코드를 공유하거나 관리해주는 코드 저장소로 GitHub, SVN 등이 있다. 그 중 오픈 소스가 많이 존재하는 GitHub에 대한 정보와 사용법을 알아보도록 하자.

- 분산 버전 관리 툴인 깃(Git)을 사용하는 프로젝트를 지원하는 웹호스팅 서비스. 여러 사람이 하나의 프로젝트를 분할해서 진행하다보면, 코드를 통합하거나 진행 사항을 확인해야할 경우가 많다. 또한 두 사람 이상이 같은 클래스에 작업을 하는 경우, 한사람의 작업이 겹쳐지거나 지워질 수 있다. GitHub는 이러한 상황에서 버전별로 프로그램 상황을 관리해서 중복을 방지하거나 실수한 코드를 되돌릴 수 있도록 도와준다.

1. 깃허브 닷컴으로 접속 후 [Sign up] 클릭

2. 사용자 이름, 이메일, 비밀번호를 입력하고 [계정 생성]을 클릭

3. Choose Personal Plan에서 유료 무료 사용을 선택하고 [Continue] 클릭

4. Step 3에서 프로그래밍 경험에 대한 체크 및 [Submit]을 클릭하면

회원가입이 완료된다.

JSP include Directive(지시자)

모쿠 — Wed, 12 Apr 2017 14:39:44 +0900

<지시자를 이용한 파일 포함>

include 지시자(directive) 동작 원리:

- include를 사용해서 다른 파일(jsp, jspf)을 포함시키면, 하나의 JSP 파일로 합쳐진 이후에, 서블릿 클래스로 변환

<header.jspf>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
 
<style>
.header {
    background-color: lightgreen;
    font-size: 200%;
    text-align: center;
    height: 60px;
    
}
</style>
 
<div class="header">
여기는 Header입니다...
</div>
Colored by Color Scripter
cs

<footer.jspf>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<style>
.footer {
    background-color: lightblue;
    text-align: center;
    height: 60px;
    
}
</style>
 
<div class="footer">
(주) 무한상사<br/>
http://www.무한상사.co.kr<br/>
TEL: 02-1132-3333
</div>
Colored by Color Scripter
cs

<04_include>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JSP</title>
</head>
<body>
 
<%-- header 파일을 include --%>
<%@ include file="header.jspf" %>
 
<h1>include Directive(지시자)</h1>
 
<div><p>본문입니다....</p></div>
 
<%-- footer 파일을 include --%>
<%@ include file="footer.jspf" %>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

JSP 에러 페이지 처리

모쿠 — Wed, 12 Apr 2017 14:35:52 +0900

<Directive를 사용한 에러 페이지 처리>

- JSP를 실행하는 도중에 Exception이 발생하면 errorPage 속성에 지정된 페이지로 이동

<02_errorPage.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    
<%@ page errorPage="error.jsp" %>
<%-- JSP를 실행하는 도중에 Exception이 발생하면 
errorPage 속성에 지정된 페이지로 이동 --%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JSP</title>
</head>
<body>
 
<h1>Directive를 사용한 에러 페이지 처리</h1>
<p> 나눗셈 결과: <%=(123/0)%></p>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

<03_errorPage.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JSP</title>
</head>
<body>
 
<h1>배포 관리자(web.xml)을 사용한 에러 페이지 처리</h1>
<a href="none.jsp">파일이 없는 링크(404 에러)</a>
 
<p>계산 결과: <%=(123/0) %></p>
 
</body>
</html>
Colored by Color Scripter
cs

<web.xml>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>WEB07_JSP1</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
  <error-page>
      <error-code>404</error-code>
      <location>/error/code404.jsp</location>
  </error-page>
    <error-page>
      <error-code>500</error-code>
      <location>/error/code500.jsp</location>
  </error-page>
</web-app>
Colored by Color Scripter
cs

<츨력화면>

JSP 동작원리 및 구성 요소(TAG)

모쿠 — Wed, 12 Apr 2017 11:32:06 +0900

<JSP 동작원리>

1. 런타임 시에 JSP 컴파일러에 의해서 JSP 파일(.jsp)이 자바 파일(.java)로 변환

==> 서블릿 클래스

2. 자바 컴파일러가 자바 파일을 컴파일해서 클래스 파일(.class)을 생성

3. JRE이 클래스 파일을 기계어로 번역해서 실행

==> 요청(request), 응답(response)를 처리

<JSP 구성요소>

1. <%@ %>: Directive(지시자)

JSP 페이지 전체에 대한 속성들을 설정

2. <%! %>: Declaration(선언문)

멤버 변수, 메소드, 내부 클래스를 선언하는 부분

3. <% %>: Scriptlet(스크립트릿)

메소드(_jspService) 내부에서 실행되는 자바 코드를 작성하는 부분

4. <%= %>: Expression(표현식)

변수의 값, 메소드의 리턴 값 등을 프린트

5. <%-- --%>: Comment(주석)

JSP 주석은 서블릿 클래스로 변환될 때 코드로 변환되지 않음!

<01_JSPTag.jsp>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    import="java.util.Date"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JSP</title>
</head>
<body>
 
<!-- HTML/XML 주석 -->
<%-- <h1>JSP Tag(구성요소)</h1> --%>
<%-- Declaration(선언문) --%>
<%!
public int add(int x, int y){
    return x + y;
}
%>
 
<%-- Scriptlet --%>
<%
// 지역 변수 선언
int result = add(10, 20);
 
// JSP에서 출력 방법
// 1) console 로그
System.out.println("result = " + result);
// 2) Writer 객체를 사용해서 응답(response)으로 출력
// Servlet에서처럼 response.getWriter()를 호출하면 안됨!
// JSP가 변환된 서블릿 클래스의 내장 객체인 out 객체를 사용해서 프린트
out.write("<p>result = " + result + "</p>\r\n");
%>
 
<%-- Expression --%>
<p>
결과 = <%=result%>
</p>
 
<%
Date date = new Date();
%>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

<이클립스> JSP 파일 생성 시 포멧 변경하기

모쿠 — Wed, 12 Apr 2017 10:02:28 +0900

<JSP 생성 시 원하는 포멧으로 설정>

- HTML5 환경을 맞추기 위해 태그 내용을 변경할 수 있음

- 'UTF-8'을 저장하여 항상 한글이 가능하게 수정

1. 메뉴 탭에서 [Window] - [Preference]를 선택

2. 순서대로 진행

3. HTML5 규격에 맞게 변경

자바 서블릿(Java Servlet) 시작하기

모쿠 — Tue, 11 Apr 2017 10:32:50 +0900

자바 서블릿(Java Servlet)은 자바를 사용하여 웹페이지를 동적으로 생성하는 서버측 프로그램 혹은 그 사양을 말하며, 흔히 "서블릿"이라 불린다.

자바 서블릿은 웹 서버의 성능을 향상하기 위해 사용되는 자바 클래스의 일종이다. 서블릿은 JSP와 비슷한 점이 있지만, JSP가 HTML 문서 안에 Java 코드를 포함하고 있는 반면, 서블릿은 자바 코드 안에 HTML을 포함하고 있다는 차이점이 있다.

자바 서블릿은 자바 EE 사양의 일부분으로, 주로 이 기능을 이용하여 쇼핑몰이나 온라인 뱅킹 등의 다양한 웹 시스템이 구현되고 있다.

- 출처 위키

서블릿(servlet)은 이클립스 내에서 실행이 가능

서블릿은 자바 기반 프로그램이기 때문에 시작전에 자바를 설치해야 함

1. 이클립스 실행 및 Dynamic Web Project를 생성

2. Java Resources/src 밑에 패키지를 생성

3. [New] -> [Servlet]을 선택하여 서블릿 파일 생성

4. Class 이름을 선택하고 [Next]

5. UrlMapping은 서블릿 클래스가 실행되는 web 경로를 정의(ex. http://localhost:8181/web06/HelloServlet)

6. 인터페이스와 servlet내에서 상속 받을 수 있는 메소스들을 선택할 수 있음

7. Finish 를 선택하여 종료

jQuery 애니메이션(animate) 01

모쿠 — Tue, 11 Apr 2017 09:52:22 +0900

<animate() 함수를 이용한 애니메이션 효과>

* animate 함수 포멧

- animate(params, speed, callback)

- params: 애니메이션을 할 속성들(JavaScript Object)

* 애니메이션 함수들

- hide(speed, callback), fadeOut(speed, callback), slideUp()

- show(speed, callback), fadeIn(speed, callback), slideDown()

- toggle(speed, callback), fadeToggle(spped, callback), slideToggle()

<09_animate.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
<style>
#panel {
    border: 1px solid grey;
    background-color: lime;
    width: 200px;
    height: 200px;
    
}
</style>
</head>
<body>
 
<h1>jQuery 애니메이션 함수들</h1>
<button type="button" id="btn1">Hide</button>
<button type="button" id="btn2">Show</button>
<button type="button" id="btn3">Toggle</button>
<div id="panel">Animation</div>
 
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
<script>
$(document).ready(function() {
    $('#btn1').click(function(){
        $('#panel').slideUp(3000);
    });
    $('#btn2').click(function(){
        $('#panel').slideDown(3000);
    });
    $('#btn3').click(function(){
        $('#panel').slideToggle(3000);
    });
    
});
</script>
</body>
</html>
Colored by Color Scripter
cs

<10_animate.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
<style type="text/css">
#panel {
    border: 1px solid grey;
    background-color: lime;
    width: 100px;
    height: 100px;
    position: relative
}
</style>
</head>
<body>
 
<h1>jQuery animate() 함수</h1>
<button type="button" id="btn1">위치 이동</button>
<div id="panel">jQuery animate</div>
 
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
<script>
$(document).ready(function() {
    $('#btn1').click(function() {
        $('#panel').animate({left: '300px', top:'300px', fontSize: '200%', opacity: '0.5'}, 3000);
    });
});
</script>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

- 09_animate.html

- 10_animate.html

jQuery 반복문(each)

모쿠 — Mon, 10 Apr 2017 17:05:28 +0900

<jQuery의 반복문 사용 : each() 함수>

- 홀수줄은 hotpink , 짝수줄은 aqua로 출력

- '컬렉션'.each(handler);

- handler: 컬렉션의 모든 원소들에 대해서 적용할 기능(동작)

<08_each.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
<style>
.hot {
    background-color: hotpink;
}
.cold{
    background-color: aqua;
}
</style>
</head>
<body>
<h1>jQuery each() 함수</h1>
<ul>
    <li>Java</li>
    <li>HTML</li>
    <li>CSS</li>
    <li>JavaScript</li>
    <li>jQuery</li>
</ul>
 
<button type="button" id="btn">Toggle Style</button>
 
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
<script>
    $(document).ready(function() {
        // '컬렉션'.each(handler);
        // handler: 컬렉션의 모든 원소들에 대해서 적용할 기능(동작)
        $('#btn').click(function() {
            var order = true;
            
            // each는 반복문(for문과 같음)
            $('li').each(function(index) {
                
                if(index % 2 == 0){
                    $(this).toggleClass('hot');
                    order = false;
                } else {
                    $(this).toggleClass('cold');
                    order = true;
                }
            });
        });
    });
</script>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

jQuery CSS 변경

모쿠 — Mon, 10 Apr 2017 16:48:47 +0900

<jQuery의 CSS 변경 방법>

<06_css.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
</head>
<body>
 
<h1>jQuery CSS 변경 방법</h1>
<p style="background-color: lightyellow">jQuery CSS</p>
 
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
<script type="text/javascript">
$(document).ready(function(){
    // jQuery를 사용한 CSS 변경
    // css('property', value)l
    // css({prop1: val1, prop2: val2, ...});
    $('p').click(function() {
        $(this).css({
            font: '200% serif',
            backgroundColor: 'lightgreen',
            border: '1px solid grey',
            textAlign: 'center'
        });
    });
});
</script>
 
</body>
</html>
Colored by Color Scripter
cs

<07_css2.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
<style>
.important{
    font-weight: bold;
    font-size: 200%;
    border: 2px solid red;
}
.blue {
    color: blue;
}
table, th, td {
}
body p{
}
</style>
</head>
<body>
 
<h1>Add/Remove CSS class</h1>
<p id="p1">단락1</p>
<p id="p2">단락2</p>
<p id="p3">단락3</p>
<button type="button" id="add-class">Add Class</button>
<button type="button" id="remove-class">Remove Class</button>
<button type="button" id="toggle-class">Toggle Class</button>
 
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
 
<script>
$(document).ready(function() {
    // addClass('클래스이름'): HTML 요소에 클래스 속성을 추가
    // removeClass('클래스이름'): HTMl 요소에서 클래스 속성을 제거
    // toggleClass('클래스이름'): 클래스 속성 추가/제거 토글
    
    $('#add-class').click(function() {
        $('#p1').addClass('important');
        $('#p2, #p3').addClass('blue');
    });
    
    $('#remove-class').click(function() {
        $('#p2, #p3').removeClass('blue');
    });
    
    $('#toggle-class').click(function() {
        $('#p2, #p3').toggleClass('blue');
    });
});
</script>
 
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

jQuery getter/setter

모쿠 — Mon, 10 Apr 2017 15:22:26 +0900

<jQuery 데이터 get, set>

* 대부분의 jQuery 함수들은 매개변수의 개수에 따라서 getter와 setter로 사용 가능

- html(): HTML 요소 내부의 html 코드를 리턴

- html('문자열'): HTML 요소 내부에 html 코드를 씀(setter)

- text(): HTML 요소 내부의 텍스트(문자열)을 리턴

- text('문자열'): HTML 요소 내부에 텍스트(문자열)을 씀

- attr('attr 이름'): 속성(attribute)의 값을 리턴

- attr('attr 이름', 'attr 값'): 속성(attr)의 값을 설정

- css('css 프로퍼티 이름'): CSS 프로퍼티 값을 리턴

- css('css 프로퍼티 이름', 'value'): CSS 프로퍼티에 값을 설정

- val(): input 상자에 입력된 값을 리턴

- val('값'): input 상자에 값을 씀

<05_getset.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
 
<script type="text/javascript">
$(document).ready(function() {
    
    $('#btn1').click(function() {
        var msg = $('p').html(); //innerHTML에 해당
        $('#output').html(msg);
    });
    $('#btn2').click(function() {
        var msg = $('p').text(); // textContent 
        $('#output').html(msg);
    });
    
});
</script>
 
</head>
<body>
 
<h1>jQuery getter/setter</h1>
 
<p>우리는 <b>jQuery</b>를 공부하고 있습니다...</p>
<button type="button" id="btn1">HTML</button>
<button type="button" id="btn2">Text</button>
 
<div id="output">
</div>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

jQuery 이벤트(event) 02

모쿠 — Mon, 10 Apr 2017 15:03:44 +0900

<jQuery의 이벤트>

<04_event2.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
<style type="text/css">
p {
    border: 1px solid grey;
    width: 200px;
    height: 200px;
    background-color: lightgreen;
    font-size: 200%;
    text-align: center;
}
</style>
 
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
<script>
$(document).ready(function() {
    // $('selector').event(function() {});
    // 하나의 HTML 요소에 여러개의 event handler를 등록
    // $('selector').on({
    //      event1: function() {},
    //      event2: function() {},
    //    ...
    // });
    $('p').on({
        mouseover: function() {
            $(this).css('background-color', 'lightyellow');
        },
        mouseout: function() {
            $(this).css('background-color', 'lightgreen');
        },
        click: function() {
            if($(this).text().match('TEST')){
            $(this).text('안녕');
            } else {
                $(this).text('TEST');
            }
        }
    });
    
});
 
</script>
 
</head>
<body>
 
<h1>jQuery Event 2</h1>
<p>TEST</p>
 
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

- 실행전

- 실행후

jQuery 이벤트(event) 01

모쿠 — Mon, 10 Apr 2017 14:53:50 +0900

<jQuery의 이벤트 함수>

<03_event.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>jQuery</title>
</head>
<body>
 
<h1>jQuery Event</h1>
<img id="bulb" alt="전구" src="images/bulb_off.gif" />
<br/><br/>
<p style="border: 1px solid black; background-color: green">hover</p>
<input type="text" id="userid" />
 
 
<!-- jQuery CDN 포함: 라이브러리 포함 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
<script>
// $(document).ready(function() {});
$(function() {
    // mouseover, mouseenter:
    // 마우스가 해당 영역 위로 올라갔을 때 
    $('#bulb').mouseover(function() {
        console.log($(this).attr('src'));
        $(this).attr('src', 'images/bulb_on.gif');
    });
    
    // mouseout, mouseleave:
    // 마우스가 해당 영역 바깥으로 나갔을 때
    $('#bulb').mouseout(function() {
        $(this).attr('src', 'images/bulb_off.gif');
    });
    
    // hover(handlerIn, handlerOut)
    //   handlerIn: 마우스가 해당 영역 위로 올라갔을 때 처리할 이벤트 핸들러
    //   handlerOut: 마우스가 해당 영역 바깥으로 나갔을 때 처리할 이벤트 핸들러
    function handlerIn() {
        console.log($('p').css('background-color'));
        $('p').css('background-color', 'yellow');
    }
    function handlerOut() {
        $('p').css('background-color', 'green');
    }
    $('p').hover(handlerIn, handlerOut);
    
    // focus: 포커스를 받았을 때(입력 가능한 상태)
    // blur: 포커스를 잃었을 때
    $('#userid').focus(function() {
        $(this).css('background-color', 'lightyellow');
    });
    
    $('#userid').blur(function() {
        $(this).css('background-color', 'white');
    });
    
    // change: 입력 내용이 변경됐을 때
    $('#userid').change(function() {
        console.log($(this).val());
        // document.getElementById('userid').value
        
        $(this).val($(this).val().toUpperCase());
    });
    
});
</script>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

- 기능 실행전

- 기능 실행후

jQuery 기본 문법

모쿠 — Mon, 10 Apr 2017 13:59:01 +0900

<jQuery의 기본문법>

- jQuery의 기본 문장 : $('selector').action();

- $('selector'): HTML 요소를 찾음. CSS 선택자(태그, 클래스, 아이디);

- action(): 해당 HTML 요소에 행해질 동작(기능)

<02_syntax.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
 
<script src="https://code.jquery.com/jquery-3.2.1.min.js">
</script>
 
</head>
<body>
 
<h1>jQuery 기본 문법</h1>
<button type="button" id="btn1">모두 숨기기</button>
<button type="button" id="btn2">클래스 숨기기</button>
<button type="button" id="btn3">아이디 숨기기</button>
 
<p>단락 1</p>
<p class="c1">단락 2, 클래스 c1</p>
<p class="c1">단락 3, 클래스 c1</p>
<p id="p1">단락 4, 아이디 p1</p>
 
<script>
// jQuery의 기본 문장 : $('selector').action();
//   $('selector'): HTML 요소를 찾음. CSS 선택자(태그, 클래스, 아이디);
//   action(): 해당 HTML 요소에 행해질 동작(기능)
 
$(document).ready(function(){
    $('#btn1').click(function() {
        $('p').hide();
    });
    
    $('#btn2').click(function() {
        $('.c1').hide();
    });
    
    $('#btn3').click(function() {
        $('#p1').hide();
    });
});
 
</script>
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

jQuery 사용하기

모쿠 — Mon, 10 Apr 2017 11:29:07 +0900

* jQuery 라이브러리를 포함시키는 방법

1. http://jquery.com/download/ 페이지에서 jQuery 라이브러리를 다운로드

-> WebContent/js 폴더에 복사

-> <script> 태그를 사용해서 복사한 js 파일을 html 파일에 포함

2. CDN(Content Delivery Network)에서 제공하는 링크 주소로 포함

1. http://jquery.com/download/ 페이지에서 jQuery 라이브러리를 다운로드

-> WebContent/js 폴더에 복사

-> <script> 태그를 사용해서 복사한 js 파일을 html 파일에 포함

2. CDN(Content Delivery Network)에서 제공하는 링크 주소로 포함

-> 링크 주소를 넣는 <script>태그에서 js 코드를 작성하면 안됨!

<01_setup.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>jQuery</title>
 
<!-- 방법1 -->
<!-- <script src="js/jquery-3.2.0.min.js">
</script>-->
<!-- 방법2 -->
<script src="https://code.jquery.com/jquery-3.2.1.min.js">
</script>
 
<script>
// document가 다 등록된 후에 실행이 되기 때문에
// 스크립트를 head에서 선언해도 상관없음
$(document).ready(function() {
    $('h2').click(function() {
        $(this).hide();
    });
});
</script>
</head>
<body>
 
<h1>jQuery 사용하기</h1>
<h2>클릭하세요! 그럼 제가 사라집니다.</h2>
<h2>Another h2 tag</h2>
 
 
</body>
</html>
Colored by Color Scripter
cs

<출력화면>

자바스크립트 이벤트(Event) 06

모쿠 — Fri, 7 Apr 2017 16:54:41 +0900

<자바스크립트 Capturing/Bubbling>

- Event Capturing: 이벤트 처리 순서가 부모 요소 -> 자식 요소

- Event Bubbling: 이벤트 처리 순서가 자식 요소 -> 부모 요소

<32_event6.html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>JavaScript</title>
<style>
div {
    border: 1px solid grey;
    padding: 20px;
}
p {
    border: 1px dotted red;
}
</style>
</head>
<body>
 
<h1>Event Capturing/Bubbling</h1>
<div id="div1">
    <p id="p1">Event Capturing: 부모 -> 자식
    </p>
</div>
 
<div id="div2">
    <p id="p2">Event Bubbling: 자식 -> 부모
    </p>
</div>
 
 
<script>
var div1 = document.getElementById('div1');
var p1 = document.getElementById('p1');
 
div1.addEventListener('click', function() { alert('div입니다!');
}, true);
p1.addEventListener('click', function() { alert('p입니다!'); }, true);
 
var div2 = document.getElementById('div2');
var p2 = document.getElementById('p2');
 
div2.addEventListener('click', function() { alert('div입니다!');
}, false);
p2.addEventListener('click', function() { 
    alert('p입니다!');
    event.stopPropagation();
    }, false);
 
</script>
 
</body>
</html>
 
 
Colored by Color Scripter
cs

<출력화면>