随着Swift逐渐趋于稳定,越来越多的公司开始使用Swift写程序,所以现在越来越多的公司需求这方面的人才.
下面我来跟大家分享一下我自己对Swift的基本理解
swift的基本认识
// 跟iOS的OC比起来
// swift语句后面没有分号, 不小心加了也不会保存
// swift导入框架头文件的时候没有尖括号, 直接写
// swift中输出不用加@
// 在swift中, 没有.h 和.m文件, 只要一个.swift文件
// 不需要引入头文件, 除非是系统的头文件
// print比NSLog强大很多
// let: 常量 var: 变量
let a:Int = 12
let str = "hello"
// swift中不支持隐式转换
// OC中强转:(float)a swift中强转: Float(a)
print(Float(a))
// 在swift中, BOOL值不再是YES和NO,而是true和false
var isTrue:Bool = true
一. 字符串
// 判断字符串是否为空
var testString = "呵呵哒"
isTrue = testString.isEmpty
// swift中字符串可以看做是字符的集合,求字符串的长度
testString.characters.count
// 转码
//str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
// 大小写转换
str.uppercaseString
str.lowercaseString
// 打印拼接字符串
//print("123 \(str)222")
let str2 = String(format: "%d:%d", 1,2)
let str3 = String(format: "%d-%d", arguments: [6,8])
let str4 = "asdasdasd"
//print(str2)
//print(str3)
// 字符串剪切
//str4.substringFromIndex(<#T##index: Index##Index#>)
// 转换
let str5: NSString = str2 as NSString
// 判断两个字符串是否相等
print(s1 == s2)
// 交换值
var str1 = "a"
var str2 = "b"
swap(&str1, &str2)
二. 数组
// 不可变数组
let array1 = ["1","2","C","D"]
let array2: [String] = ["1","2","C","D"]
let array3 = [String]()
print(array1)
print(array2)
print(array3)
// 元素个数
array1.count
// 数组遍历 (for - in 遍历要明确指出数组的类型)
for temp in array1 as [String]
{
print(temp)
}
// 元祖遍历
for (index, value) in array1.enumerate()
{
print("index = \(index), value = \(value)")
}
// 可变数组
var mArray = [String]()
// 数组的拼接
mArray.append("krystal")
mArray.append("jessica")
//mArray.append(12)
//print(mArray)
// 数组的删除
// 删除个数
mArray.removeFirst(0)
//print(mArray)
三. 字典
let dic = ["key1":"value1", "key2":"value2", "key3":"value3"]
// 通过key值访问value值
//print(dic["key1"])
// for - in 遍历
for (tempKey, tempValue) in dic
{
print("key = \(tempKey), value = \(tempValue)")
}
// 可变字典
var dic1 = ["key":"value"]
// 字典的合并
for (tempKey, tempValue) in dic
{
// 如果key存在,更新键值对,如果不存在,则增加键值对
dic1[tempKey] = tempValue
}
//print(dic1)
var dic2= ["b":10]
// 删除指定key对应的value
dic2.removeValueForKey("b")
// 删除所有
dic2.removeAll()
// 元祖, 类似C里的结构体, 可以存放字符串,数组,字典,而且可以存放在一起
var aaa = ("b",["a","b","c"],["a","b"])
print(aaa.0)
print(aaa.1)
print(aaa.1[0])
print(aaa.2)
四. 可选类型: ! 和 ?
// ? 可选性 (有值 没值)
// 其实 ?本质上是一个枚举, 有两种状态 optional(有值) optional(没值)
// 如果一个值可能为空, 则是可选类型, 用?
// 可选类型不能直接使用, 必须强制解包, 用!
// 对一个空的可选类型进行解包会引起crash
var a1: String?
a1 = "12345"
//print(a1!)
// (a2 ?? "123")对可选类型进行判断, 如果值为空,给它一个默认值
var a2: String?
a2 = "45678"
//print((a2 ?? "123").characters.count)
五. 选择结构
// 1.if语句
// {}一定不能省略
// if 没有非零即真的概念, 不可以不写判断语句
let b = 10
if b > 5
{
print("b > 5")
}
else
{
print("b < 5")
}
// 可选类型的条件分支
let str6 : String? = "vampire"
// 1. if - let
// if - let: 对可选类型的判断, 如果可选类型为空,则不执行代码块, 如果不为空则用tempStr接收这个可选类型解包后的值
if let tempStr = str6
{
print(tempStr)
}
// 2. if - let - where
// 跟 if - let相似, where是前面定义的tempStr再做一层判断
if let tempStr = str6 where tempStr.characters.count > 2
{
print("tempStr.length = \(tempStr.characters.count)")
}
// 3. guard - let - else
// 如果str为空, 进入代码块执行,最后一定要return; 如果不为空, 强制解包赋值给tempStr, 以便使用
guard let tempStr = str else
{
// code
return
}
tempStr....
2. switch语句
// (1)switch在 OC中 和 在Swift中的区别: 不局限于判断整形, 可以使浮点型, 也可以是字符串
// (2)switch后的()可以省略, {}不可以
// (3)case后至少有一条执行语句
// (4)case后的{}可以省略, break可有可无, 不会造成贯穿
// (5)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("unknown")
}
3. 枚举
// 可以关联浮点型, 字符串, 没有默认的关联值
// 关联的如果是Int类型, 会默认递增, 如果不是, 必须每个枚举都关联上对应的值
enum month:Float
{
case January = 11.0
case February = 11.1
case March = 11.2
case April = 11.3
}
// 如果明确指出一个变量/常量属于哪种类型的话, 可以直接 .枚举值
let months = month.January
//let months: month = month.January
//let months: month = .January
var month1 = month.January
month1 = .March
// hashValue: 第几个
// rawValue: 对应的值
switch month1
{
case .January:
print("hashValue = \(month1.hashValue), rawValue = \(month1.rawValue)")
print(month1)
case .February:
print("hashValue = \(month1.hashValue), rawValue = \(month1.rawValue)")
print(month1)
case .March:
print("hashValue = \(month1.hashValue), rawValue = \(month1.rawValue)")
print(month1)
case .April:
print("hashValue = \(month1.hashValue), rawValue = \(month1.rawValue)")
print(month1)
}
六.循环结构
/*该写法在Swift2.2版本后已被废弃
for(var i = 0; i < 5; i++)
{
}
*/
for var i = 0; i < 5; i++
{
print(i)
}
// 0...5 -> [0,5] 0..<5 -> [0,5)
for i in 0..<5
{
print("i = \(i)")
七. 闭包
/*
{
(参数名: 参数类型) -> 返回值类型
in
code
}
*/
// 无参无返
let block = {
() -> Void in
print("无参无返")
}
block()
// 有参无返
// tempStr: 外部参数
// Swift3.0版本后不可用
let block1 = {
(tempStr1 str1: String, tempStr2 str2: String) -> Void in
print("有参无返: \(str1), \(str2)")
}
block1(tempStr1: "a", tempStr2: "b")
let block2 = {
(str1: String, str2: String) -> Void in
print("有参无返: \(str1), \(str2)")
}
block2("krystal", "jessica")
// 无参有返
let block3 = {
() -> String in
print("无参有返")
return "无参有返"
}
print(block3())
// 有参有返
let block4 = {
(a: Int, b: Int) -> Int in
print("有参有返: \(a), \(b)")
return a + b
}
print(block4(3, 2))
八. 函数
/*
func 方法名(参数名:参数类型)
{
code
}
*/
// 函数的四种类型
// 1. 无参无返
func test()
{
print("呵呵哒")
}
test()
// 2. 无参有返
func test1() -> Int
{
return 10
}
print(test1())
// 3. 有参无返
func test2(num1: Int, num2: Int)
{
print(num1 + num2)
}
test2(2, num2: 3)
// 4. 有参有返
func test3(num1: Int, num2: Int) -> Int
{
return num1 + num2
}
print(test3(10, num2: 10))
// 5. 元祖作为返回值
func yuanzu(num1: Int, num2: Int) -> (Int, Int)
{
return (num1 + num2, num1 * num2)
}
print(yuanzu(5, num2: 6))
// 输入两个字符串, 输入一个闭包(将刚才输入的两个字符串当做参数, 并且返回一个拼接好的新的字符串)
func cString(str1: String, str2: String, block5:(tempStr1: String, tempStr2: String) -> String)
{
// 执行闭包
let string3 = block5(tempStr1: str1, tempStr2: str2)
print(string3)
}
cString("你好", str2: "haha") { (tempStr1, tempStr2) -> String in
return "\(tempStr1)\(tempStr2)"
}
未完待续.....
持续更新中.............
