Swift学习-基础的语法

      励志作为iOS的开发人员，尽管写代码的时候不会专门的挑选Swift语言，但是肯定都会熟悉Swift这个名字，楼主表示从刚开始学习objc的时候就对Swift这个名字很感兴趣，感觉很高大上，但是从很多博客上也相应的看到相关文章，不得不说，Swift必将成为以后iOS开发的主流，尽管每次更新，Swift语言都会有比较大的更新，但不能代表就不了解他，闲话不多说，想了解Swift的历史可以去百度，今天聊聊关于Swift的那点小基础,这里如果有一点点C++/Java/PHP的基础的话，类比了解起来会更容易，毕竟Swift是集合了许许多多的语言的优点。

定义变量

首先第一步必然先熟悉如何定义变量，Swift语言楼主学的时间不是很长，基本是靠类比进行学习的，所以语言不是很准确，以后有更深的了解，必然会在这里修正

定义变量首先会有两个关键字 let (不可变)与 var(可变)

有什么区别呢，如其名字，let关键字定义的属性是不能修改的，var的变量是可以修改的，文字表述可能会比较无聊，代码来解释一下吧

var stringBo:String = "RunIntoLove";//后面的引号可以不加，Swift允许，但是楼主比较习惯了
let string1Bo:String = "Run";

//进行修改值
stringBo = "Yue";
string1Bo = "Yue";//会出现报错-Cannot assign to value:'stringBo' is a 'let' constant ,就是说不能改变他的值，因为他是一个let类型的变量

那么变量名字后面的：以及后面的String是什么呢，Swift依旧保持特色，这就是他的定义变量的类型，stringBo:String 表示一个变量的名字叫做stringBo,类型是String

var stringBo = "RunIntoLove";//Swift会自动的根据后面的类型，判断stringBo的类型，所以可以不写类型
var string1Bo:String; //这样子是定义了一个字符串String类型的变量
var int1Bo:Int = 10;//这样子是定义了一个整型Int类型的变量
var string2Bo;//这里会报错，如果不直接赋值，那么后面的类型是不可以忽略的,会报错-Type annotation missing in pattern 类型描述缺少类型

数字型:Int,Double

在Swift中的类型开头都是大写的，不同于C/C++，但这也不影响使用，毕竟objc的风格也是如此，这里只说一下他的特点

//数字
var u:Int = 00010_000_000;//var u = 10000000 || var u = 10_000_000.0 这三种写法是一样的

var d:Double = 10.2;

var o = Double(u) + d;//在Swift中，不同类型的属性不能进行运算，要想进行运算，必须强制转换成相同的类型，这个时候o的值就是10000010.2

字符串:String

字符串在Swift中的用法更加灵活，比如两个字符串连接，只需要用"+"连接即可，这点是综合了C++/Java的用法，毕竟是好处嘛

var firstName:String = "RunInto"
var lastName:String = "Love"

//字符串的连接
var name:String = firstName + lastName

元组:

       元组是Swift中比较新的类型了，但是第一次看到元组的时候比较亲切，后来想了想第一次接触元组是在大学中的离散数学，它是一种能够存多种值的结构，这东西不需要定义类型，就能存储多种数据，但是有很好用，语言不能表达，为什么会有元组呢，因为Swift的函数是可以有多个返回值的，接收的时候自然会用元组来接收，用代码更好的说明下:

//定义元组

var postion = (name:"YueWen",age:22);//定义一个元组,这种定义法类似一个结构体

var person:(String,Int) = ("YueWen",22);//可以提前声明类型

var (z,m) = ("yuewen",18);//通过元组给其他元组赋值
var point2 = (name:z,age:m);


//取值
var name_1 = postion.name//与name_1 = postion.0等价
var age_1 = postion.age//与age_1 = postion.1等价

var name_2 = person.0//通过小标进行取值，类似与数组了
var age_2 = person.1

语句控制

if...else

在Swift的if-else语句中，不同的还是有的，它不允许在()里进行隐形判断，必须是显性的。

什么叫隐形呢，比如在objc中

NSInteger i = 1;

if(i)//如果i为真,报错-Type'Int' does not conform to protocol 'BooleanType'
{
    //coding..
}

这个样子在objc中允许，他会自动的将1转成YES,将0转成NO,但是Swift中上面的语法是错误的.如果想正确，必须变成显性的判断

var number:Int = 1;

if(numbe1 == 1)//如果number = 1
{
    //coding...
}

for循环

for循环没有什么较大的改动，依旧有最基础的，也有for-in循环，如下

//定义一个数组
var numberArr = [90,85,47,52,36,"123"]//这里数组比较特别，里面的数据不仅限于一种类型，比如这里的数组存的就是Int类型的数据以及String类型的数据

//循环遍历
for s in numberArr
{
    print("number = \(s)")//在iOS_9.0之后，print替换了println,println已经被废除，写的话会报错
}

//普通for循环
for (var i = 0; i < numberArr.count; i++)//Swift中调用方法废除了[],选用了. 这点与大多数的编程语言相同了
{
    var s = numberArr[i]
    print("打印出的变量为\(s)")//print 代替 println，打印的形式只需要加一个\(需要打印的内容)即可
}

