iOS 프로그래밍실무 2주차

데이터 타입(자료형) 상수(let), 변수(var)

lowerCamelCase

lowerCamelCase는 다음과 같은 특징을 가집니다:

• 첫 단어의 첫 글자는 소문자로 시작합니다.
• 이후의 각 단어는 대문자로 시작합니다.
• 단어 사이에 공백이나 구분자를 사용하지 않습니다.

lowerCamelCase는 주로 다음과 같은 경우에 사용됩니다:

• 변수 이름
• 메소드 이름
• 함수 이름
• 속성 이름

UpperCamelCase (PascalCase)

UpperCamelCase는 다음과 같은 특징을 가집니다:

• 모든 단어의 첫 글자를 대문자로 시작합니다.
• 단어 사이에 공백이나 구분자를 사용하지 않습니다.

UpperCamelCase는 주로 다음과 같은 경우에 사용됩니다:

• 클래스 이름
• 구조체 이름
• 네임스페이스

Swift에서의 데이터 타입

var x : Int
x = 10
print(x)

출력: 10

자료형의 종류와 크기가 궁금할때에는?

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

let s = MemoryLayout.size(ofValue: x)  // 8
let t = MemoryLayout<Int>.size

print(s, t)

결과값

var x : Int = 10
print(x)
print("x")
print("\(x)")
print("값은 \(x)입니다.")
print("Int32 Min = \(Int32.min) Int32 Max = \(Int32.max)")

부동 소수점 데이터 타입: Double vs Float

Double 타입(배정도, double precision)

• 64비트로 부동 소수점 수를 저장, 소수점 15자리 정밀도

Float 데이터 타입(단정도, single precision)

• 32비트로 부동 소수점 수를 저장, 소수점 6자리 정밀도

Double형이 기본이다

Bool

- 참 또는 거짓(1 또는 0) 조건을 처리할 데이터 타입

var orangesAreOrange : Bool
var orangesAreOrange : Bool = true

초깃값 true가 있으므로 : Bool은 일반적으로 생략함

Character

• 문자, 숫자, 문장 부호, 심볼 같은 유니코드(Unicode)문자 하나를 저장
• var 변수명: Character = "초깃값"

String

• 단어나 문장을 구성하는 일련의 문자
• 저장, 검색, 비교, 문자열 연결, 수정 등의 기능을 포함

var userName : String = "Kim" 
var age = 20
var message = "\(userName)의 나이는 \(age)입니다."
print(message) 

특수 문자/이스케이프 시퀀스

• \n ― 개행
  \r ― 캐리지 리턴(carriage return)
  \t ― 수평 탭
  \\ ― 역슬래시
  \" ― 큰따옴표(문자열 선언부에 큰따옴표를 쓰고 싶을 경우에 사용됨)
  \' ― 작은따옴표(문자열 선언부에 작은따옴표를 쓰고 싶을 경우에 사용됨)
  \u{nn} ― nn 위치에 유니코드 문자를 표현하는 두 개의 16진수가 배치되는 1바이트 유니코드 스칼라
  \u{nnnn} ― nnnn 위치에 유니코드 문자를 표현하는 네 개의 16진수가 배치되는 2바이트 유니코드 스칼라
  \U{nnnnnnnn} ― nnnnnnnn 위치에 유니코드 문자를 표현하는 네 개의 16진수가 배치되는 4바이트 유니코드 스칼라

변수(var)

- 변수(variable)는 프로그램에서 사용될 데이터를 저장하기 위한 메모리 공간

- 변수에 할당된 값은 변경 가능

var myVariable = 10 // :Int
var x = 0.0, y = 0.0, z = 0.0

상수(let)

- 상수(constant)는 데이터 값을 저장하기 위하여 메모리 내 공간을 제공한다는 점에서 변수와 비슷

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

let maximumNumber = 10
let π = 3.14159

let maxUserCount = 20
maxUserCount = 30

아래 UserCount 실행 시 오류가 발생함.

- 애플은 코드의 효율성과 실행 성능을 높이기 위해서 변수(var)보다는 상수(let)를 사용하라고 권장

타입 어노테이션과 타입 추론

- 스위프트에서 타입 어노테이션은 변수, 상수, 함수의 매개변수 및 반환 값에 대해 예상되는 데이터 타입을 명시적으로 지정하는 방법 / 코드가 더 명확해지고, 컴파일러가 타입 오류를 잡는 데 유용함

var age: Int = 25
let name: String = "Alice"

func add(a: Int, b: Int) -> Int {
    return a + b
}

-변수나 상수에 대한 타입을 코드 작성자가 명시하지 않아도 컴파일러가 자동으로 추론할 수 있도록 하는 것 / 타입 추론은 코드의 길이를 줄여주고, 가독성을 높여주는 장점이 있음

타입 어노테이션과 타입 추론의 차이점

