-
[Swift] ์ฐ์ฐ์ (Operator)Swift 2022. 1. 6. 22:38
(๋ชจ๋ ์ฝ๋๋ Playground์์ ์์ฑ๋์์ต๋๋ค.)
์ด๋ฒ ์๊ฐ์๋ ์ฐ์ฐ์์ ๋ํด์ ์์๋ณด๋๋ก ํ์!
์ฐ์ฐ์ (Operator)๋ ๋ง ๊ทธ๋๋ก ์ฐ์ฐ์ ํ๊ธฐ ์ํ ๊ธฐํธ๋ก, +, -, *, / ๋ฑ์ ๋งํ๋ค.
ํผ์ฐ์ฐ์ (Operand)๋ ์ฐ์ฐ์ ์ฌ์ฉ๋๋ ๊ฐ์ ์๋ฏธํ๋ค. ํผ์ฐ์ฐ์ ์์ ๋ฐ๋ผ์ ๋ถ๋ฅ๋ฅผ ํ ์ ์๋๋ฐ, ์์ธํ ์์๋ณด๋๋ก ํ์.
Unary Operator (๋จํญ ์ฐ์ฐ์)
ํผ์ฐ์ฐ์ ์๊ฐ 1๊ฐ์ธ ๊ฒฝ์ฐ๋ฅผ ๋จํญ ์ฐ์ฐ์ (Unary Operator) ๋ผ๊ณ ํ๋ค.
์ฐ์ฐ์์ ํผ์ฐ์ฐ์๋ฅผ ๊ณต๋ฐฑ ์์ด ๋ถ์ฌ์ ์จ์ผํ๊ณ , ์๋์ ๊ฐ์ด ์ฌ์ฉํ ์ ์๋ค.

์ฌ๊ธฐ์ ํผ์ฐ์ฐ์ ์์น์ ๋ฐ๋ผ์ ์ฐ์ฐ์๋ฅผ ๋ถ๋ฅด๋ ์ด๋ฆ์ด ๋ฌ๋ผ์ง๋๋ฐ,
์ฐ์ฐ์๊ฐ ํผ์ฐ์ฐ์ ์์ ์กด์ฌํ ๊ฒฝ์ฐ์๋ Prefix Operator (๋จํญ ์ ์น ์ฐ์ฐ์)
์ฐ์ฐ์๊ฐ ํผ์ฐ์ฐ์ ๋ค์ ์กด์ฌํ ๊ฒฝ์ฐ์๋ Postfix Operator (๋จํญ ํ์น ์ฐ์ฐ์)
์ฐ์ฐ์๊ฐ ํผ์ฐ์ฐ์ ์ฌ์ด์ ์กด์ฌํ ๊ฒฝ์ฐ์๋ Infix Operator (์ค์ ์ฐ์ฐ์) ๋ผ๊ณ ํ๋ค.
Binary Operator (์ดํญ ์ฐ์ฐ์)
ํผ์ฐ์ฐ์๊ฐ 2๊ฐ์ธ ๊ฒฝ์ฐ๋ฅผ ์ดํญ ์ฐ์ฐ์ (Binary Operator) ๋ผ๊ณ ํ๋ค.
์ฐ์ฐ์ ์ ์์ ๋ฐ๋์ ๊ณต๋ฐฑ์ ์ถ๊ฐํด์ผํ๋ฉฐ, ์๋์ ๊ฐ์ด ์ฌ์น์ฐ์ฐ์ ์ฌ์ฉํ ์ ์๋ค.
๋ํ, ์ดํญ ์ฐ์ฐ์๋ ๊ฐ์ ์๋ฃํ๋ผ๋ฆฌ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
์ด ๋ Int์ Int๋ฅผ ๋ํ ๊ฒฐ๊ณผ ๊ฐ์ ํ์ ์ Int, Double๊ณผ Double์ ๋ํ ๊ฒฐ๊ณผ ๊ฐ์ ํ์ ์ Double์ด๋ค.

๊ทธ๋ ๋ค๋ฉด, ์ ์์ ์ค์๋ฅผ ๋ํ ๊ฒฐ๊ณผ ๊ฐ์ ํ์ ์ ์ด๋ป๊ฒ ๋ ๊น?

์ ์์ ์ค์๋ฅผ ๋ํ๋ฉด, ๊ทธ ๊ฒฐ๊ณผ๊ฐ์ด Double๋ก ์ ์ฅ๋๋ค.
๊ทธ๋ ๋ค๋ฉด Intํ์ ์์์ Double ํ์ ์์๋ฅผ ์ ์ธํ๊ณ ์ด๊ธฐํํ ํ์, ์ด ๋์ ๋ํ ๊ฒฝ์ฐ์๋ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ๊น?
Doubleํ์ผ๋ก ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ๊ฒ์ด๋ผ๋ ๋ด ์์๊ณผ๋ ๋ฌ๋ฆฌ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.

