🎹 Xylophone 🎹

기능

• 버튼 클릭시 코드에 맞는 Sound 재생

코드

• 사용한 코드 AVFoundation - 오디오,동영상과 관련된 코드

프로젝트를 통해 알게된 점

• 모르는 코드를 검색하는 방법과 코드를 분석하는 방법.

1. 구글에 원하는 기능+언어 검색
2. 스택오버플로우에서 맞는 자료 찾기
3. 답변의 코드를 복사하여 공식문서에 찾아보기(Ex : developer.apple)

• AVFoundation Framework

마무리

• 이번 프로젝트로는 소리를 삽입하는 방법을 알게 되었고, 처음으로 다른 Framework를 사용해보았습니다. 복습하는 느낌으로 다음번에도 아이즈원 어플을 만들어봐야겠습니다. :)

❣️ Random IZ*ONE ❣️

기능

• Click 버튼을 클릭하면 random으로 imageIzone 이미지 출력

코드

• 사용한 문법 Set - Array와는 다르게 순서가 필요 없는 요소들의 묶음을 설정

프로젝트를 통해 알게된 점

• 간단하게 나마 Random Dice 프로젝트를 복습할 겸 팬심이 담긴 프로젝트를 해봤습니다. 저번에는 Array 를 통해 요소들의 묶음을 배열로 설정했는데 딱히 순서가 중요할 것 같지 않은 것들은 Set나 Dictionary를 사용해도 될 것 같아서 Set를 이용하여 만들어보았습니다.

마무리

• 확실히 책을 통해 정리했었던 문법들이 응용에 도움이 되는 것 같습니다. 개념을 모르고 무작정 쓰기만 하고 콘솔로그만 보니 지겨웠었는데 앱을 만들면서 문법의 쓰임새를 확실하게 알게 되니 재밌는 것 같습니다 :)
  

🁘 Random Dice 🁘

• Udemy 강의 내용에 대한 정리임을 밝힙니다.

코드

• 사용한 문법 let - 1 ~ 6 까지의 주사위 이미지 배열을 변하지않는 상수로 설정 var - 주사위 이미지를 diceImageView로 설정 Array - 1 ~ 6 까지 주사위 이미지를 배열로 설정
• 사용한 메서드 Int.random(in:) - random(in:) 범위 내에 값을 무작위로 설정

프로젝트를 통해 알게된 점

• Array,var,let 등의 기초 문법은 공부했던 내용들이었습니다. 하지만 막상 이를 적용해보려니 어떻게 적용해야 될지 막막했었는데 간단하게나마 앱을 직접 만들어보고 문법들을 실제로 적용해보니 어떤 식으로 돌아가는 지 느낌이 살짝 왔습니다.
  사실 문법 공부를 하면서도 변수는 왜 만들어야하는지, 상수는 왜 만들어야 하는지 완전하게 이해가 되지 않았는데 변수나 배열을 통해 복잡했던 코드들이 간단하게 정리가 되는 것을 보니 신기하기도 하고 이해가 단번에 됐습니다.

마무리

• 신학기 프로모션 받겠다고 맥북 환불하고 다시 구매하기까지 오랜 시간이 지났네요. 문법 공부만 하는 것보다 실습도 병행하는게 나을 것 같아서 Udemy 강의를 구매했습니다.
  실습은 미니 프로젝트 앱으로, 문법은 기존의 Swift로 다시 힘내서 해보겠습니다.😆
  실습을 동영상이나 이미지로 세세하게 올려볼까 하다가 도저히 안될 것 같아서 포기하고 전체 코드와 사용된 코드들, 그리고 느낀점까지만 포스팅 합니다.

• 현재 6일차까지 공부한 내용들을 복습할 겸 해서 정리해보았습니다. D + 0 : 출력 D + 1 : 변수와 상수

   D + 2 : 기본 데이터 타입

  D + 3 : 심화 데이터 타입 D + 4 : 연산자 D + 5 : 흐름제어

D+0 _ 출력

print와 dump

• print() 콘솔 로그를 남기는 용도의 함수 문자열 보간법 ()
• dump() 🔍 print 함수에 비해 자세한 정보를 출력해주는 함수.

var someVar:String = "world"
print("hello") // hello
print("hello \(someVar)") // 문자열 보간법 \() 

D+1 _ 변수와 상수

변수

var 키워드를 사용하여
var [변수명]:[데이터 타입] = [값] 의 형태로 선언한다.
🔍 변수의 경우 값을 선언하여도 값이 변할 수 있다.

상수

let 키워드를 사용하여
let [변수명]:[데이터 타입] = [값] 의 형태로 선언한다.
🔍 상수의 경우 값을 선언하면 값이 바뀌지 않는다. 🔍 상수를 사용하는 이유 중 가장 중요한 이유는 가독성이다.

let satelliteOfEarth:String = "Moon"
    print(satelliteOfEarth)
var year:Int = 2021
year = 2022
    print("내년은 \(year)년도 입니다.") // "내년은 2022년도 입니다."

D+2~3 _ 데이터 타입

Int와 UInt

• Int : Int는 +,- 부호를 포함한 정수를 표현한다.
• UInt : UInt는 - 부호를 포함하지 않는 양의 정수만을 표현한다.

var someInt:Int = -123
var someUInt:UInt = 123

Bool

• Bool : Bool은 불리언 타입으로, 참(true) 또는 거짓(false) 만을 값으로 가지는 데이터 타입이다

var someBool:Bool = false
print("강아지는 식물인가요? : \(someBool)") // false

Float 와 Double

🔎 Float와 Double은 부동소수점을 사용하는 실수이며, 부동소수 타입이라고 한다. 흔히 우리가 알고 있는 소수점 자리가 있는 수를 뜻한다.

