IOS--Swift 01

Swift 语法什么的 确实好奇怪
很像混血
一 Swift 程序

import Foundationprintln("Hello, World!")

注:创建之后就会发现和 之前用的完全不一样
1.Swift 没有 main 函数 但是有隐形 main 函数
执行方法:从 top level code 的上方 开始往下执行 即:第一个非声明语句开始 tlc 不能存在多个
2.import 引入其他类库 在 playground 里 是引入框架时才能用
3. Swift 结束 不需要分号 多条语句才会使用 数组和字典中用逗号

二 数据类型
因为 Swift 是混合了多种语言 所以他身上有很多语言的影子
1.C 语言:Int 整型; Float/Double 浮点型;
2.OC 语言: Character字符型，String字符串类型；当然还包括enum枚举、struct结构体构造类型；Array数组、Set集合、Dictionary字典集合类型
3.布尔型: true/false
4.高阶数据型:元组 (元素组合,类似数组的东西) ; 可选类型 :(Optinal)

三 playground
在 Xcode6.0之后 有了 playground 代码测试 可以实时查看你的代码
说一下这个 playground 把
它自身比较好内存 如果你的电脑不太好 还是不建议升级6.4 使用这个东西 因为它是写好一行 就会全程跑一遍 太吓人了 搞不好就会闪退
注: 学之前 要注意的两个量 var 变量 let 常量 搞清楚这两个 差不多是必备把

//类型推断 : swifit  可以根据赋的初始值 来确定 a 是什么类型let a = 10//默认 带点的就是double 类型var b = 10.01//如果想设定类型 float 需要类型声明var c :Float = 1.123//类型安全:由于Swift是强类型语言，b是Int类型而c是Float类型，二者不能运算，下面的语句报错;但是注意如果是类似于：let a=1+2.0是不会报错的，因为两个都是字面量，Swift会首先计算出结果再推断a的类型let d  = b+c //errorvar d = 20//相加:变量和常量之间没有什么阻碍 只有类型才会有阻碍let e = a+d//常量和变量的命名 可以用很多种方法 emoji 标签也可以 所有Unicode字符都是可以的let 你好 = 521var �� = 你好let π = 3.1415926let の =  512344455461var エ = 1231

简单的说一下几个类型 大概了解

/***  bool1.声明 类型: 常量/变量2.只有两种:true  /false*/var nn:Bool = falsenn = true/***  类型重命名*/typealias 整型 = Intlet f:整型 = 14/***  元组:类似数组的东西*  元素的组合*  定义*/var 元组 = (404,500)print(元组.0,元组.1)let 来个字符串 = "好吧我来了"let 服务器元组 = (网络错误:404,服务器宕机:500,凑数的:451)println(服务器元组.凑数的)println(服务器元组.1)/***  占位符 "_"下划线*/let (_,服务器宕机了) = 元组/*** 可选类型*  可选类型: toint 有值状态下是指本身  无值状态下 是 nil;*  类型安全:变量/常量的值,必须和声明的值一样 否则不能用*/let stri = "你好"let stri2 :Int? = str.toInt()println(stri2)

四 Xcode 中的 Swift
在创建的过程中 我们不能基于OC 了

语言我们选择 Swift

1 运算符

/** * 区间运算符,通常用于整形或者字符范围(例如"a"..."z"） */  // 三个点 "..." 闭区间运算符 [1...5]（从1到5，包含5）for i in 1...5 {     println("i=\(i)")} //两个点 ".."左闭右开 半开区间运算符[1,5)for i in 1..<5{ //    println("i=\(i)")}

2.集合类型
1>数组

/***  数组 的数据持有*/var array = [1,2,3,4]//数组添加元素 Swift中可变类型不再由单独的一个类型来表示，统统使用Array，如果想声明为不可变数组只要使用let定义即可array.append(5)println(array)//判断你是神马类型之后 再添加的东西需要也是这个类型//array.append("1235641")  error//println(array)// 删除 是根据下标array.removeAtIndex(0)println(array)//查找 let c = array[0]println(c)//修改 array[1] = 100 println(array)//遍历for i in array{    println(i)}//插入array.insert(699, atIndex: 4)//如果你不知道有多少 可以写array.insert(766, atIndex: array.count)println(array)//创建空数组let emptyArray :[Int] = []println(emptyArray)

2>字典

/***  字典*/var dictionary = ["Nyx":"蜘蛛女王","Anne":"我的小熊"]println(dictionary)//增加 和修改 通过 key 来确定 //如果你是修改 key 就填写你想修改 value的 key// 增加 则是当前字典没有此 keydictionary .updateValue("男朋友", forKey: "Eazireal")println(dictionary)// 删除dictionary.removeValueForKey("Anne")println(dictionary)//遍历 打印出来是()的元组for (x,y) in dictionary{    println(x)//打印出来的是 key  如果改成 y  则打印的是 value}//查找 let a = dictionary["Nyx"]println(a!)//隐式解析if let a1 = a{    println(a1)}//创建空字典 //只能存 str 类型let dic = [String:String]()//纯空字典let dics = [:]println(dic)

3.控制流
例如for、while、do while、if、switch等，而且有些前面已经使用过（例如for in循环)

