iOS开发Swift语法回顾之基本的语法与数据类型

一、变量、常量

1、Swift中分别使用let、var来定义常量与变量的。

2、Swift在定义常量或变量时，必须指定其数据类型。

格式：let a:Int = 10 （变量名 : 数据类型） 其含义是：定义了一个Int类型的常量，值为10，且不能做修改

注：Swift编译时，是通过空格或回车符来断句的，所以使用Swift语言书写的代码只要回车就行，不用以分号结束。

如果定义常量的格式为 let a = 10 其也可以执行，并不会报错，因为Swift语言会根据初始值自动推断出自己是什么类型的数据或常量（具备隐式推断的功能）

3、使用var来定义我们的变量，变量可进行重新赋值操作

如：var a = “lianxi"

       var b = “duoqiao"

以上分别定义了两个字符串类型的变量，那么我们如何来拼接它们呢？

       var c = a + b

Swift语言拼接字符串可以直接相加，它会隐式判断出你所要进行的操作，但是如果遇到两个不同数据类型的加减乘除的话，它会报错，其不支持隐式类型转换，必须提前进行显示转换成相同数据类型

     var d = 3

     var e = a + String(d)     //提前将Int类型的d显示转换成String类型

4、在定义变量的时候，在数据类型后面加？表示该变量可以为nil      例如：  var a : Int? = nil

5、在Swift中Bool类型是一个结构体，不是枚举，只有两种结果：ture 和 false ，所以不能通过以前的非0为真去判断Bool的真假

     var bool = ture

注：Swift中的变量输出为：print( \( 变量名 ) )

二、数组

1、Swift 中分别使用let和var去定义一个不可变的数组和可变的数组（使用[ ]来表示定义了一个数组）

数组的定义与定义常量和变量一样，有两种定义方式：1）定义初值，系统自动推断；2）变量后面加 :类型名

特别地：如果定义成：var array = [ 1,  2,  “a”]   根据系统特性：数组中的元素必须是同一数据类型的；那么系统推断的数组元素类型为NSObject

     var array : Array<Int> = [ 1, 2, 4]   //数组中的元素只能是Int类型的

     var array : [ Int ] = [ 1, 3 ,5 ]  等同于以上格式

2、数组跟C中的一致，也是通过下标来访问数组元素的

3、数组可通过相加来拼接数组，也可通过点语法来添加和移除数组元素（最后添加、指定位置添加、指定位置移除、移除全部元素）

4、数组里面添加数组元素