• Float : 32비트 환경에서 7자리 이하의 수까지만 표현이 가능하다
• Double : 64비트 환경에서 최소 15자리의 십진수를 표현할 수 있다.
  🔑 *둘 중 무엇을 사용해야 할 지 모른다면 Double의 사용을 권장한다. *

var someFloat:Float = 3.12345678 // 3.123456
var someDouble:Double = 1.12345678901234 // 1.12345678901234...

🔎 임의의 수 만들기

Int.random(in: 1...100)
Double.random(in: 1.1...1.2)

Character

🔎 Character은 말 그대로 '문자'를 의미한다. 문장이나 단어가 아닌 단 하나의 문자이다.

var someCharacter:Character = "❤️"
print(someCharacter) // ❤️

String

🔎 String 타입은 문자의 나열, 즉 문자열이다. String 타입에는 기본적으로 많은 메서드들과 프로퍼티들이 구현되어 있으며, 문자열과 관련된 연산자도 많다

let hello:String = "Hello"
let world:String = "World"
    print("\(hello)" + " " + "\(world)") 
    // '+' 와 문자열 보간법을 통해 출력 가능

var isSameString:Bool = false
isSameString = hello == "Hello"
    print(isSameString)
isSameString = hello == "hi"
    print(isSameString) 
    // 연산자를 이용한 문자열 비교

Any와 nill

• Any : Any는 스위프트의 모든 데이터 타입을 사용할 수 있는 데이터 타입이다.
  변수 또는 상수에 데이터 타입이 Any로 지정되어 있다면 그 변수 또는 상수에는 어떤 종류의 데이터 타입이든지 상관 없이 할당 할 수 있다.
