[2019.02.26]

원문 : 애플 개발 문서 Swift 5.0 Language Guide - Basic Operators

기본 연산자(Basic Operators)

연산자(operator)는 값을 검사하고, 변경하거나 결합하기 위해 사용하는 특별한 기호(symbol) 또는 문구(phrase)입니다. 예를들어, 더하기 연산자(+)는 let i = 1 + 2처럼, 두개의 숫자를 더하고, 논리 AND 연산자(&&)는 if enteredDoorCode && passedRetinaScan 처럼 두개의 Boolean 값을 결합합니다.

Swift는 대부분의 표준 C 연산자와 일반적인 코딩 오류를 제거하기 위해 향상시킨 몇가지 기능들을 제공합니다. 할당 연산자(=)는 실수로 동등 연산자(==) 대신 사용되는 것을 막기 위해, 값을 반환하지 않습니다. 산술(arithmetic) 연산자(+, -, *, /, %, 등등…)는 저장하는 타입의 허용된 값의 범위보다 더 크가나 더 작은 숫자로 작업할때, 예기치 않은 결과를 피하기 위해, 값 오버플로우를 발견(detect)하고 차단(disallow)합니다. Swift의 오버플로우 연산자를 사용해서 오버플로우 동작을 선택할수 있으며, Overflow Operators에서 설명되어 있습니다.

또한 Swift는 값의 범위를 간결하게 표현하기 위해 a..<b와 a...b와 같은 C에서는 찾을수 없는 범위 연산자를 제공합니다.

이번 장에서는 Swift에서의 일반 연산자를 설명합니다. Advanced Operators는 Swift의 고급 연산자를 다루고, 사용자정의 연산자를 정의하고 사용자정의 타입에 대한 표준 연산자를 구현하는 방법을 설명합니다.

용어(Terminology)

연산자는 단항(unary), 이항(binary), 삼항(ternary)이 있습니다.

• 단항(Unary) 연산자는 단일 대상(-a 처럼)에서 동작합니다. 단항 접두사(prefix) 연산자는 (!b 처럼)대상 바로 앞에 나타나고 단항 접미사(postfix) 연산자는 (c! 처럼)대상 바로 뒤에 나타납니다.
• 이항(Binary) 연산자는 2 개의 대상(2 + 3 처럼)에서 동작하고 두 대상 사이에 나타나기 때문에 중위(infix)입니다.
• 삼항(Ternary) 연산자는 3 개의 대상에서 동작합니다. C 와 같이, Swift는 하나의 삼항 연산자만을 가지며, 삼항 조건 연산자(a ? b : c)입니다.

연산자에 영향을 받는 값은 피연산자(operands)입니다. 1 + 2 표현식에서, + 기호는 이항 연산자 이고, 두개의 피연산자는 1과 2 값입니다.

할당 연산자(Assignment Operator)

할당 연산자(assignment operator)(a = b)는 a의 값에 b의 값으로 초기화하거나 업데이트합니다.

let b = 10
var a = 5
a = b
// a is now equal to 10

할당(assignment =)의 오른쪽에 여러 값이 튜플(tuple)로 있는 경우에, 그 요소들은 한번에 여러개의 상수나 변수로 분해될 수 있습니다.

let (x, y) = (1, 2)
// x is equal to 1, and y is equal to 2

C와 Objective-C 에서의 할당 연산자와 다르게, Swift에서의 할당 연산자(assignment operator)는 자체적으로 값을 반환하지 않습니다. 다음에 오는 구문은 유효하지 않습니다.

if x = y {
    // This is not valid, because x = y does not return a value.
}

이 기능은 실제 의도가 동등 연산자(==)일때 실수로 할당 연산자(=)가 사용되는 것을 막아줍니다. Swift는 코드에서 이런 종류의 오류를 피하는데 도움을 줍니다.

산술 연산자(Arithemetic Operators)

Swift는 모든 숫자 타입에 대해 4개의 표준 산술 연산자(arithmetic operators)을 지원합니다.

• 덧셈(Addition) (+)
• 뺄셈(Subtraction) (-)
• 곱셈(Multiplication) (*)
• 나눗셈(Division) (/)

