swift基本使用
swift语句后面没有分号，不过就算不小心加了分号也不会报错，但是为了语法的规范不能加分号
引框架的时候没有分号 直接写上框架名就行
swift中输出使用print
swift中字符串不用加 @ 符号
常量与变量
// 常量和变量
// 在Swift中声明变量或者声明常量的时候可以不用写变量或常量类型，因为系统会帮我们自动推导出对应的类型
// Swift中如果要在一条语句后面再加上一条语句必须用分号来分隔，但是不建议这种写法
// 变量
var a = 10; a = 20
// 常量
let b = 10
// b = 20
// 在swift中我们的变量名可以使用表情或者中文来表示，再原来的OC中是不可以的
var 😀 = 20
var 王 = 30
😀 + 王
// 当我们的变量等于一个浮点型数的时候，系统会自动推导成一个 Double 类型
var c = 99.2
// Swift中的类型
var zhengxing:Int = 100
var fudianxing:Float = 99.1
var zifuchuan:String = "aa"
// Character 为字符类型 就是只有一个字符 和C语言中的char类型
var erjie:Character = "z"
// Swift中不支持隐式转换
// 在OC中强制转换 (float)a 但在swift中是 Float(a)
Float(zhengxing) + fudianxing
字符串
var yu = "我是一只快乐的小鱼"
// 在Swift中 BOOL值不再是YES和NO了 而是 true 和 false
var isTrue = true
// 判断字符串是否为空
isTrue = huangyu.isEmpty
// Swift中字符串可以看做是字符的集合 那么 怎么求字符串的长度
yu.characters.count
// 求字节的长度
yu.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
// 在Swift中字符串的第二种写法
var abc = "x"
var abcd = String("x")
// 拼接字符串
print(abc + abcd)
// 在Swift中打印可以把对象或者变量直接写在括号中
print(abc)
// 判断2个字符串是否相等
abc == abcd
// 大小写转换
let str = "hello"
str.uppercaseString
str.lowercaseString
// 格式化创建字符串
let str2 = String(format: "%02d:%02d", 1, 2)
let str3 = String(format: "%02d-%02d", arguments: [1, 2])
print(str2)
print(str3)
str2.substringToIndex(<#T##index: Index##Index#>)
//字符串的其他操作全部转化为NSString再去操作
// 转换
let str4:NSString = str2 as NSString
数组
var arr1:Array = ["A", "2", "3", "4"];
var arr2 = ["1", "b", "3"];
// 声明一个空的数组，数组中的元素都是String类型
var arr3 = Array()
var arr4 = [String]()
// 数组遍历 for-in(明确的指出数组的类型)
for temp in array1 as [String] {
print(temp)
}
// 元祖遍历(index为数组下标，value为下标对应数组中的值)
for (index, value) in array1.enumerate()
{
print("index = \(index), value = \(value)")
}
// 添加元素
arr2 += ["forever"]
arr2.append("!")
arr2.appendContentsOf(["!", "!"])
// 在某个下标下添加元素
arr2.insert("cc", atIndex: 0)
arr2.insertContentsOf(["结婚"], at: 0)
// 删除最后元素
arr2.removeLast()
// 删除指定下标下的元素
arr2.removeAtIndex(0)
// 删除所有元素
arr2.removeAll()
字典
var dic1: Dictionary= ["a" : 10]
var dic2 = ["b" : 20]
// 空的字典
var dic3: Dictionary= [:]
var dic4 = Dictionary()
dic3 = ["b" : "c"]
dic3.removeValueForKey("b")
// 删除所有
dic3.removeAll()
// 如果一个值可能为nil，那么这个值就是可选类型，用？标识
// Optional包围的就是一个可选类型
// 可选类型不能直接使用，必须进行强制解包，!强制解包，对nil强制解包会造成crash
// unexpectedly found nil while unwrapping an Optional value 对一个空的可选类型进行强制解包
// (a1 ?? "234")对可选类型进行判断，如果可选类型值为nil，则给他一个默认值
var a1:String?
a1 = "12345"
print(a1!.characters.count)
print((a1 ?? "234").characters.count)
循环结构
for var i = 0; i < 10; i++
{
print(i)
}
// [0, 10]
for j in 0...10
{
print(j)
}
// [0, 10)
for j1 in 0..<10
{
print(j1)
}
var j2 = 10
while (j2 < 100) {
// 在Swift 3 以后不能使用 i++ 要写成 i+=1
j2 += 1
print(j2)
}
// repeat..while
repeat {
j2 += 1
} while j2 < 1000
判断
if a == 10
{
print("123")
}
else {
print("456")
}
// 可选类型的条件分支
let str:String? = "hello"
// (1) if-let是对可选类型的判断 如果可选类型为空则不执行代码块， 如果不为空则用tempStr来接收此刻这个可选类型解包后的值
if let tempStr = str {
print(tempStr)
}
// (2) if-let-where跟if-let相似，where是对前面定义的这个局部变量再做一层判断
if let tempStr = str where tempStr.characters.count > 2 {
print(tempStr)
}
// guard-let-else
// 如果可选类型str为nil，则执行code代码块，最后一定要return，如果不为nil则强制解包后的值赋值给tempStr，这样在{}外卖就可以使用tempStr
guard let tempStr = str else {
// code
return
}
tempStr......
switch
// switch 不局限判断整型，可以是浮点型，也可以是字符串等等
// switch 后面的小括号可以省略，大括号不能省略
// case 后面至少要有一条执行语句！！！并且case后面的大括号可以省略，break可以不写，不会造成贯穿
// default一定要写，并且只能写在最后
let f = 3.2
switch f {
case 3.0:
print("===3.0")
case 3.1:
print("===3.1")
case 3.2:
print("===3.2")
default:
print("unknow")
}
枚举
// (枚举值可以关联任意类型,没有默认的关联值)
// 关联如果是整型的话，会默认递增上去， 如果不是Int， 必须每个枚举值都关联上
enum Month:Int {
case January = 10
case February
case March
case April
}
// 如果明确指出一个变量/常量是属于那种枚举类型的话，可以直接.枚举赋值
let month = Month.February // let month:Month = .january
var month1 = Month.January
month1 = .February
switch month {
case .January:
print("hashValue = \(month.hashValue), rawValue = \(month.rawValue)")
print(month)
case .February:
print("hashValue = \(month.hashValue), rawValue = \(month.rawValue)")
print(month)
case .March:
print("hashValue = \(month.hashValue), rawValue = \(month.rawValue)")
print(month)
case .April:
print("hashValue = \(month.hashValue), rawValue = \(month.rawValue)")
print(month)
}
函数
// 有参无返
// 当方法有参数时， 第一个参数名不显示 要在前面加上
func test2(num1 num1: Int, num2: Int)
{
print(num1 + num2)
}
test2(num1: 2, num2: 3)
// 有参有返
func test3(num1 num1: Int, num2: Int) -> Int
{
return num1 + num2
}
test3(num1: 4, num2: 5)
// 元祖作为返回值
func yuanzu(num1 num1: Int, num2: Int) -> (Int, Int)
{
return (num1 + num2, num1 * num2)
}
yuanzu(num1: 10, num2: 10)
// 函数的嵌套
func test4()
{
print("1")
func test5()
{
print(2)
}
test5()
}
test4()
闭包 （block）
// {
// (参数名：参数类型...) -> 返回值类型
// in
// code, 执行代码
// }
// 无参无返
let closure = {
() // () -> () () -> Void
in
print("无参无返")
}
closure()
// 有参无返
let closure1 = {
(str:String, str1:String) -> Void
in
print("有参无返\(str), \(str1)")
}
closure1("hello", "world")
// 无参有返
let closure2 = {
() -> String
in
return "无参有返"
}
print(closure2())
// 有参有返
let closure3 = {
(str:String, str1:String) -> String
in
return str + str1
}
print(closure3("有参有返", "world"))