• nil : nil은 특정 타입이 아닌 '없음'을 나타내는 키워드이다. 즉, 변수 또는 상수에 값이 들어있지 않고 비어있음을 나타낸다.

  var someAny:Any = 123
  var someany:Any = "일이삼"
  var soMeany:Any = 1.23

  튜플(Tuple)

  🔍 튜플은 타입의 이름이 따로 지정되어 있지 않은, 프로그래머 마음대로 만드는 타입이다. 지정된 데이터의 묶음이라고 표현할 수 있다.
  튜플은 이름이 따로 없으므로 일정 타입의 나열만으로 튜플 타입을 생성해줄 수 있다.
  🔑 typealias - 사용할 때마다, 긴 튜플 타입을 모두 쓰게 되면 번거롭기 때문에 튜플에 별칭을 지정해줄 수 도 있다.

   var somePerson: (String, Int, Double) = ("dinx", 70, 175.1)
  print("name : \(somePerson.0) , weight : \(somePerson.1) , height : \(somePerson.2)"                                
  var someAdress:(도:String, 시:String, 구:String) = ("경기도", "OO시", "ㅁㅁ구")
    print("도는 \(someAdress.도)") // 각 데이터 타입에 이름을 붙혀줄 수 도 있다.
  typealias personTuple = (name:String , age:Int, height:Double) // personTuple 이라는 튜플 데이터 타입의 별칭을 지어 새로 생성했다.                
  let 철수:personTuple = ("김철수", 5 , 140.2)
  let 맹구:personTuple = ("박맹구", 5 , 146.3)
    print(철수) // (name: "김철수", age: 5, height:140.2

  Array

  🔎 배열을 뜻하는 Array 타입은 같은 타입의 데이터를 일렬로 나열한 후 순서대로 저장하는 형태의 컬렉션 타입이다.
  

  • var 변수명 : Array<데이터 타입> = [값, 값, 값]
  • var 변수명 : [데이터 타입] = [값, 값, 값]
    💡 배열은 항상 0번째 부터 시작함. 💡 배열에는 '순서'가 있다는 것을 꼭 기억해야함.

    var 한글 : [String] = ["가", "나", "다", "라"] 
    var 영어 : [String] = ["A", "B", "C", "E"]
    print(한글[1])
    print(영어[3]) // 인덱스를 활용해 값을 추출. [n] 번째에 있는 값 추출            
    한글.append("마") // append 메서드를 이용하여 마지막 순서에 값 추가
    영어.insert("D", at: 3) // insert 메서드를 이용하여 at: n 번째 순서에 값 추가

    Dictionary

    🔎 딕셔너리는 요소들이 순서 없이 키와 값의 쌍으로 구성되는 타입이다. 딕셔너리에 저장되는 값은 항상 키와 값의 쌍을이루며, 딕셔너리 안에는 키가 하나이거나 여러 개일 수 있다.

• var someDic: Dictionary<String(키),Int(값)> = Dictionary<String(키),Int(값)>()
• var someDic:[String:Int] = [String:Int]()
• var someDic: StringIntDictionary = StringIntDictionary()
• typealias StingIntDictionary = [String:Int]

  typealias 티어표 = [String:Int]
  var champ:티어표 = ["Olaf":1 , "Amumu":5 , "Xinziao":4]
  print(champ)

  Set

  🔎 세트는 같은 타입의 데이터를 순서 없이 하나의 묶음으로 저장하는 형태의 컬렉션 타입이다. 세트는 보통 순서가 중요하지 않거나 각 요소가 유일한 값이어야 하는 경우에 사용한다.

• var names: Set<String> = Set<String>()
• var names: Set<String> = []

  var animal: Set<String> = ["호랑이","치타","가젤","원숭이"]
  print(animal.count) // count 프로퍼티를 통해 세트 안에 값이 몇 개 있는지 확인 가능
  print(animal.isEmpty) // isEmpty 프로퍼티를 통해 값이 비어있는지 아닌지 확인 가능

  열거형(enum)

  🔎열거형은 연관된 항목들을 묶어서 표현할 수 있는 타입이다. 열거형은 제한된 선택지를 주고 싶을때,

       정해진 값 외에는 입력받고 싶지 않을 때,
       그리고 예상된 입력 값이 한정되어 있을 때 사용한다. 

   enum leagueOFlegend : String {
    case midlane = "미드" // "미드" 라는 rawValue를 설정했다.
    case jungle = "정글"
    case top = "탑"
    case adCarry = "원딜"
    case supporter = "서폿"
  } 
  =
  enum LOL {
    case mid, jg, top, adc, sup
  }

D+4 _ 연산자

연산자

🔎 연산자는 그 종류가 매우 다양하지만 자주 쓰이는 연산자를 아래와 같이 정리한다.

• 할당 연산자

    `A = B`

  A에 B의 값을 할당한다. 데이터 타입이 같아야 한다.
  
  
• 산술 연산자

   ` A + B`
   ` A - B`
  `  A * B`
  `  A / B`

  A % B 대체로 수학에서 쓰이는 연산과 같은 기능을 한다.
  
  

• 비교 연산자

  ` A == B ` : A와 B가 같은 값인지 비교하여 불리언 값을 반환
   `A >= B`  : A가 B보다 크거나 같은 값인지 비교하여 불리언 값을 반환
   `A <= B`  : A가 B보다 작거나 같은 값인지 비교하여 불리언 값을 반환
   `A > B `  : A가 B보다 큰 지 비교하여 불리언 값을 반환
  ` A < B `  : A가 B보다 작은 지 비교하여 불리언 값을 반환
  ` A != B ` : A와 B가 서로 다른 값인지 비교하여 불리언 값을 반환

  A === B : A와 B가 참조 타입 일 때 A와 B가 같은 인스턴스를 가리키는지 비교하여 불리언 값을 반환
  A와 B의 값을 비교하는 연산자이며, 불리언 값으로 반환한다는 특징이 있다.
  
  
  • 범위 연산자 A...B : A부터 B까지의 수를 묶어 범위를 표현.A와 B를 포함 A..< B : A부터 B 미만까지의 수를 묶어 범위를 표현.A를 포함하고 B는 포함되지 않음 A... : A 이상의 수를 묶어 범위를 표현.A를 포함 ...A : A 이하의 수를 묶어 범위를 표현.A를 포함 ..< A : A 미만의 수를 묶어 범위를 표현.A를 포함하지 않음
    
    
  • 부울 연산자 NOT(부정) 부울 연산자 - !B : B(불리언 값)의 참, 거짓을 반전한다. AND 부울 연산자 - A&&B : A와 B의 불리언 AND 논리 연산을 실행한다. OR 부울 연산자- A||B : A와 B의 불리언 OR 논리 연산을 실행한다.
    
    
  • 비트 연산자 비트 연산이란 2진법으로 표기된 숫자를 연산하는 것을 말한다. OR 연산 - A|B : A와 B의 OR 논리 연산을 실행한다. AND 연산 - A & B : A와 B의 AND 논리 연산을 실행한다. XOR 연산 - A^B : A와 B의 XOR 연산을 실행한다. NOT 연산 - ~A : A의 비트를 반전한 결과를 반환한다. 비트 이동(쉬프트) 연산자 : A >> B , A << B : A의 비트를 B만큼 이동한다.
    

       OR 연산은 두 개 중에 하나라도 결과가 참이면 참
       AND 연산은 두 개 다 참인 경우에만 참.
       NOT 연산은 값이 반대가 되는 것
       XOR 연산은 같은 값을 가지면 거짓, 다른 값을 가지면 참

D+5_흐름제어

🔎 흐름제어에는 조건문과 반복문이 존재한다.

if else 조건문

if 는 대표적인 조건문으로 if,else 등의 키워드를 사용하여 구현. swift의 if 구문은 조건의 값이 반드시 bool 타입이어야 함

  let someint = 100
if someint < 100 {
    print("100미만") // 만약 조건이 참이라면  아래 명령문을 실행
} else if someint > 100 { // 다른 조건이 참 이라면 아래 명령문을 실행
    print("100초과")
}  else { // 위에 조건이 전부 거짓이라면 아래 명령문을 실행
    print("100")
}

switch 조건문

switch 조건문은 스위프트의 기본 문법이라고 할 수 있다. 타 언어에서의 switch 구문과는 달리 자동으로 break가 걸려있다. break를 걸지 않으려면 fallthrough 키워드를 사용한다.

  var value1 = 4
switch (value1) {
case 4:
    print("4")
    fallthrough
case 3:
    print("3")
    fallthrough
case 2:
    print("2")
    fallthrough
case 1:
    print("1")
    fallthrough
default:
    print("none")
}

for-in 반복문

for-in 반복 구문은 반복적인 데이터나 시퀀스를 다룰 때 가장 많이 사용한다. for 문은 문자열 또는 튜플이 들어갔을 때 안에 있는 요소를 하나씩 반복한다.

  for i in 0...2 {
    print(i)
}
for i in 0...5 {
    if i.isMultiple(of: 2) {
        print(i)
        continue // continue 키워드를 사용하면 바로 다음 시퀀스로 건너뛴다.
    }  
    print("\(i) == 홀수")
}    
let helloSwift: String = "Hello, Swift!"
for char in helloSwift {
    print(char)
}

while 반복문

특정 조건(Bool 타입)이 성립하는 한 블록 내부의 코드를 반복해서 실행한다.

  var names: [String] = ["joker", "jenny", "nove", "max"]
while names.isEmpty == false {
    print("Good bye \(names.removeFirst())") // removeFirst() 는 요소를 삭제함과 동시에 삭제한 요소를 반환한다.

repeat-while 반복문

repeat 블록의 코드를 최초 1회 실행한 후, while 다음의 조건이 성립하면 블록 내부의 코드를 반복실행한다.

  var name:[String] = ["john", "chalse", "jessica", "menny"]
repeat {
    print("Good bye \(name.removeFirst())")
} while name.isEmpty == false

마무리

• 오늘은 그 동안 배웠던 것들을 복습할 겸 해서 정리를 해보았습니다. 잘 기억이 나지 않았거나 이해가 안됐지만 그냥 넘어갔었던 부분들을 중점으로 다시 책을 정독하며 정리했더니 전에는 이해가 안갔었던 개념들도 이제는 이해가 가네요! :)
  아마 내일부터는 벨로그 포스팅이 조금 어려울 것 같습니다. 신학기 프로모션을 놓치고 맥북을 구매했어서 환불을 받고 다시 구매하려고 해서요..ㅠㅠ 그래도 공부는 책과 유튜브로 하고 있겠습니다!
  오늘도 감사합니다 :)

