[Swift-Study] 기초 문법종합반 1주차 1일차 정리 - 프로퍼티와 출력, 함수

* 할당 연산자 *

“ = “ 

A = B 

 

프로그래밍 언어에서의 표현

“B 값을 A에 할당”

 

방향기억

우변에 있는 값 -> 좌변의 변수에 할당

 

let color = "Red"
print(color) // 출력값: Red

var myName = "준영"
var yourName = "안나"
foodName = fruitName
print(myName) // 출력값 : 준영

// 변수 여러개를 한번에 선언하고 값을 할당하는 방법
var a = 1, b = 2, c = 3

---

* 저장 프로퍼티 (Stored Property) *

let

 

변경할 수 없는 상수(Constant)를 선언할 때 사용

let name = "철수"
name = "짱구" // 🚨Error: Change 'let' to 'var' to make it mutable

 

var

 

변경할 수 있는 변수(Variable)를 선언할 때 사용

 

var age = 10
age = 50

---

* 연산 프로퍼티 (Computed Property) *

var

연산 프로퍼티는 그 때 그 때 계산한 값을 알려주기 때문에

변수를 나타내는 "var"를 사용하여 선언 (let은 불가능)

 

매번 계산하기 때문에 값 저장 X

var x = 10
var y = 20

//  sum이 연산 프로퍼티
var sum: Int {
    get {
        return x + y
    }
    set {
        sum = x + y
    }
}

print(sum)
// 출력값: 30
// get, set 중 get만 필요한 경우에는 키워드 생략 가능

var sum1: Int {
return x + y
}

// 아래와 같이 더 축약 가능
var sum2: Int {
x + y
}

 

* print() *

print("Hello World 🌍") // 출력값: Hello World 🌍

 

* 한 줄 텍스트 *

“내용” 를 사용하여 표현

var greeting = "Hello World 🌍"

 

* 멀티라인 텍스트 *

“””내용"”” 를 사용하여 표현합니다.

 

var greeting = """
		Hello 
		World 
		🌍 
	       """

 

* 문자 보간법 *

String Interpolation

\() 를 사용하여 표현

 

변수 또는 상수 등의 값을 문자열 내에 나타내고 싶을 때 사용

let name = "준"
var greeting = "Hello \(name) 🤗" // 출력값: Hello 준 🤗

let height = 170
let myInfo = "My height is \(height) 🤗"  // 출력값: My height is 170 🤗

 

* 한 줄 주석 *

// 한 줄 주석

 

* 멀티라인 주석 *

/* */ 를 사용하여 표현

/*

여러줄
주석
입니다

*/

 

* 함수 기본 형태 *

함수

 

- 기능의 수행 -

함수는 특정 작업이나 기능을 수행하는 코드의 블록.

이 코드 블록은 호출될 때 실행되며, 함수 내에 정의된 코드들이 순차적으로 실행

 

- 재사용성 -

함수는 코드를 모듈화하고, 같은 기능을 반복하여 사용

(코드의 중복을 피하고, 유지보수를 용이하게 만듦)

 

- 매개변수(Parameter) -

함수는 입력값을 받을 수 있음

이러한 입력값은 함수의 매개변수에 의해 받아들여짐

매개변수들은 함수 내부에서 사용되어 특정한 작업을 수행하는 데 활용

 

- 반환값(Return Value) -

함수는 어떤 값을 반환할 수도 있음

반환값은 함수가 실행되고 작업이 완료된 후에 호출 지점으로 반환

 

- 함수타입 -

Swift에서는 함수도 하나의 타입으로 취급가능

(함수를 다른 함수의 매개변수로 전달 or 함수를 다른 함수의 반환값으로 사용할 수 있음을 의미)

이를 통해 함수를 동적으로 조작하고 조합가능

---

- 메서드란? -

함수와 메서드의 차이

함수(Function)와 메서드(Method)는 유사한 기능을 수행하지만,

그들 간에는 몇 가지 중요한 차이가 있음

 

- 정의와 소속성 -

함수는 독립적으로 정의되어 있으며,

특정한 객체나 타입에 속해 있지 않습니다.

일반적으로 전역 범위에서 정의되거나 특정 범위 내에 내장됩니다.

메서드는 클래스, 구조체, 열거형 등의 특정한 타입에 속함

객체 지향 프로그래밍에서 해당 객체의 특정한 기능을 수행하기 위해 사용

 

- 호출 방식 -

함수는 직접적으로 호출

ex) addNumbers(5, 3)와 같이 함수 이름 뒤에 괄호를 사용하여 호출

쉽게 이야기해서 함수는 전역범위에 있다고 했으니 함수이름이 addNumbers 이다 라면

단순히 addNumbers 자체를 호출할 수 있습니다. 그러면 5와 3은 파라메타가 되는 것이죠.

// 함수호출 예시
let result = addNumbers(5, 3)

 