• 타입 어노테이션 (Type Annotation): 변수나 함수의 매개변수, 반환값 등에 대해 명시적으로 타입을 선언하는 것입니다. 이를 통해 코드의 명확성을 높이고, 컴파일러가 타입 오류를 잘 포착하도록 도와줍니다.
• 타입 추론 (Type Inference): 변수나 상수의 타입을 컴파일러가 자동으로 추론하는 기능입니다. 개발자가 명시적으로 타입을 선언하지 않아도, 컴파일러는 할당된 값에 맞는 타입을 자동으로 추정합니다.

- 상수를 선언할 때도 타입 어노테이션을 사용하면 나중에 코드에서 값을 할당할 수 있음

let bookTitle: String
var book = true
if book {
bookTitle = "iOS"
} else {
bookTitle = "Android"
}
print(bookTitle)

튜플 (Tuple)

- 여러 값을 하나의 개체에 일시적으로 묶는 방법

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

let myTuple = (10, 12.1, "Hi")
let (myInt, myFloat, myString) = myTuple

myTuple의 자료형은 (Int, Double, String)

typealias Void = ()

• ()는 빈 튜플(empty tuple)
• 함수(메서드)를 선언할 때 반환 값이 없으면 반환형을 지정할 필요 없음
• 그러나 함수, 메서드 또는 클로저의 형(type)에는 반환형 반드시 작성

- 리턴값이 없는 함수의 형을 작성할 때는 반드시 Void 지정

func logMessage(_ s: String) { // {앞에 ->Void나 ->() 생략
print("Message: \(s)")
}
let logger: (String)->Void = logMessage //여기서는 함수 자료형이라 ->Void 생략 불가
logger("Hello")

옵셔널(optional)

• 값을 반환할 때 오류가 발생할 가능성이 있는 값은 옵셔널 타입이라는 객체로 감싸서 반환함
• Swift에서 기본 자료형(Int, Double, String 등)은 nil값을 저장할 수 없음
• nil도 저장하려면 옵셔널 타입으로 선언해야 함
• 옵셔널 타입은 변수 또는 상수에 아무런 값이 할당되지 않는 상황을 안전하게 처리하기 위한 방법 제공
• 옵셔널 타입 변수를 선언하기 위해서는 타입 선언부 뒤에 “?” 문자를 씀

옵셔널 타입 강제 언래핑(forced unwrapping)

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

optional binding

var x: Int?
x = 10

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

var x1: Int?

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

여러 옵셔널을 언래핑

var pet1: String?
var pet2: String?
pet1 = "cat"
pet2 = "dog"
if let firstPet = pet1, let secondPet = pet2 {
print(firstPet, secondPet)
} else {
print("nil")
}

여러 옵셔널 값 동시에 언래핑

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

Nil합병연산자

let defaultColor = "black"
var userDefinedColor: String? 

var myColor = userDefinedColor ?? defaultColor
print(myColor) 
userDefinedColor = "red"
myColor = userDefinedColor ?? defaultColor

print(myColor)

옵셔널을 언래핑하는 여러가지 방법(guard-let제외)

var x: String? = "Hi"

if let a = x {
    print(a)
} else {
    print("x is nil")
}

let c = x ?? ""
print(c)

if let unwrappedX = x {
    let b = unwrappedX.count
    print(type(of: b), b)
}

let b1 = x?.count
if let count = b1 {
    print(type(of: count), count)
} else {
    print("x is nil, so no count available")
}

• 함수 내부에서 옵셔널 바인딩할 때는 if let보다는 guard let~else을 사용하는 것이 더 가독성이 좋은 소스를 만들 수 있음

 

암묵적인 언래핑

• 옵셔널이 항상 유효한 값을 가질 경우 옵셔널이 암묵적인 언래핑(implicitly unwrapped)이 되도록 선언할 수도 있음
• 클래스의 아웃렛 변수 초기화에서 많이 사용(자동 생성되는 코드)
• 강제 언래핑이나 옵셔널 바인딩을 하지 않아도 값에 접근할 수 있음
• 암묵적인 언래핑으로 옵셔널을 선언하기 위해서는 선언부에 물음표 (?) 대신에 느낌표 (!) 를 사용

// 암묵적 언래핑 옵셔널 선언
var implicitlyUnwrapped: Int! = 10

// 일반 변수처럼 사용 가능
print(implicitlyUnwrapped + 5) // 15

// nil 할당 가능
implicitlyUnwrapped = nil

// 주의: nil일 때 접근하면 런타임 에러 발생
// print(implicitlyUnwrapped + 5) // 런타임 에러

// 옵셔널 바인딩도 가능
if let unwrapped = implicitlyUnwrapped {
    print("값이 있음: \(unwrapped)")
} else {
    print("값이 없음")
}

왜 옵셔널을 사용하나요?

• 옵셔널 타입은 값을 갖지 않는다는 의미의 nil 값을 가질 수 있음
• 옵셔널 변수에 nil을 할당하면 값이 없는(valueless state) 상태임
• 옵셔널이 아닌 변수나 상수에는 nil을 할당할 수 없음

nil

• 옵셔널 변수에 값이 없을 때 할당하는 값
• 상수나 변수가 값이 없는 상태가 존재한다면 옵셔널 타입으로 선언
• 옵셔널 변수에 초깃값을 할당하지 않으면 자동으로 nil이 할당됨

