Swift 초 기초 문법 (원본)

9757 단어
Swift 의 원 조 에 대해 얼마나 알 고 있 습 니까?자신 있 으 시 네요... 이 글 을 보고 말씀 드 리 겠 습 니 다.
원조
  • 원 조 는 Swift 에서 특유 한 것 으로 OC 에 관련 데이터 형식 이 없습니다
  • 원 조 는 데이터 구조 로 여러 개의 값 을 하나의 복합 값 으로 구성 할 수 있 으 며 원 조 내 요소 의 유형 은 같 을 필요 가 없다
  • .
    원 그룹의 정의 형식:
    let      = (  ,  ...)
    

    배열사전원조!
  • 배열 로 정 의 된 데이터 단점 을 사용 합 니 다. 한 배열 에 여러 가지 데이터 형식 이 존재 하면 모든 요소 유형 이 NSObject
  • 로 변 합 니 다.
     :
    let infoArray = ["lyu" , 18]
    let name = infoArray[0] //  :name    NSObject,   String,             name.characters     
    let length = name.characters.count  //    
    
  • 사전 으로 정 의 된 데이터 단점: 한 사전 에서 value 값 에 여러 가지 데이터 형식 이 존재 하면 모든 value 형식 이 NSObject
  • 로 변 합 니 다.
     :
    let infoDic = ["name" : "lyu" , "age" : 18]
    let name = infoDic["name"]  //  :name    NSObject,   String,             name.characters     
    let length = name.characters.count  //    
    
  • 원 조 를 사용 하여 데 이 터 를 정의 합 니 다. 장점: 원 조 의 데 이 터 는 그들의 실제 유형 에 따라 저 장 됩 니 다
  •  :
    let infoTuple = ("lyu" , 18)  //               
    let name = infoTuple.0  //name    String
    let length = name.characters.count  //             
    

    원 그룹의 사용 방법
  • 원조 중의 원소 에 별명 지어 주기
  •  :
    let errorTuple = (newName : "Not Found" , newCode : 404)
    let errorName = errorTuple.newName
    let errorCode = errorTuple.newCode
    //  .0 .1      
    let errorName1 = errorTuple.0
    let errorCode1 = errorTuple.1
    
  • 원 그룹 에 별명 을 지어 주 는 또 다른 방법: 주의해 야 할 것 은 이런 방법 으로 원 그룹 을 만 드 는 것 은 원 그룹의 이름 을 얻 지 못 하 는 단점 이다. 원 그룹의 이름 을 얻 지 못 하 는 장점: 빠 른 재 구성
  •  :
    let (newName , newCode) = ("Not Found" , 404)
    let errorName = newName
    let errorCode = newCode
      :                      
    

    원 그룹의 진급 사용 방법
  • 스위치 와 조합 하여 복잡 한 조건 에 대한 판단 을 한다.
  •  :    20      ,          
            let name = "lyu"  //  
            let age = 18  //  
            var personalInfo = [String : NSObject]()  //    
            personalInfo["height"] = 1.80  //    
            switch (age,name,personalInfo) {  //    ,            ,  ,        
            case (let age , let name , let personalInfo) where age < 20:  //  age<20   case
                print(age)
                print(name)
                print(personalInfo)
            default:
                print(age)
            }
    
  • 함수 의 반환 값 으로 여러 개의 반환 값 을 만 드 는 함수
  •  :             ,    
            func getCount(nums : [Int]) -> (Int , Int) {  //           
                var oddCount = 0  //       
                var evenCount = 0  //       
                for num in nums {  //    
                    if num % 2 == 0 {            
                        oddCount += 1
                    }
                    else  //     
                    {
                        evenCount += 1
                    }
                }
                return (oddCount , evenCount)     :(  ,  )
            }
            let nums = [12,14,15,2,77,13]
            let counts = getCount(nums)
            print(counts)
            print(counts.0)
            print(counts.1)
    
  • 함 수 는 원 그룹의 요소 로 서 다 함수 동시 호출
  •  :
            func test1() -> String{
                return "test1"
            }
            func test2() -> String{
                return "test2"
            }
            func test3() -> String{
                return "test3"
            }
            let funcTuple = (a : test1() , b : test2() , c : test3())
            print(funcTuple)
    
  • 교환 값 이 교환 되 는 것 은 반드시 변수 이 고 이 두 변수 유형 은 반드시 같 아야 한다
  •  :
            var (x , y) = (11 , 22)
            (x , y) = (y , x)
            print(x , y)
    

    원 그룹의 초 진급 사용 방법
  • 가짜 난 진: 구조 체 대신 원 조 를 사용한다
  •  :
            //     
            struct newS {
                var name : String
                var age : Int
            }
            let temp = newS(name : "lyu" , age :18)
            //    
            let tuple = (name : "lyu" , age : 18)
            //        
            print(tuple.name)
            print(temp.name)
    
    Tips:   ?  ?
                    :             ,          ,          ,        
             "  "(           ~)   ,               
      :          "      "
    
  • 데 이 터 를 처리 하 는 과정 에서 특정한 함수 의 반환 값 을 임 데이터 로 다른 방법 에 전달 합 니 다.
  • 원 조 는 함수 의 매개 변수 로 할 수 있다
  • 원조 도 함수 의 반환 값 으로 할 수 있다. 그렇다면 이런 용법 도 당연히 성립 될 수 있다
  • //         
    func getViewInfo() -> (r : Int , alpha : Double , location : (Double , Double)){
            return (255 , 0.5 , (100 , 100))
    }
    //        
    func getAlpha(tuple : (r : Int , alpha : Double , location : (Double , Double))) -> Double{  
            return tuple.alpha
    }
    let alpha = getAlpha(getViewInfo())
    print(alpha)
    
  • 물론 상기 사용 방법 에 따라 우 리 는 본 사례 도 구조 체 를 사용 하여 실현 할 수 있다 고 생각 할 수 있다. 다음 과 같다.
  •         //     
            struct Location {
                var x : Double
                var y : Double
            }
            struct Info {
                var r : Int
                var alpha : Double
                var location : Location
            }
            //    
            func getViewInfo() -> (Info){
                return Info(r: 255 , alpha: 0.5 , location: Location(x: 100 , y: 100))
            }
            func getAlpha(stc : Info) -> Double{
                return stc.alpha
            }
            //    
            let alpha = getAlpha(getViewInfo())
            print(alpha)
    
    tips:
                    ,          ,                       
    
  • 원 그룹 유형 을 구체 적 으로 정의 합 니 다
  •         //typealias   C/OC  typedef,     
            typealias Tuple = (name : String , age : Int ,height : Double)  //            
            func printTuple(tempTuple : Tuple){  //  Tuple      
                print(tempTuple)
            }
            //        
            printTuple((name: "lyu" , age : 18 , height : 1.80))
            printTuple(Tuple("lyu" , 18 , 1.80))
            printTuple(("lyu" , 18 , 1.80))
    
  • 하나의 유형 요소 의 개 수 를 제약 합 니 다. 우리 가 배열 가 변 배열 을 만 들 때 이 배열 은 앞으로 7 개의 데 이 터 를 저장 하 기 를 바 랍 니 다. 예 를 들 어 일주일 동안 의 매일 강우량
  • 을 통계 하 기 를 바 랍 니 다.
    //  1:                7    
            var info = [Int]()
            info.append(11)
    //  :                 ,                 8 ,             ,        ~
    
    //  2:        
    var info : (Int,Int,Int,Int,Int,Int,Int,Int)  //  ?  7 ,         
    //  :      info         7 ,    7    
    
  • 함수 의 가 변 매개 변수 로 함수 의 매개 변수 수량 이 불확실 할 때
  •  :
    func sum(numbers : Int...) -> Int{
                return numbers.reduce(0, combine: +)  //        ,   0      
            }
            let result = sum(1,2,3)
    
  • 원조 와 범 형 원조 에서 원소 의 실제 유형 은 원조 에서 원소 유형 에 따라 확정 되 기 때문에 범 형 으로 원 조 를 구속 하기 보 다 는 우리 의 수요 에 따라 명확 한 데이터 유형의 원 조 를 정의 하고 반대로 범 형 을 제어 하 는 것 이 낫다.
  • 원 그룹의 유형 으로 함수 의 범 형 을 지정 합 니 다
  •         // :        
            func three(tuple : (c1 , c2 , c3)) -> c3{  //             ,                   
                return tuple.2
            }
            //        ,         
            let  height = three(("Lyu" , 18 , 1.88))  //  three       ,Swift    (  )     three   !     height    Double  
    
  • 수요 에 따라 부류 에서 부류 범 형
  • 을 지정 한다.
             :       
            class superClass{  //    ,       
                typealias numbers = (c1 , c2 , c3)  //                 
                func printNewNumbers(nums : numbers) -> Void {
                    print(nums)
                }
            }
            class childClass : superClass {  //    ,            ,         
            }
            let child = childClass()  //     ,                ,             ,
            child.printNewNumbers(("lyu" , 18 , 1.80))  //        
    
            //          
            class superClass{
                typealias numbers = (c1 , c2 , c3)
                func printNewNumbers(nums : numbers) -> Void {
                    print(nums)
                }
            }
            class childClass : superClass {  //                (  ,              ...)
            }
            let child = childClass()  //  ,                 
            child.printNewNumbers(("lyu" , 18 , 1.80))
    
    tips:
               ,           (     ),        ,           :
            func myNameOrAge(nameOrAge : c1) -> c1{
                return nameOrAge
            }
            let name = myNameOrAge("Lyu")  //  name    String       ,   anyObject
            let age = myNameOrAge(18)  //  age    Int       ,   anyObject
        :      return nameOrAge         nameOrAge     ,                 ,                ,    anyObject     
    
  • 원 조 를 함수 의 매개 변수 로 한다.
  • 삼원 조 를 이용 하여 외부 매개 변수 함 수 를 가 진 매개 변수
  •         func sum(a a : Int , b : Int , hello : String) -> Int {
                return a + b
            }
            let tuple = (a : 1,b : 2, hello : "hello")  //                   
            let result = sum(tuple)
    
  • 무 참 원 조 를 이용 하여 외부 매개 변수 함수 가 없 는 매개 변수
  •         func sum(a : Int , _ b : Int , _ hello : String) -> Int {
                return a + b
            }
            let tuple = (1 , 2 , "hello")  //                   
            let result = sum(tuple)
    
  • 한 함수 가 되 돌아 오 는 원 조 는 다른 함수 의 매개 변수
  •         func getTuple() -> (Int , Int , String){
                return(1, 2, "hello")
            }
            func printTuple(tuple : (Int , Int , String)){
                print(tuple)
            }
            printTuple(getTuple())
            //                 (   ),           
    

    좋은 웹페이지 즐겨찾기