Swift基础语法

Swift初体验

/// MARK for循环

// 没有OC中的 for（int i = 0 ; i < 10 ; i++）

for i in 0..<9 {

    print(i)

}

for _ in 0..<9 {

    print("Hello, playground")

}

/// MARK while 和 repeat while(OC中的do while)

var a = 10

while a > 0 {

    print(a)

    a-=1

}

repeat {



    print(a)

    a += 1

}while a < 10

/// MARK 字符串

// 遍历字符串

for c in str {

    print(c)

}

// 字符串的拼接

let str1 = "小码哥"

let  str2 = "是教育机构"

let str3 = str1 + str2

// 字符串和其他标识符之间的拼接

let name = "cm"

let age = 18

let height = 1.75

let info = "my name is \(name) , my age is \(age) , my height is \(height) "

// 字符串格式化

let min = 2

let second = 8

String(format: "%02d:%02d", arguments: [min, second])

// 截取字符串

let urlString = "https://www.baidu.com"

// 1.将String类型转换成NSString类型

let headrStr = (urlString as NSString).substring(to: 5)

let middleStr = (urlString as NSString).substring(with: NSRange(location: 5, length: 3))

let footerStr = (urlString as NSString).substring(from: 8)

/// MARK 数组

// 定义数组

// 不可变数组 let修饰标识符定义出来的数组是不可变数组

let array = ["cm", "hm", "cym"];

// 可变数组 var修饰符定义出来的数组是可变数组

//var arrayM = Array<String>()

var arrayM = [String]() // 常用创建可变数组的方法

// 可变数组的操作(增删改查)

// 添加元素

arrayM.append("cm")

arrayM.append("hm")

arrayM.append("cym")

arrayM.append("ch")

arrayM.append("xgx")

arrayM.append("cyp")

// 删除元素

arrayM.remove(at: 0)

arrayM

// 修改元素

arrayM[0] = "cm"

arrayM

// 取出某个元素 只能通过角标取出

arrayM[1]

// 遍历数组

// 1.根据角标来遍历

for i in 0..<arrayM.count {

    print(arrayM[i])

}

// 2.直接遍历元素

for name in arrayM {

    print(name)

}

// 3.遍历数组中的前几个元素

// 3.1 第一种

for i in 0..<2 {

    print(arrayM[i])

}

// 3.2 第二种(常用)

for name in arrayM[0..<3] {

    print(name)

}

// 数组的合并(相同类型的数组才能用“+”合并)

let resultArray = arrayM + array

let array1 = [123, 321, "cm"] as [Any]

let array2 = ["hm"]

let array3 = array1 + array2

// MARK 字典

// 定义字典

// 不可变字典

let dict = ["name":"cm", "age":"18", "height":"1.75"]

// 可变字典 NSObject一般用于创建对象 AnyObject一般指定类型

var dictM = [String: AnyObject]()

// 可变字典的操作(增删改查)

// 1.添加元素

dictM["name"] = "cm" as AnyObject

dictM["age"] = 18 as AnyObject

dictM["height"] = 1.75 as AnyObject

dictM["weight"] = 90 as AnyObject

dictM

// 2.删除元素

dictM.removeValue(forKey: "weight")

// 3.修改元素

// 如果字典中已经存在了对应的key，则直接修改key中的Value

// 如果字典中没有对应的key, 则直接添加对应的键值对

dictM["name"] = "hm" as AnyObject

dictM

// 获取某个元素 直接通过对应的Key获取

dictM["age"]

// 遍历字典

// 遍历所有的key

for key in dictM.keys {

    print(key)

}

// 遍历所有的Value

for value in dict.values {

    print(value)

}

// 遍历所有的键值对

for (key, value) in dictM {

    print(key)

    print(value)

}

// 字典的合并(即使类型相同也不能用“+”合并)

for (key,  value) in dict {

    dictM[key] = value as AnyObject

    // 需要注意的是：如果合并的字典中有key和被合并的字典中的key相同，则会直接修改被合并的字典中的key对应的value
}

dictM

/// MARK 元组

// 一种数据结构

// 使用

let userInfo = ("cm", 18, 1.88)