1 + 2       // equals 3
5 - 3       // equals 2
2 * 3       // equals 6
10.0 / 2.5  // equals 4.0

C와 Objective-C에서의 산술 연산자와 다르게, Swift의 산술 연산자는 기본적으로 값 오버플로우(overflow)를 허용하지 않습니다. Swift의 오버플로우 연산자(a &+ b)를 사용해서 값 오버플로우 동작을 선택할 수 있습니다. Overflow Operators를 보세요.

더하기 연산자(addition operator)는 String 연결을 지원합니다.

"hello, " + "world"  // equals "hello, world"

나머지 연산자(Remainder Operator)

나머지 연산자(remainder operator)(a % b)는 얼마나 많은 수의 b가 있는지 알아내고 남은 값(나머지(remainder))을 반환합니다.

주의
나머지 연산자(%)는 다른 언어에서 모듈로 연산자(modulo operator)라고 합니다. 하지만, Swift에서는 음수에서도 동작하며, 엄밀히 말하면(strictly speaking), 모듈로 연산하기보다는 나머지(remainder)가 된다는 것을 의미합니다.

다음은 나머지 연산자가 동작하는 방법입니다. 9 % 4를 계산하기 위해서, 먼저 9에 4가 얼마나 많은지를 계산합니다.

9 안에 두개의 4를 넣을수 있고 나머지는 1 입니다(오렌지 색으로 표시)

Swift에서 다음과 같이 작성합니다.

9 % 4    // equals 1

a % b에 대한 답을 구하기 위해 % 연산자는 다음에오는 공식을 계산하고 출력으로 remainder를 반환합니다.

a = (b x some multiplier) + remainder

some multipler는 a안에 b가 들어갈수 있는 최대 갯수입니다.

9와 4를 공식에 대입합니다.

9 = (4 x 2) + 1

a의 음수 값에 대한 나머지를 계산할때에도 같은 방법이 적용됩니다.

-9 % 4   // equals -1

-9와 4를 공식에 대입합니다.

-9 = (4 x -2) + -1

-1의 나머지 값을 줍니다.

b의 음수 값에 대해 b의 부호는 무시됩니다. 이는 a % b와 a % -b가 항상 같은 값을 주는 것을 의미합니다.

단항 빼기 연산자(Unary Minus Operator)

숫자 값의 부호는 접두사 -를 사용해서 토글(toggled)될수 있으며, 단항 빼기 연산자(unary minus operator)라고 합니다.

let three = 3
let minusThree = -three       // minusThree equals -3
let plusThree = -minusThree   // plusThree equals 3, or "minus minus three"

단항 뺄셈 연산자(-)는 공백 없이, 연산자 값 바로 앞에 붙여줍니다.

단항 더하기 연산자(Unary Plus Operator)

단항 더하기 연산자 (+)는 아무런 변경없이 연산된 값을 단순히 반환합니다.

let minusSix = -6
let alsoMinusSix = +minusSix  // alsoMinusSix equals -6

비록 단항 더하기 연산자는 실제 아무것도 하지 않지만, 음수에 대해 단항 빼기 연산자를 사용할때 코드에서 양수에 대한 대칭성(symmetry)를 제공할 수 있습니다.

복합 할당 연산자(Compound Assignment Operators)

C언어 처럼, Swift는 다른 연산자와 할당 연산자(=)를 결합하는 복합 할당 연산자(compound assignment operators)를 제공합니다. 한가지 예로 덧셈 할당 연산자(addition assignment operator)(+=)입니다.

var a = 1
a += 2
// a is now equal to 3

a += 2 표현식은 a = a + 2에 대한 축약입니다. 실제로(Effectively), 덧셈과 할당은 동시에 두 작업을 수행하는 하나의 연산자로 결합됩니다.

주의
복합 할당 연산자는 값을 반환하지 않습니다. 예를 들어, let b = a += 2를 사용할 수 없습니다.

Swift 표준 라이브러리에서 제공되는 연산자들에 대한 정보는 Operator Declarations를 보세요.

