Swift基础1

作者: SJPOP | 来源:发表于2016-02-29 16:41 被阅读92次

    Swift是苹果公司于2014年WWDC苹果开发者大会发布的开发语言,也是第一套具有与脚本语言同样的表现力和趣味性的系统编程语言,可与Objective-C共同运行于Mac OS和iOS平台,用于搭建基于苹果平台的应用程序。

    2015年开发者大会上,苹果公司推出了Swift2.0版本,完全开源。

    创建一个Swift新工程方法如下: Xcode->Create a new Xcode project -> 选择OS X -> Application -> Command Line Tool

    开头不需要引入头文件但需要引入Foundation, 不过有时需要引入一些框架。

    import Foundation
    

    每一句结束时不用加分号。

    输出语句:(向经典致敬)

    print("Hello, World!")
    

    一、声明常量和变量

    在Swift中使用"let"修饰一个常量, 使用"var"修饰一个变量。
    使用let定义一个常量, 不能重新赋值。
    Swift支持隐式类型推断,可以根据初值,自动地推断Swift的数据类型。

    let a = 10   //会自动推断a为Int类型
    //结尾不需要加";"    Swift用空格表示结束
    
    let b = "Bonjour"  //会自动推断b为String类型
    let z : String = "Bonjour"
    
    let c = 12.7  //会自动推断c为Double类型
    

    Swift 值能进行显示类型转换支持隐式类型转换,不能让两个不一样的数据类型做四则运算。
    Swift强转的格式:数据类型(需要强转的数据)

    let d = Double(a) + c
    
    

    可以直接使用中文或表情符号为常量和变量命名 (OC也可以,但不能调用)

    let 大牛 = "多炮塔神教"
    
    let 😊 = "笑"
    

    注:Swift的命名可能会困扰你

    定义两个字符串类型的常量

    let e = "呵呵"
    let f = "哒"
    

    Swift里面支持运算符的重载,会根据语境自动判断运算符的含义

    let str = e + f
    
    print(str)  //打印结果为  呵呵哒
    
    
    

    Swift里使用var定义一个变量:

    var a = 10
    
    a = 100
    

    如果需要定义一个初值为nil的变量, 必须指定变量数据类型然后加问号
    格式为:var + 变量名 + ":" + 变量类型? = nil

    //拆包
    var b : String? = nil      //注意:nil和""不同
    //let使用这样的语法没有意义
    

    注意:let定义的常量地址不可改。

    二、数组

    1. 声明数组

    Swift中声明一个数组也要使用"let"或者"var"。

    数组初始化的第一种方式:数组如果没有指定数据类型,会根据数组的初值推断数据类型
    注意:Swift的数组里面的数据类型必须是相同的

    let array = [1, 2, 4]//该数组中元素的数据类型为Int
    
    let array1 = [1, 2, 3, "a"]//该数组中元素的数据类型在Swift1.0版本是AnyObject,在Swift2.0版本是NSObject
    

    数组初始化的第二种方式:先指定数据类型

    let array2 : [Int] = [1, 2, 4]
    
    //一个错误的例子:
    //let array2 : [Int] = [1, 2, 4, "a"]
    

    定义一个空的数组

    let array3 : [Int] = []
    
    2. 数组的增删改查

    首先定义如下数组

    var array = [1, 2, 3, 4]
    

    数组的查:

    print(array[1])   //打印第二个元素
    

    数组的增:

    //在某个位置插入一个元素
    array.insert(8, atIndex: 2)
    
    //在某个位置插入一个新数组
    var array1 = [9, 10, 11, 12]
    array.insertContentsOf(array1, at: 2) 
    
    print(array)  //可以打印查看结果
    

    数组的删:

    //移除数组中所有元素
    array.removeAll()
    
    //删除数据的同时, 保存内存空间
    array.removeAll(keepCapacity: true)
    //注:Swift里面的Bool是一个枚举值, 只有true和false两种参数,默认是false
    
    //移除一个范围内的元素
    let range : Range = Range(start: 1, end: 2) //Range后面的括号相当于alloc init 的意思
    array.removeRange(range)
    
    //移除第一个元素
    array.removeFirst()
    
    //移除前两个元素
    array.removeFirst(2)
    
    //移除最后一个元素
    array.removeLast()
    

    数组的改:

    
    array[1] = 66  //修改第二个元素
    
    var array2 = [5, 6, 7, 8]
    var array3 = array + array2
    
    

    三、字典

    Swift的字典与OC类似,也是无序的,也是key对应value。

    但是Swift的字典里面所有的key必须是同一数据类型的,所有的value必须是同一数据类型的,这点与OC不同,需要注意。

    创建字典的两种方式:

    //第一种方式:Swift1.0这种方法不存在  (所以Swift1.0里字典很不好用)
    var dictionary = [1 : 2, 3 : 4, "a" : "b"]
    let dictionary1 = [1 : 2, 3 : 4, 5 : 6]
    
    //第二种方式:
    var dictionary2 : [Int : String] = [1 : "a", 2 : "b"]
    

    字典的增

    dictionary[9] = 10
    

    字典的改

    dictionary[1] = 50
    

    字典的删

    dictionary.removeValueForKey(1)
    
    dictionary.removeAll()
    
    dictionary.removeAll(keepCapacity: true)
    
    //key对应的value为nil也是删除
    dictionary[1] = nil
    

    字典的查

    print(dictionary)
    print(dictionary[1])
    print(dictionary[2])
    
    

    四、元组

    元组是不同与OC的一个容器。
    使用()表示定义一个元组,元组里面没有数据类型的概念

    //创建元组的第一种方式:
    let type = ("德累斯顿", "Dresden")
    //访问元组的第一种方式:
    print(type.0)
    
    //创建元组的第二种方式:
    let type2 : (name : String, nickName: String) = type
    //访问元组的第二种方式:
    print(type2.name)
    

    五、循环结构

    Swift中的循环结构可以分为四种循环:

    1. for循环
    
    let array = [1, 2, 3, 4, 5]
    
    //for循环不用像OC那样加括号了
    for var i = 0; i < array.count; i++ { //i++之间没有空格  i++是一句话
        print("i = \(i)")   //要打印的变量用反斜杠加括号包围起来
    }
    
    
    2. while循环
    var i = 1
    while i < 6 {
        i++
        print(i)
    }
    
    3. repeat while循环(和 do while循环 一样)

    Swift1.0版本的时候叫做do while, Swift2.0版本的时候叫做repeat while

    repeat{
    i++
    print(i)
    }while i < 10
    
    4. for-in 循环
    let array = [1, 2, 3, 4, 5]
    
    for var a in array {
        print(a)
    }
    
    

    六、分支结构

    //var timer : String? = nil
    //
    //if timer != nil{     // (timer != nil)不能换成timer  但是括号可以省略(多个条件要加括号)       因为Swift里表示真假是布尔值 ???
    //print("timer存在")
    //} else {
    //print("timer不存在")
    //}
    
    
    ////switch    Swift里面switch很强大
    ////case里自带break
    ////但default一定要有
    //let value = 13
    //
    //switch value {
    //case 0:
    //    print(value)
    //case 1:
    //    print(value)
    //default:
    //    print("超了")
    //}
    //
    //// 0...10 表示的是 从0开始到10结束并且包含10
    //// 0..<10 表示的是 从0开始到10结束但不包含10
    //// 除了上述两种没有其他的
    //switch value {
    //case 0...10:
    //    print(value)
    //case 11...20:
    //    print(value)
    //default:
    //    print("又超了")
    //}
    
    
    
    
    ////switch可以搭配元组使用
    //let point = (2, 10)
    //
    //switch point {
    //case (10, 10):
    //    print(point)
    //case (_, 10):
    //    print(point.0)
    //case (10, _):
    //    print(point.1)
    //case (_, _):
    //    print(point)
    //}
    //
    //let value = 0
    //let value1 = 100
    //switch value{
    //case 0 where value1 < 10:
    //    print(value)
    //case 0 where value1 > 10:
    //    print("正确")
    //default:
    //    print("错误")
    //}
    
    

    六、函数

    Swift中函数共有8种类型:

    无参无返回值
    无参有单个返回值
    无参有多个返回值
    有参无返回值
    有参有单个返回值
    有参有多个返回值
    inout函数
    嵌套函数

    基本结构:

    func (关键字) test (函数名) "()"(参数列表) -> Void(返回值类型)

    无参无返回值函数
     
    
    func test () -> Void {    //函数名与()之间有没有空格似乎都行
        print("无参无返回值")
    }
    test()
    
    无参有单个返回值
    func test1() -> String {
        return"无参有单个返回值"
    }
    print(test1())
    
    返回一个Int类型的数组
    func test2() -> Array <Int> {
        return [1, 2, 3]
    }
    print(test2())
    
    返回一个OC的数组
    func test2() -> NSArray {
        return [1, 2, "a", "b"]
    }
    print(test3())
    
    有参无返回值的函数

    参数格式参数名 + ":" + 参数类型

    -> Void 可以省略

    func test4(name : String, sex : String) -> Void {
    print("我叫\(name), 我的性别是\(sex)")
    }
    test4("蒙大拿", sex: "未知")
    
    //参数是一个数组格式 : 参数名 + ":" + Array<数据类型>
    func test5(phoneNumber : Array<Int>) {
        
    }
    
    
    有参有返回值
    func test6(a : Dictionary) -> Dictionary {
        return a;
    }
    
    
    无参有多个返回值
    
    func test6() -> (String, String){
        return ("HE", "AP")       
    }
    
    let type = test6()
    
    print(type)
    print(type.1)
    
    
    
    有参有多个返回值
    func test7(name : String, age : Int) -> (String, Int){
        return (name, age)
    }
    
    let type1 = test7("Silvia", age: 18)
    print("我叫\(type1.0), 今年\(type1.1)岁")
    
    
    inout函数
    //Swift函数里面的参数 默认是使用let修饰的, 是不可以更改的
    func test8(inout number : Int){
        number = 100
    }
    
    var a = 5
    test8(&a)
    print(a)
    
    
    
    func test9(inout name : String, inout name2 : String){
        let temp = name
        name = name2
        name2 = temp
    }
    test9(&name, name2: &name1)
    print(name, name1)
    
    函数嵌套
    //第一层
    func test10(){
        //第二层
        func test11(){
            //第三层
            func test12(){
                //第四层
                func test13(){
                    //第五层
                    func test14(){
                        //第六层
                        func test15(){
                            //...可以无限定义下去
                        }
                    }
                }
            }
        }
    }
    
    

    重点回顾:

    1. 隐式类型推断
    2. 隐式类型转换
    3. 运算符的重载 运算符重载
    4. var b : String? = nil

    Swift里很强大的地方有: 1. switch 2. 结构体

    相关文章

      网友评论

        本文标题:Swift基础1

        本文链接:https://www.haomeiwen.com/subject/uaygkttx.html