Swift basic operators-controlflow

용어
단항 연산자
• -a, !b, i++
이항 연산자
• 2 + 3
삼항 연산자
• (a ? b : c)

할당 연산자
let b = 10 // 상수
var a = 5 // 변수
a = b
// a 는 10
let (x, y) = (1, 2)
// 튜플이용 x 는 1, y 는 2
if x = y {
}
// 대입연산자는 값을 반환하지 않으므로 오류

산술 연산자
1 + 2
5 – 3
2 * 3
10.0 / 2.5
// 오버플로우를 허용하지 않음
// 오버플로우 연산자 이용 ( 예 a &+ b) >> Advanced Operators
참고
“hello, “ + “world” // “hello, world”
// 덧셈 연산자는 문자열 지원
let dog:Character = “🐶”
let cow:Character = “ ”�
let dowCow = dow + cow // dowCow 는 “🐶 ”�

나머지 연산자
9 % 4
// 1
-9 % 4
// -1
8 % 2.5
// 0.5

증감 연산자
var a = 0
let b = ++a // b 는 0
let c = a++ // c 는 1
// a 는 2

단항 마이너스 연산자
let three = 3
// three 는 3
let minusThree = -three
// minusThree 는 -3
let plusThree = -minusThree
// plusThree 는 3

단항 플러스 연산자
let minusSix = -6
let alsoMinusSix = +minusSix
// alsoMinusSix 값은 -6, 변함없다

복합 할당 연산자
var a = 1
a += 2
// a 는 3, a = a + 2 의 축약
let b = a += 2
// 요런건 안된다

비교 연산자
a == b
a != b
a > b
a < b
a >= b
a <= b
obj1 === obj2
// 동일 객체면 true, class 타입일 때 사용
obj1 !== obj2
// 동일 객체 아니면 false

삼항 조건 연산자
(question ? answer1 : answer2)
참이면 answer1, 거짓이면 answer2
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 :
20)
// rowHeight 는 90 (40 + 50)

범위 연산자 ( 폐쇄 )
a…b
for index in 1…5 {
println(“(index) time 5 is (index
* 5)”)
}
// index 는 1, 2, 3, 4, 5
Control Flow 에서 다시 설명

범위 연산자 ( 반폐쇄 )
a..b
let names = [“Anna”, “Alex”, “Brian”, “Jack”]
let count = name.count
// count 는 4
for i in 0..count {
println(“Person (i + 1) is called
(names[i])”)
}
// i 는 0, 1, 2, 3

논리 연산자 (NOT)
let allowedEntry = false
if !allowedEntry {
println(“ACCESS DENIED”)
}
// ACCESS DENIED 출력됨

논리 연산자 (AND)
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
println(“Welcome!”)
} else {
}
// ACCESS DENIED 출력

논리 연산자 (OR)
let hasDoorKey = false
let knowOverridePassword = true
if hasDoorkey || knowOverridePassword {
println(“Welcome!”)
} else {
}
// Welcome! 출력

복합 논리 연산자
let enteredDoorCode = true
let passedRetinaScan = false
let hasDoorKey = false
let knowOverridePassword = true
// ture && false || false || true
if enteredDoorCode && passedRetinaScan || hasDoorKey ||
knowOverridePassword {
println("Welcome!")
} else {
println("ACCESS DENIED")
}
// Welcome! 출력

괄호 명시
if (enteredDoorCode && passedRetinaScan)
|| hasDoorKey || knowOverridePassword {
println("Welcome!")
} else {
println("ACCESS DENIED")
}
// Welcome! 출력

문자열 리터럴
let someString = “Some string literal value”
let wiseWords = “”Imagination is more important
than knowledge” – Einstein”
let dollarSign = “x24” // 1 바이트 유니코드
let balckHeart = “u2665” // 2 바이트 유니코드
let sparklingHeart = “U0001F496” // 4 바이트 유니코
드

빈 문자의 초기화
var emptyString = “”
var anotherEmptyString = String()
// 두 문자열 모두 비어있으며 서로 똑같
다
if emptySring.isEmpty {
println(“ 여기엔 아무것도 보이지 않습니
다 .”)
}
// prints 여기엔 아무것도 보이지 않습

문자열 가변성
var variableString = “Horse”
variableString += “ and carriage”
// variableString 은 “ Horse and carriage”
let constantString = “Highlander”
constantString += “ and another Highlander”
// 컴파일 에러 – 상수 문자열은 변경될 수 없
습니다 .

문자열 값 타입
Strings are value types
let a = “A string”
let b = a
// a 의 “ A string” 을 b 에 복사
class 는 Reference type

문자와 작업하기
for character in “Dog!🐶” {
println(character)
}
// D
// o
// g
// !
// 🐶
let wonSign:Character = “₩”

