Swift学习之基本语法

1.数组的创建及操作

//数组
var array=[2,3,4,5]

var array1:Array=[2,3,3,4]

var array2:Array<Int>=[2,2,2,3]

var array3:[Int]=[2,3]

var array4:[Double]=[2.2,3.3]

var array5:[String]=["333"]

var array6:Array<Any>=["2",2]

var array7=["33",3]
//追加元素
array7.append("d")
//插入元素
array7.insert("hhhh", atIndex: 0)
//删除最后一个元素
array7.removeLast()
//删除指定下标的元素
array7.removeAtIndex(0)
//只删除数组中的值，保存数组的容量
array7.removeAll(keepCapacity: true)
print(array7)
print(array7.capacity)
print(array7)
for vale in array7{
    print(vale)
}

var tempArray=[5,4,3,2,1]
//升序排序
tempArray.sortInPlace()
print(tempArray)

//数组的批量操作
var array10=[1,2,3,4,5]
array10[0...2]=[10,101,10,10]
等价于
array10.replaceRange(Range(start: 0, end: 3), with: [9,9,9,9])
array10+=[1,1,1,1]
array10+=array10

print(array10)

//遍历数组
for elm in array10{
   print(elm)
}

for (index,value) in array10.enumerate(){
    print("index:\(index)==\(value)")
}

2.Range的创建

var range:Range<Int>=Range(start: 0, end: 5)
var range1=0...5
var range2=0..<5
print(range)
print(range1)
print(range2)

3.Dictionary的创建及操作

var dict:Dictionary<String,String>=["2":"2"];
var dict2=["2":2,"3":3]
for (key,value) in dict2{
  print("key==\(key),value=\(value)")
}
//遍历字典所有的key
for key in dict2.keys{
   print(key)
}
//遍历字典所有的value
for value in dict2.values{
    print(value)
}


----------


var dict=["app":"苹果","ban":"香蕉"]
dict["app"]="菠萝"
//如果key不存在，此方法会把新key和新值加入dict
if let orig=dict.updateValue("苹果", forKey: "app"){
    //存在当前key，改变后的值
    print(dict["app"])
    //存在当前key，改变前的值
    print(orig)
}
//根据key删除对应的值
dict.removeValueForKey("app")
print(dict)

dict["an"]="一个"
//根据key删除元素，若key不存在，此方法把新key和新值加入dict
if let old=dict.removeValueForKey("and"){

    print(old)
}

4.func

//函数
func showIntArray(array:[Int]){
    for a in array{
      print(a)
    }
}

showIntArray([1,2,3,4,5])


func maxOfValue(num1 a:Int,num2 b:Int)->Int{
    return a>b ? a : b
}

print(maxOfValue(num1: 9, num2: 20))

let p0:(Double,Double)=(0,0)
let p1:(Double,Double)=(6,6)

func getLengthAndWidth(p0:(Double,Double),p1:(Double,Double))->(legnth:Double,width:Double){

    return (abs(p0.1-p1.1),abs(p0.0-p1.0))
}

print(getLengthAndWidth(p0, p1: p1
    ).legnth)


func divisionOperation(dividend dividend:Double,divisor:Double)->Double{
   return dividend/divisor
}

divisionOperation(dividend: 3.3, divisor: 3)

5.闭包

//闭包
let sayhello={
   print("hello")
}

sayhello()


let add:(Int,Int)->Int={
    (a:Int,b:Int)->Int in
    return a+b
}


// 利用闭包实现冒泡排序
1.第1种写法
func show(array:[Int]){
  for x in array
  {
    print("\(x)");
    }
}

func arrSort(inout array:[Int],cmp:(Int ,Int)->Int){

    let  cnt = array.count
    for var i=1; i<cnt ; i++ {

        for var j=0; j<cnt-i; j++ {

            if(cmp(array[j],array[j+1]) == -1){
                let t=array[j];
                array[j]=array[j+1]
                array[j+1]=t
            }
        }
    }
}


var array=[20,2,3,70,8]

show(array)
let intCmp={
    (a:Int,b:Int)->Int in
    if a>b{
       return -1
    }
    else if a<b{
       return 1
    }
    else{
       return 0
    }
}
arrSort(&array,cmp: intCmp)
show(array)

//第2种写法
arrSort(&array,cmp: {

    (a:Int,b:Int)->Int in
    if a>b{
        return -1
    }
    else if a<b{
        return 1
    }
    else{
        return 0
    }
})
// 第3种方法
arrSort(&array,cmp: {
    (a,b) in
    if a>b{
        return -1
    }
    else if a<b{
        return 1
    }
    else{
        return 0
    }
})

