Swift 학습

주말에 한가하면 swift를 만나면 X코드의 플레이 그라운드에서 swift를 하는 것도 재미있어요. 코드를 작성하면서 한 번 검사해 봐요.

토대

기본 유형

Int Double Float String Bool

let c = 1_000_000_000
let d:Int = 1
let e:Double = 1.5
let f:Float = 2.2
let g:String = "12"

변수와 상수

let 상수 var 변수는 swift에서 다른 형식으로 은밀하게 변환되지 않습니다.하나의 값을 다른 형식으로 변환해야 한다면, 현식 변환을 해야 한다.
\()를 사용하여 값을 문자열로 변환할 수도 있습니다.

명시적 변환

let str = "The width is"
let intlet = 94
let result = str + String(intlet)
print(result)

let a = 3
let b = 0.1415926
let pi = Double(a)+b

let version = 4
let     = "   swift \(version)"

배열과 사전

[]을 사용하여 배열과 사전을 만들 수도 있고 []와 [:]를 사용하여 빈 배열과 사전을 설정할 수도 있습니다.

let emptyArray = [String]()
let emptyDictionary = [String: Float]()
var str = "Hello, playground"
var array = [1,2,3,4,5,6,7,8]
var ar1 = array[1]
array[1]=5
ar1 = array[1]
var dic = [String:Any]()
dic = ["a":"1","b":2.2,"c":3]
var ar2 = dic["c"]
array = []
dic=[:]

의 원조

여러 데이터의 집합은python과 유사하다

 var tuples = ("aven" , 200 , false)
 let (nickname,code,success) = tuples
 let (name,_,_) = tuples

 print (tuples.0)//aven
 print (nickname)//aven
 print (name)//aven
 let test = ( nickname:"aven" , code:200 , success:false )
 print (test.nickname)//aven

논리 조작

만약 switch와 조건 조작
-if 문장에서 조건은 부울 표현식이어야 한다.if와let을 함께 사용하여 값이 부족한 상황을 처리할 수 있다.선택할 수 있는 값을 처리하는 또 다른 방법은 사용??기본값을 제공하기 위해 조작부호를 사용합니다.옵션 값이 없으면 기본값으로 대체할 수 있습니다.switch는 임의의 데이터 및 각종 비교 작업을 지원합니다. - switch에 일치하는 자구가 있으면 프로그램은 switch 문구를 종료하고 아래로 내려가지 않기 때문에 자구의 끝에break를 쓸 필요가 없습니다.그러나default을 꼭 넣어야 한다. 그렇지 않으면 잘못 보고할 수 있다.
for-in, for,while,repeat-while를 순환합니다. for-in은 사전을 두루 훑어보며 키 값이 맞다는 두 변수가 필요합니다.사전은 무질서한 집합이기 때문에 그들의 키와 값은 임의의 순서로 교체되어 끝난다.주기에서.< 사용 가능범위.<==> 사용[),...==> [] repeat-while 유사do-while

 let array = [11, 22, 33, 44, 55,66,77,88,99,111]
 var team = 0
 for data in array {
    if data > 50 {
        team += 3
    } else {
        team += 1
    }
 }
///////////////////
 var optionalName: String? = nil
 var greeting = "Hello!"
 if let name = optionalName {
    greeting = "Hello, \(name)"
 }else{
    greeting = "nobody"
 }

 let nickName: String? = "aven"
 let fullName: String = "X"
 let informalGreeting = "Hi \(nickName ?? fullName)"

//////////////////////////////////////////////////////

 let vegetable = "red pepper"
 switch vegetable {
 case "celery":
    print("Add some raisins and make ants on a log.")
 case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
 case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
 default:
    print("Everything tastes good in soup.")
 }

////     
let dic = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
 ]
 var largestNumber = 0
 var largestKey: String = ""
 for (key, values) in dic {
    for value in values {
        if value > largestNumber {
            largestNumber = value
            largestKey = key
        }
    }
 }
 print(largestKey)
 print(largestNumber)


 var n = 2
 while n > 100 {
    n = n * 2
 }
 print(n)//2
 var m = 2
 repeat {
    m = m * 2
 } while m > 100
 print(m)//4

 for i in 0..<4 {
    print(i)//0 1 2 3
 }

함수.

func는 하나의 함수를 설명하고, ->는 함수 반환 값의 유형을 지정하며, 모듈을 사용하여 한 함수가 여러 개의 값 변수로 함수에서 수조로 표현될 수 있도록 합니다.함수는 매개 변수 이름을 매개 변수의 라벨로 사용하고, 매개 변수 이름 앞에서 매개 변수 라벨을 사용자 정의하거나 을 사용할 수 있습니다.매개변수 태그를 사용하지 않음을 나타냅니다.

func hi(name: String) -> String {
    return "Hello \(name)."
}
print( hi(name:"aven"))//Hello aven.

func hi2(_ name: String) -> String {
    return "Hello \(name)."
}
print( hi2("aven"))//Hello aven.

func hi2(nickname name: String) -> String {
    return "Hello \(name)."
}
print( hi2(nickname:"aven")) //Hello aven.

func compare(_ numbers: [Int]) -> (min: Int, max: Int, sum: Int) {
   var min = numbers[0]
   var max = numbers[0]
   var sum = 0
   for score in numbers {
       if score > max {
           max = score
       } else if score < min {
           min = score
       }
       sum += score
   }   
   return (min, max, sum)
}
let result = compare([11,2,34,56,1])
print (result) //(min: 1, max: 56, sum: 104)

/////
func data(numbers: Int...) -> Double {
    var sum = 0
    let count = numbers.count
    for number in numbers {
        sum += number
    }
    if count == 0 {
        return 0
    }
    return Double(sum/count)
 }
 print(data(numbers: 1,2,111))//38.0
 print(data(numbers: 22,1,43,12,53))//26.0
 print(data())//0.0

함수는 중첩될 수 있습니다.중첩된 함수는 외부 함수의 변수에 접근할 수 있습니다.

func newdata(_ number: Int) -> Int {
    var y = number;
    func add() {
       y += 5
    }
    add()
    return y
}
print(newdata(18)) //23

함수는 다른 함수의 반환값으로 할 수도 있고, 매개 변수로 다른 함수에 전달할 수도 있다.

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        print (number)
        return 1 + number
    }
    return addOne //((Int) -> Int)
 }
 var increment = makeIncrementer() //((Int) -> Int)
 increment(7) //8

 func hasAnyMatches(bumber: Int, condition: (Int) -> Bool) -> Bool {
    if condition(bumber) {
        return true
    }
    return false
 }
 func lessThanTen(number: Int) -> Bool {
    return number < 10
 }
 var number = 9
 hasAnyMatches(bumber: number, condition: lessThanTen) // true

패키지 닫기: 그것은 나중에 호출될 수 있는 코드입니다.패킷의 코드는 패킷 역할 영역의 변수와 함수에 접근할 수 있으며, 패킷이 다른 역할 영역에서 실행되더라도.함수는 사실상 특수한 클러치이다.익명 클립을 만드는 데 {}을 사용할 수 있습니다.in을 사용하여 매개 변수와 반환값 형식의 성명을 패키지 함수체와 분리합니다.

var numbers = [20, 19, 7, 12]
let ok = numbers.map({
    (number: Int) -> Int in
    if(number%2 != 0){
        return 0
    }else{
        return number
    }
 })
print(ok)//[20, 0, 0, 12]
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)//[60, 57, 21, 36]
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)//[20, 19, 12, 7]