swift3.0基础语法(2)

1.Hello Word

2.基础语法

3.构造器、析构方法

4.扩展、协议

 

变量/常量，元组声明 

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开始依次递增，如第一个指定值 以后的没有指定，则以第一个值开始，依次递增。