조건문

if 구문

if else 구문은 대표적인 조건문으로 if,else 등의 키워드를 사용하여 구현한다. swift의 if 구문은 **'값이 꼭 Bool 타입'이어야 한다.
else if 는 몇 개가 이어져도 상관없고 else 블록은 없어도 상관 없다. else if 의 조건을 충족해서 블록 내부의 명령문이 실행되면 그 다음에 이어진 else if 의 조건을 충족하더라도 실행되지 않고 조건문을 빠져나온다.

let someInteger = 100

if someInteger < 100 {
    print("100미만")
} else if someInteger > 100 {
    print("100초과")
}  else {
    print("100")
}

let first:Int = 10
let second:Int = 10

if first > second {
    print("역시 처음이야")
} else if first < second {
    print("두번째가 짱이지")
} else {
    print("그거나그거나~")
}

let one:Int = 5
let two:Int =  5
var biggerValue:Int = 0

if one > two {
    biggerValue = one
} else if one == two {
    biggerValue = one
} else if first < two {
    biggerValue = two
} else if one == 5 {
    biggerValue = 100       //  위에 조건이 충족되어 있기 때문에 100은 출력 되지 않는다.
}

print(biggerValue)

let sameOne:Int = 5
let sameTwo : Int = 5
var sameValue : Int = 0

if (sameOne > sameTwo) {
    sameValue = sameOne
}   else if (sameOne == sameTwo) {
    sameValue = sameOne
}   else if (sameOne < sameTwo) {
    sameValue = sameTwo
}   else if (sameOne == 5) {
    sameValue = 100         // 위와 동일함, 조건을 소괄호로 묶어주는 것은 선택사항
}

let userID:String = "xind"

var inPutID:String = "xind"


