Swift

κΈ°λ³Έ μ—°μ‚°μž ( Basic Operators )

κΈ°κ°€μ •ν›ˆ 2022. 7. 16. 17:38

 

μ•ˆλ…•ν•˜μ„Έμš”! Swift κΈ°λ³Έ μ—°μ‚°μžμ— κ΄€ν•˜μ—¬ λ‚΄μš©μ„ 정리해보도둝 ν•˜κ² μŠ΅λ‹ˆλ‹€! Λ™β°™Λ™

μ •λ¦¬ν•˜λ©΄μ„œ 기쑴에 μ•Œλ˜ λ‚΄μš©μ„ λ³΅μŠ΅ν•˜λ©° μƒˆλ‘­κ²Œ μ•Œκ²Œ 된 λ‚΄μš©μ„ κ³΅λΆ€ν•©λ‹ˆλ‹€!

아직은 많이 λΆ€μ‘±ν•  수 μžˆμœΌλ‹ˆ ν‹€λ¦° λ‚΄μš©μ΄λ‚˜ μ˜€νƒ€κ°€ μžˆλ‹€λ©΄ λŒ“κΈ€ λΆ€νƒλ“œλ¦½λ‹ˆλ‹€!

πŸ“šμ°Έκ³  λ¬Έμ„œ 및 링크

 

Basic Operators — The Swift Programming Language (Swift 5.7)

Basic Operators An operator is a special symbol or phrase that you use to check, change, or combine values. For example, the addition operator (+) adds two numbers, as in let i = 1 + 2, and the logical AND operator (&&) combines two Boolean values, as in i

docs.swift.org

 


μ—°μ‚°μžλž€ 값을 확인, λ³€κ²½ λ˜λŠ” κ²°ν•©ν•˜λŠ” 데 μ‚¬μš©ν•˜λŠ” 특수 기호 λ˜λŠ” κ΅¬λ¬Έμž…λ‹ˆλ‹€ 

 

Terminology ( μš©μ–΄ )

  • 단항 μ—°μ‚°μž : -a , !b , c!      ->  단일 λŒ€μƒμ—μ„œ μž‘λ™ν•˜λ©° λŒ€μƒμ˜ λ°”λ‘œ μ•ž 뒀에 λ‚˜νƒ€λ‚˜λŠ” μ—°μ‚°μžμž…λ‹ˆλ‹€.
  • 이항 μ—°μ‚°μž :  a + b , a - b  ->  두 λŒ€μƒ μ‚¬μ΄μ—μ„œ μž‘λ™ν•˜λ©° 두 λŒ€μƒμ˜ 사이에 λ‚˜νƒ€λ‚˜λŠ” μ—°μ‚°μžμž…λ‹ˆλ‹€.
  • μ‚Όν•­ μ—°μ‚°μž : a ? b : c         ->  μ„Έ 가지 λŒ€μƒμ—μ„œ μž‘λ™ν•˜λ©° μ˜ˆμ™€ 같은 ν˜•νƒœμ˜ 쑰건뢀 μ—°μ‚°μžμž…λ‹ˆλ‹€.

 

ν• λ‹Ή μ—°μ‚°μž 

ν• λ‹Ή μ—°μ‚°μžλŠ” μƒμˆ˜λ‚˜ λ³€μˆ˜μ˜ 값을 μ΄ˆκΈ°ν™”μ‹œν‚€κ±°λ‚˜ λ³€κ²½ν•©λ‹ˆλ‹€.

let a = 10
var a = 5
a = b 
//a 값은 10

 

μ‚°μˆ  μ—°μ‚°μž 

μ‚°μˆ  μ—°μ‚°μž (   +  :  λ§μ…ˆ   ,   -  : λΊ„μ…ˆ   ,   *  : κ³±μ…ˆ   ,    : λ‚˜λˆ—μ…ˆ   )

