swift3.0基础语法(2)

2.基础语法

变量/常量，元组声明

var  aaa = 0;//声明变量aaa 首次赋值时自动解析为Int类型

var aaa:Int = 0;//声明Int类型变量aaa

let aaa = 0;//声明常量aaa 首次赋值时自动解析为Int类型，常量值不可被修改

let aaa:Int = 0;//声明Int类型常量aaa ，常量值不可被修改

在swift中除了简单的数据类型外，还有高级的数据类型（类，函数，结构，元组等等），其中比较有趣儿的是元组类型，因为其在代码的可读性与自由度上都很舒适，下面进行简单的元组数据声明。

/*

*声明元组变量/常量

*/

var/let   aaa = (值0，值1，值2，值3...);

aaa.0;//值0

aaa.1;//值1

aaa.2;//值2

var/let   (a,b,c,d...) = (值0，值1，值2，值3...);//一一对应

a;//值0

b;//值1

c;//值2

类型别名

类型别名就是为了现有类型定义的替代名称。

typealias 类型别名 = 数据类型名称

typealias  myInt = int;//声明myInt 赋值为int类型

var maxInt = myInt.max;//声明变量maxInt  和int.max等价

maxInt;// int.max

运算符

&：按位与

|：按位或

^:按位异或

~：取反

<<：左移

>>：右移
&+：溢出加法
&-：溢出减法
&*：溢出乘法
<:小于
<=:小等于
>:大于
>=:大等于
==:等于
!=:不等于
&&：逻辑与
||：逻辑或
！：逻辑非
*=：乘后赋值
/=:除后赋值
%=:取余后赋值
+=:加后赋值
-=:减后赋值
<<=:左位移后赋值
>>=:右位移后赋值
&=:按位与后赋值
^=:按位异或后赋值
|=:按位或后赋值
??:空和运算
?::三目运算

数据类型

1.数组

let/var intArray:[Int] = [];

2.字典

var/let dic = [key:value,key1:value1,key2:value2...];

3.集合

let/var letters:Set<Character> = ["A","B","C"];

注意：类型声明时，其可变或不可变使用var和let进行区分。使用let声明为不可变集合，其长度是不能被改变的，在字典中，不可变意味着不能替换已经存在的键的值，但和数组不可变有些不同，字典可以修改其值，数组值不可修改。

流程控制

1.if...else if...else...

var a:Int = 0;

var b:Int = 1;

if a==b{

    print("a和b相同");

}else if b>a {

    print("b大于a");

}else{

    print("b小于a");

}

2.switch

var a:Int = 20;

switch (a){

    case 5:

        print("a==5");

    case 20:

        print("a==20");

    default:

        print("前面条件都不符合");

}

3.for...in...

var a = [1,2,3,4,5...];

for x in a{

    print("\(x)");

}

4.repeat while...

repeat{

    a/=10;

    print("a is \(a)");

} while a!=0

函数和闭包

1.函数

//若想调用有参函数，想将参数名省略 可以在定义参数时前面加上"_"

func 函数名(_参数名1：数据类型 = 默认值1，参数名2：参数类型 = 默认值2...)->返回值类型/（返回值1：返回值类型1，返回值2：返回值类型2...）{

    //函数体

    return 返回值类型参数/（返回值类型1参数，返回值类型2参数...）

}

//可变参数函数

func 函数名1(numbers:Int...)->返回值类型{

    //函数体

}

//可变参数调用

函数名1(1,2,3,4,5,6);

//输入输出参数

var a:Int = 2;

func changeA(lastA:inout Int){

    lastA = 4;

}

print("\(a)");  //a = 2

changA(lastA:&a);

print("\(a)"); //a = 4

//方法作为参数或返回值

func 函数名(参数名:(参数类型1，参数类型2...)->返回值类型)->(参数类型1，参数类型2...)->返回值类型{
 //函数体 
}

2.闭包

var/let v1 = {(参数1：参数类型，参数2：参数类型...)->返回值 in

    return 返回值类型参数；

}

var/let v1 = {

    //$0,$1,$2...来表示参数 省略

    //N个参数的操作

}

下标脚本

subscript(变量:类型)->返回值类型{

    return 返回值;

}

下标脚本一般应用于一些功能性的辅助，如方法下标方法名(参数)[0] 这样的灵活性调用。

类型检查

1.is

实例 is 子类型

is关键字可以用来检查一个实例/对象的所属类型。

"i am superman" is String //true

2.as/as?

实例 as 类型

as/as? 就是用来强制转换形式的关键字，当转换一定成功时才可以使用强制转换形式的检查。

var lib = ["123",12];

for l in lib{

    var a:Int = l as Int;

}

枚举

enum 枚举名称:枚举类型{

    case  变量 = 值;
    //枚举属性
    var reNum:Int{
        return 10;
    }
    static var reNum1:Int{
        return 100;
    }
    func 方法名(参数)->返回值类型{
        self；//self为当前枚举中的某一成员对象
        return 返回值;
    }

//....  }
枚举名称.变量.rawValue；//访问变量原始值
枚举名称.变量.reNum; //10
枚举名称.reNum1；//100
枚举名称.方法名();//执行 方法名 方法

枚举类型在程序的诸多设计中存在关键的逻辑作用，可以让代码更加的符合面向对象规则，是一种逻辑上理解的应用，但本人觉得，如果会用的会觉得枚举的重要及舒适，如果不会用的程序依然会跑，但其设计和很多方面的逻辑灵活都不如前者。

枚举间可进行灵活的嵌套，如数组。

注：当枚举类型为Int时，如未指定变量值，则第一个以0开始依次递增，如第一个指定值之后的没有指定，则以第一个值开始，依次递增。