비교 연산자(Comparision Operators)

Swift는 모든 표준 C의 비교 연산자(comparison operators)를 지원합니다.

• 같다 (a == b)
• 같지 않다 (a != b)
• 더 크다 (a > b)
• 더 작다 (a < b)
• 더 크거나 같다 (a >= b)
• 더 작거나 같다 (a <= b)

주의
또한 Swift는 동일한 객체 인스턴스를 참조하는지 테스트하기 위해 사용하는 두개의 식별 연산자(identity operators)를 제공합니다. 자세한 정보는, identily Operators를 보세요.

각각의 비교 연산자들은 상태가 true인지 아닌지를 나타내는 Bool 값을 반환합니다.

1 == 1   // true because 1 is equal to 1
2 != 1   // true because 2 is not equal to 1
2 > 1    // true because 2 is greater than 1
1 < 2    // true because 1 is less than 2
1 >= 1   // true because 1 is greater than or equal to 1
2 <= 1   // false because 2 is not less than or equal to 1

비교 연산자들은 종종 if문과 같은 조건문에서 사용됩니다.

let name = "world"
if name == "world" {
    print("hello, world")
} else {
    print("I'm sorry \(name), but I don't recognize you")
}
// Prints "hello, world", because name is indeed equal to "world".

if문에 대한 자세한 것은, Control Flow를 보세요.

같은 타입을 가지고 같은 숫자값을 가지는 경우에 두개의 튜플(tuples)을 비교할 수 있습니다. 튜플(Tuples)은 왼쪽에서 오른쪽으로 비교되며, 한번에 하나의 값으로, 두 값들이 같지 않을때까지 비교합니다. 두 값은 비교되고, 비교의 결과로 튜플 비교의 전체 결과를 결정하게 됩니다. 모든 요소들이 동일한 경우, 튜플은 같습니다. 예를들어:

(1, "zebra") < (2, "apple")   // true because 1 is less than 2; "zebra" and "apple" are not compared
(3, "apple") < (3, "bird")    // true because 3 is equal to 3, and "apple" is less than "bird"
(4, "dog") == (4, "dog")      // true because 4 is equal to 4, and "dog" is equal to "dog"

위 예제에서, 첫번째 줄에서 왼쪽에서 오른쪽으로(left-to-right) 비교하는 것을 볼수 있습니다. 1이 2보다 작기 때문에, (1, "zebra")는 (1, "apple")보다 작은 것으로 간주되며, 튜플에 있는 다른 값들과는 상관없습니다. 튜플의 첫번째 요소에 의해 비교는 이미 결정되었기 때문에, "zebra"가 "apple"보다 작지 않은 것은 중요하지 않습니다. 하지만, 튜플의 첫번째 요소가 동일한 경우, 두번째 요소가 비교됩니다-이는 두번째와 세번째 줄에서 처리되고 있습니다.

튜플은 연산자가 튜플의 각각의 값에 적용될수 있는 경우에만 주어진 연산자로 비교될수 있습니다. 예를 들어, 아래 코드에서 보여주는(demonstrated) 것처럼, String과 Int값은 <연산자를 사용해서 비교될수 있기 때문에, (String, Int) 타입의 튜플들은 비교할수 있습니다. 이와 반대로(constrast), (String, Bool)타입의 튜플은 Bool값에 < 연산자를 적용할수 없기 때문에, < 연산자로 비교될수 없습니다.

("blue", -1) < ("purple", 1)        // OK, evaluates to true
("blue", false) < ("purple", true)  // Error because < can't compare Boolean values

주의
Swift 표준 라이브러리는 7개 미만의 튜플에 대한 튜플 비교 연산자를 포함합니다. 7개 이상의 튜플을 비교하기 위해, 비교연산자를 직접 구현해야 합니다.

삼항 조건 연산자(Ternary Conditional Operator)

삼항 조건 연산자(ternary conditional operator)는 question ? answer1 : answer2 형식을 가진 3부분으로 된 특별한 연산자 입니다. question이 true 또는 false인지를 기반으로해서 두개의 표현식을 하나로 간결하게 만든것입니다. question이 true인 경우, answer1로 처리하고 그 값을 반환합니다; 반대의 경우에는 answer2로 처리하고 그 값을 반환합니다.