swift μ‚°μˆ  μ—°μ‚°μžλŠ” 기본적으둜 값이 μ˜€λ²„ν”Œλ‘œ λ˜λŠ” 것을 ν—ˆμš©ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€. 

더보기

μ˜€λ²„ν”Œλ‘œλž€ μ „μ‚°μ—μ„œ λ²”μœ„λ₯Ό μ΄ˆκ³Όν•˜λŠ” 것을 λ§ν•©λ‹ˆλ‹€. 
- λ©”λͺ¨λ¦¬ 곡간을 λ²—μ–΄λ‚˜λŠ” 것도 ν•΄λ‹Ήλ˜λ©° ν‘œν˜„ λ²”μœ„λ₯Ό λ²—μ–΄λ‚˜λŠ” 것도 ν•΄λ‹Ήλ©λ‹ˆλ‹€.

5 + 10	// 15
10 - 5	// 5
5 * 10	// 50
10 / 2  // 5

 

λ‚˜λ¨Έμ§€ μ—°μ‚°μž 

κ³„μ‚°ν•˜κ³  남은 κ°’( λ‚˜λ¨Έμ§€ )을 λ°˜ν™˜ν•©λ‹ˆλ‹€.

9 % 4 // 1
-9 % 4 // -1 μŒμˆ˜κ°’ λ˜ν•œ 방법이 μ μš©λ©λ‹ˆλ‹€

 

단항 λΉΌκΈ° μ—°μ‚°μž

단항 λΉΌκΈ° μ—°μ‚°μžλŠ” 곡백 없이 연산이 μˆ˜ν–‰λ˜λŠ” κ°’ λ°”λ‘œ μ•žμ— μΆ”κ°€λ©λ‹ˆλ‹€.

let two = 2
let minusTwo = -two	// -2
let plusTwo = -minusTwo	// 2

 

단항 ν”ŒλŸ¬μŠ€ μ—°μ‚°μž

단항 ν”ŒλŸ¬μŠ€ μ—°μ‚°μžλŠ” λ³€κ²½ 없이 λ‹¨μˆœνžˆ 연산이 μ§„ν–‰λ˜λŠ” 값을 λ°˜ν™˜ν•©λ‹ˆλ‹€.

let minusFive = -5
let alsoMinusFive = +minusFive	// -5

 

볡합 ν• λ‹Ή μ—°μ‚°μž

β€» 볡합 ν• λ‹Ή μ—°μ‚°μžλŠ” 값을 λ°˜ν™˜ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€. 예) let b =  a += 1    은 μ‚¬μš©ν•  수 μ—†μŠ΅λ‹ˆλ‹€.

var a = 1
a += 2	// -> ν’€μ–΄μ„œ ν•΄μ„ν•˜λ©΄  a = a + 2 λ”°λΌμ„œ κ²°κ³ΌλŠ” 3

 

비ꡐ μ—°μ‚°μž 

5 == 5		//	a == b	κ°™λ‹€	//true
5 != 10		//	a != b	같지 μ•Šλ‹€	//true
10 > 5		//	a > b	크닀	//true
5 < 10		//	a < b	μž‘λ‹€	//true
5 >= 5		//	a >= b	ν¬κ±°λ‚˜ κ°™λ‹€	//true
10 <= 5		//	a <= b	μž‘κ±°λ‚˜ κ°™λ‹€	//false

비ꡐ μ—°μ‚°μžλ₯Ό μ΄μš©ν•˜μ—¬ λ™μΌν•œ μœ ν˜•κ³Ό λ™μΌν•œ 수의 값을 가진 두 개의 νŠœν”Œμ„ 비ꡐ할 수 μžˆμŠ΅λ‹ˆλ‹€.

νŠœν”Œμ€ λΉ„κ΅μ—μ„œ 같지 μ•Šμ€ 두 값을 찾을 λ•ŒκΉŒμ§€ λ°©ν–₯으둜 μ™Όμͺ½μ—μ„œ 였λ₯Έμͺ½μœΌλ‘œ ν•œ λ²ˆμ— ν•œ κ°‘μ”© λΉ„κ΅λ©λ‹ˆλ‹€.

