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()