Swift学习笔记

//swift中Playground所见即所得

var str = "Hello, playground"

var value1 = 20//定义并且初始化一个整型变量

value1 += 35

println("value1 = \(value1)")//输出

let value2 = 50//定义并且初始化一个整形常量

println(value1 +value2)

var array1 = ["abc","bcd","cde"]//定义并且初始化一个数组变量

for element in array1{

println(element + " ")

}

//定义函数返回值类型是String

func getPerson(name:String,age:Int)->String

{

 return "name:" + name +"  " +"age:\(age)"

}

println()

//调用函数getPerson

let person = getPerson("Lilei",25)

println("person is \(person)")

//定义可以返回多个值的函数

func getProduct(p_id:Int)->(name:String,age:Int,sex:String){

return("Iphone",26,"男")

}

println(getProduct(26))//输出

println("product name:\(getProduct(26).name)")//输出函数返回的name

//定义Country类

class Country{

var name = "China"

    let area:Float =960

    //定义一个成员方法

    func getDescription()->String{

    return"Country:\(name)  Area:\(area)"

    }

}

let country = Country()//创建一个Country的常量

//调用类方法

println(country.getDescription())

//定义一个类扩展，相当于将一个类的某一部分拿出来单独定义

extension Country{

    func getAddress()->(plant:String,location:String){

    return("Eath","北京")

    }

}

//调用拓展方法输出返回值中得plant

println("plant:\(country.getAddress().plant)")

//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------分割线

数据类型总结

//swift数据类型是静态定义动态推导

//如果不指定变量数据类型，变量必须进行初始化

//var id非法

var id:Int//合法

var id1:Int = 10

//对于常量，不管是否指定数据类型都要进行初始化

//let const1//非法

//let const2:Int非法

//不管是变量还是常量一旦确定了数据类型，是不能进行后期改变的。

//var value:String = 123错误用法，必须进行初始化字符串

var num1 = 100

print("num is " +toString(num1))//全局函数转换字符串

print("num is\(num1)")//嵌入变量或者常量的形式

let minIntValur = Int32.min//Int32的最小值.max为获取最大值

let binaryInt = 0b1100//二进制12

let bajinzhi = 0o55//八进制45

let shiliu = 0x144//十六进制324

let intNum1 = 1_000_000//利用下划线分割数字

var float1 = 1.38

var int1 = Int(float1)//强行转换

typealias NewTpye = String//类型别名

var str1:NewTpye = "123"

var isFile:Bool = true//布尔和判断

if isFile

{

  print("is file")

}

var charValue1:Character ="1"//字符，因为和字符串用的都是上引号所以要指定类型，默认为字符串，数量为0或者是1

//初始化一个空的字符串

var strEmpty = ""

var strEmpty1:String

var strEmpty2 = String()

//枚举获取字符串字符

var hello = "这是一个单个输出字符的字符串"

for c in hello

{

  print("-" + c + "-")

    

}

//获取unicode编码

for c inhello.unicodeScalars

{

   println("\(c.value)")

}

var str11 = "i am "

var str12 = "lilei"

var str121 = str11 +str12//字符串与字符串，字符串和字符都可以相加连接

let wantStr = "\" 今天不想上班 \""//输出特殊字符

println(wantStr)

var strVA = "abc"

var strVB = "bcd"

//字符串比较

if strVA  <strVB

{

    println("abc比 bcd小")

}

//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

var small = "abc"

var big = small.uppercaseString//小写转换大写

var smallT = big.lowercaseString//大写转换小写

//元组tuples，就是可以包含多个值的数据类型

let newtuples1 = ("new",6888)

println(newtuples1)

var (name,price )=newtuples1//元组的两个值赋值给变量

println(name);println("name:\(name),price:\(price)")//取值输出

var tuples2 = ("newiphone",12888)

println(tuples2)

var (_,price1) =tuples2//如果只是取其中的一部分值可以用下划线占位

println(price1)

price1 = 6888//重新赋值

println(price1)

var tuples3 = (tupname1:"123",tupname2:"456")//为元素命名

println(tuples3.tupname1)//类似于属性的取值

//可选类型

//主要是为了解决对象变量或者常量为空的情况，之前的变量或者常量必须不能为空。Swift中的可选类型则允许变量（常量）中没有值（设为nil）。和OC中的nil不同，前者标示没有值，后者标示变量的值为空。

var numStr:String ="123"

var numValue:Int? =numStr.toInt()

println(numValue)