Int์ Double์ ํ์ ์ด ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ํ ์๊ฐ ์๋ค๊ณ ํ๋ค.
๊ทธ๋ ๋ค๋ฉด ์ ์์์ 1๊ณผ 2.3์ ๋ํ์ ๋์๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์์์๊น??
๊ตฌ๊ธ์ ๊ฒ์ํด๋ณธ ๊ฒฐ๊ณผ!
์์์๋ 1๊ณผ 2.3์ ๋ํด์ ๋ช ์์ ์ผ๋ก ๊ฐ์ ํ์ ์ ์ง์ ํด์ฃผ์ง ์์๊ธฐ ๋๋ฌธ์, ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก ์ ์ ํ ํ์ ์ ์ ํํด์ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์๋ ๊ฒ์ด๋ผ๊ณ ํ๋ค. ๋ค์ ๋งํด ์์ 1๊ณผ 2.3์ ์ปดํ์ผ๋ฌ์๊ฒ 1 (Double) + 2.3 (Double)๋ก ๋ฐ์๋ค์ฌ์ง ๊ฒ์ด๋ค.
๊ทธ๋ฌ๋๊น, a์ b๋ฅผ ๋ํ๋ ๊ณผ์ ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ด์ ๋ ํ์ ์ด ๋ค๋ฅธ ๋ ๊ฐ์ ๋ํ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์ธ ๊ฒ์ด๋ค.
์ด ์ค๋ฅ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด Type Conversion์ ๋ํด ์์๋ณด์.
Type Conversion์ด๋, ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋ ๊ฐ์ ๋ค๋ฅธ ํ์์ผ๋ก ๋ฐ๊ฟ์ ์๋ก์ด ๊ฐ์ผ๋ก ์์ฑํ๋ ๊ฒ์ด๋ค.
ํ์ (ํ๋ณํํ ๊ฐ) ๊ณผ ๊ฐ์ด ์ฌ์ฉ์ ํ๋ฉฐ, Type Conversion์ด ์คํจํ๋ฉด nil์ด ๋ฆฌํด๋๋ค.
๋ง์ฝ Type Conversion์ ํ ๋ ๊ฐ์ ์ ์ฅํ ๊ณต๊ฐ์ด ์ถฉ๋ถํ์ง ์๋ค๋ฉด, ์๋์ ๊ฐ์ด ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์๋ค.
Int8์ Int๋ฅผ ์ ์ฅํ๊ธฐ์๋ ์ ์ฅ๊ณต๊ฐ์ด ๋ถ์กฑํ๊ธฐ ๋๋ฌธ์ ์๋์ ๊ฐ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค.
๋ฐ๋ผ์ ์ถฉ๋ถํ ๊ณต๊ฐ์ ๊ฐ์ ์ ์ฅํ ์ ์๋๋ก ํด์ผํ๋ค!

์ฐธ๊ณ ๋ก Int8, Int, UInt์ ๊ฐ์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์๋ ์ฌ์ง๊ณผ ๊ฐ๋ค.

์ด์ a์ b๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํด Type Conversion์ ์ฌ์ฉํด๋ณด์.
2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋๋ฐ, Doubleํ์ Int๋ก ํ๋ณํํ์ฌ Int + Int๋ก ๊ณ์ฐํ๊ฑฐ๋, Int๋ฅผ Double๋ก ํ๋ณํํ์ฌ Double + Double๋ก ๊ณ์ฐํ๋ ๊ฒ์ด๋ค.
Type Conversion์ ํ ๊ฒฝ์ฐ, ์๋ฌด๋๋ ๊ฐ์ ์์ค์ ๋ฐฉ์งํ๊ธฐ ์ํด์๋ Int๊ฐ ์๋ Double๋ก ํ๋ณํํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค!

