初识你---------Swift【上篇】

从2014年WWDC（苹果开发者大会）发布的新开发语言Swift，到2015年的WWDC开发者大会上，苹果公司推出了Swift2.0版本，而且Swfit彻底开源。并且每一次Xcode的更新Swift都会跟着作各类调整，如今已经有好多项目都在使用，尤为是在移动端的动画切换方向，

更是给用户带来了一场新的视觉盛宴，那就简单认识一下Swift

首先是Swif定义变量的方式

在Swift中使用“let”修饰一个常量，使用“var”修饰一个变量;

• let修饰常量的值是不能够更改的；
• var修饰的变量的值是能够更改的；
• 在声明常量和变量的时候可使用表情符号、中文等命名常量名和变量名。

 Swift定义变量或者常量的时候，须要标识出变量或者常量的类型，若是不标识，会根据初始值自动推断。

如:

//会自动推断变量a为Int类型 var a = 10 //会自动推断常量b为String类型 let b = "windsSunShine"

Swift会根据初值自动的推断出本身是什么类型的变量或者是常量，因此在开始定义的时候必定要赋初值或者指定数据类型，可是

Swift不支持隐式类型转换的

即不一样类型的两个数据之间不能进行操做

若是让两个不同的数据类型变量或者常量作加减乘除的操做须要提早改变变量或者是常量的数据类型

如：

var a = 100 var b = 300.5 var c = Double(a) + b

当在Swift里面设置nil值时须要在数据类型的后面添加一个？ 表示这个变量能够为nil

 

var a1 : Int? = nil;

// 在Swift里面Bool类型是一个结构体，只有两种结果，true 和false 因此不能经过之前的非0 为真去肯定Bool的真假

错误写法

//var bool  = 0;

// 正确写法

var bool = true print(bool)

在Swift里面定义字符串变量

// 字符串的拼接 // var c = "dasadas" var d = "sdfafsdcx" // c d 拼接字符串  var f = c + d

须要注意的是此时的  c d  f 都是 var类型的

 

在Swift里面定义数组：

 

使用 [ ] 去表示定义一个数组

// 定义的基本方式

 第一种  根据初值定义

let array = [1, 2, 3]

Swift中数组里面的元素必须是同一数据类型【在Swift 2.0作的改变】

array1里面会自动转换成NSObject对象类型

let array1 = [1, 2, 3, "b"]

 第二种  先指定数组里面元素的类型，在去给初值

 

let array2:[Int] = [1,2,3];

访问数组元素

// 使用var定义数组 数组中若存在值能够根据下标更改 var array:[Int] = [100]; // var array1:[Int] = [1,2,3,4,5]; // 运算符重载 var array2 = array + array1 print(array2); // 在数组的末尾添加一个元素 // array必须是变量的类型 array.append(10000) // //// 在数组中插入一条数据 array.insert(200000, atIndex: 1) //移除数组中的某个元素 array.removeAtIndex(1) print(array)

 

在Swift里面定义字典：

 

定义字典的格式：

 

let/var 字典名 = [key: value, key : value];

let dictionary = ["a" : 1, "b" : 2];

若是字典由初值去肯定key和value的数据类型，则里面的key和value的数据类型能够不一样

// Swift2.0以前不能够 let dictionary1 = ["a" : 1, "b" : 2, 4 : "4"];

// 自定义输出

  print("type1.0 ====\(type1.0)");

 \ 后面的（）里面写入的是具体的对应的值

 

 

// 建立一个字典类型的变量，能够为空值nil var dictionary2:[String:Int]? = nil var dictionary2:[String:Int]? = ["1":300]; // 使用？ 修饰的数组在调用是须要在数组名后面添加一个"!"进行拆包 // 建立字典中的某个key值对应的value dictionary2!["1"] = 200; print(dictionary2);

在Swift里面定义元组：

 

 定义一个元组的格式：

 let 或者 var + 元组名字 =（ 元素 ）

元组是Swift中尤其特殊的一个，在Swift中真正实现能够有多的返回值的状况就是经过元组实现的

let type11 = ("windsSunShine",18); // let type22:(name :String, age : Int) = type11 // print(type22); //// 拼接打印 print("My name\(type22.name),My age is \(type22.age)岁")

//switch 能够搭配元组使用 // 定义元组使用（） let point = (10,10) // 应用与动画的实现 switch point { case (10, 10): // 为（10，10）这个点时输出元组  print(point) case(_,10): // 使用_忽略某个条件 print(point.1) case(10,_): print(point.0) case(_,_): // 可使用__忽略全部条件  print(point) }

注意：

在Swift中 i++ 于 i ++ 是不一样的，

在Swift 写i ++ 是错误的 它是根据空格或者回车来断句的，因此必定要注意空格的使用

 

Swift的if判断语句：

在if判断中 Swift和 Objective-c的区别在于 在判断语句中要将条件写完整 括号无关紧要

 