//var numV:Int = numStr.toInt()必须定义为可选的Int类型，否则无法编译成功

//println(numValue!)//如果变量为空的时候程序会中断，

//var numValue1:Int! = "123"//如果为空会抛出异常

//区间操作符

for i in 0...10//0到10

{

    println("\(i)")

}

for i in 0..<10//0到9

{

    println("\(i)")

}

//------------------------------------------------------------数组和字典

let firstArray = ["a","b"]//数组本身和元素都不可修改

println(firstArray)

var typeArray1:[String]//简写的空数组定义,没有初始化

//println(typeArray1)//只有声明没有初始化的数组不能被引用

var typeArray2:Array<Int> = [1,2,3,4]//定义了Int类型的数组

//与OC不同数组的元素职能是同样的数据类型

var typeArray = [1,2,3,"a"]//,实际上已经不是Swift的数组，编译器自动转换为NSArray而不是Array

var myMutableArray:NSMutableArray = [1,1,2,"a"]//自定义可变的OC数组

//创建空数组

var nullArray = []

var nullArray1 = [Int]()

var nullArray2:[String] = []

var nullArray3:Array<Float> = []

var nullArray4:[String] = []

var fourInts = [Int](count:4, repeatedValue:9)//初始化一个数量为4每个元素的值为9

var addArr1 = [1,2]

var addArr2 = [3,4]

var addArr = addArr1 +addArr2//加法合并数组

println(addArr)

println("\(addArr.count)")//获取元素个数

println("\(addArr[0])")//获取元素

 addArr.insert(9, atIndex:2)//插入

 println(addArr)

 addArr.removeAtIndex(0)//删除

addArr.removeLast()//删除最后面的

addArr.append(9)//添加

println(addArr)

//数组区间赋值

var products = [1,2,3,4,5,6,7,8,9]

products[0...1] = [8]

println(products)

//数组区间赋值就是将前面索引的数据全部删除，然后在删除的位置上添加入等号后面的数组，以等号后面的数组数量为准

//获取数组所有元素

for i in 0..<products.count

{

 println("\(products[i])")

}

for value in products

{

println("\(value)")

}

//在Swift中字典使用Dictionary结构体标示

var dic1:Dictionary<String,String> = ["a":"b","c":"d"]//标准

var dic2:[String:String] = ["name":"lilei"]//省略

var dic3 = ["age":"six"]//直接进行初始化

var dicns = ["ag":"six","age":23]//编译器自动转换为NSDictionary

var dicMutable:NSMutableDictionary = ["name":"lilei","age":25]//

var dicnull = Dictionary<Int,String>()//空

var dicnull2 = [Int:String]()

dic3 = [:]//清空字典，不能用于初始化

var dd = ["name1":"lilei1","name2":"lilei2"]

//-----------------------------------------------------------函数

//函数和方法的区别就是方法的作用域仅仅在于方法内，而函数是全局的

func makeCount(str1:String,str2:String)->(count1:Int,count2:Int)

{

 return(1,2)

}

let cou = makeCount("123","456")

println(cou)

//扩展参数

func getAll1(str1:String,str2:String)->String

{

    return "name is" + str1 +"and" + str2

}

var all = getAll1("lilei","hanmeimei")

func getAll2(name str1:String,str2:String)->String

{

    return "name is" + str1 +"  and " +str12

}

all = getAll2(name:"lilei","hanmeimei")//有扩展参数的函数调用方法不同

