Swfi基础1

Swift不要求在每行语句的结尾使用分号(;)，但当你在同一行书写多条语句时，必须用分号隔开 :

var myString="Hello, World!";print(myString)

Optional 是一个含有两种情况的枚举，None和Some(T)，用来表示可能有或可能没有值。任何类型都可以明确声明为（或者隐式转换）可选类型。当声明一个可选类型的时候，要确保用括号给？操作符一个合适的范围。例如，声明可选整数数组，应该写成([Int])?；写成Int[]?会报错。

整型字面量

整型字面量可以是一个十进制，二进制，八进制或十六进制常量。 二进制前缀为 0b，八进制前缀为 0o，十六进制前缀为 0x，十进制没有前缀：
以下为一些整型字面量的实例：

let decimalInteger=17         // 17 - 十进制表示 
let binaryInteger=0b10001     // 17 - 二进制表示
let octalInteger=0o21         // 17 - 八进制表示
let hexadecimalInteger=0x11   // 17 - 十六进制表示

1.25e2 表示 1.25 ⨉ 10^2，也就是 125.0；同样，1.25e－2 表示 1.25 ⨉ 10^－2，也就是 0.0125。

字符串型字面量

字符串型字面量由被包在双引号中的一串字符组成，形式如下：
"characters"
字符串型字面量中不能包含未转义的双引号 （"）、未转义的反斜线（\）、回车符或换行符。
转移字符含义

\0空字符
\\反斜线 \
\b退格(BS) ，将当前位置移到前一列
\f换页(FF)，将当前位置移到下页开头
\n换行符
\r回车符
\t水平制表符
\v垂直制表符
\'单引号
\"双引号
\0001到3位八进制数所代表的任意字符
\xhh...1到2位十六进制所代表的任意字符

以下为字符串字面量的简单实例：

let stringL="Hello\tWorld\n\n全栈教程官网：\'http://www.jser.com\'"
print(stringL)

以上程序执行结果为：

Hello   World
全栈教程官网：'http://www.jser.com'

控制语句描述

continue 语句
告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。
break 语句
中断当前循环。
fallthrough 语句
如果在一个case执行完后，继续执行下面的case，需要使用fallthrough(贯穿)关键字。

字符串函数及运算符

Swift 支持以下几种字符串函数及运算符：

**isEmpty:**判断字符串是否为空，返回布尔值
**hasPrefix(prefix: String):**检查字符串是否拥有特定前缀
**hasSuffix(suffix: String):**检查字符串是否拥有特定后缀。
**Int(String):**转换字符串数字为整型。 实例:
let myString: String = "256"
let myInt: Int? = Int(myString)
**String.characters.count:**计算字符串的长度

遍历字符串中的字符

Swift 的 String 类型表示特定序列的 Character（字符） 类型值的集合。 每一个字符值代表一个 Unicode 字符。
您可通过for-in循环来遍历字符串中的characters属性来获取每一个字符的值：
for ch in"Hello".characters { print(ch) }

创建数组

以下实例创建了一个类型为 Int ，大小为 3，初始值为 0 的空数组：

