1.新建Xocode Swift 程序
2.(基本使用)
在Swift中没有.h 和.m文件 只有一个.Swift文件 在Swift中不需要引入头文件
swift的命名不能使用保留字和箭头/开头不能用数字,没有其它任何规定,甚至都可以使用小狗小猫命名.
print 的性能比NSLog要好用很多 而且他可以自动换行 很强大
//swift中 输出使用的print
//Switf中字符串不用加 @ 和分号 符号
print("Hellow Word !")
① let 和var 使用
1.1 let 定义常量,var 定义变量,let定义的必须在声明时指定初始值,普通的var声明也必须赋初始值
可以在一行同时声明多个常量或变量,用逗号隔开;如果每个常量对应一个var或let只需要用分号隔开即可.
每个常量和变量都一定会有固定的类型,如果没有指定类型,swift会根据后面的赋值类型来推断.
//这是变量a
var a = 10;a = 20
//常量
let b = 10
//Switf 中我们的变量名可以使用表情或者中文来表示 再原来的OC中是不可以的
var 🐶 = 20
var 小明 = 30
//当我们的变量等于一个小数点的时候 他会自动给我们推到成Double 类型
var c = 99.0
let a:Int = 12;
var str = "hello"
1.2 Switf 中的类型
var a:Int = 100
var b:Float = 99.0
var c:String = "小二"
//Character为 字符类型 就是只有一个字符 和C语言中的char相似
var d:Character = "z"
1.3 字符串
var huangyu = "我是一只快乐的小鱼啊"
//在Switf中 BOOL值不再是YES 和NO 而是True 和false
var isTrue:Bool = true
//判断字符串是否为空
isTrue = huangyu.isEmpty
//Switf 中字符串可以看做字符串 的集合 那么怎么求字符串的长度？？？
//求字节的长度
huangyu.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
//求字符串的长度
huangyu.characters.count
//在Switf中字符串的第二种写法,两种写法都代表空的 不同的写法
var 🐌 = ""
var abcd = String()
//拼接字符串
var a = "王伟"
var b = "xiaomi"
a + b + "123"
//在Switf中打印可以把对象或者变量直接写在括号里
print(a)
a == b ///判断两个字符串是否相等
//交换两个字符串
var smile = "smile"
var cry = "cry"
swap(&smile, &cry)
smile
cry
var happy = smile
smile = cry
cry = happy
大小写转化
str.uppercaseString;//大写
str.lowercaseString;//小写
两个字符串相等 （==）
let string1 = "hello"字符串通过加法运算符（+）连接在一起：
let string2 = "you"
var welcome = string1 + string2 //值为hello you
也可以通过加法赋值运算符（+=）将一个添加到一个几经存在字符串变量上：
var string = "hai"
string += string2 //值为hai you
也可以用append方法将一个字符附加到一个字符串变量的尾部：
let exclamationMark: Character = "!"
welcome.append(exclamationMark) //值为 hello you !
注意：
您可以用append方法将一个字符附加到一个字符串变量的尾部：
字符串插值
插入字符串面量的每一项都在以反斜线为前缀的圆括号中：
let a = 3
let b = "\(a) times 2.5 is \ (Double(a) * 2.5)"
// b 是 "3 times 2.5 is 7.5"
1.4 数组
var array1:Array = ["小米","拼接","校园"]
var array2 = ["小袁","hate","小米"]//声明一个空的数组 驻足中的元素都是String类型
var array3 = Array()
//声明一个空的String类型的数组
var array4 = [String]()
array2[1] = "love"
//向数组后面添加元素
array2 += ["何必","那么","认真"]
array2.append("123")
//只能添加一个数组
array2.appendContentsOf(["678","890"])
//插入元素
//在某个小标添加元素
array2.insert("结婚", atIndex: 0)
//在某个下标添加数组
array2.insertContentsOf(["他们结婚了,快发红包"], at: 0)
//删除最后元素
array2.removeLast()
//删除对应下标元素
array2.removeAtIndex(0)
//删除数组中所有元素
array2.removeAll()
//把数组类型提出来1.5 字典
let array1:[String] = ["A","2","3","4"]
// ()代表初始化 相当于oc里面的 init/initWith
//数组里面的是字符串格式
let array2 = [String]（）
//可变数组
var mutableArray = [String]()
mutableArray .append("hello")
mutableArray.append("world")
//mutableArray.append(23)
print(mutableArray)
//数组中遍历 for-in(明确的指出数组元素的类型)
for temp in array1{
print(temp)
}
//数组中遍历 for-in(明确的指出数组元素的类型)
for temp in array0 as [String]{
print(temp)
print(temp.characters.count)
}
//元组遍历 拿到下标
for (index,value) in array0.enumerate()
{
print("index = \(index),value = \(value)")
1.5 字典
var dict1: Dictionary= ["a":10]var dic1 = ["b":20]//空的字典var dict3 :Dictionary= [:]var dict31 :Dictionary= [:]var dict32 = Dictionary()
dict3 = ["b" : "c"]
//删除对应下标,key对应的Value
dict3.removeValueForKey("b")
//删除所有
dict3.removeAll()
/for - in 遍历
for (tempKey, tempvalue) in dict
{
print("key = \(tempKey),value = \(tempvalue)")
}
//可变字典
var dict3 = ["key":"value"]
//字典的合并 通过遍历合并
for (tempkey,tempValue) in dict
{
//如果key存在 则是一个更新键值对的操作 如果不存在 则是增加一个键值对的操作
dict3[tempkey] = tempValue;
}
print(dict3)
1.6 元组（元组 类似C语言中的结构体 他可以存放字符串字典 数组 而且可以存放在一起）
var aaa = ("b" , ["a":"b"],["a","b","c"],"a")
aaa.0
aaa.1
aaa.2[2]
aaa.3
②循环
2.1、 for in 循环
//在Switf3.0之前可以这样写
for var v = 0 ;v < 10 ; v ++
{
}
for var v = 0; v < 10; v ++
{ print(v)
}
在Switf3.0之后可以这样写
//[0,10]
for f in 0...10
{
print(f)
}
//[0,10)
for f1 in 0..<10
{
print(f1)
}
//条件分支
//if 条件语句（）可以省略 ，{}不可以省略
//if 没有非零即真的概念
let tempValue = 10
if tempValue > 5{
print("tempValue > 5")
}
//可选类型的条件分支3种
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.length = \(tempStr.characters.count)")
}
//(3)guard - let -else( 守护)
//如果可选类型Str为nil ，则执行code代码块 最后一定要把return ，如果不为nil 则强制解包后的值赋给tempStr，这样{}外面就可以使用tempStr
//guard let tempStr = Str else{
// return
//}
// tempStr.........
2.2 while循环
var f2 = 10
while (f2 < 100)
{
// 在Switf 3之后 不能使用i++要写成 i+=1
f2 += 1
print(f2)
}
//repeat..while
repeat{
f2 += 1
}while (f2 < 1000)
2.3判断
if (a == 10)
{
print("123")
}else{
print("456")
}
③ 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 Month1:Int {
case January = 10
case February
case March
case April
}
//关联整型
enum Month:Int {
case January
case February
case March
case April
}
float类型
enum Month:Float {
case January = 10.1
case February = 11.2
case March = 11.3
case April = 11.4
}
//如果明确指出一个变量/常量是属于哪种枚举类型的话 可以直接.枚举值赋值，否则就 枚举类型.枚举值
let month:Month = Month.January
let month1:Month = .January
var month2 = Month.February
month2 = .January
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)
}
⑤ ？ 和 ！的用法和区别
？： 表示 可选性 即 有值 没有值；
let a :Int? //这样是没有任何意义 但是var 是可以的
//其实 ？ 本质上是一个枚举 有两种状态 optional（有值） potional（没值）
var a :Int? //代表初值为nil
print(a)
//var a: Int? = 10
//print(a)
! 代表肯定有值，当声明变量的时候 后面没有 ？ 的话，必须给一个初值
var a:Int! = 10
print(a)
解包/强制解包 解包：有很多种方式 但是解包有很多种缺陷 如果我们强制解包了 那个值没有初值 那么程序就会崩溃
var a: Int? = 10
var b = a!
print(b)
print(a!)
var a:Int? = 10
var b: Int! = a
print(b)
//强制解包
var a:Int? = 10
var b = a
print(b!)
这种初值为0 强制解包 造成程序崩溃
var a:Int?
var b = a
print(b!)
⑥ 函数（四种形式）
//无参数无返回值
func test()
{
print("i love swift")
}
//无参数有返回值
//OC - (int)test1;
func test1() -> Int
{
return 10
}
test1()
//有参数无返回值
//当方法有参数的事后 第一个参数名 不显示 要在前面加上参数名
func test2(num1 num1: Int,num2 :Int) {
print(num1 + num2)
}
test2(num1: 10, num2: 20)
/有参数有返回值
func test3(num1 :Int,num2 :Int) ->Int
{
return num1 + num2
}
test3(10, num2: 10)
//元祖作为返回值
func yuanzu(num1 :Int,num2 :Int) -> (Int,Int)
{
return (num1 + num2,num1 * num2)
}
yuanzu(10, num2: 10)
//函数的嵌套
func test4()
{
print("1")
func test5()
{
print("2")
}
test5()
}
test4()
/*
外部参数：外面调用的饿时候 能够看到的是参数
内部参数 内部进行运算的事后需要用到的参数
func test(外部参数1 内部参数1: Int,外部参数2 内部参数2 : Int) ->返回值
{
return 内部参数1 +内部参数2
}
test6(外部参数1: 10, 外部参数2: 10)
*/
func test6(num1 a :Int,num2 b:Int) -> Int {
return a + b
}
test6(num1: 10, num2: 10)
//在函数中 所有的参数类型都是let来修饰的，所以我们要改变的话 就必须再不声明一个 Var变量
//inout 修饰相当于 我们之前的指针变量 让外界传进来一个值 来修改我们的值
func test7(inout num1 :Int,num2 :Int) {
num1 = 100
print(num1 + num2)
// return num1 + num2
}
var number1 = 10
var number2 = 10
test7(&number1, num2: number2)
//简单52626计算器
//要求使用外接传入两个数 和一个的符合 + - * /来进行计算结果
//要求使用函数嵌套
func jisuanqi (num1 :Float,fuhao:Character ,num2:Float) -> Float
{
switch (fuhao) {
case "+":
func jia(a :Float, b:Float)->Float{
return a + b
}
return jia(num1, b: num2)
case "-":
func jian(a :Float, b:Float)->Float{
return a - b
}
return jian(num1, b: num2)
case "*":
func cheng(a :Float, b:Float)->Float{
return a * b
}
return cheng(num1, b: num2)
case "/":
func chu(a :Float, b:Float)->Float{
return a / b
}
return chu(num1, b: num2)
default:
return 0
}
}
⑦ 闭包（类似block 形式）
/*
int (^aaa)(int a,int b) = ^{
}
*/
/*闭包格式 闭包作用回调传值
var 闭包变量 ={
（参数名：参数类型）-> 返回值类型 in
代码块
}
*/
var max = {
(a: Int,b:Int)->Int in
return a > b ? a : b
}
print(max(10,20))
var stringLenth = {
(string:String) -> Int in
return string.characters.count
}
print(stringLenth("12300"))
// 输入两个字符串，输入一个闭包（将刚才输入的两个字符串当做参数，并且返回一个拼接好的新的字符串）
func combineString(str1:String,str2:String,closure:(tempStr1:String,tempStr2:String) -> String) {
combineString("hello", str2: "world") { (tempStr1, tempStr2) -> String in
return "\(tempStr1)\(tempStr2)"
}
//闭包执行
let string =
closure(tempStr1:str1,tempStr2:str2)
print(string)
}
//定义一个方法 （输入参数color,frame,closure(是将刚才的color，frame
//当做参数，返回一个UIView)）,返回一个UIView,添加到View上
func setFunc(color:UIColor,frame:CGRect,closure:(tempColor:UIColor,tempFrame:CGRect) -> UIView) -> UIView {
let view:UIView = closure(tempColor:color,tempFrame:frame)
return view
}
let view:UIView =
setFunc(UIColor .blueColor(), frame: CGRectMake(0, 0, 375, 667)) { (tempColor, tempFrame) -> UIView in
let view = UIView()
view.backgroundColor = tempColor
view.frame = tempFrame
return view
}
view.addSubview(view)
//swift里面不写self 一般只有在闭包内部才会强制要求写self
*/
⑧ 懒加载
//懒加载一个控件
/*
lazy var 变量名：变量类型 = {
code
return
}
*/
lazy var btn:UIButton = {
var tempBtn = UIButton(type:UIButtonType.ContactAdd)
tempBtn.frame = CGRectMake(80, 100, 60, 60)
tempBtn.backgroundColor = UIColor.greenColor()
return tempBtn
}()
3.单例
① 创建一个类
//单例写法一
/*
let s1 = singleDog.shareSingleDog
s1.name = "wangqiang"
let s2 = singleDog.shareSingleDog
print(s2.name)
*/
//单例写法二
/*
let s3 = singleDog.shareSingleDog()
s3.name = "zhangsan"
let s4 = singleDog.shareSingleDog()
print(s4.name)
*/
4.异常捕获
1.创建 json文件
2.在viewController中viewDidLoad进行数据解析json文件
let path = NSBundle.mainBundle().pathForResource("iOS04", ofType: "json")
let data:NSData = NSData(contentsOfFile: path!)!
do{
let rootArray = try NSJSONSerialization.JSONObjectWithData(data, options: .MutableContainers) as! [[String :String]]
print(rootArray)
}catch{
//异常捕获 序列化出错的时候就自动来到这里
print("error")
}
3.创建一个类作为model
//字典转模型 模型中如果有基本数据类型的话 基本数据类型不可以为可选类型，否则在KVC赋值中会找不到对应的key值，如果可选类型话 应该给初始值
var age:Int = 0
var gender:String?
//字典转模型
init(dict:[String:AnyObject]) {
super.init()
setValuesForKeysWithDictionary(dict)
}
// 如果自定义了初始化方法并且没有实现系统默认的初始化方法，那么外界访问不到该类的默认初始化方法，想要访问的花必须手动实现
// override init() {
// super.init()
// }
