iOS-Swift3常用语法

转载请注明出处:http://blog.csdn.net/qxuewei/article/details/52862160

常量和变量

在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..//    print(arrM1[i])
}

//直接遍历元素值
for item in arrM1{
//    print(item)
}

//区间遍历
arrM1.append("老婆")
for item in arrM1[0..<2]{
//    print(item)
}

//数组合并 必须相同类型数组
let arr01 = ["小码哥","黑马",7000] as [Any]
let arr02 = ["邱学伟","努力"] as [Any]
let arr03 = arr01 + arr02

字典

字典允许按照某个键来访问元素
字典是由两部分集合构成的，一个是键（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<String>
class person{
    var optionalName : Optional<String>
}

//可选类型拆包
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
    }
}