var a=["a","b","c","d","e","f","g"]let b=a[1]/***  switch支持一个case多个模式匹配，同时case后不用写break也会在匹配到种情况后自动跳出匹配，不存在隐式贯穿，如果想要贯穿在case之后添加"fallthrough"关键字*/switch b{case "a","b":    println("b=a or b=b")case "c","d","e","f":    println("b in (c,d,e,f)")default:    println("b=g")}/** * 匹配区间,同时注意switch必须匹配所有情况，否则必须加上default */let c:Int=88switch c{case 1...60:    println("1-60")case 61...90:    println("61-90")case 91...100:    println("91-100")default:    println("1>c>100")}/***  元组匹配、值绑定、where条件匹配*  注意下面的匹配没有default，因为它包含了所有情况*/var d=(x:900,y:0)switch d{case (0,0):    println("d in (0,0)")case (_,0): //忽略x值匹配    println("d in y")case (0,let y)://值绑定    println("d in x,y=\(y)")case (-100...100,-100...100): //注意这里有可能和第一、二、三个条件重合，但是Swift允许多个case匹配同一个条件，但是只会执行第一个匹配    println("x in（0-100），y in （0-100）")case let (x,y) where x==y: //where条件匹配,注意这里的写法等同于：(let x,let y) where x==y    println("x=y=\(x)")case let (x, y):    println("x=\(x),y=\(y)")}

其他语言中通常可以使用break、continue、return（Swift中添加了fallthrough）等来终止或者跳出某个执行语句，但是对于其行为往往是具有固定性的，例如break只能终止其所在的内层循环，而return只能跳出它所在的函数。在Swift中这种控制转移功能得到了加强，那就是使用标签。利用标签你可以随意指定转移的位置

var a=5whileLoop:while --a>0 {    for var i=0;i<a;++i{        println("a=\(a),i=\(i)")        break whileLoop        //如果此处直接使用break将跳出for循环，而由于这里使用标签直接跳出了while，结果只会打印一次，其结果为：a=4,i=0    }}

4 元组
在开发过程中有时候会希望临时组织一个数据类型，此时可以使用一个结构体或者类，但是由于这个类型并没有那么复杂，如果定义起来又比较麻烦，此时可以考虑使用元组。

/** * 元组的基本用法 */var point=(x:50,y:100) //自动推断其类型：(Int,Int)point.x //可以用类似于结构体的方式直接访问元素,结果：50point.y //结果：100point.0 //也可以采用类似数组的方式使用下标访问，结果：50point.1 //结果：100//元组也可以不指定元素名称，访问的时候只能使用下标let frame:(Int,Int,Int,Float)=(0,0,100,100.0)println(frame) //结果：(0, 0, 100, 100.0)//注意下面的语句是错误的，如果指定了元祖的类型则无法指定元素名称//let frame:(Int,Int,Int,Int)=(x:0,y:0,width:100,height:100)var size=(width:100,25) //仅仅给其中一个元素命名size.width //结果：100size.1 //结果：25var httpStatus:(Int,String)=(200,"success") //元组的元素类型并不一定相同var (status,description)=httpStatus //一次性赋值给多个变量，此时status=200，description="success"//接收元组的其中一个值忽略另一个值使用"_"(注意在Swift中很多情况下使用_忽略某个值或变量)var (sta,_)=httpStatusprintln("sta=\(sta)") //结果：sta=200/** * 元组作为函数的参数或返回值，借助元组实现了函数的多个返回值 */func request()->(code:Int,description:String){    return (404,"not found")}var result=request()result.0 //结果：404result.1 //结果：not foundresult.code //结果：404result.description //结果：not found

5 可选类型
所谓可选类型就是一个变量或常量可能有值也可能没有值则设置为可选类型.由于Swift是强类型语言，如果在声明变量或常量时没有进行赋值，Swift并不会默认设置初值

三 函数
函数是一个完成独立任务的代码块，Swift中的函数不仅可以像C语言中的函数一样作为函数的参数和返回值，而且还支持嵌套，并且有C#一样的函数参数默认值、可变参数等。

/** func :声明一个函数:param: sayHi :函数名 可以一样 不过传入的参数会不一样 就能区别:param: name :string 为函数参数:param: - > 箭头指向返回值类型 如果没有返回值 就不用箭头指向:returns: 大括号里是内部实现*/① func sayHi (name:String)->String{    //字符串拼接    return "123\(name)"}let hello = sayHi("Nyx")println(hello)//无返回值 参数为 int 的函数  内部实现打印传入数字② func double (nubmer:Int)->Void{   println(nubmer)}double(200)③ func sayHi (浮点数:Float)->String{    return "\(浮点数*2)"}println(sayHi(2))//let 浮点 = sayHi(12.2)//println(浮点)

2 外部参数

/***  外部参数*/func helloWorld (姓名 name: String){    println("hello,\(name)")}helloWorld(姓名: "Anne")//使用# 简写外部参数 func helloWorld (#name:String){    println("Bye,\(name)")}helloWorld(name: "伊泽瑞尔")

注意事项
1.Swift通过var进行变量定义，通过let进行常量定义（这和其他高级语言比较类似，例如F#）；
2.Swift添加了类型推断，对于赋值的常量或者变量会自动推断其具体类型；
3.Swift是强类型语言（应该说它比C#、Java等强类型语言控制还要严格），不同的数据类型之间不能隐式转化，如果需要转化只能强制转化；