// μ™Όμͺ½μ—μ„œ 였λ₯Έμͺ½μœΌλ‘œ 비ꡐ 
(1, "zebra") < (2,"apple")	//1은 2보닀 μž‘μœΌλ―€λ‘œ zebra,apple은 λΉ„κ΅ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€	//true
(3, "apple") < (3, "bird")	//3κ³Ό 3은 κ°™κΈ° λ•Œλ¬Έμ— λ„˜μ–΄κ°€κ³  apple은 bird보닀 μž‘κΈ°λ•Œλ¬Έμ—	//true
(4, "dog") == (4, "dog")	//4와4λŠ” κ°™κΈ°λ•Œλ¬Έμ— λ„˜μ–΄κ°€κ³  dog dogλŠ” κ°™κΈ° λ•Œλ¬Έμ—	//true

("blue",-1) < ("purple",1)	//blueλŠ” purple보닀 μž‘κΈ°λ•Œλ¬Έμ— λ„˜μ–΄κ°€κ³  -1은 1보닀 μž‘κΈ°λ•Œλ¬Έμ—	//true
("blue", false) < ("purple" , true)	// boolean(λΆˆλ¦¬μ–Έκ°’)은 비ꡐλ₯Ό ν• μˆ˜μ—†μ–΄	//false

β€» 비ꡐ μ—°μ‚°μžλ₯Ό μ΄μš©ν•˜μ—¬ νŠœν”Œμ„ λΉ„κ΅ν•˜λ €λ©΄ 7개 미만의 μš”μ†Œκ°€ μžˆμ–΄μ•Ό ν•©λ‹ˆλ‹€. 7개 이상을 λΉ„κ΅ν•˜λ €λ©΄ μ—°μ‚°μžλ₯Ό 직접 κ΅¬ν˜„ν•΄μ•Ό ν•©λ‹ˆλ‹€

 

μ‚Όν•­ 쑰건 μ—°μ‚°μž

μ‚Όν•­ 쑰건뢀 μ—°μ‚°μžλŠ” ν˜•μ‹μ„ ν•„μš”λ‘œ ν•˜λŠ” μ„Έ λΆ€λΆ„μœΌλ‘œ 이루어진 특수 μ—°μ‚°μžμž…λ‹ˆλ‹€. μ°Έκ³Ό 거짓인지에 λ”°λ₯Έ ν•˜λ‚˜μ˜ 값을 κ³ λ¦…λ‹ˆλ‹€.

question ? answer1:answer2 //quesiton쑰건이 참일 경우 answer1이 μ‹€ν–‰ 거짓인 κ²½μš°μ—λŠ” answer2이 μ‹€ν–‰
// 참일 경우
let contentHeight = 10
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 20 : 50)	//30

// 거짓일 경우
let contentHeight = 10
let hasHeader = false
let rowHeight = contentHeight + (hasHeader ? 20 : 50)	//60

μ‚Όν•­ 쑰건 μ—°μ‚°μžλŠ” μ½”λ“œλ₯Ό 보닀 짧게 λ§Œλ“€μ–΄ 가독성을 λ†’μ—¬μ€λ‹ˆλ‹€πŸ‘

 

Nil 병합 μ—°μ‚°μž 

nil 병합 μ—°μ‚°μžλŠ”  a ?? b ν˜•νƒœλ₯Ό κ°–λŠ” μ—°μ‚°μžμž…λ‹ˆλ‹€.

μ˜΅μ…”λ„ λ³€μˆ˜μΈ aλ₯Ό μ–Έλž˜ν•‘ν•˜μ—¬ λ§Œμ•½ aκ°€ nil인 κ²½μš°μ— bλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.

// μ€„μž„λ§
a != nil ? a! : b
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"