var x : Int // 항상 값이 존재
var y : Int? // 옵셔널 변수, 값이 없을 수도 있음
var z : Int! // 옵셔널 변수, 값이 없을 수도 있음

 

옵셔널은 연관 값(associated value)을 갖는 enum

var x : Int? = 20 //.some(20) 
var y : Int? = Optional.some(10)
var z : Int? = Optional.none
var x1 : Optional<Int> = 30 
print(x, y, z, x1)

 

---

연산자(operator)

대입 연산자

• 왼쪽에 있는 피연산자는 값이 할당되는 변수 또는 상수이며, 오른쪽에 있는 피연산자는 할당할 값

var a = 10
print(a)

var x, y, z: Int
x = 5
y = 5
z = 5
print(x, y, z)

 

산술 연산자

• 보통 두 개의 피연산자를 받는 이항(binary) 연산자

let a = 10
let b = 3

print("a + b =", a + b)
print("a - b =", a - b)
print("a * b =", a * b)
print("a / b =", a / b)
print("a % b =", a % b)

 

복합 대입 연산자

var a = 10

a += 5
print("a += 5:", a)

a -= 3
print("a -= 3:", a)

a *= 2
print("a *= 2:", a)

a /= 4
print("a /= 4:", a)

a %= 3
print("a %= 3:", a)

 

증감 연산자

• x = x + 1 / x = x - 1
• x+=1 / x -=1 이런 식으로 사용해야함
• ++과 --방식은 사용할 수 있었으나 지금은 사라진방법입니다

비교 연산자

let a = 10
let b = 20

print(a == b)  
print(a != b)  
print(a > b)   
print(a < b)   
print(a >= b)  
print(a <= b)

 

논리 연산자

• NOT(!), AND(&&), OR(||)와 XOR(^)

let a = true
let b = false

print(a && b)
print(a || b)
print(!a)
print(!b)

 

범위 연산자

for i in 1...5 {
    print(i)  // 1부터 5까지 출력
}

for i in 1..<5 {
    print(i)  // 1부터 4까지 출력

 

삼항 연산자

let a = 10
let b = 20

let result = a > b ? "a가 b보다 크다" : "a가 b보다 작거나 같다"
print(result)

 

nil-Coalescing Operator (nil합병연산자)

var name: String? = nil
let greeting = name ?? "안녕하세요!"
print(greeting)  // 출력: "안녕하세요!"

name = "John"
let greeting2 = name ?? "안녕하세요!"
print(greeting2)  // 출력: "John"

• nil일 경우 안녕하세요가 출력되고 아닐경우에는 name이 출력이 됩니다.

---

제어문

for-in 반복문

 

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

while 반복문

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

 

break

• 반복문이 완료되는 조건 전에 반복문을 빠져나오기
• 현재의 반복문에서 빠져나와서 반복문 바로 다음에 있는 코드를 실행

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

 

continue문

for i in 1...10 {
if i % 2 == 0 {
continue
}
print(i)
}

 

if문

var x = 10
if x > 5 {
print("5보다 큽니다")
}

//if~else문
var x = 3
if x % 2 == 0 {
print("짝수입니다")
}else{
print("홀수입니다")
}

//다중 if else문
var num = 3
if num == 1 || num == 3 {
print("당신은 남성이군요!\n")
}else if num == 2 || num == 4 {
print("당신은 여성이군요!\n")
}else {
print("당신은 대한민국 사람이 아니군요!\n")
}

 

 

guard문

• guard문은 표현식이 거짓(false)으로 판단될 경우에 수행될 else 절을 반드시 포함해야 함
• else 절에 속한 코드는 현재의 코드 흐름을 빠져 나갈 수 있는 구문(return, break, continue, throw 구문)을
  반드시 포함해야 함

guard~let

var x = 1 
while true { 
guard x < 5 else { break }//조건(x<5)이 거짓일 때 실행(break)
print(x) //1 2 3 4, 조건(x<5)이 참일 때 실행
x = x + 1 
}

 

func multiplyByTen(value: Int?) {
guard let number = value else {
print("nil")
return
}
print(number*10) 
}
multiplyByTen(value: 3) //30
multiplyByTen(value: nil)

 

switch-case문

var value = 0
switch (value)
{
case 0:
print("영")
case 1:
print("일")
case 2:
print("이")
case 3:
print("삼")
default:
print("4이상")
}

 

fallthrough 

• case문 다음에 break 문을 포함할 필요가 없음
• Swift는 일치하는 case문을 만나면 자동으로 빠져나옴
• case별로 빠져 나가지 않고 아래로 계속 내려가게 하려면 fallthrough 문 사용

---

함수

• 특정 작업을 수행하는 코드 블록
• 수행하기 위하여 데이터가 제공될 수 있으며, 함수를 호출한 코드에 작업한 결과를 반환할 수도 있음\

func sayHello() { //->Void 생략
print("Hello")
}
sayHello()