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"))