swift基础_swift基础入门 - CSDN
  • 注:由于基础部分在Swift Tour 中已经大体的说明了,所以在详解中不会达到100%的原文释义 Constants and Variables 常量和变量 常量和变量都需要声明名称和类型(作为程序员,这些基础也就不说了),常量一次赋值...

    注:由于基础部分在Swift Tour 中已经大体的说明了,所以在详解中不会达到100%的原文释义


    Constants and Variables  常量和变量

    常量和变量都需要声明名称和类型(作为程序员,这些基础也就不说了),常量一次赋值不能改变,变量的值可以改变



    Declaring Constants and Variables   声明常量和变量

    常量和变量在使用之前必须要声明,使用let关键字定义常量,var关键字定义变量

    下面的例子可以用来定义用户登录的时候最大的尝试次数:

    let maximumNumberOfLoginAttempts = 10
    var currentLoginAttempt = 0

    可以在一行定义多个变量或者常量,用逗号隔开:

    var x = 0.0, y = 0.0, z = 0.0



    Type Annotations  类型标志

    类型标志(类型注释)可以标记你定义的变量或者常量允许存储的类型,在变量/常量的名称后面放置一个冒号,然后留一个空格,然后写上类型的名称

    var welcomeMessage: String
    这个变量就可以存储String类型了

    welcomeMessage = "Hello"
    在实际编码过程中,你几乎不需要给变量/常量类型标志,因为当你第一次赋值的时候,Swift已经知道了变量的类型,如果声明变量的时候没有赋值,那Swift才通过类型标志识别变量的类型



    Naming Constants and Variables   命名变量和常量

    你可以使用任意你喜欢的字符命名变量和常量,包括Unicode编码:

    let π = 3.14159
    let 你好 = "你好世界"
    
    你妹的,白打了那么多了,因为粘贴一个表情,后面写的都没有了,好桑心啊
    

    在Swift中,对于常量和变量的名称定义宽泛了许多

    常量和变量命名的时候不能包含数学符号、箭头、私人定义的Unicode字符,或者用点和横线拼接的字符,也不允许以数字开头,但是数字可以在名称中的其他地方

    一旦你用一种确定的类型定义了一个常量或者变量,你就不能用同样的变量名定义其他变量了,也不允许改变变量/常量的类型,变量也不可以转换成常量,常量也不可以转换成变量

    如果你想使用Swift关键字作为变量名称,那么小伙伴只能对你说(no zuo no die why you try),既然你这么坚持用的话,Swift也提供了你使用的方法,使用括号把变量名称括起来,像这样(`)

    改变变量的值:

    var friendlyWelcome = "Hello!"
    friendlyWelcome = "Bonjour!"
    // friendlyWelcome is now "Bonjour!"
    常量的值不能改变,改变会报编译错误:

    let languageName = "Swift"
    languageName = "Swift++"
    // this is a compile-time error - languageName cannot be changed


    Printing Constants and Variables    打印常量和变量

    可以使用println进行打印:

    println(friendlyWelcome)
    // prints "Bonjour!
    之前用过OC的都知道啦,和NSLog一个功能,C,C++里面也有啊,而且还可以带参数的。

    println和print的区别就是:都是用来控制台打印的,println打印之后换行,print打印之后不换行

    也可以打印一个字符串:

    println("This is a string")
    // prints "This is a string
    还有一种方法可以将变量或者常量放到字符串中,将变量放入括号()中,在前面加上反斜杠 \ ,如 \(变量.常量)

    println("The current value of friendlyWelcome is \(friendlyWelcome)")
    // prints "The current value of friendlyWelcome is Bonjour!


    Comments    注释

    单行注释

    // this is a comment
    多行注释

    /* this is also a comment,
    but written over multiple lines */
    嵌套注释:

    /* this is the start of the first multiline comment
    /* this is the second, nested multiline comment */
    this is the end of the first multiline comment */

    嵌套注释的功能就是可以一次性注释一大段的代码,而且不用管这段代码中间的其他注释



    Semicolons    分号

    Swift代码可以不写分号,每一行是一个语句,当然写了也可以,如果一行要放两个语句,就用分号隔开

    let cat = "cats"; println(cat)
    // prints "cats"


    展开全文
  • Swift中有一个Alamofire第三方是进行网络请求的,它是AFNetworking的作者写的Swift形式,今天先介绍一下,利用pod导入AFNetworking,SVProgressHUD,MJRefresh等第三方实现刷新数据、加载更多、网络请求,同时使用了...

    Swift中有一个Alamofire第三方是进行网络请求的,它是AFNetworking的作者写的Swift形式,今天先介绍一下,利用pod导入AFNetworking,SVProgressHUD,MJRefresh等第三方实现刷新数据、加载更多、网络请求,同时使用了MVC的模式进行界面搭建,随后研究Alamofire实现网络请求的功能,再分享给大家。。。。

    本文有两个界面,首界面直接使用的AFNetworking进行网络请求,然后界面展示

    首界面创建表格:

    self.myTableView = UITableView.init(frame: CGRect.init(x: 0, y: 0, width: SCREEN_W, height: SCREEN_H), style: UITableViewStyle.plain);
            self.myTableView.delegate = self;
            self.myTableView.dataSource = self;
            self.myTableView.rowHeight = 80;
            self.myTableView.tableHeaderView = UIView.init();
            self.myTableView.tableFooterView = UIView.init();
            self.view.addSubview(self.myTableView);
            //注册Cell
            self.myTableView.register(MyCellTableViewCell.self, forCellReuseIdentifier: "myCell");
            // Nib 注册
            //self.tableView.registerNib(UINib(nibName: "MyCellTableViewCell", bundle: nil), forCellReuseIdentifier: "myCell")

            //添加下拉刷新
            self.myTableView.mj_header = MJRefreshNormalHeader(refreshingBlock: {
                //数据加载
                self.pageIndexI = 1;
                self.dataHttpRequest(pageIndexStr: NSString.init(format: "%d", self.pageIndexI));
            });
            //设置启动即刷新
            //self.myTableView.mj_header.beginRefreshing();

    然后进行网络请求方法:

    //MARK:-------AFNetworking基本的数据请求形式(未封装的方法)
        func dataHttpRequest(pageIndexStr:NSString) {
            
            SVProgressHUD.show(withStatus: "正在加载");
            if pageIndexStr.isEqual(to: "1") {
                self.dataArray.removeAllObjects();
            }
            
            let urlStr = "http://www.healthmanage.cn/android/hrsBabyAction_loadHrsBabyHealth.action";
            let paramsDic = ["userId":"38567","pagesize":"8","pageIndex":pageIndexStr];
            
            //AFNetworking使用POST请求
            let sessionManager = AFHTTPSessionManager.init();
            sessionManager.responseSerializer.acceptableContentTypes?.insert("text/plain");
            sessionManager.post(urlStr, parameters: paramsDic, progress: nil, success: { (_, responseObject) -> Void in
                //print("输出此时的数据请求结果......\(responseObject)");
                
                SVProgressHUD.dismiss(withDelay: 1);
                self.myTableView.mj_header.endRefreshing();
                //守卫语句,用于判断不符合条件时安全退出,而不是crash
                guard (responseObject as? NSDictionary) != nil else{
                    print("返回数据为nil,或者 类型不匹配");
                    return;
                };

                let resultDic = responseObject as! NSDictionary;
                let successB = resultDic["success"] as! Bool;
                if(successB){
                    //如果返回有值
                    let itemArray = resultDic["ITEMS"] as! NSArray;
                    
                    if(self.myTableView.mj_footer != nil)
                    {
                        self.myTableView.mj_footer.endRefreshing();
                    }
                    else
                    {
                        //判断数组数量和page,如果符合条件就添加上拉加载
                        if(itemArray.count == 8 && pageIndexStr.isEqual(to: "1"))
                        {
                            self.myTableView.mj_footer = MJRefreshBackNormalFooter(refreshingBlock:{ () -> Void in
                                
                                self.pageIndexI = self.pageIndexI+1;
                                self.dataHttpRequest(pageIndexStr: NSString.init(format: "%d", self.pageIndexI));
                            })
                        }
                    }
                    
                    for dic in itemArray {
                        //因为数组中是:[String:AnyObject]字典类型,所以不能使用as!NSDictionary,我是这么理解的,不知道对不对
                        let itemDic = dic as! [String:AnyObject];
                        self.dataArray.add(itemDic);
                    }
                    self.myTableView.reloadData();
                }
                else
                {
                    //请求无数据NOVALUE情况
                    if self.dataArray.count>0{
                        self.myTableView.mj_footer.endRefreshing();
                        self.myTableView.mj_footer = nil;
                    }
                }
                }) { (_, error) in
                    print("请求数据错误报告...........\(error)");
                    SVProgressHUD.showError(withStatus: "网络请求错误");
            }

    首界面完成后进行第二层界面的设计,采用MVC的结构进行样式创建:


    创建表格界面,然后使用数据请求工具和Model进行数据的解析,然后在Cell中进行Model数据的展示

    数据请求工具方法:

    //创建请求数据的工具方法
        //参数说明:mType:方式   URLString:url   parametersDic:参数   success:成功闭包结构   failure:失败闭包结构
        func urlRequestTool(mType:MethodTypes,URLString:String,parametersDic:Dictionary<String,Any>?,successComplete: @escaping SuccessClosure,failureComplete:@escaping FailureClosure) {
            SVProgressHUD.show(withStatus: "正在加载");
            if mType == .GET {
                self.get(URLString, parameters: parametersDic, progress: nil, success: { (_, respData) -> Void in
                    //返回数据
                    SVProgressHUD.dismiss(withDelay: 1);
                    successComplete(respData);
                }, failure: { (_, err) in
                    //返回错误
                    SVProgressHUD.dismiss(withDelay: 1);
                    failureComplete(err);
                })
            }else{
                self.post(URLString, parameters: parametersDic, progress: nil, success: { (_, respData) in
                    //返回数据
                    SVProgressHUD.dismiss(withDelay: 1);
                    successComplete(respData);
                }, failure: { (_, err) in
                    //返回错误
                    SVProgressHUD.dismiss(withDelay: 1);
                    failureComplete(err);
                })
            }
        }

    Model类:

    class MyDic: NSObject {
        var petNameStr:String!;
        var genderIdStr:String!;
        var birthdayStr:String!;
        
        init(dict:[String:AnyObject]) {
            super.init();
            self.petNameStr = dict["petName"] as! String!;
            self.genderIdStr = dict["genderId"] as! String!;
            self.birthdayStr = dict["birthday"] as! String!;
        }
    }

    Cell中数据展示:
        func setMyDicModel(dataModel:MyDic)
        {
            self.nameLabel.text = dataModel.petNameStr;
            let sexStr = dataModel.genderIdStr;//也可以转成NSString使用
            //NSString 有一个方法isEqualToString 方法用来判断两个字符串是否完全相等,String没有这个方法,但是因为String是值类型所以可以直接用 == 判断是否完全相等。
            if sexStr == "1" {
                self.sexImgView.image = UIImage.init(named: "baby_sex_boy");
                self.headImgView.image = UIImage.init(named: "baby_default_boy");
            }
            else
            {
                self.sexImgView.image = UIImage.init(named: "baby_sex_girl");
                self.headImgView.image = UIImage.init(named: "baby_default_girl");
            }
            
            self.birthDayLabel.text = NSString.init(format: "生日:%@",dataModel.birthdayStr) as String;
        }

    效果图:


    具体代码讲解看源码中的文字注释,如果不错请点赞,谢谢,转载请注明出处。。。。:https://github.com/hbblzjy/Swift-RefreshHTTP.git



    展开全文
  • Swift学习-基础的语法

    2016-05-06 10:17:10
    i 励志作为iOS的开发人员,尽管写代码的时候不会专门的挑选Swift语言,但是肯定都会熟悉Swift这个名字,楼主表示从刚开始学习objc的时候就对Swift这个名字很感兴趣,感觉很高大上,但是从很多博客上也相应的看到相关...

          励志作为iOS的开发人员,尽管写代码的时候不会专门的挑选Swift语言,但是肯定都会熟悉Swift这个名字,楼主表示从刚开始学习objc的时候就对Swift这个名字很感兴趣,感觉很高大上,但是从很多博客上也相应的看到相关文章,不得不说,Swift必将成为以后iOS开发的主流,尽管每次更新,Swift语言都会有比较大的更新,但不能代表就不了解他,闲话不多说,想了解Swift的历史可以去百度,今天聊聊关于Swift的那点小基础,这里如果有一点点C++/Java/PHP的基础的话,类比了解起来会更容易,毕竟Swift是集合了许许多多的语言的优点。


    定义变量


    首先第一步必然先熟悉如何定义变量,Swift语言楼主学的时间不是很长,基本是靠类比进行学习的,所以语言不是很准确,以后有更深的了解,必然会在这里修正

    定义变量首先会有两个关键字 let (不可变)与 var(可变)

    有什么区别呢,如其名字,let关键字定义的属性是不能修改的,var的变量是可以修改的,文字表述可能会比较无聊,代码来解释一下吧
    var stringBo:String = "RunIntoLove";//后面的引号可以不加,Swift允许,但是楼主比较习惯了
    let string1Bo:String = "Run";
    
    //进行修改值
    stringBo = "Yue";
    string1Bo = "Yue";//会出现报错-Cannot assign to value:'stringBo' is a 'let' constant ,就是说不能改变他的值,因为他是一个let类型的变量

    那么变量名字后面的:以及后面的String是什么呢,Swift依旧保持特色,这就是他的定义变量的类型,stringBo:String 表示一个变量的名字叫做stringBo,类型是String
    var stringBo = "RunIntoLove";//Swift会自动的根据后面的类型,判断stringBo的类型,所以可以不写类型
    var string1Bo:String; //这样子是定义了一个字符串String类型的变量
    var int1Bo:Int = 10;//这样子是定义了一个整型Int类型的变量
    var string2Bo;//这里会报错,如果不直接赋值,那么后面的类型是不可以忽略的,会报错-Type annotation missing in pattern 类型描述缺少类型

    数字型:Int,Double

    在Swift中的类型开头都是大写的,不同于C/C++,但这也不影响使用,毕竟objc的风格也是如此,这里只说一下他的特点
    //数字
    var u:Int = 00010_000_000;//var u = 10000000 || var u = 10_000_000.0 这三种写法是一样的
    
    var d:Double = 10.2;
    
    var o = Double(u) + d;//在Swift中,不同类型的属性不能进行运算,要想进行运算,必须强制转换成相同的类型,这个时候o的值就是10000010.2

    字符串:String

    字符串在Swift中的用法更加灵活,比如两个字符串连接,只需要用"+"连接即可,这点是综合了C++/Java的用法,毕竟是好处嘛
    var firstName:String = "RunInto"
    var lastName:String = "Love"
    
    //字符串的连接
    var name:String = firstName + lastName

    元组:

           元组是Swift中比较新的类型了,但是第一次看到元组的时候比较亲切,后来想了想第一次接触元组是在大学中的离散数学,它是一种能够存多种值的结构,这东西不需要定义类型,就能存储多种数据,但是有很好用,语言不能表达,为什么会有元组呢,因为Swift的函数是可以有多个返回值的,接收的时候自然会用元组来接收,用代码更好的说明下:
    //定义元组
    
    var postion = (name:"YueWen",age:22);//定义一个元组,这种定义法类似一个结构体
    
    var person:(String,Int) = ("YueWen",22);//可以提前声明类型
    
    var (z,m) = ("yuewen",18);//通过元组给其他元组赋值
    var point2 = (name:z,age:m);
    
    
    //取值
    var name_1 = postion.name//与name_1 = postion.0等价
    var age_1 = postion.age//与age_1 = postion.1等价
    
    var name_2 = person.0//通过小标进行取值,类似与数组了
    var age_2 = person.1

    语句控制

    if...else

    在Swift的if-else语句中,不同的还是有的,它不允许在()里进行隐形判断,必须是显性的。
    什么叫隐形呢,比如在objc中
    NSInteger i = 1;
    
    if(i)//如果i为真,报错-Type'Int' does not conform to protocol 'BooleanType'
    {
        //coding..
    }

    这个样子在objc中允许,他会自动的将1转成YES,将0转成NO,但是Swift中上面的语法是错误的.如果想正确,必须变成显性的判断
    var number:Int = 1;
    
    if(numbe1 == 1)//如果number = 1
    {
        //coding...
    }

    for循环

    for循环没有什么较大的改动,依旧有最基础的,也有for-in循环,如下
    //定义一个数组
    var numberArr = [90,85,47,52,36,"123"]//这里数组比较特别,里面的数据不仅限于一种类型,比如这里的数组存的就是Int类型的数据以及String类型的数据
    
    //循环遍历
    for s in numberArr
    {
        print("number = \(s)")//在iOS_9.0之后,print替换了println,println已经被废除,写的话会报错
    }
    
    //普通for循环
    for (var i = 0; i < numberArr.count; i++)//Swift中调用方法废除了[],选用了. 这点与大多数的编程语言相同了
    {
        var s = numberArr[i]
        print("打印出的变量为\(s)")//print 代替 println,打印的形式只需要加一个\(需要打印的内容)即可
    }


    do-while循环 - repeat-while循环  iOS9之后用repeat替换do

    依旧通过便利上数组来举例
    //do while循环
    var k = 0
    
    repeat//iOS9.0之后用repeat代替了do
    {
        var s = numberArr[k]
        print("do while 循环打印出的变量是\(s)")
        k++
    }while(k < numberArr.count)

    while循环

    //while循环
    var k1 = 0;
    while(k1 < numberArr.count)
    {
        print("while 循环打印出的变量是\(numberArr[k1])");
        k1++ ;
    }

    Switch语句

    switch语句变动还是比较大的,因为在objc以及其他的语言中,每次case完毕之后都需要在后面加一个break,不然会穿透到下一个case语句,但是在switch语句中,不需要加break,默认不穿透,需要穿透的事后只需要加 fallthrough 关键字即可
    //switch
    let iso = "iOS"
    switch iso//switch后面的变量可以使字符串,不仅仅只限于数字了
    {
        case "iso":
            print("iso 为 iOS")
        //break 可以省略,swift不穿透
        //穿透需要加 fall through,加上这一句就是说执行完这句话之后会继续执行case:"Android"
        
        case "Android":
            print("iso 为 Android")
        
        case "JS":
            print("iso 为 JS");
        default:
        print("最后了")
        
    }

    函数

    函数形式发生了变化,声明方法以及函数,用func关键字,返回值不再存在与函数之前,而是用放在 ’ -> ‘之后,如果返回值为Void,可以省略

    无返回值无参

    func testFunction()
    {
        print("测试方法!")
    }

    有一个参数没有返回值

    //带参的函数
    func testFunction(s:String)
    {
        print("参数是\(s)")
    }

    如果想真正的修改参数值,用inout关键字

    这句话是什么意思呢,就是说当做参数放到函数中,无论在函数中对该参数进行任何的操作,原来的实参是不变的,加上inout关键字就相当于C语言的指针,C++的引用&,里面对参数的更改实际上就是修改的实参
    func testFunction0(inout s:String)//表示实参可以改变,改变之后参数也会发生变化,类似C++的引用
    {
        s = "Run";
        print("参数是\(s)")
    }
    
    var s:String = "RunIntoLove";
    testFunction0(&s);//在执行完毕这一句话之后,s就变成了Run

    带多个参数,无返回值

    //带多个参数的函数
    func testFunction(s:String , i:Int)
    {
        print("我的参数是\(s),\(i)")
    }
    testFunction("RunIntoLove", i: 5)


    返回一个返回值的函数

    //返回值函数
    func testFunctionF(v1:String, andVaule v2:Int, andNumber v3:Int) ->String//逗号不要丢
    {
        return "\(v1)\(v2)\(v3)"
    }
    var string = testFunctionF("RunIntoLove", andVaule: 10, andNumber: 8)
    print("返回值参数是:\(string)");//返回值参数是:RunIntoLove108

    返回多个返回值的函数

    //无参 返回3个值,但是需要用一个元组接收
    func testFunction123() ->(String ,String ,String)
    {
        return ("RunIntoLove","Study","Swift")
    }
    //用元组接收
    var (name1,action,target) = testFunction123()
    print("\(name1) \(action) \(target)");//RunIntoLove Study Swift

    函数嵌套函数-一般人不建议用

    //函数嵌套函数
    func testFunctionInFounction() -> Int//返回值类型为Int
    {
        var y134:Int = 100
        
        //方法可以嵌套方法
        func add()
        {
            y134 += 5  //可以用外部的变量
            y134++  //变量与++之间不能有空格,不然编译器会报错
        }
        //执行方法
        add()
        return y134
    }
    
    var number12 = testFunctionInFounction()
    print("number12 = \(number12)")//number12 = 106


    闭包_Closure-objc的Block

    如果之前了解了objc的Block代码块就很好理解了,就是说在参数的位置放置一个函数,将方法的函数当做一个参数来用
    通过一个简单的例子来看,写一个数组,如果里面有大于100的就返回true,否则返回false: Swift的Bool类型只有True或者False
    首先定义一个数组
    var arrInt = [80,12,45,789,85,63,110] //定义一个数组

    接着写一个用闭包完成的方法,用来完成该项功能
    func hasClosureMatch(arr:[Int],value:Int,function:(num:Int, value:Int)-> Bool) ->Bool//参数的方法参数有两个,一个数字,一个参考数字,返回值为bool, 外部大的方法的参数为 一个Int型的数组,参考值,以及一个闭包
    {
        //开始遍历数组
        for item in arr
        {
            //使用参数中的函数
            if(function(num:item, value:value))
            {
                return true
            }
        }
        
        return false
    }

    调用该方法
    //定义个方法,查找arr里面是否有比100大的数
    var v1 = hasClosureMatch(arrInt,value:100,function:
    {
        (num:Int,value:Int) -> Bool in
        return num >= value //当该数字num大于参考值value的时候返回sure,否则返回false
    })//打印结果为ture,因为110大于100


    闭包相对于比较难理解点,不过结合Block会简单很多。

    Swift 因为基础类型都有Array,Dictionary,String,且功能都比较强大,楼主有疑惑,什么时候用NSArray等对象,什么时候用array类型,如果有明白的人,麻烦请告诉一下楼主,十分感谢.
    展开全文
  • 4.对象和类(Objects and Classes) 1.同java一致,使用class和类名来创建一个类。 2.使用init创建一个构造方法,使用deinit创建一个析构方法,通过构造方法来初始化类实例。创建类实例同java一致,在类名后面加上()...

    4.对象和类(Objects and Classes)

    1.同java一致,使用class和类名来创建一个类。

    2.使用init创建一个构造方法,使用deinit创建一个析构方法,通过构造方法来初始化类实例。创建类实例同java一致,在类名后面加上()(实际是调用无参数的构造方法init(),构造方法也可以带参数)。使用.来访问实例的属性和方法。

    class NamedShape {
        var numberOfSides: Int = 0//每个属性都需要初始化一个值——无论是通过声明(就像numberOfSides)还是通过构造器(就像name)。
        var name: String
        init(name: String) {
            self.name = name//self同java中的self,隐示参数,表示类实例
        }
        func simpleDescription() -> String {
            return "A shape with \(numberOfSides) \(name) sides."
        }
    }
    var namedShape = NamedShape(name: "popkidorc")
    namedShape.simpleDescription()//A shape with 0 popkidorc sides.

    3.子类的定义方法是在它们的类名后面加上父类的名字,用:分割。创建类的时候可以忽略父类。子类如果要重写父类的方法的话,需要用override标记(与java不同,若没有添加override就重写父类方法的话编译器会报错,编译器同样会检测override标记的方法是否确实在父类中)。

    class Square: NamedShape {
        var sideLength: Double
        init(sideLength: Double, name: String) {
            self.sideLength = sideLength
            super.init(name: name)
            numberOfSides = 4
        }
        func area() ->  Double {
            return sideLength * sideLength
        }
        override func simpleDescription() -> String {
            return "A square with sides of length \(sideLength)."
        }
    }
    let test = Square(sideLength: 5.2, name: "my test square")
    test.area()//27.04
    test.simpleDescription()//A square with sides of length 5.2.

    4.类的属性可以有gettersetter,如果不需要计算属性,但要在设置一个新值之前或之后运行一些代码,使用willSetdidSet

    class EquilateralTriangle: NamedShape {
        var sideLength: Double = 0.0
        init(sideLength: Double, name: String) {
            self.sideLength = sideLength//设置子类声明的属性值
            self.area = sideLength*1.732/2
            super.init(name: name)//调用父类的构造器
            numberOfSides = 3//改变父类定义的属性值。
            //其他的工作比如调用方法、getters和setters也可以在这里执行。
        }
        var perimeter: Double {
            get {
                return 3.0 * sideLength
            }
            set {
                sideLength = newValue / 3.0//新值的名字是newValue
            }
        }
        var area: Double {
            willSet{
                println("an new value \(newValue)")
            }
        }
        override func simpleDescription() -> String {
            return "An equilateral triagle with sides of length \(sideLength)."
        }
    }
    var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
    triangle.perimeter//9.3
    triangle.perimeter = 9.9
    triangle.sideLength//3.3
    triangle.perimeter//9.9
    triangle.area//2.6846

    
    

    5.方法的参数名除了第一个外,都需要在调用的时候显式说明。方法的参数名默认和它在方法内部的名字一样,也可以定义另一个名字,在方法内部使用。

    class Counter {
        var count: Int = 0
        func incrementBy(amount: Int, numberOfTimes times: Int) {
            count += amount * times
        }
    }
    var counter = Counter()
    counter.incrementBy(2, numberOfTimes: 7)//14

    6.操作可选值变量时,可以再在操作(比如方法、属性和子脚本)之前加?如果?之前的值是nil?后面的东西都会被忽略,并且整个表达式返回nil。否则,?之后的东西都会被运行。在这两种情况下,整个表达式的值也是一个可选值。

    let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
    let sideLength = optionalSquare?.sideLength//操作前加?

    5.枚举和结构(Enumerations and Structures)

    1.使用enum来创建一个枚举。和类一样,枚举可以包含方法。使用case声明枚举成员。

    2.枚举的成员还可以设置默认值(当然可以不用设置,默认从0开始的整数,0、1、2),我们叫原始值,这些值的类型是相同的,并且设置了为第一个成员的原始值后,剩下成员的原始值会按照顺序赋值。通过toRaw方法获取成员的原始值,fromRaw方法尝试通过原始找到枚举成员(若找不到则为nil)。

    enum Rank: Int {
        case Ace = 1
        case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
        case Jack, Queen, King
        func simpleDescription() -> String {
            switch self {
            case .Ace://枚举成员使用缩写.Ace来引用,因为已经知道self的值是一个Rank。已知变量类型的情况下可以使用缩写。
                return "ace"
            case .Jack:
                return "jack"
            case .Queen:
                return "queen"
            case .King:
                return "king"
            default:
                return String(self.toRaw())
            }
        }
    }
    let ace = Rank.Ace//枚举成员Rank.Ace需要用全名来引用,因为常量ace没有显式指定类型。
    let aceRawValue = ace.toRaw()//1
    if let convertedRank = Rank.fromRaw(1) {
        let threeDescription = convertedRank.simpleDescription()//ace
    }

    3.使用struct来创建一个结构。结构和类有很多相同的地方,比如方法和构造器。它们之间最大的区别就是结构是传值,类是传引用。

    struct Card {
        var rank: Rank
        func simpleDescription() -> String {
            return "The \(rank.simpleDescription())"
        }
    }
    let threeOfSpades = Card(rank: .Three)
    let threeOfSpadesDescription = threeOfSpades.simpleDescription()//The 3

    4.一个枚举的成员可以有实例值(也可以叫关联值)。相同枚举成员的实例值可能不同,创建枚举实例的时候传入。而在定义枚举时候设置的原始值对于所有实例都是相同的。

    enum ServerResponse {
        case Result(String, String)
        case Error(String)
    }
    
    let success = ServerResponse.Result("6:00 am", "8:09 pm")//实例值
    let failure = ServerResponse.Error("Out of cheese.")
    
    switch success {
    case let .Result(sunrise, sunset):
        let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."//Sunrise is at 6:00 am and sunset is at 8:09 pm.
    case let .Error(error):
        let serverResponse = "Failure...  \(error)"
    }

    6.协议和扩展(Protocols and Extensions)

    1.使用protocol来声明一个协议,类似于java中的接口,为了和interface做为区别我们叫做协议。类、枚举和结构都可以实现协议(发现枚举实现协议协议中好像不能带有属性,希望大神指教)。

    protocol ExampleProtocol {
        var simpleDescription: String { get }//在属性声明后写上{ get set }表示属性为可读写的。{ get }表示属性为可读的。即使为可读的属性实现了setter方法,它也不会出错。
        mutating func adjust()//mutating关键字用来标记一个会修改结构体的方法
    }
    class SimpleClass: ExampleProtocol {
        var simpleDescription: String = "A very simple class."
        var anotherProperty: Int = 69105
        func adjust() {//不用mutating标记,因为class中的方法经常会修改类
            simpleDescription += "  Now 100% adjusted."
        }
    }
    var a = SimpleClass()
    a.adjust()
    let aDescription = a.simpleDescription//A very simple class.  Now 100% adjusted.
    
    struct SimpleStructure: ExampleProtocol {
        var simpleDescription: String = "A simple structure"
        mutating func adjust() {
            simpleDescription += " (adjusted)"
        }
    }
    var b = SimpleStructure()
    b.adjust()
    let bDescription = b.simpleDescription//A simple structure (adjusted)

    2.使用extension来为现有的类型添加功能(称作扩展),比如添加一个计算属性的方法。可以使用扩展来给任意类型添加协议,甚至是你从外部库或者框架中导入的类型。

    extension Int: ExampleProtocol {
        var simpleDescription: String {
            return "The number \(self)"
        }
        mutating func adjust() {
            self += 42
        }
    }
    var i = 7;
    i.adjust()//直接写7.adjust()会有异常,这是因为7是常量,而adjust是mutating改变类方法
    i.simpleDescription//The number 49
    i//49

    3.可以像使用其他命名类型一样使用协议名,可以创建一个有不同类型,但是都实现一个协议的对象集合。当处理类型是协议的值时,协议外定义的方法不可用。

    let protocolValue: ExampleProtocol = a
    protocolValue.simpleDescription
    // protocolValue.anotherProperty  // Uncomment to see the error

    7.泛型(Generics)

    1.<>里写一个名字来创建一个泛型方法或者类型。 也可以创建泛型类、枚举和结构体。

    func repeat<T>(item: T, times: Int) -> [T] {
        var result = [T]()
        for i in 0..<times {
            result.append(item)
        }
        return result
    }
    repeat("knock", 4)//["knock", "knock", "knock", "knock"]

    2.在类型名后面使用where来指定一个需求列表,例如要限定实现一个协议的类型,需要限定两个类型要相同,或者限定一个类必须有一个特定的父类。简单起见,可以忽略where,只在冒号后面写接口或者类名。<T: Equatable><T where T: Equatable>是等价的。

    func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> Bool {//限定SequenceType类型,并且Element实现Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。
        for lhsItem in lhs {
            for rhsItem in rhs {
                if lhsItem == rhsItem {
                    return true
                }
            }
        }
        return false
    }
    anyCommonElements([1, 2, 3], [3,4])//true
    
    func anyCommonElementsNew <T, U, R where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element, R == T.Generator.Element> (lhs: T, rhs: U) -> [R] {//限定序列SequenceType类型,并且Element实现Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。
        var results = [R]()
        for lhsItem in lhs {
            for rhsItem in rhs {
                if lhsItem == rhsItem {
                    results.append(lhsItem)
                }
            }
        }
        return results
    }
    anyCommonElementsNew(["1", "2", "3", "4"], ["3","4","6"])//["3", "4"]

    点击进入ooppookid的博客

    展开全文
  • Swift入门(一)

    2015-04-12 23:36:57
    Swift入门系列,语言基础,包括基本数据类型,条件、循环语句语法等
  • Swift Swift是苹果公司在WWDC2014上发布的全新开发语言,用于搭建基于苹果平台的应用程序。其语法内容混合了OC、JS、Python,语法简单,使用方便,并可与OC混合使用。 ... 代码仓库地址 2020年06月01日 ...
  • Swift入门笔记(一)

    2018-09-25 13:00:18
    Swift 简介 苹果公司2014年WWDC 推出 开源 语言 适用于iOS7+ 及 OS X Mavericks+的应用开发 Swift 语言与之前的Objectiv-C可共存(可以调用OC写的代码库,嵌入OC代码之中) Swift 语言不向下兼容,3.0以上逐渐...
  • 下载链接:Swift基础教程 带完整书签:
  • ios-Swift基础框架.zip

    2020-03-29 23:33:43
    分享一套Swift基础框架
  • Swift基础框架的封装

    2017-04-28 16:17:04
    最近闲来无事,就自学了swift编程语言,并且根据之前OC的经验,封装了Swift版本的基础框架,一些常用的的方法,常用的类库和第三方,都封装到了一起,方便以后新项目的使用,在这里,分享给大家,欢迎大家下载使用,...
  • Swift基础之PickerView选择器Demo
  • Swift基础(六)解包

    2016-07-11 15:36:49
    // 解包(if let语句和 guard语句)  // 1. if let 可选类型在每次访问的时候都会提取并检测他的值是否存在,但有时候根据程序结构可以推断可选量在首次赋值后必然存在值,这时就不需要每次验证值是否存在了。...
  • Swift 基础语法二

    2014-06-11 10:38:19
    // Playground - noun: a place ...//Swift的条件语句包括if和switch,循环语句包含for-in、for、while和do-while,循环/判断条件不需要括号,但循环/判断体(body)必需括号: let individualScores = [75, 43, 103, 8
  • IOS开发——Swift基础篇1  早期的iOS开发都是使用Objective-C语言来进行的,而Swift语言,是2014年的WWDC大会上,苹果公司推出的一门全新的开发语言,是专门为了Cocoa(Mac)和Cocoa Touch(iOS)开发而创造的全新编程...
  • 第一章 SWIFT 基础知识.PDF第一章 SWIFT 基础知识.PDF第一章 SWIFT 基础知识.PDF第一章 SWIFT 基础知识.PDF
  • swift基础学习(03)

    2016-05-08 09:44:46
    swift基础学习
  • Swift基础之仿资讯类实现频道的长按拖拽
  • 高德地图开发需要自己到官网http://lbs.amap.com/console/ 注册一个ak,新建一个swift工程,然后在Info.plist...高德地图的库以及依赖库加入到项目里面需要的库如下截图:添加头文件具体的方式见Swift基础--调用第三
  • 三、Swift基础介绍 本章将对Swift做一个简单说明,内容取自《The Swift Programming Language》及http://www.chinaz.com/swift/的中文翻译,并加之自己的理解。 首先swift全局作用域中的代码会被自动当做程序的...
  • IOS开发——Swift基础篇2 Playground的创建和使用 常量、变量和字符串 简单类型和类型推断 流程控制 1. Playground的创建和使用在上一篇中我们已经大致讲解过了Playground的作用了,现在我们就开始利用这个工具来...
1 2 3 4 5 ... 20
收藏数 29,809
精华内容 11,923
关键字:

swift基础