do-while循环 - repeat-while循环  iOS9之后用repeat替换do

依旧通过便利上数组来举例

//do while循环
var k = 0

repeat//iOS9.0之后用repeat代替了do
{
    var s = numberArr[k]
    print("do while 循环打印出的变量是\(s)")
    k++
}while(k < numberArr.count)

while循环

//while循环
var k1 = 0;
while(k1 < numberArr.count)
{
    print("while 循环打印出的变量是\(numberArr[k1])");
    k1++ ;
}

Switch语句

switch语句变动还是比较大的，因为在objc以及其他的语言中，每次case完毕之后都需要在后面加一个break,不然会穿透到下一个case语句,但是在switch语句中，不需要加break,默认不穿透，需要穿透的事后只需要加 fallthrough 关键字即可

//switch
let iso = "iOS"
switch iso//switch后面的变量可以使字符串，不仅仅只限于数字了
{
    case "iso":
        print("iso 为 iOS")
    //break 可以省略，swift不穿透
    //穿透需要加 fall through，加上这一句就是说执行完这句话之后会继续执行case:"Android"
    
    case "Android":
        print("iso 为 Android")
    
    case "JS":
        print("iso 为 JS");
    default:
    print("最后了")
    
}

函数

函数形式发生了变化，声明方法以及函数，用func关键字，返回值不再存在与函数之前，而是用放在 ’ -> ‘之后，如果返回值为Void,可以省略

无返回值无参

func testFunction()
{
    print("测试方法！")
}

有一个参数没有返回值

//带参的函数
func testFunction(s:String)
{
    print("参数是\(s)")
}

如果想真正的修改参数值，用inout关键字

这句话是什么意思呢，就是说当做参数放到函数中，无论在函数中对该参数进行任何的操作，原来的实参是不变的，加上inout关键字就相当于C语言的指针，C++的引用&,里面对参数的更改实际上就是修改的实参

func testFunction0(inout s:String)//表示实参可以改变，改变之后参数也会发生变化，类似C++的引用
{
    s = "Run";
    print("参数是\(s)")
}

var s:String = "RunIntoLove";
testFunction0(&s);//在执行完毕这一句话之后，s就变成了Run

带多个参数，无返回值

//带多个参数的函数
func testFunction(s:String , i:Int)
{
    print("我的参数是\(s),\(i)")
}
testFunction("RunIntoLove", i: 5)

返回一个返回值的函数

//返回值函数
func testFunctionF(v1:String, andVaule v2:Int, andNumber v3:Int) ->String//逗号不要丢
{
    return "\(v1)\(v2)\(v3)"
}
var string = testFunctionF("RunIntoLove", andVaule: 10, andNumber: 8)
print("返回值参数是：\(string)");//返回值参数是：RunIntoLove108

返回多个返回值的函数

//无参 返回3个值，但是需要用一个元组接收
func testFunction123() ->(String ,String ,String)
{
    return ("RunIntoLove","Study","Swift")
}
//用元组接收
var (name1,action,target) = testFunction123()
print("\(name1) \(action) \(target)");//RunIntoLove Study Swift

函数嵌套函数-一般人不建议用

//函数嵌套函数
func testFunctionInFounction() -> Int//返回值类型为Int
{
    var y134:Int = 100
    
    //方法可以嵌套方法
    func add()
    {
        y134 += 5  //可以用外部的变量
        y134++  //变量与++之间不能有空格，不然编译器会报错
    }
    //执行方法
    add()
    return y134
}

var number12 = testFunctionInFounction()
print("number12 = \(number12)")//number12 = 106

闭包_Closure-objc的Block

如果之前了解了objc的Block代码块就很好理解了，就是说在参数的位置放置一个函数，将方法的函数当做一个参数来用

通过一个简单的例子来看，写一个数组，如果里面有大于100的就返回true,否则返回false: Swift的Bool类型只有True或者False

首先定义一个数组

var arrInt = [80,12,45,789,85,63,110] //定义一个数组

接着写一个用闭包完成的方法，用来完成该项功能

func hasClosureMatch(arr:[Int],value:Int,function:(num:Int, value:Int)-> Bool) ->Bool//参数的方法参数有两个，一个数字，一个参考数字，返回值为bool, 外部大的方法的参数为 一个Int型的数组，参考值，以及一个闭包
{
    //开始遍历数组
    for item in arr
    {
        //使用参数中的函数
        if(function(num:item, value:value))
        {
            return true
        }
    }
    
    return false
}

调用该方法

//定义个方法，查找arr里面是否有比100大的数
var v1 = hasClosureMatch(arrInt,value:100,function:
{
    (num:Int,value:Int) -> Bool in
    return num >= value //当该数字num大于参考值value的时候返回sure,否则返回false
})//打印结果为ture,因为110大于100

闭包相对于比较难理解点，不过结合Block会简单很多。

Swift 因为基础类型都有Array,Dictionary,String,且功能都比较强大，楼主有疑惑，什么时候用NSArray等对象，什么时候用array类型,如果有明白的人，麻烦请告诉一下楼主，十分感谢.