메서드는 해당하는 객체 또는 타입에 대해 호출

ex) myObject.increment()와 같이 객체 또는 타입 인스턴스 뒤에 메서드 이름을 호출

메서드는  클래스, 구조체, 열거형 안에 있는 특정한 타입이니까 객체 또는 타입에 의해 호출이 되는 겁니다.

그래서 myObject라는 클래스나 구조체나 열거형의 객체중 하나라고 친다면

그 객체의 들어있는 메서드를 .(점)을 통해 호출이 가능한 것입니다.

// 메서드 호출 예시
class MyClass {
    func myMethod() {
        print("Hello, world!")
    }
}

let myObject = MyClass()
myObject.myMethod() // 메서드 호출

 

- 소속성 -

함수는 특정한 객체의 속성이나 상태에 접근 불가능

함수는 주어진 매개변수를 받아들여 작업을 수행하고 값을 반환하는데 집중

 

메서드는 객체 또는 타입의 속성에 직접적으로 접근가능

(메서드가 해당 객체의 상태를 변경하거나 속성에 접근하여 작업을 수행하는 데 사용)

 

- 정리 -

함수는 특정한 타입에 속하지 않으며 독립적으로 정의되고 호출

반면에 메서드는 특정한 타입에 속해 있으며, 해당 타입의 인스턴스에 대해 작동하고 상태를 변경할 수 있는 함수

// 함수를 선언하는 방식
func 함수_이름(아규먼트_레이블: 파라미터_타입) -> 리턴_타입 {
  // ... 코드
} 
/* 
위에 스네이크 케이스(Snake Case)는 한글이라서 사용하였는데
스네이크 케이스라는게 여러 단어를 하나의 식별자로 표현할 때 
단어 사이에 밑줄(_)을 사용하여 구분하는 명명 규칙입니다. 
스네이크 케이스는 일반적으로 소문자로만 구성되며, 
각 단어는 밑줄로 구분합니다.
*/
// 네이밍 컨벤션으로 카멜케이스를 사용합니다 (ex- methodName / method_name)
// 한글의 경우는 대소문자가 존재하지 않으니 카멜 케이스가 없습니다.
// 카멜케이스는 단어와 단어 사이에 단어가 시작하는 첫 글자는 대문자로 시작하는 것을 말합니다.

// 예시 1
func sayHi(friend: String) {
  print("Hi~ \(friend)!")
}
sayHi(friend: "준")

// 예시 2
func sayHi(to friend: String) {
  print("Hi~ \(friend)!")
}
sayHi(to: "준")

// 예시 3
func sayHi(_ friend: String) -> String {
  return ("Hi~ \(friend)!")
}
print(sayHi("준"))
// 출력값: Hi~ 준!

위 코드의 "예시 1"의 "sayHi" 를 봅시다.

함수는 동작이기 때문에 동사로 시작하는 것이 좋습니다.

( say : 말하다, Hi 안녕이라고 )

 

그 다음 문법에 (friend: String)

파라미터(parameter) 가 들어가 있죠?

"String"(문자열) 타입의 상수 "friend"가 들어가 있으며,

print("Hi~ \(friend)!") 라는 것을 동작하는 함수라는 것을 알 수 있죠

그렇다면

// 예시 1
// 선언구문
func sayHi(friend: String) {
  print("Hi~ \(friend)!")
}

여기까지는 선언문을 이야기 하며,

// 호출구문
sayHi(friend: "준")

이 구문이 호출, 즉 실행문을 의미하는 것이죠.

그래서 "sayHi" 를 실행한다면,

이때 "friend" 의 값을 넣어주어야 하는데,

"준"를 넣어주면 위 함수를 호출하는 순간

"Hi 준" 이 출력이 되는 것 입니다.

 

다음으로 예시 2를 보면

// 예시 2
// 선언구문
func sayHi(to friend: String) {
  print("Hi~ \(friend)!")
}
// 호출구문
sayHi(to: "준")

"예시 1"과 내용은 같지만 "to" 라는 것을 확인할 수 있습니다.

"to"는 아규먼트 레이블(argument label) 중 하나입니다.

이 "to"는 호출하는 시점에 사용할 수 있는 레이블이에요!

 

"예시 2"를 호출할 때 "friend"를 사용하지 않고 "to"를 사용했죠?

이렇게 하면 좀더 직관적으로 의미전달이 가능합니다.

해석 하자면 "안녕이라고 말한다, 준에게" 라는 뜻을 담고 있는 것이 됩니다.

하지만

함수 선언 내부에서는 "to"를 사용하는 것이 아닌 "friend" 사용 합니다.

내부에서는 "friend"만 사용해서 결국 "to: 준" 이지만 "준"이라는 값이 "friend"에 들어가서 

"Hi준!" 이 똑같이 나오는 것을 확인해볼 수 있습니다.

 

"예시 3"의 경우도 마찬가지로 내용은 같습니다.

