iOS-Swift3常用语法

常量和变量

在swift中规定:在定义一个标识符时必须明确说明该标识符是一个常量还是变量
使用let来定义常量,定义之后不可以修改
使用var来定义变量,定义之后可以修改

//定义标示符表明是变量还是常量!
//let  常量
let age : int = 24
//var  变量
var name = "qiuxuewei"
var pi:double = 3.1415

注意事项:
常量:是指向的对象不可以再进行修改.但是可以通过指针获得对象后,修改对象内部的属性
在真实使用过程中,建议先定义常量,如果需要修改再修改为变量(更加安全)

//定义常量view 和 btn 可以利用指针指向的不可修改的对象,对对象内属性进行更改,推荐使用let定义常量
let view = uiview(frame: cgrect(x: 16, y: 64, width: 100, height: 100))
view.backgroundcolor = uicolor.red

let btn = uibutton(type: uibuttontype.custom)
btn.frame = cgrect(x: 8, y: 8, width: 64, height: 64)
btn.settitle("确定", for: uicontrolstate.normal)
btn.backgroundcolor = uicolor.green
view.addsubview(btn)

swift中数据类型

swift中的数据类型也有:整型/浮点型/对象类型/结构体类型等等
整型

有符号

常用:int : 和平台相关(默认,相当于oc的nsinteger)
int8 : 有符号8位整型
int16 : 有符号16位整型
int32 : 有符号32位整型
int64 : 有符号64位整型

无符号

uint : 和平台相关(常用,相当于oc的nsuinteger)(默认)
uint8 : 无符号8位整型
uint16 : 无符号16位整型
uint32 : 无符号32位整型
uint64 : 无符号64位整型

浮点型

float : 32位浮点型
double : 64浮点型(默认)

// 定义一个int类型的变量m,并且赋值为10
var m : int = 10
// 定义一个double类型的常量n,并且赋值为3.14
let n : double = 3.14

swift是强类型的语言
swift中任何一个标识符都有明确的类型
即如果将一变量定义为整型,就不可对他进行浮点型的赋值

// 定义变量时没有指定明确的类型,但是因为赋值给i一个20.20为整型.因此i为整型
var i = 20
// 错误写法:如果之后赋值给i一个浮点型数值,则会报错
// i = 30.5

// 正确写法
var j = 3.33
j = 6.66

swift中在进行基本运算时必须保证类型一致

//对不同类型的变量/常量进行运算需要将其转化为相同类型的
let a = 20
let b = 13.14
let c = double(a) + b
print(c)

逻辑分支

分支即if/switch/三目运算符等判断语句,通过分支语句可以控制程序的执行流程

if语句

在swift的判断句中必须有明确的真假
不再有非0即真
必须有明确的bool值
bool有两个取值:false/true

//判断句必须有真假值
var d:int = 2;
if d != 0 {

}else{

}

var score = 99
if score < 60 {
    print("不及格")
}else if score < 80{
    print("及格")
}else if score < 100{
    print("优秀")
}else{
    print("毕业")
}

//可选类型,因为只有声明成可选类型后,才可以判断是否为空
let ifview :uiview? = uiview();

if ifview != nil{
    print("有")
}else{
    print("没有")
}

三目运算符

跟oc格式保持一致

//三目运算符
a == score ? a : score

guard

guard是swift2.0新增的语法
它与if语句非常类似，它设计的目的是提高程序的可读性
guard语句必须带有else语句，它的语法如下：
当条件表达式为true时候跳过else语句中的内容，执行语句组内容
条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw

guard 条件表达式 else {
    // 条换语句
    break
}
语句组

//guard
var age = 18
func online(age:int) -> void{
    guard age >= 18 else {
        print("回家去")
        return
    }
    print("可以上网")
}
online(age: age)

switch

//switch 用法
//sex:0 -> 男  sex:1 -> 女
let sex = 0
//普通用法 - case后可以不跟break(默认会有break)
switch sex{
case 0:
    print("男")
case 1:
    print("女")
default:
    print("未知")
}

//可判断多个值
switch sex{
case 0,1:
    print("正常人")
    //如果case穿透需要加此关键字
//    fallthrough
default: break
//    print("不正常")
}

//如果希望出现之前的case穿透,则可以使用关键字fallthrough
let sex = 0

switch sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}

//浮点型的switch判断
let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}

//可判断字符串
let sexstr = "人妖"
switch sexstr {
case "男":
    print("男")
case "女":
    print("女")
default:
    print("人妖")
}

//区间判断
//swift中的区间常见有两种
//开区间:0..<10 表示:0~9,不包括10
//闭区间:0...10 表示:0~10
score = 59
switch score{
case 0..<60:
    print("不及格")
case 60..<80:
    print("及格")
case 80...100:
    print("优秀")
default: break
}

循环

for循环

在swift3以后摒弃了c语言常用的 var i = 0; i < 6; i++ 格式