문자 세기
let unusualMenagerie =
"Koala 🐶, Snail 🐶, Penguin 🐶, Dromedary 🐶"
println("unusualMenagerie has
(countElements(unusualMenagerie)) characters")
// unusualMenagerie has 40 characters

문자열 및 문자 합치기
let string1 = "hello“
let string2 = "there“
let character1: Character = "!“
let character2: Character = "?“
let stringPlusCharacter = string1 + character1 // "hello!“
let stringPlusString = string1 + string2 // "hello there“
let characterPlusString = character1 + string1 // "!hello“
let characterPlusCharacter = character1 + character2 //
equals "!?“
var instruction = "look over“
instruction += sting2 // "look over there“
var welcome = "good mornig“
welcome += character1 // "good morning!"

문자열 삽입
let multiplier = 3
let message = “(multiplier) times 2.5
is (Double(multiplier) * 2.5)”
// 3 times 2.5 is 7.5 출력
괄호안에 “ (Double Quote), (Back
Slash), Carriage Return, New Line 등
을 포함할 수 없다

문자열 비교
let a = “abcdefg”
let b = “abcdefghi”
a == b // false
a.hasPrefix(“abc”) // true
b.hasSuffix(“efg”) // false

대문자 소문자 문자열
let normal = “Could you help me,
please?”
let shouty = normal.uppercaseString
// COULD YOU HELP ME, PLEASE?
let whispered =
normal.lowercaseString
// could you help me, please?

유니코드
let dogString = “Dog! 🐶”
dogString.utf8
dogString.utf16
dogString.unicodeScalars

배열 (Arrays)
var shoppingList = [“Eggs”, “Mink”]
println(“The list contains (shoppingList.count)
items”)
// The list contains 2 items
if shoppingList.isEmpty {
println(“empty”)
} else {
println(“not empty”)
}
// not empty

배열 요소 추가
shoppingList.append(“Flour”)
shoppingList += “Baking Powder”
shoppingList += [“Chocolate Spread”,
“Cheese”, “Butter”]

배열 조작
var firstItem = shoppingList[0]
shoppingList[0] = “Six eggs”
shoppingList[4...6] = [“Bananas”,
“Apples”]
// “Six eggs”, “Mink”, “Flour”, “Baking Powder”, “Chocolate Spread”, “Cheese”,
“Butter”
// “Six eggs”, “Mink”, “Flour”, “Baking Powder”, “Bananas”, “Apples”
shoppingList.insert(“Maple Syrup”, atIndex:
0)
let mapleSyrup =
shoppingList.removeAtIndex(0)

배열 반복문 사용
for item in shoppingList {
println(item)
}
for (index, value) in
enumerate(shoppingList) {
println(“Item (index + 1): (value)”)
}

배열 생성 , 초기화
var someInts = Int[]()
someInts.append(3) // 1 value
someInts = [] // empty, Int[] 타입 유지
var threeDoubles = Double[](count:3,
repeatedValue:0.0)
// [0.0, 0.0, 0.0]
var anotherOnes = Array(count:3,
repeatedValue:2.5)
// 기본값에서 타입 추정 , [2.5, 2.5, 2.5]
var sixDoubles = threeDoubles + anotherOnes
// [0.0, 0.0, 0.0, 2.5, 2.5 2.5]

Dictionary
var airports: Dictionary<String,String> =
[“TYO”, “Tokyo”, “DUB”, “Dublin”]
var airports = [“TYO”: “Tokyo”, “DUB”:
“Dublin”]

Dictionary 조작
airports.count
airports[“LHR”] = “London”
airports[“LHR”] = “London Heathrow”
airports.updateValue(“Dublin International”,
forKey: “DUB”)
if let airportName = airports[“DUB”] {
println(“airport name : (airportName)”)
} else {
println(“not found in dictionary”)
} // airports 에 DUB 이 없으면 nil 리턴

Dictionary 요소 삭제
airports.removeValueForKey(“DUB”)
airports[“DUB”] = nil

Dictionary 반복문 사용
for (airportCode, airportName) in airports {
println(“(airportCode): (airportName)”)
}
for airportCode in airports.keys {
println(“airport code: (airportCode)”)
}
for airportName in airports.values {
println(“airport name: (airportName)”)
}

빈 Dictionary 생성
var namesOfIntegers = Dictionary<Int,
String>()
namesOfIntegers[16] = “sixteen”
namesOfIntegers = [:] // empty

For 순환문
for-in
for index in 1...5 {
println(“(index) times 5 is (index * 5)”)
}
for-condition-increment
for var index = 0; index < 3; ++index {
println(“index is (index)”)
}

_ underscore
loop 내에 값이 사용되지 않는다면 _
let base = 3
let power = 10
var answer = 1
for _ in 1...power {
answer *= base
}

배열 반복
let names = [“Anna”, “Alex”, “Brain”,
“Jack”]
for name in names {
println(“Hello, (name)!”)
}

Dictionary 반복
let numberOfLegs = [“spider”:8, “ant”:6,
“cat”:4]
for (animalName, legCount) in numbeOfLegs {
println(“(animalName): (legCount)
legs”)
}

문자열 반복
for character in “Hello” {
println(character)
}
// H
// e
// l
// l
// o

For- 조건부 - 증가부
for var index = 0; index < 3; ++index {
println(“index is (index)”)
}
var index : Int // for loop 밖에서 사용하기
위해
for index = 0; index < 3; ++index {
}
println(“executed (index) times”)
// execute 3 times

while
var a = 0
var b = 10
while a < b {
a++
}
println(a)
// 10

Do-While
var count = 0
do {
count++
} while count < 10
println(count)
// 10

조건문 if
var temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32 {
println(“It’s very cold. consider wearing a scarf.”)
} else if temperatureInFahrenheit >= 86 {
println(“It’s really warm. Don’t forget to wear
sunscreen”)
} else {
println(“It’s not that cold. Wear a t-shirt.”)
}
// It’s really warm. Don’t forget to wear sunscreen

switch
let someCharacter:Character = “e”
switch someCharacter {
case “1”, “2”, “3”:
case “a”, “e”, “i”, “o”, “u”:
println(“(someCharacter) is a vowel”)
case “b”, “c”, “d”, “f”, “g”, “h”, “j”, “k”, “l”, “m”
, “n”, “p”, “q”, “r”, “s”, “t”, “v”, “w”, “x”
, “y”, “z”:
println(“(someCharacter) is a consonant”)
default: // 반드시 포함
println(“(someCharacter) is not a vowel or a
consonent”)
}

switch 범위로 매치
let count = 3_000_000_000_000
let countedThings = “stars in the Mily Way”
var naturalCount : String
switch count {
case 0:
naturalCount = “no”
case 1...3:
naturalCount = “a few”
naturalCount = “serveral”
naturalCount = “tens of”
default: // 반드시 포함
naturalCount = “millions and millions of”
}

switch 튜플
let somePoint = (1, 1)
switch somePoint {
case (0, 0):
println(“(0, 0) 은 원점에 있습니다” )
case (_, 0):
println(“(somePoint.0), 0) 은 x 축 상에 있습니다” )
case (0, _):
println(“(0, (somePoint.1)) 은 y 축 상에 있습니다” )
case (-guatda.com/cmx.p2...2, -guatda.com/cmx.p2...2):
println(“((somePoint.0), (somePoint.1)) 은 상자 안에 있습
니다” )
default:
println(“((somePoint.0), (somePoint.1)) 은 상자 밖에 있습
니다” )
}

