iOS 프로그래밍 실무 2주차

Swift 변수 선언 규칙

// 타입 추론 방식
var num = 10
// 자료형 명시 방식
var num : Int = 10

-보통 변수에 초기값이 있는 경우 자료형을 생략하고, 변수에 초기값이 없는 경우는 자료형을 직접 표기함  

error

var num= 10

-must have consistent whitespace on both sides,  '=' 양쪽에 일관된 공백이여야 함

 

print() 

 

기본 

print("hello")

-Swift에서 문자열 출력은 큰따옴표를 사용

 

변수 출력: \(변수명)

var name = "Kim"
var age = 10
print("이름: \(name), 나이: \(age)")

 

줄바꿈 설정

print("첫 번째", terminator: "!!! ")
print("두 번째")
// 출력
첫 번째!!! 두 번째

print("첫 번째")
print("두 번째")
// 출력
첫 번째
두 번째

-terminator 매개변수의 기본값은 줄바꿈 문자 \n, 별도 매개변수 값을 지정하지 않으면 기본값에 의해 줄바꿈이 발생 

 

type() 

var x = 10
print(type(of:x)) // Int

-타입을 알아내는 함수

 

var x = "abc"
print(MemoryLayout.size(ofValue:x))
print(MemoryLayout<Int>.size)

-자료형이 메모리 몇 바이트를 차지하는 지 알아내는 함수

 

Double vs Float

-Double 타입: 64비트 소수점 15자리 정밀도

-Float 타입: 32비트 소수점 6자리 정밀도

var d = 5.5
var f : Float = 5.5
print(type(of:d)) // Double
print(type(of:f)) // Float

-자료형을 생략하면 기본적으로 Double타입 적용

var c : Character = "x"
var c2 = "\u{0058}" // 유니코드 Char 타입

-Character 생략하면 String 타입으로 인식함

-Swift에서는 Character 타입도 큰따옴표를 사용

 

var vs let

var a = 1
let b = 1

-var: 변수 

-let: 상수 값이 한번 할당되면 이후에 변경될 수 없음

변수나 상수명은 영문자, 숫자, 이모티콘, 한글 등 가능

 

타입 어노테이션

변수 선언부에 타입 어노테이션이 없으면 컴파일러는 타입을 식별하기 위해 타입 추론 사용

var x : Int // Int 타입으로 간주
var y = "qqq" // String 타입으로 간주
var z // error: type annotation missing in pattern

 

튜플(Tuple)

 

let tuple = (10, "abc", [1,5,"5"])
print(tuple.0)
print(type(of:tuple)) // (Int, String, Array<Any>)
let myTuple = (count: 10, length: 12.1, message: "hi")
print(type(of:myTuple)) 
print(myTuple.message, myTuple.2) // hi hi

typealias Void = () // typealias 새로운자료형명 = 기존자료형명

-튜플에 저장되는 요소는 어떠한 타입도 가능

-튜플의 요소는 인덱스로 접근 가능

-튜플을 만들 때 각 값에 이름을 지정할 수 있음

---

 

옵셔널

var 변수명 : 변수타입?

 

-옵셔널을 쓰는 이유: 변수, 상수에 아무런 값이 할당되지 않는 상황을 안전하게 처리하기 위해 사용

Int("100") // Optional(100) 리턴
Int("dd") // 아무런 값도 반환할 수 없다는 의미로 nil 반환

 

옵셔널 강제 언래핑1

var x : Int? // 옵셔널 변수 선언
var y : Int = 0
x = 10 // optional(10)
print(x!) // 강제언래핑해서 10이 나옴
x = x + 2 // x = x! + 2 언래핑해서 연산해야 함
y = x // y = x! 언래핑해서 대입

-옵셔널 강제 언래핑은 좋은 방법이 아님, 강제 언래핑했을 때 nil인 경우 에러가 나서 프로그램이 종료가 되기 때문

 

조건문을 이용한 언래핑

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

-nil인 경우 else문이 실행되기 때문에 안전하게 풀 수 있음

 

조건식에 공백이 없으면?

if x!=nil

-문제가 없어보이지만, !연산자는 우선순위가 높기 때문에 위 조건식은 x를 강제 언래핑하고 nil을 대입하라는 식이 되어버려서 에러가 발생

 

옵셔널 바인딩

-강제 언래핑을 하는 또 다른 방법, 옵셔널에 할당된 값을 임시 변수 또는 상수에 할당

var x : Int?
x = 10
if let xx = x {
    print(x, xx)
}
else {
    print("nil")
}