//for 循环
//0-4循环
for i in 0 ..< 5  {
    print(i)
}
//0-5循环
for i in 0 ... 5  {
    print(i)
}
//2次循环不需要变量
for _ in 0 ..< 3{
    print("hello world!")
}

while循环

while的判断句必须有正确的真假,没有非0即真

var aa = 0
while aa < 10 {
    //在swift3以后摒弃了 a++ 操作 改为 a+=1
    aa += 1
}
print(aa)

repeat while循环

swift中将 do-while 改为 repeat-while

var bb = 0
repeat {
    print(bb)
    bb += 1
} while bb < 10

字符串

oc和swift中字符串的区别
在oc中字符串类型时nsstring,在swift中字符串类型是string
oc中字符串@”“,swift中字符串””
使用 string 的原因
string 是一个结构体，性能更高
nsstring 是一个 oc 对象，性能略差
string 支持直接遍历
swift 提供了 string 和 nsstring 之间的无缝转换

//字符串
let str = "i am qiuxuewei"

//遍历字符串
for cc in str.characters{
    print(cc)
}

//字符串截取 将string转化为nssring 操作 (xxx as nsstring)
let myname = (str as nsstring).substring(from: 5)


//字符串与其他类型数据拼接
let tempheight : double = 1.83
let tempheight1 = "身高 \(tempheight) cm"
let tempheight2 = "身高" + "\(tempheight)" + "cm"

//字符串格式化 - 用于保留n位小数或格式化时间格式
let min : int = 9;
let doc : int = 8;

//let time : string = string(format: <#t##string#>, arguments: <#t##[cvararg]#>)
let time: string = string(format: "%02d分 : %02d秒", arguments: [min, doc])

数组

数组（array）是一串有序的由相同类型元素构成的集合
数组中的集合元素是有序的，可以重复出现
swift中的数组
swift字典类型是array，是一个泛型集合

数组分成:可变数组和不可变数组
使用let修饰的数组是不可变数组
使用var修饰的数组是可变数组

//数组
//b不可变数组
let arr1 : [string] = ["邱学伟","王珂惠","妈妈"]
let arr2 = ["邱学伟","王珂惠"]
let arr3 = ["邱学伟","烟台大学","不羁阁","疯火科技"]

//可变数组
var arrm1 = arr3;
var arrm2 : [any] = ["身高",1.83 ]


//添加元素
arrm1.append("10000000")

//删除元素
//删除最后一个元素并且会把最后一个元素返回
arrm1.removelast()
//移除指定下标元素
arrm1.remove(at: 0)


/遍历数组
//通过下标遍历
for i in 0..

字典

字典允许按照某个键来访问元素 字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合 键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的 swift中的字典 swift字典类型是dictionary，也是一个泛型集合

swift中的可变和不可变字典 使用let修饰的数组是不可变数组 使用var修饰的数组是可变数组

//字典
//不可变字典
let dict1 : dictionary = ["name":"邱学伟" as anyobject,"age":24 as anyobject]
let dict2 : [string : anyobject] = ["name" : "邱学伟" as anyobject, "height" : 1.83 as anyobject]
let dict3 : [string : any] = ["name" : "邱学伟", "age" : 24]

//可变字典
var dictm1 : dictionary
var dictm2 : [string : any]
var dictm3 = ["name" : "邱学伟", "age" : 24] as [string : any]

//操作字典
//增
dictm3["height"] = 1.83

//删
dictm3.removevalue(forkey: "age")

//改
dictm3["老婆"] = "王珂惠"

//遍历字典
//key
for key in dictm3.keys{
//    print(key)
}

//value
for value in dictm3.values {
//    print(value)
}

//key和value
for (key,value) in dictm3 {
    print(key , value)
}

//字典合并
var dictm4 = ["学历" : "本科","电话" : "110"] as [string : any]
for (key,value) in dictm3 {
    dictm4[key] = value
}

元祖

swift新增数据类型 类似于数组或者字典 可以用于定义一组数据

//定义元组 常用作函数的返回值
let tuple2 = (crazyfire1 : "zar",crazyfire2 : "扩散",person : 6) //常用的定义方法 
let tuple1 = ("zar","扩散","wish",6);
let (crazyfire1,crazyfire2,person1,personnumber) = ("zar","扩散","wish",6)

//用法
tuple2.crazyfire1

let error = (errorcode : 404, errorinfo : "not found")
print(error.errorcode)
print(error.errorinfo)

可选类型

在oc开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型) 在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强语言) 但是开发中赋值nil,在所难免.因此推出了可选类型

可选取值: 有值/空值

//可选类型
//错误写法!//var optionalnameerror : string = nil
//正确定义写法
//定义方法1:
var optionalnameright : string? = nil
//定义方法2:
var optionalname : optional
class person{
    var optionalname : optional
}

//可选类型拆包
optionalname = "xiaoming"

//一般在拆包时需要对可选类型进行判断,是否为空
//此种写法容易产出崩溃点
let xxxname = "呵呵哒的" + optionalname!

//定义
var phonenum : string?


phonenum = "+86 110"