if userID == inPutID {
    print("Hello," + "\(userID)")
} else {
    print("Who are you?")

switch 구문

• switch 구문은 if문과 같이 조건 제어문에 속하지만 switch 구문은 부등식이 사용될 수 없다.
  if문이 'Bool 타입에 의해 true일 경우' 블록이 실행된다고 한다면, switch문은 '비교할 변수가 어떤 값을 가지냐'에 따라 실행문을 선택하게 된다. 즉 switch문은 크고 작다를 표현하는 것이 아니라, 동등 조건만 검사할 수 있다.

let someString:String = "리신"

switch someString {
case "리신" :
    print("정글")
case "트리스타나" :
    print("원딜")
default :
    print("트롤")
}

var value = 2
var days: Int = 0

switch (value) {
case 1,3,5,7,8,10,12:
    print("31일까지 존재")
case 4,6,9,11:
    print("30일까지 존재")
case 2:
    print("28 혹은 29일까지 존재")
default:
    print("달을 정확히 입력하세요")
}

let num = 25
let count: String

switch num {
case 0...9 :
    count = "한자리 수"
case 10...99:
    count = "두자리 수"
case 100...999:
    count = "세자리 수"
default:
    count = "네자리 수 이상"
} // num 이라는 상수에 대하여, num이 0~9까지의 범위 이면 count = 한자리 수.

print("\(count)입니다.")


var value1 = 4
switch (value1) {
case 4:
    print("4")
    fallthrough
case 3:
    print("3")
    fallthrough
case 2:
    print("2")
    fallthrough
case 1:
    print("1")
    fallthrough
default:
    print("none")
}   // fallthrough는 break를 걸지 않고 쭉 내려온다. (스위프트에서는 자동으로 break가 걸려있기 때문에)

• 타 프로그래밍 언어에서의 switch 는 case 가 끝날 때 마다 break를 넣어줘야 하지만 Swift에서는 자동으로 break가 걸린다.

반복문

조건에 따라 실행되어야 하는 명령어는 조건문을 통해 분기한다면, 같거나 비슷한 명령을 반복 실행할 때는 반복문을 사용. 특히나 배열과 같은 시퀀스, 순서가 있는 데이터는 반복문으로 편하게 처리할 수 있다.

for-in 구문

for-in 반복 구문은 반복적인 데이터나 시퀀스를 다룰 때 가장 많이 사용한다. for 문은 문자열 또는 튜플이 들어갔을 때 안에 있는 요소를 하나씩 반복한다.

for 임시 상수 in 시퀀스 아이템(문자열,튜플) { 실행 코드 }

for i in 0...2 {
    print(i)
}

for i in 0...5 {

    if i.isMultiple(of: 2) {
        print(i)
        continue // continue 키워드를 사용하면 바로 다음 시퀀스로 건너뛴다.
    }

    print("\(i) == 홀수")
}

let helloSwift: String = "Hello, Swift!"

for char in helloSwift {
    print(char)
}

var result: Int = 1
for _ in 1...3 { 
    result *= 10 // 시퀀스에 해당하는 값이 필요 없다면 와일드카드 식별자(_)를 사용
}

print("10의 3제곱은 \(result)입니다.")


let freinds: [String:Int] = ["Jay":35, "Joe":25, "Anna":28]

for n in freinds {
    print(n)
}

• Dictionary를 이용한 for-in 구문

let 픽창:[String:String] =
    ["탑" : "다리우스", "정글" : "리신", "미드" : "아칼리", "원딜" :"진", "서폿" : "레오나" ]

for (포지션, 챔피언) in 픽창 {
    print("\(포지션) : \(챔피언)") // 포지션에는 키, 챔피언에는 값
}

• Set를 이용한 for-in 구문

let 지역번호:Set<String> = ["02", "031", "042", "041"]

for 번호 in 지역번호 {
    print(번호)
}

while 구문

특정 조건(Bool 타입)이 성립하는 한 블록 내부의 코드를 반복해서 실행한다.

var names: [String] = ["joker", "jenny", "nove", "max"]

while names.isEmpty == false {
    print("Good bye \(names.removeFirst())") // removeFirst() 는 요소를 삭제함과 동시에 삭제한 요소를 반환한다.

repeat-while 구문

• repeat 블록의 코드를 최초 1회 실행한 후, while 다음의 조건이 성립하면 블록 내부의 코드를 반복실행한다.

var name:[String] = ["john", "chalse", "jessica", "menny"]

repeat {
    print("Good bye \(name.removeFirst())")
} while name.isEmpty == false

마무리

• 책에는 정말 문법에 대한 내용만 나와있고 자세한 설명이 나와있지 않았습니다.. 예를 들어 switch와 if문에 대한 차이도 자세하게 명시되어 있지 않고 그저 '타 프로그래밍 언어와 비슷한 기능을 한다' 라고만 나와있어서 이해하기가 어려웠습니다. 그래서 c언어의 switch문을 찾아보고 나와있는 개념을 적어두었습니다. 프로그래밍에 대한 아무런 지식이 없는 비전공자에게는 하나하나 이해하기가 너무 어렵네요 T.T
  
  앞으로는 문법 공부를 겸해서 SwiftUI나 실질적으로 어플리케이션을 만들어볼까 합니다. 문법만 공부하다보니 저에게 지금 당장 필요하지 않은 세세한 문법까지 보게 되는 것 같아, 실습을 병행하면서 공부해볼까 합니다.
  Swift 문법과 더불어 실습까지 포스팅 해보도록 하겠습니다.

감사합니다 :)

1. 할당 연산자

• 값을 할당 할 때 사용하는 연산자이다.
  

  A = B
  (A에 B를 할당)

var aType:Int = 5
var bType:Int = 10

aType = bType // aType = 10 

2. 산술 연산자

• 산술 연산자는 대체로 수학에서 쓰이는 연산과 같은 역할을 수행한다.

  1. A + B
     (A와 B를 더한 값을 반환한다)
  2. A - B
     (A에서 B를 뺀 값을 반환한다)
  3. A * B
     (A와 B를 곱한 값을 반환한다)
  4. A / B
     (A를 B로 나눈 값을 반환한다)
  5. A % B
     (A를 B로 나눈 나머지 값을 반환한다)

let type1:Int = 1
let type2:Int = 2

type1 + type2 // 3
type1 - type2 // -1
type1 * type2 // 2
type1 / type2 // 0
type1 % type2 // 1

3. 비교 연산자

• 비교 연산자는 두 값을 비교할 때 사용하는 연산자이다.

  1. A == B
     (A와 B가 같은 값인지 비교하여 Bool 값을 반환
  2. A >= B
     (A가 B보다 크거나 같은 값인지 비교하여 Bool 값을 반환)
  3. A <= B
     (A가 B보다 작거나 같은 값인지 비교하여 Bool 값을 반환)
  4. A > B
     (A가 B보다 큰 값인지 비교하여 Bool 값을 반환)
  5. A < B
     (A가 B보다 작은 값인지 비교하여 Bool 값을 반환)
  6. A!= B
     (A와 B가 다른 값인지 비교하여 Bool 값을 반환)
  7. A === B
     (A와 B가 참조(레퍼런스)타입 일 때 A와 B가 같은 인스턴스를 가리키는 지 비교하여 Bool 값을 반환)
  8. A !== B
     (A와 B가 참조(레퍼런스)타입 일 때 A와 B가 같지 않은 인스턴스를 가리는 지 비교하여 Bool 값을 반환)
  9. A ~= B
     (A와 B의 패턴이 매치되는지 확인하여 Bool 값을 반환)

let type가:Int = 1
let type나:Int = 3

type가 == type나 // false
type가 >= type나 // false
type가 <= type나 // true
type가 > type나 // false
type가 < type나 // true
type가 != type나 // true
type가 ~= type나 // false

4. 삼항 조건 연산자

• 피 연산자가 세 개인 삼항 조건 연산자이다.

  Question? A : B (Question(Bool 값)이 참이면 A를, 거짓이면 B를 반환

type가 > type나 ? type가 : type나 
// 'type가(1)'가 'type나'(3) 보다 큽니까? -> 거짓이므로 'type나'의 값인 '3' 반환

5. 범위 연산자

• 범위 연산자는 값의 범위를 나타내고자 할 때 사용한다.

  1. A...B
     (A부터 B까지의 수를 묶어서 범위로 표현.A와 B를 포함한다)
  2. A..<B
     (A부터 B미만 까지의 수를 묶어서 범위로 표현.A는 포함하고 B는 포함하지 않는다)
  3. A...
     (A 이상의 수를 묶어 범위로 표현.A를 포함)
  4. ...A
     (A 이하의 수를 묶어 범위로 표현.A를 포함)
  5. ..<A
     (A 미만의 수를 묶어 범위로 표현.A를 포함하지 않음)

var type3:Int = 100
var type4:Int = 1000

type3...type4
type3..<type4
type3...
...type3
..<type3

6. 부울 연산자

• 불리언 값의 논리 연산을 할 때 사용.

  NOT(부정) 부울 연산자 : !B : B(불리언 값)의 참, 거짓을 반전한다.

    AND 부울 연산자 : A && B : A와 B의 불리언 AND 논리 연산을 실행한다.
    OR 부울 연산자 : A||B : A와 B의 불리언 OR 논리 연산을 실행한다.

• * *Example **

  true and false ==> false
  true and true ==> true
  false and false ==> false
  true or true ==> true
  true or false ==> true
  false or false ==> false
  Not true ==> false
  Not false ==> true

var someTrue:Bool = true
var someFalse:Bool = false

!someFalse // true
!someTrue // false
someTrue && someFalse // false
someTrue || someFalse // true

7. 비트 연산자

• 비트 연산이란 2진법으로 표기된 숫자를 연산하는 것을 말한다.
  OR 연산 : A|B : A와 B의 OR 논리 연산을 실행한다. AND 연산 : A & B : A와 B의 AND 논리 연산을 실행한다. XOR 연산 : A^B : A와 B의 XOR 연산을 실행한다. NOT 연산 : ~A : A의 비트를 반전한 결과를 반환한다. 비트 이동(쉬프트) 연산자 : A >> B , A << B : A의 비트를 B만큼 이동한다.

    OR 연산은 두 개 중에 하나라도 결과가 참이면 참
    AND 연산은 두 개 다 참인 경우에만 참.
    NOT 연산은 값이 반대가 되는 것
    XOR 연산은 같은 값을 가지면 거짓, 다른 값을 가지면 참

var someBit:Int = 8
var someBite:Int = 4

someBit|someBite // 12
someBit & someBite // 0
someBit ^ someBite // 12
~someBit // -9
someBit >> 2 // 2 (someBit = 1000 , 오른쪽으로 2칸 이동해서 이진법 10으로 변환, 이진법 10은 십진법 2)

• 비전공자로서 비트 연산에 대한 개념이 아예 없다시피 하여 비트 연산에 대해 따로 찾아봤습니다.

OR 연산은 두 값이 공통되지 않아도 값이 있다면(1), 그 값을 가져옵니다. AND 연산은 두 값 중 공통된 값만을 가져옵니다. NOT 연산은 그 값의 반대 값을 가져옵니다. XOR 연산은 공통된 값을 (0) 또는 거짓으로, 공통되지 않은 값을 (1) 또는 참으로 가져옵니다. Shift 연산은 그 값의 자리수를 꺽새 방향으로 숫자만큼 밀어냅니다.

마무리

슬슬 컴퓨터 지식이나 수학적 지식이 요구되는 단계가 온 것 같습니다. 문법 책으로 공부하고 있기 때문에 컴퓨터 지식에 대해서 제대로 나와있진 않더라구요.
예를 들면, 논리 연산이나 XOR 연산에 대한 어떤 설명도 나와있지 않고 그냥 표시하는 방법만 알려주기 때문에 어떤 뜻인지 이해하기가 어려워 따로 찾아봐야 했습니다.

컴퓨터 과학에 대한 지식과 자료구조, 알고리즘에 대한 공부도 병행해야 할 것 같습니다.

감사합니다 : )

1. 타입 별칭 (typealias)

• 스위프트의 데이터 타입이든, 임의로 만든 데이터 타입이든 이미 존재하는 데이터 타입에 임의로 별칭을 부여. 기존에 사용하던 데이터 타입의 이름과 프로그래머가 만든 별칭 모두 사용 가능

typealias myInt = Int
var age : myInt = 99

typealias myDouble = Double
var height : myDouble = 187.9

2. 튜플형 (Tuple)

• 튜플은 타입의 이름이 따로 지정되어 있지 않은, 프로그래머 마음대로 만드는 타입이다.
  '지정된 데이터의 묶음' 이라고 표현 할 수 있다.
  튜플은 타입 이름이 따로 없으므로 일정 타입의 나열만으로 튜플 타입을 생성할 수 있다

var person: (String, Int, Double) = ("dinx", 75, 187.9)
    print("이름 = \(person.0), 몸무게 = \(person.1), 신장 = \(person.2)")
        ==> "이름 = dinx, 몸무게 = 75, 신장 = 187.9"

person.0 = "철수"
person.1 = 71
person.2 = 175.2
    print("이름은 \(person.0), 몸무게는 \(person.1)kg, 신장은 \(person.2)cm 입니다")
        ==> "이름은 철수, 몸무게는 71kg, 신장은 175.2cm 입니다"
            //person을 변수로 선언했으므로 변경 가능

• 튜플의 요소마다 이름을 붙힐 수도 있다.

var person2: (name:String, weight:Int, height:Double) = ("영민",65,165.2)
    print("이름:\(person2.name), 몸무게:\(person2.weight), 신장:\(person2.height)")
    ==> "이름:영민, 몸무게:65, 신장:165.2"

• 튜플에 별칭을 지정할 수도 있다.

typealias personTuple = (name: String, weight:Int, height:Double)

let chulsu : personTuple = ("철수" , 75 , 170.2)
let mangu : personTuple = ("맹구" , 80 , 190.4)
    print("이름:\(chulsu.name), 몸무게:\(chulsu.weight), 신장:\(chuls.height)")
        ==> "이름:철수, 몸무게:75, 신장:170.2"
            //personTuple 이라는 튜플을 하나의 별칭 타입으로 지정하여 사용한 것. 

3. 컬렉션형

• 튜플 외에도 많은 수의 데이터를 묶어서 저장하고 관리할 수 있는 컬렉션 타입이 있다.
  배열(Array), 딕셔너리(Dictionary), 세트(Set) 등이 있다.

3.1 배열(Array)

• 배열은 같은 타입의 데이터를 '일렬로 나열' 한 후 순서대로 저장하는 형태의 컬렉션 타입이다.

// 배열 선언하기

var name:[String] = ["철수","맹구","훈
이","짱구"]

var name:Array<String> = ["철수", "맹구", "훈이","짱구"]
    print(name[2])
           ==> 맹구
            // 배열에서 2번째 순서의 값을 출력함

name.append("유리") // 배열에 마지막 순서에 값을 추가.append 메서드
name.append(contenOf: ["나미리","채송화"] // 배열에 값 추가.append(contentOf:)
name.insert("수지", at: 2) // 2번째 순서에 값(수지)를 추가.insert(값,at:순서) 

3.2 딕셔너리(Dictionary)

• 딕셔너리는 요소들이 순서 없이 키와 값의 쌍으로 구성되는 컬렉션 타입이다. 딕셔너리에 저장되는 값은 항상 키와 쌍을 이루게 되는데, 딕셔너리 안에는 키가 하나이거나 여러개 일 수 있다. 단, 하나의 딕셔너리 안의 키는 같은 이름을 중복해서 사용할 수 없다.

typealias StringIntDictionary = [String:Int] // typealias 를 이용하여 단순하게 표현

var numberForName: Dictionary<String, Int> = Dictionary<String,Int>() // 키는 String, 값은 Int 인 Dictionary를 생성합니다.

var numberForName0: [String:Int] = [String:Int]() // 위와 같은 표현임

var numberForName1: StringIntDictionary = StringIntDictionary() // 위와 같은 표현임

var numberForName2: [String:Int] = ["민수":100, "영희":200, "철수":300, "짱구":250]
    print(numberForName2["민수"] as Any)

3.3 세트(Set)

• 세트는 같은타입의 데이터를 순서 없이 하나의 묶음으로 저장하는 형태의 컬렉션 타입이다. 세트 내의 값은 모두 유일한 값이며, 즉 중복된 값이 존재하지 않는다. 다음의 경우 세트를 이용한다.

1. 순서가 중요하지 않을 때
2. 각 요소가 유일한 값이어야 하는 경우

let jungleChampion : Set<String> = ["Xinchao","Werick","Olaf","Garen"]
let topChampion : Set<String> = ["Singed","Olaf","Garen","Camile"]

let interSection : Set<String> = jungleChampion.intersection(topChampion)
    print(interSection)
    ==> ["Olaf", "Garen"]
// 교집합

let symmetricDiffSet: Set<String> = jungleChampion.symmetricDifference(topChampion)
    print(symmetricDiffSet)
    ==> ["Werick", "Xinchao", "Singed", "Camile"]
// 여집합의 합

let unionSet: Set<String> = jungleChampion.union(topChampion)
    print(unionSet)
    ==> ["Werick", "Xinchao", "Singed", "Camile", "Olaf", "Garen"]
// 합집합

let subtractSet: Set<String> = jungleChampion.subtracting(topChampion)
    print(subtractSet)
    ==> ["Werick", "Xinchao"]
// 차집합


// 포함관계 연산 

var 미드챔피언 : Set<String> = ["아지르","판테온","피즈","브랜드","제라스"]
var 서폿챔피언 : Set<String> = ["바드","알리스타","브랜드","제라스","판테온"]

var 챔피언 : Set<String> = 미드챔피언.union(서폿챔피언) // 미드챔피언과 서폿챔피언을 챔피언에 포함시킨다.

print(챔피언)
    ==> ["알리스타", "피즈", "브랜드", "제라스", "판테온", "바드", "아지르"]

4. 열거형(enum)

• 열거형은 연관된 항목들을 묶어서 표현할 수 있는 타입이다. Swift에서의 열거형은 강력한 기능을 가지고 있기 때문에 잘 알아야 한다. 열거형은 배열이나 딕셔너리 같은 타입과 다르게 사용자가 정의한 항목 값 외에는 추가/수정이 불가능하다. 그렇기 때문에 딱 정해진 값만 열거형 값에 속할 수 있다.
  다음과 같은 경우 열거형을 사용한다.
  1. 제한된 선택지를 주고 싶을 때
  2. 정해진 값 외에는 입력받고 싶지 않을 때
  3. 예상된 입력 값이 한정되어 있을 때

enum 원딜 {
    case 케이틀린
    case 바루스
    case 트리스타나
    case 베인
    case 진
}

enum 원딜2 {
    case 트위치 , 코그모 , 자야 , 카이사
}

var 일티어원딜: 원딜 = 원딜.진
var 이티어원딜: 원딜2 = .자야

// 열거형의 원시 값 지정과 사용 (.rawValue)

enum 정글러 : String {
    case 초식정글 = "아무무"
    case 육식정글 = "우디르"
    case 성장형정글 = "쉬바나"
    case 갱킹형정글 = "리신"
    case 예능정글 = "티모"
}

let 정글러종류: 정글러 = 정글러.육식정글

    print("제가 잘하는 정글은 \(정글러종류) 입니다.") // rawValue인 "우디르"가 아니라 육식정글로 출력
    print("저의 모스트 정글챔피언은 \(정글러종류.rawValue) 입니다.") // 지정해준 rawValue인 "우디르"로 출력

마무리

오늘은 어제 기본 데이터 타입보다 살짝 어려운 심화 데이터 타입을 배웠습니다. 확실히 어제보다 살짝 난이도가 있는 것 같은 느낌이 들었습니다. 최대한 이해하기 쉽게 예제에 나와있는 변수나 값들을 제가 좋아하는 게임인 리그오브레전드를 대입하여 바꾸어 보았습니다. 공부는 현재 야곰님의 Swift프로그래밍3판을 통해 진행중입니다. :) iOS 앱 개발자가 되는 그 날까지 화이팅!!

1. Bool 타입

• Bool 타입은 불리언 타입으로 참(True) 또는 거짓(False) 만을 값으로 가진다.

var someBool: Bool = true
someBool = false
var anotherBool:Bool = false
let iLoveYou : Bool = true
let isTimeUnlimited:Bool = false

print("시간은 무한합니까?: \(isTimeUnlimited)")
print("나는 당신을 사랑하나요?: \(iLoveYou)")
print("이것은 진실입니까? : \(someBool)")

2. Int와 UInt

• Int는 +,- 를 포함한 정수를, UInt는 -를 포함하지 않는 양의 정수를 표현한다.

var someInt: Int = -10
someInt = 100

var someUInt:UInt = 10
someUInt = 1

Int.random(in: -100...100) // 범위 내의 임의의 숫자 만들기

3. Float 타입과 Double 타입

• Float 타입은 64비트 환경에서 6자리의 숫자까지만 표현 가능

• Double 타입은 64비트 환경에서 최소 15자리의 십진수를 표현 가능

var someFloat:Float = 10.12345
var someDouble:Double = 10.213124124
어떤 타입을 사용해야 할 지 모를 때는 Double을 사용할 것

Character 타입

• Character 타입은 말 그대로 문자를 의미한다.

var someCharacter:Character = "A"
var otherCharacter:Character = "가"

4. String 타입

• String 타입은 문자의 나열, 즉 문자열을 의미한다.

  let someName:String = "SDH" // 상수로 선언된 문자열은 변경이 불가능하다.
  var introduce:String = String() // 이니셜라이저를 사용하여 빈 문자열을 생성
  introduce.append("저는") // append 메서드를 통해 문자열을 이어붙힐 수 있다.
  introduce = introduce+" " + someName + "입니다" // + 연산자를 통해서도 문자열을 이어붙일 수 있다.
  print(introduce)
  

print("name의 글자 수 = (someName.count)") // 변수명.count = 변수의 글자 수 파악 print("introduce가 비어있습니까? : (introduce.isEmpty)") // 변수명.isEmpty = 해당 변수에 값이 있는지 없는지 파악

### 4.1 String 타입의 다양한 기능

let hello:String="Hello" let xind:String="Xind" var greeting:String = hello + " " + xind + "!"

print(greeting)

greeting = hello greeting += " " greeting += xind greeting += "!"

print(greeting)

특수문자 스위프트에는 문자열 내에서 일정 기능을 하는 특수문자(또는 제어문자)가 있다. \n = 줄바꿈 문자 \ 문자열 내에서 백슬래쉬를 표현할 때 사용 " 문자열 내에서 큰 따옴표를 표현할 때 사용 \t 탭 문자, 키보드의 탭키를 눌렀을 때와 같은 효과 \O 문자열이 끝났음을 알리는 null 문자 */

print("스위프트의 특수문자는 \n줄바꿈과 \백슬래쉬를 표현하고 "큰따옴표"를 이렇게 표현하고 띄워쓸 땐 \t이렇게 \t를 이용")

## 5. Any,AnyObject와 nil

- `Any` 는 스위프트의 모든 데이터 타입에 사용할 수 있다.
- `AnyObject`은 클래스의 인스턴스에 할당 * (추후 공부)
- `nil` 은 특정 타입이 아닌 '없음' 혹은 '비어있음'을 뜻하는 키워드* (추후 공부)

var someAny: Any = "dinx" someAny = 26 someAny = 175.1

print(someAny)

```

Any 타입이 사용하기 편하긴 하지만 스위프트에서는 데이터 타입을 정확히 명시하는 것이 오류의 위험을 최소화하는 방법 중 하나이기 때문에 가급적 사용을 지양할 것.

변수

• 기본적으로 변수란 변할 수 있는 값을 의미한다.

스위프트에서 변수를 생성하려면 var 키워드를 사용한다. var [변수의 이름] : [데이터 타입] = [값]의 형태로 선언한다. 변수를 생성할 때 데이터 타입은 생략할 수 있다.

이를 타입 추론 이라고 하는데, 변수를 생성할 때 데이터 타입을 생략하면 컴파일러가 변숫값의 타입을 추론하여 타입을 지정한다.
이는 스위프트의 강력하고도 편한 기능이지만, 자칫 잘못된 타입 추론으로 인해 오류가 생기면 이 오류를 찾는데에 시간이 걸릴 수도 있기 때문에 처음부터 타입을 명시하는 편이 좋다.

상수

• 상수란 변하지 않는 값을 의미한다.

스위프트에서 상수를 생성하려면 let 키워드를 사용한다. let [상수의 이름] : [데이터 타입] = 값 의 형태로 선언한다. 변수와 마찬가지로 상수를 생성할 때의 데이터 타입도 생략이 가능하다.

• 상수를 사용하는 이유 상수를 사용하는 다양한 이유 중에서 가장 중요한 이유는 가독성이다.
  상수는 변하지 않는 값이므로 상수로 값을 선언하면, 이후 코드에서 값의 변화가 없다는 사실을 주석이나 API 문서 등을 살펴보지 않아도 직관적으로 알 수 있다.
  즉, 차후 값의 변경을 신경 쓰지 않아도 된다는 것이다.

  • 대표적으로 변하지 않는 원주율이나 최대값 등을 상수로 선언

연습

1. 변수 선언하기

var age : Int = 25
var job = "iOS Dev"
var weather = "rainny"
weather = "sunny"
job = "student"
age = 26 

print("내 나이는\(age)살 이고 오늘의 날씨는 \(weather)입니다.")

• age와 weather을 변수로 설정해놨으므로 age에는 26이, weather에는 sunny가 출력된다.

2. 상수 선언하기

let name : String = "dinx"
let planet = "Earth"
planet = "Mars"

print("내가 사는 행성은 \(planet)입니다.")

• planet을 상수로 선언했으므로 "Mars"가 아닌 "Earth"가 출력된다.