userInfo.0

userInfo.1

// 可以给元组每一个元素起一个别名

let userInfo1 = (name : "cm", age: 18, height: 1.88)

userInfo1.name //(userInfo1.0)

userInfo1.age

userInfo1.height

/// MARK 可选类型

// *重点* swift中有规定:对象中的任何属性在创建对象时，都必须有明确的初始化值

// 定义的方式

class Student : NSObject {

    // 1>不常用的方式

    var name : Optional<String> = nil

    // 2>语法糖(常用)

    var age : String? = nil

    var height : Double? = nil
}

var student = Student()

// 给可选类型赋值

student.name = "cm"

student.age = "18"

//student.height = 1.88

// 取出可选类型中的值(强制捷报，需要注意的是，在强制解包前先对可选类型进行非nil判断)

if student.height != nil {

    print(student.height!)

}

print(student.name!, student.age!)

// 可选绑定

if let name = student.name {

    print(name)

}

// 可选类型的应用场景

// 通过字符串创建一个NSURL对象

let url = NSURL(string: "https://www.baidu.com")

let url1 : NSURL? = NSURL(string: "https://www.baidu.com")

if let url1 = url1 {

    let request = NSURLRequest(url: url1 as URL)

}

// 函数的使用注意

内部参数:只有在内部才可以看到对应的参数名称

外部参数:在调用时可以看到参数名称

1> 默认情况函数的第一个参数是内部参数:只有在内部才可以看到

2> 默认情况下,从第二个参数开始,即是内部参数也是外部参数

3> 如果一个参数想要成为外部参数,可以在参数名前加标示即可

4> 如果一个参数,不要想外部参数,则可以在参数名称前,加_

/// MARK 函数

// 没有参数，没有返回值

func about() {

    print("iphoneXR");

}

// 有参数，没有返回值

func callPhone(name:String, tel:Int) {

    print("打电话给\(name)\(tel)")

}

// 没有参数，有返回值

func readMessage() -> (String) {

    return "有返回值"

}

// 有参数，有返回值

func sum(num1: Int, num2: Int) ->Int {

    return num1 + num2

}

about()

callPhone(name: "cm", tel: 13720327550)

readMessage()

sum(num1: 11, num2: 22)

/// MARK 类的定义

// 面向对象的基础是类，类产生了对象

// class是是swift中的关键字，用于定义类。注意：1.定义的类是可以没有父类,那么该类是rootclass 2.通常情况下，定义类时,继承NSObject(非OC的NSObject)

class Preson :NSObject {

    var age : Int = 0

    override func setValue(_ value: Any?, forUndefinedKey key: String) {

    }
}

let p = Preson()

p.age = 18

print(p.age)

// 类的属性定义

class StudentInfo : NSObject {

    var name : String? = nil

    var age : Int = 0



    var mathScore : Double = 0.0

    var chineseScore : Double = 0.0



    // 定义计算属性：通过别的方式计算得到结果的属性，称为计算属性

    var averageScore : Double {

        return (mathScore + chineseScore) * 0.5

    }



    // ==> 定义方法，可以返回平均成绩

    func getAverageScore() -> Double {

        return (mathScore + chineseScore) * 0.5

    }



    // 定义类属性：类属性是和整个类相关的属性,而且是通过类名进行访问的

    static var courseCount : Int = 0

}

StudentInfo.courseCount = 2

// 创建对象

let studentInfo = StudentInfo()

// 给对象的属性赋值

studentInfo.name = "cym"

studentInfo.age = 10

studentInfo.mathScore = 90

studentInfo.chineseScore = 100

print(studentInfo.averageScore)

/// MARK 类的定义

class Person : NSObject {

    var name : String?

    var age : Int = 0

    var height : Double = 0.0

}

let p = Person()

// 注意:赋值不是调用set方法,直接拿到属性给属性赋值

p.name = "why"

p.age = 18

p.height = 1.88

// Swift懒加载使用lazy关键字来修饰属性

    // 在属性后面跟= {}进行具体的赋值

    lazy var names : [String]? = {

        // () -> ([String]) in

        print("加载数据")

        return ["cym", "cm", "hm"]

    }()