iOS 실무 2주차

변수를 선언할 때는
must have consistent whitespace on both sides  에러 주의!

var x =10

 

자료형의 종류와 크기를 아는 방법

var x = 10
print(type(of:x))
print(MemoryLayout.size(ofValue: x))
var myWeight = 58.58
print(type(of: myWeight)) // Double

 

swift에서 상수를 선언할 때는 let 키워드를 사용

let x = 10
x = 20 //에러!

 

자료형 tuple과 array

let myTuple = (10,12,12.1123,10,"Hi")
print(myTuple)

let oddNumbers = [1,3,5,7,9]
print(oddNumbers)

 

tuple에 인덱스로 접근하기

let myTuple = (10, 12.1, "hi")
var myString = myTuple.2
print(myString) // hi

 

tuple의 자료형은?

let myTuple = (10, 12.1, "hi")
print(type(of:myTuple)) // (Int, Double, String)

tuple에 각 이름을 할당 가능하며 이름(label)으로 접근 가능

let myTuple = (count: 10, length: 12.1, message: "hi")
print(myTuple.message, myTuple.2) // hi hi
print(type(of:myTuple)) //(count: Int, length: Double, message: String)

옵셔널

값을 반환할 때 오류가 발생할 가능성이 있는 값은 옵셔널 타입으로 감싸서 반환할 수 없다면 nil을 반환한다.

var x : Int? = 10
print(x) // Optional(10)

Optional값을 푸는 방법

1. 강제 언래핑

var x : Int? = 10
print(x!) // 10

var x : Int? = 10
var y : Int = 0

x = x! + 2 // x + 2 는 x가 옵셔널이기떄문에 불가능
y = x! //y = x 옵셔널Int 타입을 그냥 Int타입에 할당 불가능 
print(x, y)

강제 언래핑을 할때 x가 nil이라면 크래시가 나기 때문에 안전하게 언래핑을 해주어야 한다

var x : Int?

print(x!) //심각한 에러!

//------------------------
var x : Int?
x = 10
if x != nil {
    print(x!)
} else {
    print("nil")
}

var x : Int?


if x!=nil {//이런식으로 작성하면 !연산자의 우선순위 때문에 
    ...    //x! = nil 이런식으로 언래핑이 먼저 되어서 에러가 나기 때문에 주의!
}

 

2.optional binding

옵셔널 바인딩을 이용하여 옵셔널에 할당된 값을 임시 변수 또는 상수에 할당

var x : Int?
x = 10

if let xx = x { 
  print(x, xx) //Optional(10) 10
}

var x1 : Int?

if let xx = x1 {
  print(x, xx) 
} else {
  print("nil")
}

var x2 : Int? = 10

if let x2 {
    print(x2)
}

여러 옵셔널 변수를 한번에 언래핑하는 방법은 콤마 사용

var pet1: String?
var pet2: String?
pet1 = "cat"
pet2 = "dog"

if let pet1, let pet2 {
print(pet1, pet2)
} else {
print("nil")
}

3. Nil합병 연산자
?? Nil 합병연산자 옵셔널이 nil일때 다음 값으로 할당

var age : Int?
age = 20
print(age) // Optional(20)
var myAge = age ?? 1
print(myAge) // 20

 

암묵적인 언래핑 옵셔널

 

var x : Int! = 10
var y :Int = 10

print(x + y) // 원래는 직접 언래핑 해줘야 하지만 자동 언래핑
//20

 

 

class MyAge {
var age : Int!
init(age: Int) {
self.age = age
}
func printAge() {
print(age) //optional(1)
print(age+1) //2, age! + 1 라고 쓰지 않아도 됨
let age1 : Int = age
print(age1) //1
let age2 = age + 2
print(age2) //3
}
}
var han = MyAge(age:1)
han.printAge()

옵셔널로 프로퍼티를 지정하면 age가 자동으로 nil로 초기화된다.
ex) 특정 input에는 사용자가 값을 넣을수도, 아닐수도 있기 때문에 이러한 상황에 옵셔널을 사용한다.

 

연산자

범위 연산자

x...y //x에서 시작해서 y로 끝나는 범위
1...4 // 1,2,3,4

//반 열린 범위연산자

x..<y
1..<4 // 1,2,3

let names = ["a","b","c","d"]

for name in names[2...] { 
    print(name)// c, d
}
for name in names[...2] {
    print(name) // a, b, c
}
for name in names[..<2] { 
    print(name) // a, b
}

nil 병합 연산

var age : Int?
age = 20
print(age) // Optional(20)
var myAge = age ?? 1
print(myAge) // 20