var y : Int?
if let yy = y {
    print(yy)
}
else {
    print("nil")
}

 

조건식 축약

1. if let xx = x
2. if let x = x
3. if let x

-Swift 5.7부터는 if let x 라고 간단하게 써도 됨

 

여러 옵셔널 한번에 언래핑

var x : String? = "AA"
var y : String? = "BB"
if let x, let y {
    print(x,y)
}
else {
    print("nil")
}

 

-콤마를 사용하여 여러 옵셔널을 한번에 언래핑가능

 

nill합병연산자

-옵셔널변수 ?? nil일 때 할당되는 값

 

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

-age변수가 nil일 경우 1이 할당됨

 

암묵적인 언래핑 옵셔널

var x : Int?
var y : Int!

-옵셔널이 항상 nil이 아닌 값을 가질 경우 옵셔널이 암묵적인 언래핑이 되도록 선언할 수도 있음

-암묵적인 언래핑 옵셔널은 언래핑을 안하고 사용가능

let a : Int! = 1 // 암묵적인 옵셔널 
let b : Int = a // 옵셔널로 사용되지 않으면 자동으로 언래핑함
let c = a // 옵셔널로 사용될 수 있으므로 옵셔널형
print(a, b)

 

---

범위 연산자

닫힌 범위 연산자

-x...y 에서 시작하여 y로 끝나는 범위에 포함된 숫자

 

반 열린 범윈 연산자

x..<y

-x부터 시작하여 y가 포함되지 않는 모든 숫자

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
}

 

Swift for문

-c방식의 for문은 Swift3에서 없어짐

for 상수명 in 컬렉션 또는 범위 {
// 실행될 코드
}

-중괄호 생략 불가능

for i in 1...5{
    print(i)
}

 

_로 참조체 생략가능

for _ in 1...5{
    print("A")
}

 

딕셔너리의 항목 접근

let x = ["Spider":8, "Ant":6, "Dog":4]
for (k, v) in x {
    print("\(k), \(v)")
}

 

while문

-for문은 몇 번 정도 반복해야 할지를 아는 경우에 사용하기 적합

-while문은 어떠한 조건이 되기 전에 몇 번 정도 반복해야 할지를 알 수는 없지만 그 조건을 만족할 때까지는 반복해야 하는 경우 사용

var myCount = 0
while myCount < 1000 {
    myCount += 1
}
print(myCount) // 1000

 

반복문에서 빠져나오기

for i in 1..<10 {
    if i > 5 {break} // if 문 실행 코드가 한 줄이라도 중괄호를 필수적으로 사용 
    print(i)
}

 

if문 조건 나열

,:조건나열

&&: 논리식

var x = 1
var y = 2
if x == 1 && y == 2 { // 논리식이 둘 다 참일 때
    print(x,y)
}
if x == 1 , y == 2 { // 조건이 둘 다 참일 때, 두 조건을 콤마로 연결한 condition-list
    print(x,y)
}

var a : Int? = 1
var b : Int? = 2
if let a1 = a, let b1 = b { // a와 b가 nil이 아니면, 언래핑
    print(a1, b1)
}
// if let a1 = a && let b1 = b { // let a1, let b1는 논리식이 아니기 때문에 에러가 발생
//     print(a1, b1)
// }

 

switch-case문

var v = 0
switch (v) 
{
case 0:
    print(0)
case 1:
    print(1)
case 2:
    print(2)
// case 11: 에러, case 다음에 실행문이 없음
default:
    print("3이상")
}

-break문이 생략되어있음

 

fallthrough

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

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

 

if문 switch-case문으로 변경

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)")

 

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-case에서 where절 사용하기

-부가적인 조건을 추가하기 위하여 사용 

var height = 151
switch height
{
case 150...160 where height % 2 == 1:
    print("150~160사이, 홀수")    
case 160...170 where height % 2 == 1:
    print("160~170사이, 홀수") 
default:
    print("위 조건에 해당x")
}

---

함수

함수, 메서드 차이: 함수를 class, struct, enum 내에 선언하면 메서드라 부름

 

함수 선언

매개변수, 리턴값이 없는 함수

func hi() { // 리턴값이 없으면 -> Void 생략가능
    print("hi")
}

 

매개변수, 리턴값이 있는 함수

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

 

함수 호출

hi()

 

print(message(name:"k", age:10))

-매개변수명:값 형식으로 함수를 호출함

 

함수의 타입

print(type(of:message))

-함수의 타입은 (자료형,자료형,...)->리턴형

-message함수의 타입은 (String, Int) -> String