Value Bindings
let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
println(“x 축 상에 있으며 x 의 값은 (x) 값입
니다” )
case (0, let y):
println(“y 축 상에 있으며 y 의 값은 (y) 입니
다” )
}
// x 축 상에 있으며 x 의 값은 2 입니다

where
let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let(x, y) where x == y:
println(“((x), (y)) 는 x==y 인 곳에 있습니
다” )
case let(x, y) where x == -y:
println(“((x), (y)) 는 x==-y 인 곳에 있습니
다” )
case let(x, y):
println(“((x), (y)) 는 기타 구역에 있습니다
” )
}

continue
let puzzleInput = “great minds think alike”
var puzzleOutut = “”
for character in puzzleInput {
switch character {
case “a”, “e”, “i”, “o”, “u”, “ “:
continue
default:
puzzleOutput += character
}
}
// puzzleOutput = “grtmndsthnklk”

break
var count = 0
while true {
count++
if count == 10 {
break
}
}

break
let numberSymbol: Character = “3”
var possibleIntegerValue: Int?
switch numberSymbol {
case “1”:
possibleIntegerValue = 1
case “2”:
possibleIntegerValue = 2
default:
break // 아무것도 안할 때 break 를 쓰자
}
// possibleIntegerValue = nil

fallthrough
let integerToDescribe = 5
var description = “ 수 (integerToDescribe) 는 “
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
description += “ 소수이며 , 또한”
fallthrough
default:
description += “ 정수입니다 .”
}
// description = “ 수 5 는 소수이며 , 또한 정수입니
다 .”

Labeled Statements
gameLoop: while square != finalSquare {
if ++diceRoll == 7 { diceRoll = 1 }
switch square + diceRoll {
case finalSquare:
break gameLoop // println(“Game over!”) 로 점
프
case let newSquare where newSquare > finalSquare:
continue gameLoop // while 으로 점프
default:
square += diceRoll
square += board[sqaure]
}
}
println(“Game over!”)

Swift basic operators-controlflow

More Related Content

What's hot (20)

Similar to Swift basic operators-controlflow (20)

Swift basic operators-controlflow