三、字典  (也是[ ]来表示）

1、定义字典格式： let/var 字典名 = [key : value, key : value ]

如果字典是通过定义初值的方法去定义，里面的key和value数据类型可以不相同

而字典通过指定类型来定义，里面的key和value数据类型不可改变

var dictionary : [ Sting : Int ] = [ “a” : 1, “b” : 2]

2、字典也可以创建一个可以为nil的字典，也是用？修饰

而通过？修饰的变量在使用的时候，必须在变量名后面添加！来进行拆包读取

dictionary![“a”] = 100    (通过key值读取并做修改）

四、元组 （Swift中新增类型）

元组定义时是用（）来表示的

元组的元素可以通过下标定义和读取，也可以通过key/value定义和读取

元组定义时给定元素类型使用（）

注:若果使用指定类型定义，元组里面的元素相同，也必须每个元素对应一个类型

它的读取与字典和数组不同，不用使用【】，而是直接使用点语法 ：元组名 .下标  或 元组名 . key

五、分支语句

     if 判断与OC中的区别不大，有两点改变：1）条件可不用加括号；2）条件必须写全，如：bool == ture

     区间条件：…和..<

     …代表从0开始到最后一位，包含最后一位的值

     ..<代表从0开始到最后一位，但是不包含最后一位的值

     switch分支

     与OC中switch相比：1、每一个分支不用加break，系统会默认添加

                                       2、每一个分支都必须写东西，不能为空

                                       3、可以使用fallthrough来贯穿执行两个分支代码

                                       4、可以对一个区间条件进行匹配使用

                                       5、可以搭配一个元组一起使用（使用_来忽略某一个条件）

                                       6、可以使用where来作为判断条件

六、循环语句

     for； for…in ；   while； repeat…while（代替了do...while）

    基本语法与OC与类似，是有一点改变，条件的括号可以省略不写

七、函数

     Swift中的函数有以下几个不同于OC函数的特点：

     1、使用元组可实现有多个返回值的函数

     2、Swift中，一个参数有两个名字，内部参数名和外部参数名

         内部参数名：在函数内部使用的参数名称。

         外部参数名：在函数调用时候，显示的参数名称

     3、在函数内部是不能修改参数值的，因为它是默认使用let来定义的，如果需要修改，需要手动使用var来定义

     4、默认情况下，多参数函数的第一个参数名，不在外部显示，其他参数的外部参数名与内部变量名一致，如果不想让它们在外部显示，可以在定义参数名前加_来忽略外部参数名

     5、Swift中定义的函数里面还能定义函数（函数能够嵌套定义）

另外：inout参数:
1.参数默认是用let修饰,即常量
2.在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.

3.如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.

     函数只是一个格式的转变：各种代码格式如下：

  //Swift里面的函数是一个变量
//无参数无返回值 ( -> Void 可省略不写）
//定义函数的格式：
//func （关键字） test（函数名）（参数）->返回值类型
//{
//    函数体
//}
//如果没有返回值， -> Void 可以省略
func test() -> Void {
    print("我是一个无参数无返回值的函数")
}
//调用函数
test()

//无参数有返回值
func test1() -> String {
   
    return "a"
}
print(test1())

//返回一个OC的数组类型
func test2() -> NSArray {
   
    return [2,3, 4]
}
print(test2())

//返回一个Swift的数组类型
func test3() -> Array<NSObject> {
   
    return [1,2, "33"]
}

print(test3())

//Swift中可以返回多个返回值，其实就是返回一个元组
func test4() -> (String,Int,Int,Array<NSObject>) {
   
    return ("a",10,10, [1,2])
}
print(test4())

//有参数无返回值
func test5(name : String, age :Int) {
   
    print(name, age)
}

test5("你猜", age: 12)

//定义一个参数是数组类型的函数
func test6(people : Array<NSObject>) {
   
    print(people)
}
test6([1,2, 3, "33"])

//Swift中含有内部参数名和外部参数名
//下面的函数中 你好 是外部参数名
//           nicai 是内部参数名
func test7(你好 不好:String) {
   
    print(不好)
    print("你好不好")
}
test7(你好:"你也好")

//如果不想让外界知道你的外部参数名，可以使用_忽略掉外部参数名，每个参数都会自带一个外部参数名的，如果不写则和内部参数名一致
func test8(name: String, age :Int){
   
    print("name =\(name), age =\(age)")
}

//test8(<#T##name: String##String#>, age: <#T##Int#>)

//在函数内部是不能修改参数值的，因为每一个参数是默认使用let定义的
//如果需要修改的话，可以手动的使用var定义参数
func test9(var name : String) {
   
    name = "a"
}

//inout修饰的函参数，是var定义的，在使用的时候可以改变传进来的参数的值
func test10(inout name : String) {
    name = "韩一路"
}

var name = "过冬"

test10(&name)

print(name)


func test11(inout people : (String,String)) {
   
    let temp = people.0
    people.0 = people.1
    people.1 = temp
   
}

var since = ("100","500")

test11(&since)

print(since)


func test12(name : String, age :String) ->String
{
    let string = "我叫\(name),今年\(age)岁"
    return string
}

let string = test12("刘永杰", age: "25")
print(string)

func test13(people : (String,Int)) ->Array<String>
{
    return ["我叫\(people.0),今年\(people.1)岁"]
}

let array = test13(("刘永杰",25))
print(array[0])

//函数里面可以嵌套定义一个新的函数,可以无限地循环下去
func test14() {
    func test1() {
        func test2(){
           
        }
    }
    func test2() {
        func test1() {
           
        }
    }
   
}

test14()