Swift基础语法(一)

OC转Swift快速教程(基础篇)

1.常量变量篇

定义一个常量

let a : Int = 10

定义一个变量

var b : Int = 20

b = 30

常量不能被修改，变量可以被修改

常量不可被修改的真实含义是指针不可以再指向其他对象，但是可以通过指针获取这个对象，然后修改其中的属性

比如

let view : UIView = UIView(frame: CGRect(x: 10, y: 10, width: 50, height: 50))

view.backgroundColor = UIColor.red

在真实使用过程中,建议先定义常量,如果需要修改再修改为变量(更加安全)

2.Swift中的数据类型

Int Double Float等等这些类型不用说了，那什么有符号无符号整型什么的都无所谓，玛德，搞这么多麻烦的东西，看着头疼，不适合快速转型

let e : Int = 10 //感觉一个Int基本搞定一切

var f : Double = 3.14

类型推导：Swift可以自动进行类型推导，根据后面的数值自动去推导前面变量或者常量的类型，比如

let c = 10

var g = 20.5

按住option+左键,可以自动知道前面变量的类型

Swift中没有隐式转换，相同类型之间的数值才能进行运算，所以牵扯到一个强转的问题

比如：

let h = 20

let i = 10.4

let j = Double(h) + I //这里必须强转

3.Swift中if和switch和guard逻辑分支

3.1做判断必须有明确的类型,可以不加()

if h {

    print("哈哈")

}

的时代已经过去

现在的写法是

if h>10 {       //必须明确指定真假

    print("哈哈")

}

3.2switch分支

Switch中case下不加break，会自动在后面加上

let l = 0

switch l {

case 0:

    print("男")

default:

    print("女")

}

所以如果非要使用case穿透的话就

let sex = 0

switch sex {

case 0:

    print("哈哈")

    fallthrough

case 1:

    print("正常人")

default:

    print("其他")

}

3.3switch的区间判断

let score = 88

switch score {

case 0..<60:

    print("不及格")

case 60..<80:

    print("几个")

case 80..<90:

    print("良好")

case 90..<100:

    print("优秀")

default:

    print("满分")

}

开区间:0..<10 表示0-9，不包括10

闭区间:0...10 表示0-10, 包括10

3.4三目运算符

let k = c > h ? c : h  //注意这里类型要一致，否则要强转

3.5 guard

Swift2.0后出现的语句，如果非真则走else里的代码，提高程序的可读性

var m = 10

func haha(m : Int) -> Int{

    guard m>=10 else {

        print("哈哈")

        return m

    }

    print("呵呵")

    return m + 1

}

let n = haha(m: m)

n为11

为什么是提高程序的可读性？

看这段代码

let s = 87

if s < 60 {

    print(“1”)

} else if s <= 70 {

    print(“2”)

} else if s <= 80 {

    print(“3”)

} else if s <= 90 {

    print(“4”)

} else {

    print(“5”)

}

这么多if...else的嵌套，看起来的话比较麻烦，如果用guard就可以提高可读性，在s=60的时候。。。s=70的时候。。。

4.循环

4.1 for循环的写法

for i in 0 ..< 10 {

    print(i)

}

也就是for (i=0 i<10 i++){

}

特殊写法

如果在for循环中不需要用到下标i

for _ in 0..<10{

}

while循环

var a = 0

while a<10 {

    a+=1

}

do…while循环,swift中使用repeat代替了do

var b = 0

repeat {

    b+=1

}while b<10

5.字符串

Swift中使用String而非OC中的NSString

原因：

         1.因为String是一个结构体，性能更高

         2.NSString是一个OC对象，性能略差

         3.String支持直接遍历

         4.Swift提供了String和NSString之间的无缝转换

字符串的使用

let str1 = "hello"

let str2 = "world"

let str3 = str1+" "+str2   //拼接字符串

let name = "哈哈"

let age = 18

let message = name+"说:哎呦我已经\(age)岁了"

字符串的格式化

let min = 3

let second = 5

let time = String(format:"%02d:%02d",min,second)

6.数组

可变数组：必须初始化才能使用

var arr : [String] = [String]();

arr.append("哈哈")

不可变数组：

let arr1 : [String] = ["哎呦","不错"]

遍历

for i in 0..<array.count{

    print(array[i])

}

forin遍历

for k in array{

    print(k)

}

数组的合并

var arrays = ["fwerf","efwf","weweq"]

var array1 = ["dew","csf"]

var array2 = arrays + array1

一个数组中不要存放多种类型的数据

7.字典

初始化：

     let dict = ["name" : "why", "age" : 18] //不可变字典

     var dict2 : [String:AnyObject] = [String AnyObject]()//定义一个可变字典，AnyObject就相当于OC中的NSObject

    

    var dict1 : Dictionary<Int,String> //注意逗号

    dict1 = [1:"haha",2:"嘿嘿"];

 字典的合并

    var dict2 = ["name":"aiyou","age":18] as [String : Any]

    var dict3 = ["height":1.80] as [String : Any]

    for (key,value) in dict3 {

           dict2[key] = dict3[key]

    }

    print(dict2)

8.元祖

我感觉类似于数组和字典，元祖中的每一个数据叫做元素

普通写法：

let err = (404,"没找到")

print(err.0) //表示获取元祖中的第一个元素，其他的不用说了吧

起别名的方式：

let err1 = (errCode : 404,status : "没找到")

print(err1.errCode)

let (errCode,status) = (404,"没找到")

print(errCode)

9.可选类型：Swift中的可选类型是个比较难理解，这个在第二篇中再提

10.函数

注：在OC中是没有函数这个概念的，OC中的是方法，OC中准确的叫做消息转发，然后运行时调用底层C的函数

10.1 内部参数：函数的内部可以看到的参数就是函数的内部参数，就相当于参数列表。

外部参数：函数的外部可以看到的参数，例如：

       

   func ride(h num1 : Int, a num2 : Int, b num3 : Int) -> Int {

    return num1 * num2 * num3

   }

   var result1 = ride(h: 20, a: 4, b: 5)

这里的h,a,b调用的时候函数的外部参数

10.2 函数如果没有传递任何参数，可以使用默认参数

func makecoffee(type :String = "卡布奇诺") -> String {

    return "制作一杯\(type)咖啡。"

}

let coffee2 = makecoffee()

let coffee3 = makecoffee(type: "拿铁")

10.3 Swift中函数的参数个数可以变化，不确定有多少个参数的情况下可以使用(…)的方式

func sum(numbers:Double...) -> Double {

    var total: Double = 0

    for number in numbers {

        total += number

    }

    return total

}

sum(numbers: 100.0, 20, 30)

sum(numbers: 30, 80)

10.4 函数中默认是值传递，地址传递

func swap1( a : inout String, b : inout String) {

    let temp = a

    a = b

    b = temp

    

    print("a:\(a), b:\(b)")

}

var aa = "哎呦"

var bb = "呵呵"

swap1(a: &aa, b: &bb)

交换了两个单词的地址