var timer :[Int]? = nil; if timer != nil{ }else { }

 

Swift的循环语句：

for：

 

 

//..< 表明 从数字1 开始到数字n 可是不能包括数字n //... 表明的是从数字1 开始到数字n可是包含数字n for var i in 0..<array22.count{ print(array22[i]) }

 

 

 

此时咱们能够用Swift就能够写一个冒泡排序了以下：

 

var array33 = [23,45,43,12,13]; print(array33) for var i = 0; i < 5; i++ { for var j = 0; j < 4 - i; j++ { if array33[j] > array33[j+1] { var temp = array33[j]; array33[j] = array33[j+1] array33[j+1] = temp } } } print(array33);

While循环：

若是说for循环是“屌丝”循环的话，那while必定是那个高富帅

var i = 0; while i < 10 { i++ print(i); } // Swift里面没有 do-while 循环用repeat替代， 在Swift1.0时，Swift中也是do-while 而在2.0以后成了repeat-while  repeat { i++ print(i) }while i < 10

 

分支循环switch

switch在Swift中和OC的区别在于

Swift中不用写break ,可是default里面须要写东西，每个case里面也须要写东西

let value = 0; switch value { case 0: print(value) fallthrough // 表示0状况下面的语句所有执行 case 1: print("value======\(value)") default: print("error")

 

switch还能够对值进行区间的匹配

 

switch value { case 0...10: // 包含10  print(value); case 11..<20: // 不包含20 print("value=====\(value)") default : print("error") }

switch能够搭配where使用

 

let a1 = 10 switch a1 { case 1 where a1 < 10: print(10) default: print(100) }

Swift里面的方法的叫法与OC中有些许的不一样在Swift中成为函数变量 ，而定义函数变量的的关键字就是： func

 

 定义函数的格式：

 

func（关键字） test(函数名)（参数）-> 返回值类型{}

 

 若是没有返回值能够将 -> Void 省略

 

无参无返回值

func test() -> Void { print("我是一个无参无返回值的函数") } func test1(){ print("精简以后的函数") } // 调用函数 test() test1()

 

 

无参有返回值

 

 

 

func test2() -> String { return "a" } print(test2());

 

 

 

// 返回一个OC的数据类型 func test3() -> NSArray { return ["a","c",3] }

 

 

// 返回一个Swift的数组 要明确元素的类型  func test4() -> Array<Int> { return [1,3,4] } func test5() -> Array<NSObject> { return [1, 3, "r"] }

 

 

有多个返回值的现象：

 

 

// Swift中能够返回多个返回值，实质上是返回一个元组 func test6() ->(String, Int) { return ("a", 6)

 

 

有参无返回值

func test11( name: NSString){ print(name) }

// 参数是数组类型的函数 有返回值必定要写 -> func test22(people : Array<Int>) -> Void { }

 

在Swift的函数变量中还有一个特别的地方，那就是函数的命名方面

在Swift中包含

外部参数名 

内部参数名 举例以下：

 

func test33(waibu neibu:String) { print(neibu); print("windsSunShine") } // // // test33(waibu: "hello");

打印结果为：

hello  // 先打印的是内部参数对应的值，即调用的值

windsSunShine  // 接着打印的是函数要执行的内容

 

 

若是不想让外界知道你的外部参数名的话可使用下划线忽略掉外部参数名，每个参数会自带一个外部参数名的，若是不写则和内部参数名一致：以下面的函数的外部参数名 age ,内部参数名也是age

 

func test44(nihao name:String, age:Int) { print("name = \(name),age =\(age)") }

除此以外

在函数的内部是不能改动参数的值的，由于每个参数是默认使用let定义的

若是须要改的话，能够手动的使用var定义

func test9(var name : String) { name = "a" }

func test1(inout name: String) { name = "你好" } var name = "我很好" test1(&name) print(name)

打印结果是： 你好

使用inout修饰参数名，是var定义的 能够更改参数的值 在使用时能够改变传进来的参数值

在Swift里面能够嵌套定义函数：而在OC中只容许嵌套调用不容许嵌套定义的，同时在C 语言的函数中也是不容许嵌套定义函数的

func test14() { func test1() { func test2() { } } }

 

最后经过上面的基础，咱们能够简单的封装一个小demo用来数组的排序：代码以下：

 

先建立一个file在file里建立一个函数：

func maopao( inout array1 : Array<Int>) -> Void { for var i = 0; i < array1.count; i++ { for var j = 0; j < array1.count - 1 - i; j++ { if array1[j] > array1[j+1] { let temp = array1[j] array1[j] = array1[j+1] array1[j+1] = temp } } } }

接着就能够在外部调用了

 override func viewDidLoad() { super.viewDidLoad() var array = [1,23,56,2,7,14,87,23,10]; maopao(&array); print(array); }

欢迎转载，请注明转载和原文出处：http://www.cnblogs.com/windsSunShine/p/4989476.html