var someInts = [Int](count: 3, repeatedValue: 0)
var someStrs=[String()
someStrs.append("Apple")
someStrs+=["Google"]
// enumerate() 以元组的形式遍历数组
for (index, item) in someStrs.enumerate() {print("在 index = \(index) 位置上的值为 \(item)")}
可以通过只读属性 isEmpty 来判断数组是否为空

移除 Key-Value 对

我们可以使用removeValueForKey()方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值，如果不存在返回 nil 。实例如下：

var someDict:[ Int : String]=[1:"One",2:"Two",3:"Three"]
var removedValue=someDict.removeValueForKey(2)

遍历字典

我们可以使用for-in循环来遍历某个字典中的键值对。实例如下:

var someDict:[Int: String]=[1:"One",2:"Two",3:"Three"]
for ( key, value) in someDict {print("字典 key \(key) -  字典 value \(value)")}

使用只读的count属性来计算字典有多少个键值对
通过只读属性isEmpty来判断字典是否为空
输入输出函数
定义一个输入输出参数时，在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。

fun cswapTwoInts (inouta: Int, inoutb: Int){
    let = a
    a = b
    b = t
}
var x =0,y =100
print("x =\(x) ;y =\(y)")

swapTwoInts(&x, b:&y)
print("x =\(x) ;y =\(y)")

函数嵌套

函数嵌套指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。
实例如下：

func calcDecrement(forDecrement total:Int)->()->Int{
    var overallDecrement=0
    func decrementer()->Int{
        overallDecrement-=total
        return overallDecrement
   }
    return decrementer
}
let decrem=calcDecrement(forDecrement:30)
print(decrem())

以上程序执行输出结果为：

-30
sort 函数

sort(:)方法会返回一个与原数组大小相同,包含同类型元素且元素已正确排序的新数组，原数组不会被sort(:)方法修改。
sort(_:)方法需要传入两个参数：
1.已知类型的数组
2.闭包函数，该闭包函数需要传入与数组元素类型相同的两个值，并返回一个布尔类型值来表明当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回true，反之返回false。
实例

let names=["AT","AE","D","S","BE"]
// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards( s1:String, s2:String)>Bool{
    returns1>s2
}
var reversed=names.sort(backwards)
print(reversed)

以上程序执行输出结果为：

["S", "D", "BE", "AT", "AE"]

如果第一个字符串 (s1) 大于第二个字符串 (s2)，backwards函数返回true，表示在新的数组中s1应该出现在s2前。 对于字符串中的字符来说，"大于" 表示 "按照字母顺序较晚出现"。 这意味着字母"B"大于字母"A"，字符串"S"大于字符串"D"。 其将进行字母逆序排序，"AT"将会排在"AE"之前。
参数名称缩写功能
您可以直接通过$0,$1,$2来顺序调用闭包的参数。
实例

let names = ["AT","AE","D","S","BE"]
var reversed = names.sort({$0>$1})
print(reversed)

$0和$1表示闭包中第一个和第二个String类型的参数。
以上程序执行输出结果为：

["S", "D", "BE", "AT", "AE"]

如果你在闭包表达式中使用参数名称缩写, 您可以在闭包参数列表中省略对其定义, 并且对应参数名称缩写的类型会通过函数类型进行推断。in 关键字同样也可以被省略.
尾随闭包
尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。

func someFunctionThatTakesAClosure(closure:()->Void){
    // 函数体部分
}
// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure({
   // 闭包主体部分
})
// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(){
    // 闭包主体部分
}

结构体应用

在你的代码中，你可以使用结构体来定义你的自定义数据类型。
结构体实例总是通过值传递来定义你的自定义数据类型。
按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：
1 结构体的主要目的是用来封装少量相关简单数据值。
2 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
3 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
结构体不需要去继承另一个已存在类型的属性或者行为。
举例来说，以下情境中适合使用结构体：

• 几何形状的大小，封装一个width属性和height属性，两者均为Double类型。
• 一定范围内的路径，封装一个start属性和length属性，两者均为Int类型。
• 三维坐标系内一点，封装x，y和z属性，三者均为Double类型。

在实例方法中修改值类型

Swift 语言中结构体和枚举是值类型。一般情况下，值类型的属性不能在它的实例方法中被修改。
但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择变异(mutating)这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。
方法还可以给它隐含的self属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。

struct area{
    var length = 1
    var breadth = 1
    func area()->Int{
        return length*breadth
   }
    mutating func scaleBy(res:Int){
        length *= res
        breadth *= res
        print(length)
        print(breadth)
    }
}
var val=area(length:3,breadth:5)
val.scaleBy(3)
val.scaleBy(30)
val.scaleBy(300)