//swift中如果进行强制解包操作会崩溃,所以在解包的时候需要进行判断
if phonenum != nil{
    var changephonenum = "new" + phonenum!
}

//可选绑定,判断phonenum是否有值,1如果没有值直接跳过,2如果有值拆包后将值赋值给tempphonenum
if let tempphonenum = phonenum {
    print("解包后有值")
}

//可选类型应用场景
let urlstring = "www.qiuxuewei.com"
let url : nsurl? = nsurl(string: urlstring)

//创建nsrequest对象
//需要先判断可选类型数据是否有值
if url != nil{
    let request = nsurlrequest(url: url! as url)
}

if let tempurl = url {
    let request = nsurlrequest(url: tempurl as url)
}

函数

即为oc中的方法 定义格式:

func 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
}

函数的四种类型:

//函数
//1.没有参数,没有返回值
func run() -> void{
    print("跑跑跑...")
}
run()

//其中如果函数木有返回值, " -> void "可以省略!
func run2() {
    print("省略后,跑跑跑...")
}
run2()


//2.有参数,没有返回值
func callphone(phone : string) -> void{
    print("打电话给 \(phone)")
}
callphone(phone: "110")

func callphone2(phone : string){
    print("打电话给 \(phone)")
}
callphone2(phone: "119")

//3.没有参数,有返回值
func readmsg() -> string{
    return "今天早起学习了么?"
}
print(readmsg())

//4.有参数,有返回值
func add(number1 : double, number2 : double) -> double{
    return number1 + number2
}
print(add(number1: 100, number2: 9.99))

默认参数 某些情况,如果没有传入具体的参数,可以使用默认参数

//默认参数
func makesport(type : string = "篮球") -> void{
    print("打\(type)")
}
makesport()
makesport(type:"排球")

可变参数 swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数 它们必须具有相同的类型 我们可以通过在参数类型名后面加入（…）的方式来指示这是可变参数

//可变参数
func sum(numbers : double...) -> double{
    var total : double = 0.00
    for number in numbers {
        total += number
    }
    return total
}
print(sum(numbers: 1,2,3))

引用类型(指针的传递) 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要在函数内部将传递值设置为变量 因为需要在内部改变其值

//交换两个值
//值传递
func swap1( a:double, b:double){
    var b = b
    var a = a

    let temp = a
    a = b
    b = temp

    print("交换后: a\(a) ,b\(b)")
}
swap1(a: 1, b: 9)

类

//类
class person : nsobject{

    //存储属性
    //1>如果类型是结构体或类,定义为可选类型
    //2>如果是基本数据类型,定义时直接初始化0 / 0.0
    var name : nsstring?
    var age = 0
    var height = 0.00

}

class student : person {

    //存储属性
    var chinesescore = 0.0
    var mathscore = 0.0

    //计算属性,由其他属性值计算而来
    var totalscore : double{
        //可省略get
//        get{
            return chinesescore + mathscore
//        }
    }

    var avgscore : double{
        return ( chinesescore + mathscore ) * 0.5
    }

    //类属性,设置或者获取属性值必须通过类名进行获取
    static var scorecount : int = 2;
}

let stu = student();
stu.name = "邱学伟"
stu.age = 18
stu.chinesescore = 119
stu.mathscore = 120
stu.totalscore
stu.avgscore
student.scorecount

自定义构造函数

class animal : nsobject{
    var type : string?
    var name : string?

    //自定义构造函数
    init(type : string, name : string) {
        self.type = type;
        self.name = name;
    }
}

let cat = animal(type: "猫", name: "咪咪")
cat.type
cat.name

字典转模型式自定义构造函数

//字典转模型 构造方法
class dog : nsobject{
    var master : string = ""
    var age : int = 0

    init(dict : [string : any]) {
        self.master = dict["master"] as! string
        self.age = dict["age"] as! int
    }
}
let 哈士奇 = dog(dict: ["master" : "邱学伟", "age" : 10])
哈士奇.master
哈士奇.age

swift支持类的继承,此写法是继承自其他类本类的构造方法

//字典转模型 构造方法
class dog : animal{
    var master : string = ""
    var age : int = 0

    init(dict : [string : any]) {
        super.init(type: "猫科", name: "二哈")
        self.master = dict["master"] as! string
        self.age = dict["age"] as! int
    }
}
let 哈士奇 = dog(dict: ["master" : "邱学伟", "age" : 10])
哈士奇.type
哈士奇.name
哈士奇.master
哈士奇.age

类的运算符重载

在java中熟悉的语法,大多数人都不会陌生 注意在自定义的类中不可以继承自nsobject, nsobject是用oc封装的,有大量oc语法特性.

class person: anyobject {
    //运算符重载:
    func sum(num1 : int,num2 : int) -> int {
        return num1 + num2
    }
    //参数类型不同
    func sum(num1 : double,num2 : double) -> double {
        return num1 + num2
    }
    //参数个数不同
    func sum(num1 : int,num2 : int,num3 : int) -> int {
        return num1 + num2 + num3
    }
}