β€» 만일  userDefinedColorName 값은 nil값이 μ•„λ‹ˆλΌλ©΄.  => userDefinedColorName! μ–Έλž˜ν•‘ν•˜μ—¬ λ°˜ν™˜ν•©λ‹ˆλ‹€.

            userDefinedColorName 값이 nilκ°’μž…λ‹ˆλ‹€ -> defaultColorName을 λ°˜ν™˜ν•©λ‹ˆλ‹€.

 

λ²”μœ„ μ—°μ‚°μž 

κ°’μ˜ λ²”μœ„λ₯Ό ν‘œν˜„ν•˜κΈ° μœ„ν•œ 단좕킀인 μ—¬λŸ¬ λ²”μœ„ μ—°μ‚°μžκ°€ μžˆμŠ΅λ‹ˆλ‹€.

  • 폐쇄 λ²”μœ„ μ—°μ‚°μž
  • 반개방 λ²”μœ„ μ—°μ‚°μž
  • 단츑 λ²”μœ„

1. 폐쇄 λ²”μœ„ μ—°μ‚°μž

폐쇄 λ²”μœ„ μ—°μ‚°μžλŠ” ( a...b )κΉŒμ§€μ˜ λ²”μœ„λ₯Ό μ •μ˜ν•˜λ©°  aκ°’κ³Ό b값을 ν¬ν•¨ν•©λ‹ˆλ‹€. 

β€» 쑰건은 aκ°€ b보닀 크면 μ•ˆ λ©λ‹ˆλ‹€

for-in loopμ—μ„œ 자주 μ΄μš©λ©λ‹ˆλ‹€.

for i in 1...3{
	print(" \(i) times 3 is \( i * 3 )" ) 
}
// 1 times 3 is 3
// 2 times 3 is 6
// 3 times 3 is 9

 

2. 반개방 λ²”μœ„ μ—°μ‚°μž

반개방 λ²”μœ„ μ—°μ‚°μžλŠ” ( a..<b )κΉŒμ§€μ˜ λ²”μœ„λ₯Ό μ •μ˜ν•˜λ©° a값은 ν¬ν•¨ν•˜μ§€λ§Œ b값은 ν¬ν•¨ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€.

β€» 쑰건은 aκ°€ b보닀 크면 μ•ˆ λ©λ‹ˆλ‹€. a == b 값이면 κ²°κ³Ό λ²”μœ„λŠ” λΉ„μ–΄μžˆμŠ΅λ‹ˆλ‹€.

λ°°μ—΄κ³Ό 같은 0λΆ€ν„° μ‹œμž‘ν•˜λŠ” μž‘μ—…ν•  λ•Œ μœ μš©ν•©λ‹ˆλ‹€.

let names = [ "Anna" , "Alex" , "Brian" , "Jack" ]
let count = names.count	//	4
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

 

3. 단츑 λ²”μœ„

λ²”μœ„ μ—°μ‚°μžμ˜ ν•œμͺ½μ—μ„œ 값을 μƒλž΅ν•  수 μžˆμŠ΅λ‹ˆλ‹€. 

// namesλŠ” μ•žμ„  μœ„μ—μ„œ μ •μ˜ν•œ λ°°μ—΄μž…λ‹ˆλ‹€.
// λ°°μ—΄μ˜ 인덱슀2μ—μ„œ λ°°μ—΄μ˜ λκΉŒμ§€

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

// λ°°μ—΄μ˜ μ‹œμž‘λΆ€ν„° 인덱슀2κΉŒμ§€
for name in names[...2]{
	print(name)
}
//Anna
//Alex
//Brian

//λ°°μ—΄μ˜ μ‹œμž‘λΆ€ν„° 인덱슀2 μ „κΉŒμ§€ 
for name i names[..<2]{
	print(name)
}
//Anna
//Alex

//λ‹¨μΈ‘λ²”μœ„λŠ” νŠΉμ • 값이 포함 λ˜μ–΄ μžˆλŠ”μ§€ 여뢀도 ν™•μΈν• μˆ˜μžˆμŠ΅λ‹ˆλ‹€.
let range = ...5
range.contains(7)	//false
range.contains(4)	//true
range.contains(-1)	//true