func getAll3(#name:String,#age:Int)->String

{

     return "name is " + name +" age is " +String(age)

}

all = getAll3(name:"lilei", age:20)//扩展参数和内部参数合二为一

//函数设置默认参数

func getAll4(#name:String ="Mike")->String

{

    return "name is " + name

}

all = getAll4()

//可变参数(数量可变，要放置在最后面)

func getAll5(#name:String,strArr:String...)->String

{

    var total = " ";

    for a in strArr{

     total += " and " + a

    }

 return "name is " + name + total

}

all = getAll5(name:"Make","a","b","c")

println(all)

//函数默认的参数都是常量如果要在函数内部修改参数需要设置参数为变量

func find1(var changeStr:String)->String

{

   changeStr = "bcd"

    return changeStr

}

var change1 = "abc"

println(find1(change1))

println(change1)//注意此处还是abc，修改是函数内部

//输入输出参数，可以在函数内部进行值的改变

func outPutFunc(inout name:String,age:Int)->String{

    name = "Mike"

    return "Name:" + name +" age:" +toString(age)

}

var nameaa = "lilei"

println(outPutFunc(&nameaa,18))

println(nameaa)

//------------------------------------------------闭包，利用编译器的强大的推到功能简化表达式

var nums = [7,4,9,6,3,5,2]

func sortedFun(s1:Int,s2:Int)->Bool{

 return s1 < s2

}

var sortedNums = sorted(nums,sortedFun )//升序排列

println(sortedNums)

//{ (parameters)->returnType in statements}闭包表达式格式

//{(s3:Int,s4:Int)->Bool in return s3 < s4}//sortendNums函数转换为闭包后

var sortedNum1s = sorted(nums, {(s1:Int,s2:Int)->Boolinreturn s1 < s2})//闭包属于表达式的一种可以作为参数传入

println(sortedNum1s)

var sortedNum2s = sorted(nums, {(s1,s2)->Boolinreturn s1 < s2})//省略参数值

println(sortedNum2s)

var sortedNum3s = sorted(nums, {(s1,s2)inreturn s1 < s2})//省略返回值类型

println(sortedNum3s)

var sortedNum4s = sorted(nums, {(s1,s2)in s1 < s2})//省略reutrn

println(sortedNum4s)

var sortedNum5s = sorted(nums, {$0 < $1})//省略参数名称用$0,$1,$2代替第一个参数，第二个参数，第三个参数

println(sortedNum5s)

var sortedNum6s = sorted(nums, <)//直接用运算符表达式

println(sortedNum6s)

//尾随闭包，尾随在函数定义部分的后面，尾随闭包的作用是如果函数最后一个返回值是闭包，在调用该函数时，可以将比报写在函数外面，如果函数只有一个参数，那么函数最后面的一对圆括号都可以省略

var sortedNum7s = sorted(nums){$0 < $1}//尾随闭包同上面的sorted(nums, {$0 < $1})

//----------------------------------------------------------

//枚举

enum CompassPoint

{

  case North

    case East

    case South

    case West

}

enum CompassPoint1

{

    case North, South, East, West

}

//上面的内容不同于OC，不会隐式等于0，1，2，3，不同的枚举成员拥有各自不同的值

var direction = CompassPoint.East

println(direction)//不会输出1，而是输出Enum Value

direction = .North//再次调用的时候直接指定枚举成员即可

//组合枚举成员

enum Machinist

{

    case Car(String,Int)

    case Mobile(String,String)

}

let product1 = Machinist.Car("奔驰",3000000)

switch product1

{

case .Car(let namee,let pricee):

        println("name:\(namee),price:\(pricee)")

case .Mobile(let namee,let pricee):

    println("name:\(namee),price:\(pricee)")

}

//name:奔驰,price:3000000"

//设置枚举成员的原始值

enum Planet: Int

{

    case M = 1 ,K,L//后面的自动推导2，3

}

println(Planet.M.toRaw())//不能直接调用

//--------------------------------------------------------

//枚举也可以含有方法

//--------------------------------------------------------类和结构体

/*共同点：

1.支持定义属性，方法，附属脚本，定义构造器，可用扩展和协议，

不同点：

类的功能是包含结构体的功能，类还增加了一些功能，支持继承，类型转换允许在运行时检查和解释一个类实例的类型，支持析构方法，支持通过引用计数的方式让一个类对象实例被引用多次

结构体是传值，类是传的引用

*/

struct Resolution {

    var width = 100

    var height = 100

}

class Video {

    var respitop = Resolution()

    var frameRate = 0

    var name:String?

    var sco = "abc"

    

}

//创建

let someResolution = Resolution()

let someVideo = Video()

//访问成员

println(someResolution.height)

println(someVideo.frameRate)

println(someVideo.respitop.height)

someVideo.frameRate = 200

println("\(someVideo.frameRate)")

//分为值类型和引用类型，Int,Float,String等都是值类型，值类型在赋值的时候是一个拷贝的过程，新的值和原来的值没有任何关系，修改后也不会影响原来的值。而对于一些复杂的类型，比如类，就是引用类型，如果对象之间发生赋值操作，就相当于该类被多次引用。结构体定义为值类型。结构体也是值类型。

/*

判断两个变量或者常量引用了同一个类对象

*/

let v1 = Video()

let v2 = Video()

var v3 = v1

if v1 === v3

{

    println("引用了同一个对象")

}else{

   println("引用了不同对象")

}

if v1 !== v2

{

    println("引用了不同对象")

}else{

   println("引用了相同对象")

}

//有点特殊，结构体和类中所有能访问的成员除了方法都叫做属性

struct Fixed

{

    var firstValue:Int

    let length:Int

}

var rang = Fixed(firstValue: 100, length: 80)//初始化并且赋值

rang.firstValue = 18000

class Book {

    var name:String = ""

    var price:Float = 900

}

var newBook = Book()

class Shappe {

    var number = 0

    var name:String

    init(name:String){//构造函数用于初始化实例

    

        self.name = name

    }

    func simple()->String{

    

        return "A shape with \(number) sides."

    }

}

var sha = Shappe(name: "li lei")

sha.number = 9

class Square:Shappe {

    var side:Double = 0.0

    init(side:Double,name:String){

    self.side = side

        super.init(name: name)

        number = 8

    }

    func area()->Double{

        return Double(number) * side

    }

    override func   simple() -> String {

        return "A shape with \(number) sides.o"

    }

}

let testt = Square(side: 199.8, name: "my test ")

testt.area()

testt.simple()

class Equ:Shappe {

    var sideL:Double = 0.0

    init(sideL:Double,name:String){

    self.sideL = sideL

        super.init(name: name)

        number = 99

    }

    var per:Double{

        get{

        

            return 8 * sideL

        }

        set {

            sideL = newValue / 3.0

        }

    }

     override func simple() -> String {

        return "an equ with \(sideL)."

    }

}

var tri = Equ(sideL: 999, name: "Equ")

tri.per

tri.per = 9.9

class Counter {

    var count:Int = 0

    func crement(amount:Int,numberOfTimes times:Int){

    count += amount * times

    }

}

var counter = Counter()

counter.crement(100, numberOfTimes: 80)

let optionalEqu = Equ(sideL: 999, name: "hello")//可选值

let sidel = optionalEqu.sideL

//惰性存储属性,只有在第一次访问时才进行初始化

class DataImportance{

  var fileName = "Data.text"

    func process()->String{

        println("刚刚执行")

     return "data.text"

    }

}

class DataManager {

    lazy var importan = DataImportance().process()

    var data = ""

    

}

let manager = DataManager()

manager.data += "Some Data"

manager.data += "123"

println(manager.data)

println(DataManager().importan)

//属性观察器，不能同时与set get方法同时使用

class StepCounter{

    var total:Int = 9

        {

        willSet(newTotal){

         println("willSet total = \(newTotal)")

        }

        didSet(oldTotal){

         println("didSet old total = \(oldTotal)")

        }

         

    }

    var num:Int = 0{

        willSet{

        println("willSet num = \(newValue)")//默认值

        }

        didSet{

        println("oldSet num = \(oldValue)")

        }

    }

}

let step = StepCounter()

step.total = 100

step.total = 200

//静态属性，结构体和枚举用static,类class，类不支持静态存储属性

struct MyStruct{

     //静态存储属性

    static let com = "abc"

       //静态计算属性

    static var computeredTypeProperty:String{

       return "Hello world"

    }

}

//静态属性不能访问非静态属性，但是非静态属性中却可以访问静态属性

//全局函数默认为所有的参数都是局部参数名也可以称为内部参数名，但是方法会在默认情况下将第一个参数作为局部参数名，而将后面的作为局部参数名和外部参数名，

//方法的变异mutating，结构体和枚举类别中的参数值默认是不可修改的，如果要修改就要加上mutating,类中添加var

struct St{

var x = 0.0,y = 0.0

    mutating func move(dex:Double,dey:Double){

       

     x = 9.8 + dex

     y = 9.8 + dey

        

    }

    mutating func changeSelf(){

    self = St()//修改自己

        

    }

}

//类型方法,self指类型本身而不是类型的实例

struct MySt{

    static var x:Int = 100

    static func method(x:Int)

    {

      println("self.x = \(self.x)")

        println("x=\(x)")

    }

}

//下标，

class MySubscript

{

    subscript (key1:String,key2:Int)->String{

      

        if key2 == 1

        {

            return "China"

            }

            else if key2 == 2

        {

            return "American"

            }

        else{

            return "Canada"

            }

    }

}

println("qwe")

var pp = MySubscript()

println(pp["c",1])

//扩展,和OC中的categories类似，但是没有名字，，应用于已有的类，结构体，枚举中，

/*添加计算型属性和计算静态属性，定义实例方法和类型方法，提供新的构造器，定义下表，定义和使用新的嵌套类型，使一个已有类型符合某个协议*/