Switf 실습 4

/*int multi(int num1, int num2) { // C, C++ 함수
    return num1 * num2
}
printf(multi(5, 6))*/
func multi(num1: Int, num2: Int) -> Int { // Swift 함수
    return num1 * num2
}
print(multi(num1: 5, num2: 6));
//결과 : 30




func multi(num1: Int, num2: Int) -> Int { 
    return num1 * num2
}
print(multi(num1: 5, num2: 6));
func multi(number1 num1: Int, number2 num2: Int) -> Int { 
    return num1 * num2
}
print(multi(number1: 5, number2: 6));
func multi(_ num1: Int, _ num2: Int) -> Int { 
    return num1 * num2
}
print(multi(5, 6));
func multi(_ num1: Int, number2 num2: Int) -> Int { 
    return num1 * num2
}
print(multi(5, number2: 6));
//결과 : 30
//30
//30
//30




func sub(num: Int) -> Int
{
    return num - 1
}
func setNumber(num: Int)
{
    number = num
}
func getNum() -> Int
{
    return num
}
func sub(num1: Int, num2: Int) -> Int
{
    return num1 - num2
}
func setNumber12(num1: Int, num2: Int)
{
    number1 = num1;
    number2 = num2;
}




func multi(number1 num1: Int, number2 num2: Int) -> Int { 
    print(#function)  
    return num1 * num2
}
let subValue = multi(number1: 5, number2: 8)
print(subValue)
//결과 : multi(number1:number2:)
//40




print("고혈압 판정 프로그램")
print("수축기 때의 혈압을 입력해주세요. : ")
let userBloodPrs = Int(readLine()!) // mmHg
var result = ""
if let bloodPress = userBloodPrs {
    if bloodPress < 120 { 
        result = "정상"
    } else if bloodPress >= 120 && bloodPress < 130 {
        result = "주의 혈압"
    } else if bloodPress >= 130 && bloodPress < 140{
        result = "고혈압 전단계"
    } else if bloodPress >= 140 && bloodPress < 160 {
        result = "고혈압 1기"
    } else { // bloodPress >= 160
        result = "고혈압 2기"
    }
    print("수축기 혈압 : \(bloodPress), 판정 : \(result)")
}
else {
    print("잘못 입력하셨습니다.")
}
//결과 : 고혈압 판정 프로그램
//수축기 때의 혈압을 입력해주세요. : 
//130
//수축기 혈압 : 130, 판정 : 고혈압 전단계




func judgementHighBloodPressure(userBloodPrs: Int?) -> String {
    var result = ""
    if let bloodPress = userBloodPrs {
        if bloodPress < 120 { 
            result = "정상"
        } else if bloodPress >= 120 && bloodPress < 130 {
            result = "주의 혈압"
        } else if bloodPress >= 130 && bloodPress < 140{
            result = "고혈압 전단계"
        } else if bloodPress >= 140 && bloodPress < 160 {
            result = "고혈압 1기"
        } else { // bloodPress >= 160
            result = "고혈압 2기"
        }
        return "수축기 혈압 : \(bloodPress)mmHg, 판정 : \(result)"
    }
    else {
        return "잘못 입력하셨습니다."
    }
}
print("고혈압 판정 프로그램")
print("수축기 때의 혈압을 입력해주세요. : ")
let inputBloodPrs = Int(readLine()!) 
print(judgementHighBloodPressure(userBloodPrs: inputBloodPrs))
//결과 : 고혈압 판정 프로그램
//수축기 때의 혈압을 입력해주세요. : 
//130
//수축기 혈압 : 130mmHg, 판정 : 고혈압 전단계




func judgementHighBloodPressure(userBloodPrs: Int?) -> String {
    var result = ""
    if let bloodPress = userBloodPrs {
        switch bloodPress {
            case bloodPress 0..<120:
                result = "정상"
            case bloodPress 120..<130
                result = "주의 혈압"
            case bloodPress 130..<140
                result = "고혈압 전단계"
            case bloodPress 140..<160
                result = "고혈압 1기"
            default
                result = "고혈압 2기"
        }
        return "수축기 혈압 : \(bloodPress)mmHg, 판정 : \(result)"
    }
    else {
        return "잘못 입력하셨습니다."
    }
}
print("고혈압 판정 프로그램")
print("수축기 때의 혈압을 입력해주세요. : ")
let inputBloodPrs = Int(readLine()!) 
print(judgementHighBloodPressure(userBloodPrs: inputBloodPrs))
//결과 : 고혈압 판정 프로그램
//수축기 때의 혈압을 입력해주세요. : 
//130
//수축기 혈압 : 130mmHg, 판정 : 고혈압 전단계




func convertMlToL(ml: Double) -> Double {
    return ml / 1000.0
}   
let toL = convertMlToL // 변수에 함수를 대입 : 1급 객체 조건 충족
print("\(convertMlToL(ml: 12))L") 
print("\(toL(12))L") // 매개변수명(ml:)을 쓰지 않는다.
//결과 : 0.012L
//0.012L




func convertMlToL(ml: Double) -> Double {
    return ml / 1000.0
}   
func executeFunc(funcToRun: (Double) -> Double, inputMl: Double) { // 함수를 매개변수로 사용 : 1급 객체 조건 충족 
    print(funcToRun(inputMl))
}
let toL = convertMlToL // 변수에 함수를 대입
executeFunc(funcToRun: toL, inputMl: 12)
//결과 : 0.012




func convertMlToL(ml: Double) -> Double {
    return ml / 1000.0
}  
func convertMlToMicroliter(ml: Double) -> Double {
    return ml * 1000.0
}
let toL = convertMlToL // 변수에 함수를 대입
let toMicroL = convertMlToMicroliter // 변수에 함수를 대입
func chooseFunc(funcName: String) -> (Double) -> Double { // 함수를 리턴값으로 사용 : 1급 객체 조건 충족
    if funcName == "toL" {
        return toL
    }
    else { // toMicroL or another
        return convertMlToMicroliter
    }
}
func executeFunc(funcToRun: (Double) -> Double, inputMl: Double) { // 함수를 매개변수로 사용 
    print(funcToRun(inputMl))
}
executeFunc(funcToRun: chooseFunc(funcName: "toL"), inputMl: 12)
executeFunc(funcToRun: chooseFunc(funcName: "toMicroL"), inputMl: 12)
//결과 : 0.012
//12000.0




func hate(something: String) -> String {
    return "I hate " + something
}  
func love(something: String) -> String {
    return "I love " + something
}
let loveSomething = love // 변수에 함수를 대입
print(love(something: "coding"))
print(loveSomething("coding")) // 변수에 함수를 대입했을땐 매개변수 명을 쓰지 않는다.
let hateSomething = hate // 변수에 함수를 대입
func executeFunc(funcToRun: (String) -> String, inputThing: String) { // 함수를 매개변수로 사용 
    print(funcToRun(inputThing))
}
executeFunc(funcToRun: loveSomething, inputThing: "coding") // == loveSomething("coding")
executeFunc(funcToRun: hateSomething, inputThing: "coding") // == hateSomething("coding")
func chooseFunc(feel: String) -> (String) -> String { // 함수를 리턴값으로 사용
    if feel == "happy" {
        return loveSomething
    }
    else { // sad or another
        return hateSomething
    }
}
let funcH = chooseFunc(feel: "happy") // == loveSomething
print(type(of: funcH)) // (String) -> String
print(funcH("Swift")) // == loveSomething("Swift")
// 결과 : I love coding
//I love coding
//I love coding
//I hate coding
//(String) -> String
//I love Swift




func sub(num1: Int, num2: Int) -> Int {
    return num1 - num2
}
print(sub(num1: 9, num2: 3))
let closureSub = { (num1: Int, num2: Int) -> Int in // closure (익명함수)
    return num1 - num2
}
print(closureSub(9, 3)) // 매개변수명을 입력하면 안된다.
// 왜냐하면 closureSub은 함수를 변수 안에다 대입한 것이기 때문
print(type(of: sub))
//결과 : 6
//6
//(Int, Int) -> Int




func hi() {
    print("hi")
}
func hello(param: () -> Void) { 
    param()
    print("hello")
} 
// 함수 호출
hello(param: hi) // 매개변수로 함수 넘기기
hello(param: {() in print("hi")}) // closure(가상함수) 사용
hello(param: { print("hi")}) // 매개변수, in 생략
hello() { print("hi")}// trailing closure
/*함수를 호출할 때 함수의 마지막 매개변수가 함수이면 trailing closure를 사용
할 수 있다. 매개변수 명을 생략하고 함수를 괄호 밖으로 빼낸 후에 closure을 구현 
하면 된다.*/
// 결과 : hi
//hello
//hi
//hello
//hi
//hello
//hi
//hello






// 함수 기본형
func addStr(str1: String, str2: String) -> String {
    return str1 + " " + str2
}
print(addStr(str1: "hello", str2: "soyoung"))

// addStr을 closure로 구현
let addString = {(str1: String, str2: String) -> String in 
    return str1 + " " + str2
}
print(addString("hello", "soyoung"))

// closure 구현
let subtract = {(num1: Int, num2: Int) -> Int in
    return num1 - num2
}
print(subtract(3, 1))

// 함수를 매개변수로 가지는 함수 구현
func executeFunc1(param1: String, param2: String, paramFunc: (String, String) -> String) -> String{
    return paramFunc(param1, param2)
}
print(executeFunc1(param1: "happy", param2: "day", paramFunc: addString))
func executeFunc2(param1: Int, param2: Int, paramFunc: (Int, Int) -> Int) -> Int{
    return paramFunc(param1, param2)
}
print(executeFunc2(param1: 10, param2: 5, paramFunc: subtract))

//함수 호출할 때 함수대신 closure넣기
var executeFuncResult = executeFunc1(param1: "hi", param2: "there", paramFunc: {(str1: String, str2: String) -> String in 
    return str1 + " " + str2
})
print(executeFuncResult)

// trailing closure(후행 클로저) : 마지막 매개변수 이름을 생략하고 소괄호 외부에 클로저 구현
executeFuncResult = executeFunc1(param1: "rainny", param2: "day") {(str1: String, str2: String) -> String in 
    return str1 + " " + str2
}
print(executeFuncResult)

// 리턴형 생략
executeFuncResult = executeFunc1(param1: "hi", param2: "there", paramFunc: {(str1: String, str2: String) in 
    return str1 + " " + str2
})
print(executeFuncResult)

// 리턴형 생략, trailing closure(후행 클로저)
executeFuncResult = executeFunc1(param1: "haha", param2: "hoho") {(str1: String, str2: String) in 
    return str1 + " " + str2
}
print(executeFuncResult)

// 매개변수, 리턴형, in 생략, 단축인자($0, $1) 사용 
executeFuncResult = executeFunc1(param1: "battle", param2: "ground", paramFunc: {
    return $0 + " " + $1
})
print(executeFuncResult)

// 매개변수 생략, 단축인자 사용, 리턴형, in 생략, trailing closure(후행 클로저)
executeFuncResult = executeFunc1(param1: "tales", param2: "runner") {
    return $0 + " " + $1
}
print(executeFuncResult)

// 매개변수, 리턴형, in, return 생략, 단축인자 사용
executeFuncResult = executeFunc1(param1: "kart", param2: "rider", paramFunc: {
    $0 + " " + $1
})
print(executeFuncResult)

// 매개변수, 리턴형, in, return 생략, 단축인자 사용, trailing closure(후행 클로저)
// 코드가 가독성도 좋아지고 깔끔해진 것을 볼 수 있다.
executeFuncResult = executeFunc1(param1: "dark", param2: "soul") { $0 + " " + $1 }
print(executeFuncResult)
// 결과 : hello soyoung
//hello soyoung
//2
//happy day
//5
//hi there
//rainny day
//hi there
//haha hoho
//battle ground
//tales runner
//kart rider
//dark soul





class Student {
    // stored property
    let name = "kimnana" // 반드시 값을 초기화 해줘야 한다.
    let number = "202012000"
    let major = "컴소과"
    let age : Int? // 옵셔널 변수로 선언시 값을 초기화하지 않아도된다.(알아서 nil 들어가기 때문)
}




class Student {
    // stored property
    var name = "kimnana" // 반드시 값을 초기화 해줘야 한다.
    var number = "202012000"
    var major = "컴소과"
    var age : Int? // 옵셔널 변수로 선언시 값을 초기화하지 않아도된다.(알아서 nil 들어가기 때문)
    func getStudentInformation() { // 인스턴스 메서드(인스턴스가 호출)
        print("이름 : \(name)\n학번 : \(number)\n전공 : \(major)")
    }
}
var student : Student = Student() // Student 클래스 인스턴스 생성, : Student 생략 가능
student.getStudentInformation() // 함수 호출
print(student.age) // nil이 들어감
//결과 : 이름 : kimnana
//학번 : 202012000
//전공 : 컴소과
//nil

 

 

 

 

 

 

출처 : iOS프로그래밍기초(21-2학기)한성현교수 강의 내용 변형 및 요약