Comparison Operator (๋น๊ต ์ฐ์ฐ์)
๋น๊ต ์ฐ์ฐ์๋ ๋ชจ๋ ์ดํญ ์ฐ์ฐ์๋ก ์ฌ์ฉ๋๋ฉฐ, ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๊ฐ์ ์๋ฃํ๋ง ๋น๊ต๊ฐ ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฒฐ๊ณผ ๊ฐ์ ํญ์ boolean์ด๋ค.
==, !=, >, >=, <, <= ๋ก ์ฌ์ฉํ๋ค.
Logical Operator (๋ ผ๋ฆฌ ์ฐ์ฐ์)
์ฐธ๊ณผ ๊ฑฐ์ง์ ๊ตฌ๋ถํ๋ ์ฐ์ฐ์๋ก, ๋ชจ๋ ํผ์ฐ์ฐ์์ ์ฐ์ฐ ๊ฒฐ๊ณผ๋ ํญ์ boolean์ด๋ค.
Logical AND (&&)๋ ๋ชจ๋ ํผ์ฐ์ฐ์๊ฐ true์ธ ๊ฒฝ์ฐ์๋ง true๋ฅผ ๋ฆฌํดํ๊ณ , ๊ทธ ์ธ์ ๊ฒฝ์ฐ๋ ๋ชจ๋ false๋ฅผ ๋ฆฌํดํ๋ค.
Logical OR (||)๋ ๋ชจ๋ ํผ์ฐ์ฐ์๊ฐ false์ธ ๊ฒฝ์ฐ์๋ง false๋ฅผ ๋ฆฌํดํ๊ณ , ๊ทธ ์ธ์ ๊ฒฝ์ฐ๋ ๋ชจ๋ true๋ฅผ ๋ฆฌํดํ๋ค.
Logical NOT (!)์ ํผ์ฐ์ฐ์ ์์ !๋ฅผ ๋ถ์ด๋ ๊ฒ์ธ๋ฐ, ๊ฐ์ ๋ฐ๋๋ก ๋ฐ๊ฟ์ค๋ค. true๋ฅผ false๋ก, false๋ฅผ true๋ก ๋ฆฌํดํด์ค๋ค.
Ternary Operator (์ผํญ ์ฐ์ฐ์ / ์กฐ๊ฑด ์ฐ์ฐ์)
ํผ์ฐ์ฐ์์ ์ฐ์ฐ์ ์ ์์ ๊ณต๋ฐฑ์ ์ถ๊ฐํ๋ ๊ฒ์ผ๋ก, ์กฐ๊ฑด ? ๊ฒฐ๊ณผ1 : ๊ฒฐ๊ณผ2 ์ ๊ฐ์ด ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
์กฐ๊ฑด์ ๊ธฐ์ค์ผ๋ก 2๊ฐ์ ๊ฐ ์ค ํ๋๋ฅผ ์ ํํ๋ ๊ฒ์ธ๋ฐ, ์กฐ๊ฑด์ด true๋ผ๋ฉด ๊ฒฐ๊ณผ1์, false๋ผ๋ฉด ๊ฒฐ๊ณผ2๊ฐ ์ฐ์ฐ์ ๊ฒฐ๊ณผ๋ก ์ฌ์ฉ๋๋ค.
์ด ๋, ์กฐ๊ฑด์ ํญ์ boolean์ด๊ณ , ๊ฒฐ๊ณผ1, ๊ฒฐ๊ณผ2์ ์๋ฃํ์ ๋น์ฐํ ๊ฐ์์ผ ํ๋ค.
์ผํญ ์ฐ์ฐ์๋ ์๋ ์ฌ์ง๊ณผ ๊ฐ์ด ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.

Assign Operator (ํ ๋น ์ฐ์ฐ์)
ํ ๋น ์ฐ์ฐ์๋ ๋ง ๊ทธ๋๋ก ๊ฐ์ ํ ๋นํด์ฃผ๋ ์ฐ์ฐ์๋ฅผ ์๋ฏธํ๋ค.
var ๋ณ์์ด๋ฆ = ์ด๊ธฐ๊ฐ ์์ =๋ฅผ ์๋ฏธํ๋ฉฐ, ํ ๋น ์ฐ์ฐ์์ ๊ฒฐ๊ณผ๋ Void์ด๋ค. ์ฆ, ๊ฐ์ ๋ฆฌํดํ์ง ์๋๋ค๋ ๋ป์ด๋ค.
์ถ๊ฐ์ ์ผ๋ก +=, -=, *=, /= ์ ๊ฐ์ ๋ณตํฉ ํ ๋น ์ฐ์ฐ์๋ ์กด์ฌํ๋ค.
'Swift' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Swift] Range Operator (๋ฒ์ ์ฐ์ฐ์) (0) 2022.01.09 [Swift] ๋จ๋ฝ ํ๊ฐ (Short-circuit Evaluation) (0) 2022.01.07 [Swift] Type Inference, Type Annotation (0) 2022.01.05 [Swift] Scope (0) 2022.01.04 [Swift] ๊ธฐ๋ณธ ์ฉ์ด ์ ๋ฆฌ (0) 2022.01.03