β€»  ( ...a )인 κ²½μš°μ—λŠ” λ°˜λ³΅μ„ μ‚¬μš©ν•  수 μ—†μŠ΅λ‹ˆλ‹€. -> λ°˜λ³΅μ„ μ‹œμž‘ν•΄μ•Ό ν•˜λŠ” μœ„μΉ˜κ°€ λͺ…ν™•ν•˜μ§€ μ•ŠμŠ΅λ‹ˆλ‹€.

    ( a... ) 인경우 λ°˜λ³΅μ€ κ°€λŠ₯ν•©λ‹ˆλ‹€. ν•˜μ§€λ§Œ λ¬΄ν•œλŒ€λ‘œ κ³„μ†λ˜κΈ° λ•Œλ¬Έμ— λŒμ•„κ°€λŠ” 루프에 λŒ€ν•œ λͺ…μ‹œμ  μ’…λ£Œ 쑰건을 μΆ”κ°€ν•΄μ•Ό ν•©λ‹ˆλ‹€.

 

논리 μ—°μ‚°μž 

논리 μ—°μ‚°μžλŠ” boolean(λΆˆλ¦¬μ–Έ) 논리 값을 true와 false둜 μˆ˜μ •ν•˜κ±°λ‚˜ κ²°ν•©ν•©λ‹ˆλ‹€. 

  • 논리 λΆ€μ •   NOT      :  !a
  • 논리 κ³±      AND      :   a && b
  • 논리 ν•©      OR         :   a || b

 

1. 논리 λΆ€μ • NOT μ—°μ‚°μž

논리 NOT μ—°μ‚°μžλŠ” !a 논리 값을 λ°˜μ „ν•˜μ—¬ true -> false 이 되고 false -> true 값이 λ©λ‹ˆλ‹€.

NOT μ—°μ‚°μžλŠ” 접두사 μ—°μ‚°μžμ΄λ©° 곡백 없이 연산이 μˆ˜ν–‰λ˜λŠ” κ°’ λ°”λ‘œ μ•žμ— λ‚˜νƒ€λ‚©λ‹ˆλ‹€.

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

Bool μƒμˆ˜ 및 λ³€μˆ˜ 이름을 주의 깊게 μ„ νƒν•˜λ©΄ μ½”λ“œλ₯Ό κ°„κ²°ν•˜κ²Œ 읽을 수 있으며 이쀑 λΆ€μ • λ˜λŠ” ν˜Όλ™λ˜λŠ” 논리 λ¬Έμž₯을 ν”Όν•  수 μžˆμŠ΅λ‹ˆλ‹€.

 

2. 논리 AND μ—°μ‚°μž

두 ν”Όμ—°μ‚°μžκ°€ λͺ¨λ‘ 0이 μ•„λ‹ˆλ©΄ 쑰건이 참이 λ©λ‹ˆλ‹€.

// μ„œλ‘œ 두값이 달라 κ²°κ³ΌλŠ” false둜 λ‚˜μ˜΅λ‹ˆλ‹€.

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

 

3. 논리 OR μ—°μ‚°μž

두 ν”Όμ—°μ‚°μž 쀑 ν•˜λ‚˜κ°€ 0이 μ•„λ‹ˆλ©΄ 쑰건이 참이 λ©λ‹ˆλ‹€.

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

 

 

 

 


κΈ°λ³Έ μ—°μ‚°μžμ— λŒ€ν•œ 정리λ₯Ό ν•΄λ³΄μ•˜μŠ΅λ‹ˆλ‹€!

λ‹€μŒμ€ λ¬Έμžμ—΄μ— κ΄€λ ¨ν•˜μ—¬ 정리λ₯Ό ν•΄λ³΄κ² μŠ΅λ‹ˆλ‹€!!