그 삼항 조건 연산자는 아래 코드를 간결하게 한 것입니다.

if question {
    answer1
} else {
    answer2
}

다음에 오는 예제는 테이블 행(row)에 대한 높이를 계산합니다. 그 행(row)이 헤더인 경우에, 행의 높이는 컨텐츠 높이보다 50 포인트 더 크고 헤더가 아닌 경우에는 20 포인트 더 커야 합니다.

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90

위 예제는 아래 코드를 간결하게 한 것입니다.

let contentHeight = 40
let hasHeader = true
let rowHeight: Int
if hasHeader {
    rowHeight = contentHeight + 50
} else {
    rowHeight = contentHeight + 20
}
// rowHeight is equal to 90

첫번째 예제의 삼항 조건연산자의 사용은 rowHeight가 코드 한줄로 올바른 값으로 설정할수 있으며, 두번째 예제에서 사용된 코드보다 더 간결(concise)합니다.

삼항조건 연산자는 두 펴현식중 하나를 결정하는데 효과적인 간결함을 제공합니다. 삼항조건 연산자를 주의해서 사용해야하며, 과도하게 사용하면 코드를 읽기 어렵게 만듭니다. 삼항 조건 연산자의 인스턴스 여러개를 하나의 복합문에서 사용하는 것은 피해야 합니다.

Nil 결합 연산자(Nil-Coalescing Operator)

nil 결합 연산자(nil-coalescing operator) (a ?? b)는 옵셔널 a가 값을 가지고 있는 경우 언래핑(unwraps)하거나 nil인 경우에 기본값 b를 반환합니다. 이 표현식 a는 항상 옵셔널 타입입니다. 표현식 b는 a에 저장된 타입과 반드시 같아야 합니다.

nil 결합 연산자는 아래 코드를 간결하게 한 것입니다.

a != nil ? a! : b

위 코드는 삼항 조건 연산자를 사용하고 nil이 아닐때 래핑된 값을 사용하기 위해 강제 언래핑(a!)하고, 그렇지 않으면 b를 반환합니다. nil 결합 연산자는 간결하고 읽기쉬운 형식으로 조건문을 확인하고 언래핑하는 것을 캡슐화하는 우아한 방법을 제공합니다.

주의
nil이 아닌 경우에, b의 값은 처리되지 않습니다. 이는 연산 생략(short-circuit-evaluation)이라고 합니다.

아래 예제는 기본 색상 이름과 옵셔널 사용자정의된 색상 이름간에 고르기 위해 nil 결합 연산자를 사용합니다.

let defaultColorName = "red"
var userDefinedColorName: String?   // defaults to nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is nil, so colorNameToUse is set to the default of "red"

userDefinedColorNmae 변수는 옵셔널 String으로 정의되어 있으며, 기본 값은 nil입니다. userDefaultColorName은 옵셔널 타입이기 때문에, 값을 가져오기 위해 nil 결함 연산자를 사용할 수 있습니다. 위 예제에서, 연산자는 colorNameToUse라는 String 변수에 대한 초기값을 결정하는데 사용됩니다. userDefinedColorNmae이 nil이기 때문에, 그 표현식 userDefinedColorName ?? defaultColorName은 defaultColorName 또는 "red"값을 반환합니다.

userDefinedColorName에 nil이 아닌 값을 할당하고 nil 결합 연산자를 다시한번 확인하는 경우에, 그 값은 userDefinedColorName 내부에 래핑(wrapped)된 갓이 기본값 대신 사용됩니다.

userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is not nil, so colorNameToUse is set to "green"

범위 연산자(Range Operators)

Swift는 범위 값을 간결하게 표현하는 몇가지 범위 연산자(range-operators)를 가지고 있습니다.

폐쇄된 범위 연산자(Closed Range Operator)

폐쇄된 범위 연산자(closed range operator) (a...b)는 a에서 b까지의 범위를 정의하고, a와 b의 값을 포함합니다. a 값은 반드시 b보다 크지 않아야 합니다.