// 예시 3
// 선언구문
func sayHi(_ friend: String) -> String {
  return ("Hi~ \(friend)!")
}
// 호출구문
print(sayHi("준"))
// 출력값: Hi~ 준!

잘 살펴보면 ( "_" ) 언더바, "friend", 화살표("-> String")를 확인할 수 있습니다.

 

( "_" ) 언더바는 "to"와 마찬가지로 아규먼트 레이블(argument label) 중 하나입니다.

사용가치는 ( "_" ) 언더바 와 "to" 모두 같습니다.

하지만

기능에 조금 차이가 있습니다.

( "_" ) 언더바 = 호출하는 쪽에서 파라미터(parameter) 이름을 명시 하지 않아도 문제가 되지 않습니다.

 

쉽게 정리하자면

첫번째 들어오는 "friend"라는 파라미터(parameter)가

"friend"라는 이름을 명시하지 않더라도 "준" 이라는 값만 넣어주면

"준" 이라는 값이 "friend" 들어가게 됩니다.

그래서 "Hi ("friend")"가 되는데...

하.지.만 

"예시 3" 에서는 "print"를 붙여 주어야합니다.

 

왜냐구요?

정의된 함수 뒤에 붙인 ("-> String") 즉, 문자열로 반환 한다는 표현이 있죠?

그리고 2번째 구문에 "return" 이라는 키워드가 붙어 있습니다.

여기서 "return"은 "반환값" 을 의미하며 선언구문의 함수를 실행해서 나오는 결과 값을 다시 뱉어 주겠다는 것이죠

그래서 ("Hi~ \(friend)!") 즉, "Hi준"라는 값을 뱉어주겠다는 것이 됩니다.

그러면 호출구문의 "(sayHi("준"))" 의 전체가 "("Hi~ \(friend)!")" 가 되는 것입니다.

 

Tip) Input(입력값)과 Output(출력값)을 고려

조금 더 부연 설명을 한다면 수학에서 y = f(x) 라고 하는데

"x"라는 것은 "input"이고 "y"가 "Output"이 되는 것이죠

// 위의 그림에서 x는 입력값, y 혹은 f(x)는 출력값
// 이를 풀어서 설명하면 x라는 데이터를 이용해서 y 혹은 f(x)라는 결과를 도출 시키면 되는 것 입니다.

// 정상 몸무게 = (키 - 100) * (9/10) 이라고 할 때
// 특정 키에 알맞은 몸무게를 구하는 함수 라고 한다면
func getWeight(height: Int) -> Double {
    let weight = (height - 100) * 9 / 10
    return Double(weight)
}

위에서부터 잘 보면 x는 우리에게 필요한 데이터들이며,

y 혹은 f(x)는 우리에게 필요한 결과 라고 보시면 되는데

이를 위해서는 말로 정의를 할 수 있어야 합니다.

 

먼저 정상 몸무게를 구하는 공식이 키에서 100을 빼고 0.9를 곱하는 것이라고 했을 때

위 문제에서 구하고 싶은 것은 "특정 키에 알맞은 몸무게를 구하는 함수다" 라고 한다면

필요한 것(필요한 데이터)은(는) "특정 키" 이며, 위 코드에서 계산하고 싶은 것은 "몸무게"죠?!

그렇다면

"특정 키"가 "파라미터(parameter)"로 들어가며 몸무게가 "return"으로 가야하겠죠?!

그래서 위 코드 에서의 "특정 키"는 Int(정수) 타입으로써 정의가 되고

몸무게는 Double(실수)타입으로 정의를 한다면

"getWeight" 몸무게를 구한다 라는 뜻이 되고 "height"을 놓고 "Double"을 "return" 하겠다고 한뒤

함수 내부에서 연산처리를 해주면 됩니다.

 

키에서 "100"을 빼고, "0.9"를 곱해서 나온 "weight"를 "Double"타입으로 "return" 해주면 끝입니다.

 

이번엔 반대로 "특정 몸무게에 알맞는 키를 구하는 함수"를 살펴봅시다.

// 특정 몸무게에 알맞은 키를 구하는 함수
func getHeight(weight: Int) -> Double {
    let height = weight * 10 / 9 + 100
    return Double(height)
}

그렇다면 Input(입력값)이 "몸무게"이며, Output(출력값)이 "키"라는 것이겠죠?!

그래서 몸무게 "weight"이 변수 "getHeight"에 들어가며 이 타입은 "Int" 타입으로 정의해주고

키는 "Double" 타입으로 리턴해줍니다.

그러면 "height"은 수식을 반대로 뒤집으면 되겠죠?!

그래서 몸무게에 "10"을 곱하고 "9"로 나눈 다음 + "100"을 하면 키가 나오게 되는 것이죠

키를 "Double" 타입으로 바꿔주어서 "return"을 해주면 되겠죠?!

 

이런식으로 함수를 작성하면 되겠습니다.