제어문

for-in문

let names = ["a","b","c","d"]

for name in names { 
    print(name)// a, b, c, d
}

for i in 1...5 {
    print("\(i) 안녕")
}
//1 안녕
//2 안녕
//3 안녕
//4 안녕
//5 안녕
for _ in 1...5 {
    print("안녕")
}
//안녕
//안녕
//안녕
//안녕
//안녕

 

dictionary의 항목 접근

let numberOfLegs = ["Spider": 8, "Ant": 6, "Dog": 4]

for (animalName, legCount) in numberOfLegs {
    print("\(animalName)s have \(legCount) legs")
}
//Dogs have 4 legs
//Spiders have 8 legs
//Ants have 6 legs

 

반복문 중간에 빠져나오려면 break문 사용

for i in 1..<10 {
    if i > 5 {
        break
    }
    print(i)
}

 

if문 조건에서의 콤마

var x = 1
var y = 2

if x == 1 && y == 2 { //논리식이 둘 다 참일 때
    print(x, y)
}

if x == 1, y == 2 { //조건이 둘 다 참 일때, 두 조건을 콤마로 연결
    print(x, y) 
    
}

 

var x : Int? = 1
var y : Int?  = 2

if let x , let y  { //콤마는 보통 옵셔널 바인딩을 할 때 사용
    print(x, y) 
    
}

 

let weight = 60.0
let height = 170.0
let bmi = weight / (height*height*0.0001) // kg/m*m
var body = ""
if bmi >= 40 {
body = "3단계 비만"
} else if bmi >= 30 && bmi < 40 {
body = "2단계 비만"
} else if bmi >= 25 && bmi < 30 {
body = "1단계 비만"
} else if bmi >= 18.5 && bmi < 25 {
body = "정상"
} else {
body = "저체중"
}
print("BMI:\(bmi), 판정:\(body)")

if-else문을 이용한 BMI 결과 판정

var value = 0
switch (value) {
case 0:
  print("영") //case 0: 반드시 실행문을 써줘야 함
case 1:
  print("일")
case 2:
  print("이")
case 3:
  print("삼")
default:
  print("4이상")
}

var value = 3
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 or 29 일입니다")
  default:
    print("월을 잘못 입력하셨습니다")
}

콤마를 통해 여러 그룹으로 묶어서 case를 만들 수도 있음.

if-else문으로 만든 bmi 판정 프로그램을 swich-case문으로 리팩토링

let weight = 60.0
let height = 170.0
let bmi = weight / (height*height*0.0001) // kg/m*m
var body = ""

switch bmi {
  case ..<18.5:
    body = "저체중"
  case 18.5..<25:
    body = "정상"
  case 25..<30:
    body = "1단계 비만"
  case 30..<40:
    body = "2단계 비만"
  default:
    body = "3단계 비만만"
}

print("BMI:\(bmi), 판정:\(body)")

 

switch, catch, while, guard, for 문 등에서 부가적인 조건을 추가하기 위해 where절 사용 가능

var temperature = 60
switch (temperature)
{
case 0...49 where temperature % 2 == 0:
print("Cold and even")
case 50...79 where temperature % 2 == 0:
print("Warm and even")
case 80...110 where temperature % 2 == 0:
print("Hot and even")
default:
print("Temperature out of range or odd")
}

 

fallthrough

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

case별로 빠져나가지 않고 계속 내려가게 하려면 fallthrough사용

 

함수

Parameter(파라미터)

• 함수 또는 메서드를 정의할 때 사용됩니다.
• 함수 내부에서 사용할 변수의 이름과 타입을 지정합니다.
• 호출될 때 아규먼트 값을 받는 역할을 합니다.

 

func greet(name: String) { print("Hello, \(name)!") }

위 코드에서 name: String이 파라미터입니다.

---

Argument(아규먼트)

• 함수를 호출할 때 전달하는 실제 값을 의미합니다.
• 파라미터에 전달되어 함수 내부에서 사용됩니다.

swift

복사편집

greet(name: "Swift") // "Swift"가 아규먼트(인자)

여기서 "Swift"가 아규먼트(인자)입니다.

 

함수를 선언하는 방법

func sayHello() { //리턴값 없으면( -> Void ) 지정하지 않아도 됨
print("Hello")
}

sayHello()

 

매개변수가 있는 함수 정의

func message(name: String, age: Int) -> String {
return("\(name) \(age)")
}

let msg = message(name:"doyoon",age:20)
print(msg)

함수의 타입

func message(name: String, age: Int) -> String {
return("\(name) \(age)")
}

print(type(of: message))//(String, Int) -> String