폐쇄된 범위 연산자는 for-in 반복문과 같이 모든 값을 사용하길 원하는 범위를 반복할때 유용합니다.

for index in 1...5 {
    print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

for-in 반복문에 대한 자세한 것은 Control Flow를 보세요.

반 개방 범위 연산자(Half-Open Range Operator)

반 개방 범위 연산자(half-open range operator) (a..<b)는 a에서 b까지의 범위를 정의하지만, b를 포함하지는 않습니다. 첫번째 값이 포함되었지만 마지막 값은 그렇지 않기에, 반 개방(half-open)이라고 합니다. 폐쇄 범위 연산자처럼, a의 값은 b보다 반드시 크지 않아야 합니다. a의 값이 b와 같은 경우에, 결과의 범위는 비어있을 것입니다.

반 개방 범위는 배열처럼 0을 기반(zero-based)으로 한 작업을 할때 특히 유용하며, 목록의 길이(포함하지 않음)를 계산할때 유용합니다.

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    print("Person \(i + 1) is called \(names[i])")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

배열이 4개의 항목을 가지고 있지만, 반 개방 범위이기 때문에, 0..<count는 3(배열의 마지막 항목의 인덱스)까지만 세는 것을 주의합니다. 배열에 대한 자세한 것은 Arrays를 보세요.

단방향 범위(One-Side Ranges)

폐쇄 범위 연산자는 가능한한 한 방향으로 계속되는 범위 형식을 가집니다-예를들어, 그 범위는 배열의 인덱스 2에서 배열의 끝의 모든 요소들을 포함합니다. 이 경우에, 범위 연산자의 단방향으로부터 값을 생략할 수 있습니다. 연산자가 한쪽에만 값을 가지고 있기 때문에 그 범위는 단방향 범위(one-sided range)라고 합니다. 예를 들어:

for name in names[2...] {
    print(name)
}
// Brian
// Jack

for name in names[...2] {
    print(name)
}
// Anna
// Alex
// Brian

또한 반 개방 범위 연산자는 마지막 값으로 작성한 단방향 형식을 가지고 있습니다. 양쪽 방향에 값을 가질때처럼, 마지막 값은 범위에 포함되지 않습니다. 예를 들어:

for name in names[..<2] {
    print(name)
}
// Anna
// Alex

단방향 범위 연산자(One-side ranges)는 서브스크립트(subscripts) 뿐만아니라 다른 곳(contexts)에서도 사용될 수 있습니다. 시작이 명확하지 않기 때문에, 첫번째 값을 생략한 단방향 범위를 반복 할 수 없습니다; 하지만, 범위가 무한정 계속되기 때문에, 반복문에 명시적인 종료 조건을 추가해야 합니다. 또한 아래 코드에서 보는 것처럼, 단방향 범위가 특정 값을 포함하는지 확인할 수 있습니다.

let range = ...5
range.contains(7)   // false
range.contains(4)   // true
range.contains(-1)  // true

논리 연산자(Logical Operators)

논리 연산자(Logical operators)는 Boolean 로직 값 true와 false를 수정하거나 결합합니다. Swift는 C 기반 언어에서 볼수 있는 3개의 표준 논리 연산자를 지원합니다.

• 논리 NOT (!a)
• 논리 AND (a && b)
• 논리 OR (a || b)

NOT 논리 연산자(Logical NOT Operator)

NOT 논리 연산자 (!a)는 true는 false로가 되며, false는 true가 되도록 Boolean 값을 반전합니다.

NOT 논리 연산자는 접두사(prefix) 연산자이고, 연산 중인 값 바로 앞에 공백업이 표시합니다. 다음 예제에서 보는 것처럼 a가 아니다(not a)로 읽을 수 있습니다.

let allowedEntry = false
if !allowedEntry {
    print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"

if !allowedEntry 구문은 허용되지 않은 항목인 경우(if not allowed entry)로 읽을 수 있습니다. 다음에 오는 줄은 허용되지 않은 항목(not allowed entry)이 true이며, allowedEntry는 false인 경우입니다.

예제에서 처럼, Boolean 상수와 변수 이름을 주의해서 선택하면, 코드를 읽기 쉽고 간결(concise)하게 유지하는데 도움이 되며, 이중 부정(double negatives)이나 혼란스로운 로직 상태를 피할 수 있습니다.

AND 논리 연산자(Logical AND Operator)

AND 논리 연산자(Logical AND Operator) (a && b는 두 값 모두 반드시 true가 되야만 전체 표현식이 true가 되는 논리적인 표현식을 생성합니다.

값이 하나라도 false인 경우에, 전체 표현식은 false가 될것입니다. 사실 첫번째(first) 값이 false인 경우, 전체 표현식이 true가 될수 없기 없기때문에, 두번째 값은 확인조차하지 않습니다. 이를 연산 생략(short-circuit evalution)이라고 합니다.

이 예제는 두개의 Bool 값을 확인하고 두 값 모두 true인 경우에만 사용할 수 있습니다.

let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"

OR 논리 연산자(Logical OR Operator)

OR 논리 연산자(logical OR operator) (a || b)는 두개의 인접한(adjacent) 파이프 문자(|) 로 구성된 중위(infix) 연산자 입니다. 두개의 값중 하나라도 true인 경우에 전체 표현식이 true가 되는 논리 표현식을 생성하기 위해 사용합니다.

위의 AND 논리 연산자처럼, OR 논리 연산자는 표현식에 연산 생략(short-circuit evaluation)을 사용합니다. OR 논리 연산자의 왼쪽부분이 true인 경우에, 전체 표현식이 변경될수 없기 때문에, 오른쪽은 처리되지 않습니다.

아래 예제에서, 첫번째 Bool값(hasDoorKey)은 false이지만, 두번째 값 (knowsOverridePassword)는 true입니다. 하나의 값이 true이기 때문에, 전체 표현식은 true이고 사용할 수 있습니다.

let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "Welcome!"

논리 연산자 결합하기(Combining Logical Operators)

더 길고 복잡한 표현식을 생성하기 위해 여러개의 논리 연산자들을 결합할 수 있습니다.

if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "Welcome!"

이 예제는 더 길고 복잡한 표현식을 생성하기 위해, 여러개의 &&과 || 연산자를 사용합니다. 하지만 &&와 || 연산자는 여전히 두개의 값에 대해서만 연산하며, 실제로 3개의 작은 표현식을 묶어놓은 것입니다. 예제는 다음과 같이 읽을 수 있습니다:

정확한 문(door)의 코드를 입력하고 망막(retina) 스캔을 통과하거나, 문의 유효한 키를 가지고 있거나, 비상 비밀번호를 알고 있는 경우에 사용할 수 있습니다.

enteredDoorCode, passedRetinaScan, hasDoorKey의 값을 기반으로, 처음 두개의 하위 표현식은 false입니다. 하지만 비상 비밀번호를 알고 있으면, 전체 복합 표현식은 여전히 true가 됩니다.

주의
Swift의 논리 연산자 &&와 ||는 왼쪽 결함(left-associative)이며, 여러개의 논리 연산자에서 맨 왼쪽 표현식 부터 먼저 계산하는 것을 의미합니다.

명시적인 괄호(Explicit Parentheses)

복잡한 표현식의 의도를 쉽게 읽을수 있도록, 괄호(parentheses)가 절대적(strictly)으로 필요하지 않을때에도 포함하는게 유용할 때가 있습니다. 위의 문을 사용하는 예제에서, 의도를 명확히 하기 위해서, 복합 표현식의 첫번재 부분에 괄호를 추가하는게 유용합니다.

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "Welcome!"

괄호(parentheses)는 처음 두개의 값이 전체 로직에서 분리 가능한 상태의 일부가 되는 것을 명확히 해줍니다. 복합 표현식의 결과는 바뀌지 않지만, 전체 의도는 명확해 집니다. 가독성은 언제나 간결함보다 선호됩니다; 괄호는 의도를 명확히 해주는데 도움이 되는 곳에서 사용합니다.