// 第4种方法
arrSort(&array,cmp: {
    let a=$0,b=$1
    if a>b{
        return -1
    }
    else if a<b {
        return 1
    }
    else{
        return 0
    }
})
----------
//尾随闭包
var array=[20,2,3,70,8]
array.sortInPlace()//默认升序
//降序
array.sortInPlace({
   return $0 > $1
})
//升序
array.sortInPlace(){
   return $0 > $1
}
show(array)

6.嵌套函数

//函数嵌套
func swap( var intout a : Int ,var intout b : Int){

    let t=a
    a = b
    b = t
}

func arrSort(inout array:[Int]){
    //func swap( var intout a : Int ,var intout b : Int){
    //let t=a
    //a = b
    //  b = t
    //}
    let  cnt = array.count
    for var i=1; i<cnt ; i++ {

        for var j=0; j<cnt-i; j++ {

            if((array[j]>array[j+1])){

                swap(&array[j], &array[j+1])
            }
        }
    }
}

var array=[20,2,3,70,8]

arrSort(&array)

show(array)

7.枚举

//枚举
enum Method:Int{
//   case Add
//   case Sub
//   case Mul
//   case Div

    case Add = 5,Sub = 6,Mul = 7,Div = 8
}
var value0:Method = .Add
var value1 = Method.Sub

func seleMethod(op: Method)->(Double,Double)->Double{

    switch op{
    case .Add:
        func add(a:Double,b:Double)->Double{
          return a + b
        }
        return add
    case .Sub:
        func sub(a:Double,b:Double)->Double{
            return a-b
        }
        return sub
    case .Mul:
        return {return $0 * $1}

    case .Div:
        return {$0 / $1}

    }
}

let mehtod = seleMethod(Method.Add)
print(mehtod(4.0,5.0))

print(seleMethod(.Add)(5.0,7.0))

print(Method.Add.rawValue)

enum MethodStr:String{

    case Add = "ss",Sub = "sss",Mul = "ssss",Div = "sssss"
}

print(MethodStr(rawValue: "Add"))

//关联值
enum LineSegmentDescriptor{
    case StartAndEndPattern(start:Double,end:Double)
    case StartAndLengthPattern(start:Double,length:Double)
}
var  lsd=LineSegmentDescriptor.StartAndEndPattern(start: 10, end: 30)
lsd=LineSegmentDescriptor.StartAndEndPattern(start: 10, end: 30)
switch lsd{
case .StartAndEndPattern(let s,let e):
    print("\(s)->\(e)")
case .StartAndLengthPattern(let s,let len):
    print("\(s)->\(len)")
}

8.结构体

//结构体
//例子1
struct Rect{
    var width:Double=0.0
    var height:Double=0.0
}
//不带参数的构造
var rect:Rect = Rect()

rect.width=100
rect.height=100
print(rect.width)
print(rect.height)

//函数体逐一构造器，1、需要按照顺序，2、所有成员变量都必须构造
var rect1:Rect = Rect(width: 20, height: 30)
print(rect1)

//例子2
struct Rect{
    var width:Double=0.0
    var height:Double=0.0
    //成员方法可以访问使用成员变量
    func getWith()->Double{
        return width
    }

    func show(){
      print("width=\(width),height=\(height)")
    }
}

//例子3
struct myRect{
    var origion:(x:Double,y:Double)=(0,0)
    var size:(w:Double,h:Double)=(0,0)
    //计算属性
    var center:(x:Double,y:Double){
        get{
          return (origion.x + size.w/2,origion.y + size.h/2)
        }
        set(n){
            //计算属性不能被赋值
           origion.x=n.x - size.w/2
           origion.y=n.y - size.h/2
        }

    }
}

var rect = myRect()
rect.origion=(10,10)
rect.size=(20,20)
print("center;=\(rect.center)")


struct myRect1{
    var origion:(x:Double,y:Double)=(0,0)
    var size:(w:Double,h:Double)=(0,0)
    //计算属性
    var center:(x:Double,y:Double){
        get{
            return (origion.x + size.w/2,origion.y + size.h/2)
        }
        set{
            //计算属性不能被赋值,系统默认的setter值
            origion.x=newValue.x - size.w/2
            origion.y=newValue.y - size.h/2
        }

    }
}