iOS Swift5.1基础学习样例

最新推荐文章于 2022-08-01 17:17:13 发布

FORMAT-qi

最新推荐文章于 2022-08-01 17:17:13 发布

阅读量2.8k

点赞数

分类专栏： Swift

本文链接：https://blog.csdn.net/weixin_46602773/article/details/105049146

版权

Swift 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

前言
swift 基础知识合集
参考：Swift编程

一、基础部分

1.常量和变量

    let a = 10 //声明常亮
    var b = 0 //声明变量
    //1.1常量和变量的命名
    let π = 3.14159
    let 你好 = "你好世界"
    let 🐶🐮 = "dogcow"

2.类型注解

    var str: String
    str = "Hello"
    //2.1定义多个同类型变量
    var red, green, blue: Double

3.数据类型

    //3.1 整数
        //查看对应类型最大值和最小值
        let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型
        let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型
        //int 范围 -2,147,483,648 ~ 2,147,483,647
    //3.2 浮点数 3.14159、0.1 和 -273.15
        // 两种类型都匹配的情况下，将优先选择 Double。
    //3.3 Bool 布尔
        var bool = true
    //3.4 String 字符串
        var hello = "Hello, World!"
    //3.5 Character 字符
        var Character = "C"
    //3.6 类型安全和类型推断
        let length = 42  // 会被推测为 Int 类型
        let pi = 3.14159  // 会被推测为 Double 类型
        let anotherPi = 3 + 0.14159 // 会被推测为 Double 类型

4.数值型类型转换

  		//4.1 整数->浮点
        let three = 3
        let p = Double(three) + 0.1415926
   		//4.2 浮点 -> 整数
        let integerPi = Int(p)

5.类型别名

		 //typealias newname = type
		 typealias Feet = Int
		 var distance: Feet = 100

6. 元组

	    var a = (1,25.5,"hello",true)
		var b: (Int,String) = (1,"hello")
		//取值方法 类数组[] 索引
		print(a.0)//取a元组中的第一个元素
		//赋值方法
		a.0 = 10
		//带参数的元组
		var a = (name1: 10,name2: "nihao")
		a.name1//取值
		//元组拆分
		let (name1,name2) = (10,"你好")
		print(name1) //10
		print(name2) //你好

7. 可选绑定

	    var a: Int? = 10 //打印会出现optional
	    var b: Int?  // 默认为nil
	    // !强制解包
	     print(a!)
	    if let d = Int("123") {
	        print("d赋值成功:\(d)")
	    } else {
	        print("赋值失败")
	    }
	    
	    if let one = Int("4"), let two = Int("42"), one < two && two < 100 {
	        print("\(one) < \(two) < 100")
	    }
	    //输出 4 < 42 < 100

8. 错误处理

	   func makeSomething() throws {
	        // 这个函数有可能抛出错误
	    }
	
	    do {
	        try makeSomething()
	        print("do something成功")
	    } catch{
	        print("do something失败")
	    }

二、基本运算符

+ - * / //基础运算符:加减乘除

==  !=  >  <  >=  <= //比较运算符

&&  ||  !  //逻辑运算符 与或非

a ? b : c  //三元运算符: 如果a为真取b的值 为假取c的值

?? 	      //合并空值运算符 (没有则取一个默认值a ?? b)

(a...b)   //区间运算符

(a..<b)   //半开区间运算符

[2...]    //闭区间的 单侧区间

[..<2]    //半开区间操作符的单侧表达形式

三、字符串和字符

多行字符串

	let str1 = "These are the same."
	let str2 = """
	These are the same.
	"""

多行换行符空白字符串超出部分被包含在多行字符串字面量中

字符串字面量的特殊字符
转义字符 \0(空字符)、\(反斜线)、\t(水平制表符)、\n(换行符)、\r(回车符)、"(双引号)、’(单引号)。
Unicode 标量，写成 \u{n}(u 为小写)，其中 n 为任意一到八位十六进制数且可用的 Unicode 位码。
常用方法

	var str = ""  
	// 检查是否为空
	if str.isEmpty {
    print("str是空字符串")
	}
	// 拼接字符串
	let str1 = "hello"
	let str2 = " world"
	var str3 = str1 + str2
	// 遍历字符串
	for char in "character" {
    print(char)
   var str = "hello";
	//尾部添加
	str.append(" world")
	// str = helloworld
	//插值
	str.insert("!", at: str.endIndex)
	// str = hello world!
	//移除
	str.remove(at: str.index(before: str.endIndex))
	// str = hello world
	//长度
	let range = str.index(str.endIndex, offsetBy: -6)..<str.endIndex
	str.removeSubrange(range)
	// str = hello
     
}

四、集合类型

1. 数组

	//创建
	var a = [1,2,3]
	var b: [String] = ["1","2"]
	var c : Array<Double> = [1.3,2.3]
	var d = Array(repeating: -1,count: 3)//初始值是-1 长度为3
	//增
	a += [4]//[1,2,3,4]
	a.append(5)//[1,2,3,4,5]
	//删
	a.remove(at: 0) // [2,3,4,5]
	//改
	a[0] = 6
	//查
	a[0]
	//插
	a.insert(6,at: 3) //[6, 3, 4, 6, 5]
	//排序
	var array = ["A","B","C","D","E","F"]
	array.sort { (s1, s2) -> Bool in
	    if s1>s2 {
	      return  true
	    }   else  {
	        return  false;
	    }
	}
	//过滤 过滤掉"D"
	array.filter { (item) -> Bool in
	    item == "D"
	}
	//数组的比较
	var array1 = [1,2,3]
	var array2 = [1,2,3]
	if array1 == array2 {
	    print("相等")
	}else{
	    print("不相等")
	}
	//遍历
	var array3 = [1,2,3]
	for item in array3 {
	    print(item)//每个数组中的元素的值
	}
	for index in 0..<array3.count {
	    print(array3[index])
	}

2. Set集合

	var set1 = Set<Character>() //空集合
	var setList = ["A","B","C"]
	//长度
	setList.count
	//插入
	setList.insert("D", at: setList.endIndex)//["A","B","C","D"]
	//删除
	setList.remove(at: 0)//["B","C","D"]
	//是否包含
	setList.contains("B")
	//合并
	let setA: Set<Int> = [1, 3, 5, 7, 9, 8]
	let setB: Set<Int>  = [0, 2, 4, 6, 8]
	let setC: Set<Int>  = [2, 3, 5, 7]
	
	// 方法根据两个集合的所有值创建一个新的集合  重复的会合并
	setA.union(setB).sorted() // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
	//根据两个集合的交集创建一个新的集合
	setA.intersection(setB).sorted() // []
	//不在另一个集合中的值创建一个新的集合
	setA.subtracting(setC).sorted() // [1, 8, 9]
	//根据两个集合不相交的值创建一个新的集合。
	setA.symmetricDifference(setC).sorted() // [1, 2, 8, 9]
	
	// 遍历
	for item in setList {
	    print("\(item)")
	}
	// 有序遍历
	 var setListB = ["2","3","1","5","4"]
	 for item in setListB.sorted() {
	     print("\(item)")
	 }
	
	let setD: Set<String> = ["A", "B"]
	let setE: Set<String> = ["C", "E", "F", "A", "B"]
	let setF: Set<String> = ["G", "H"]
	
	//判断setD中的所有值是否也被包含在setE
	setD.isSubset(of: setE) // true
	//判断setE是否包含setD中所有的值。
	setE.isSuperset(of: setD) // true
	//setE  setF 是否没有交集
	setE.isDisjoint(with: setF)// true

3.字典

	//创建
	var a: Dictionary<String,String> = [:]
	var b: [String: String] = [:]
	var c = [Int: String]();
	
	//基本操作
	a["1"] = "A"; //赋值
	
	a["1"] = "B"//修改
	
	a["2"] = "C"//增加
	a["3"] = "D"//增加
	//删除
	a.removeValue(forKey: "2")
	//a.remove(at: a.startIndex)
	//获取keys  values
	let keyList = [String](a.keys)
	let valueList = [String](a.values)
	//过滤
	a.filter { (key, value) -> Bool in
	if (key == "a") {
	    return false
	}
	    return true
	}
	//循环遍历
	for (key,value) in a {
	    //循环出key和value
	    print(key + ":" + value)
	}

五、控制流


	//1. for-in
	let chars = ["a", "b", "c", "d"]
	for char in chars {
	    print(char)
	}
	//
	let person = ["age": 8, "weight": 130, "heigh": 170]
	for (key, value) in person {
	    print("\(key) : \(value)")
	}
	//
	for index in 1...5 {
	    print("\(index) times 5 is \(index * 5)")
	}
	
	// 2. While 循环
	//While
	var i = 0;
	while i < 5 {
	    i += 1
	    print(i)
	}
	
	// repeat-while
	var j = 0;
	// 先执行后判断
	repeat{
	    j += 1;
	    print(j)
	}while j<5
	
	//3. if
	
	if i>j{
	
	} else if i>j  {
	
	}else{
	    
	}
	//4. switch
	// 4.1 元组  _表示可能的值
	let point = (1, 1)
	switch point {
	case (0, 0):
	    print("\(point) 在原点")
	case (_, 0):
	    print("\(point) 在X轴")
	case (0, _):
	    print("\(point) 在Y轴")
	case (-2...2, -2...2):
	    print("\(point) 在正方形内部")
	default:
	    print("\(point) 在正方形外部")
	}
	
	//4.2 值绑定 case 分支允许将匹配的值声明为临时常量或变量，并且在 case 分支体内使用
	let point1 = (2, 0)
	switch point1 {
	case (let x, 0):
	    print("x : \(x)")
	case (0, let y):
	    print("y :\(y)")
	case let (x, y):
	    print("点 在 (\(x), \(y))")
	}
	//4.3 Where  where 语句来判断额外的条件
	let point2 = (1, -1)
	switch point2 {
	case let (x, y) where x == y:
	    print("(\(x), \(y)) 在 x == y 上")
	case let (x, y) where x == -y:
	    print("(\(x), \(y)) 在 x == -y 上")
	case let (x, y):
	    print("(\(x), \(y))")
	}
	    
	// 4.5
	//continue  立刻停止本次循环，重新开始下次循环
	//break 结束整个循环
	//fallthrough  语句让 case 之后的语句会按顺序继续运行，且不论条件是否满足都会执行。
	//return   直接返回
	//   guard xxx else { return   }  xxx 条件为假 执行else
	//throw  抛出错误

六、函数


	//1,函数的定义
	func test() {
	    print("123")
	}
	//带返回参数(int)的函数  可以被写成一行 return 语句的函数都可以忽略 return。
	func test() -> Int {
	     3
	}
	
	//带返回参数(int)和参数(string)的函数
	func test(value: String) -> Int{
	    print(value)
	    return 3
	}
	//可变参数
	func test(value: String...) {
	    //是个数组
	    for item in value {
	    print(item)
	    }
	}
	//关于 参数名称
	func test(firstValue secondValue: String) {
	}
	//调用
	test(firstValue: "test")
	
	//_符号忽略外部名称 (外部名称和内部名称不能互用 内部名称不能忽略)
	func test(_ name: String){
	}
	test("123")
	
	//  输入输出 函数 inout 标志 外部参数 可以在函数内部改变
	func swapTwoInts(_ a: inout Int, _ b: inout Int) {
	    let temp = a
	    a = b
	    b = temp
	}
	var a = 3
	var b = 107
	swapTwoInts(&a, &b); // a = 107 b = 3
	
	//嵌套函数
	func outFunc(backward: Bool) -> (Int) -> Int {
	    func insideFuncA(input: Int) -> Int { return input + 1 }
	    func insideFuncB(input: Int) -> Int { return input - 1 }
	    return backward ? insideFuncB : insideFuncA
	}
	var num = -6
	let funcC = outFunc(backward: num > 0)
	// moveNearerToZero now refers to the nested stepForward() function
	while num != 0 {
	    print("\(num)")
	    num = funcC(num)
	}
	// -6 -5 -4 -3 -2 -1

七、闭包

	// 语法
	//{(parameters) -> return type in
	//   statements
	//}
	let chars = ["C", "A", "E", "B", "D"]
	
	//函数
	func backward(_ s1: String, _ s2: String) -> Bool {
	    return s1 > s2
	}
	var reversedChars = chars.sorted(by: backward)
	
	// 闭包
	reversedChars = chars.sorted(by: { (s1: String, s2: String) -> Bool in
	    return s1<s2
	})
	
	//简写  参数名称简写 $0 代表第一个参数 。。    单行表达式 省略return
	reversedChars = chars.sorted(by: { $0 > $1 } )
	/*Swift 的 String 类型定义了关于大于号（<）的字符串实现，
	其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值。
	而这正好与 sorted(by:) 方法的参数需要的函数类型相符合。
	因此，可以简单地传递一个大于号，
	Swift 可以自动推断找到系统自带的那个字符串函数的实现*/
	reversedChars = chars.sorted(by: < )
	
	//尾随闭包
	let digitNames = [
	    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
	    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
	]
	let numbers = [16, 58, 510]
	
	let strings = numbers.map {
	    (number) -> String in
	    var number = number
	    var output = ""
	    repeat {
	        output = digitNames[number % 10]! + output
	        number /= 10
	    } while number > 0
	    return output
	}
	
	//逃逸闭包  逃逸闭包的生命周期是长于函数的。
	func getData(closure:@escaping (Any) -> Void) {
	    print("函数开始执行--\(Thread.current)")
	    DispatchQueue.global().async {
	      DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+2, execute: {
	        print("执行了闭包---\(Thread.current)")
	        closure("123")
	      })
	    }
	    print("函数执行结束---\(Thread.current)")
	  }
	getData { (data) in
	    print("闭包结果返回--\(data)--\(Thread.current)")
	}

八、枚举

	//定义
	enum test {
	case A
	case B
	case C
	}
	print(test.A)
	//设置枚举初始值
	enum test1: Int {
	case A = 1
	case B = 2
	}
	print(test1.A.rawValue)
	//遍历枚举
	//令枚举遵循 CaseIterable 协议。
	//Swift 会生成一个 allCases 属性，用于表示一个包含枚举所有成员的集合
	enum test2: CaseIterable{
	case A //0
	case B//1
	}
	//拿到case数组 然后遍历就行了
	var list = test2.allCases;

九、结构体和类

	// 结构体是值类型 赋值给其它对象时 值会被拷贝
	struct Resolution {
	    var width = 0
	    var height = 0
	}
	let vga = Resolution(width: 640, height: 480)
	var cinema = vga
	cinema.width = 2048
	print(vga.width) //640
	print(cinema.width) //2048
	// 类是引用类型
	class VideoMode {
	    var resolution = Resolution()
	    var interlaced = false
	    var frameRate = 0.0
	    var name: String?
	}
	let tenEighty = VideoMode()
	tenEighty.resolution = vga
	tenEighty.interlaced = true
	tenEighty.name = "1080i"
	tenEighty.frameRate = 25.0
	
	let alsoTenEighty = tenEighty
	alsoTenEighty.frameRate = 30.0
	print(tenEighty.frameRate) //30.0
	print(alsoTenEighty.frameRate) //30.0

十、结构体和类

	// 结构体是值类型 赋值给其它对象时 值会被拷贝
	struct Resolution {
	    var width = 0
	    var height = 0
	}
	let vga = Resolution(width: 640, height: 480)
	var cinema = vga
	cinema.width = 2048
	print(vga.width) //640
	print(cinema.width) //2048
	// 类是引用类型
	class VideoMode {
	    var resolution = Resolution()
	    
	    var interlaced = false
	    var name: String = ""
	    var frameRate = 0.0
	    var size : Resolution {
	        get {
	            Resolution(width: resolution.width, height: resolution.height)
	        }
	        set {
	            resolution.width = newValue.width
	            resolution.height = newValue.height
	        }
	    }
	    var totalSteps : Int = 0 {
	        // set 之前调用
	        willSet(newTotalSteps) {
	            print("将 totalSteps 的值设置为 \(newTotalSteps)")
	        }
	        // set 之后调用
	        didSet {
	            if totalSteps > oldValue  {
	                print("增加了 \(totalSteps - oldValue) 步")
	            }
	        }
	    }
	}
	let tenEighty = VideoMode()
	tenEighty.resolution = vga
	tenEighty.interlaced = true
	tenEighty.name = "1080i"
	tenEighty.frameRate = 25.0
	print(tenEighty.size) //Resolution(width: 640, height: 480)
	tenEighty.size = Resolution(width: 100, height: 100)
	print(tenEighty.size) //Resolution(width: 100, height: 100)
	
	let alsoTenEighty = tenEighty
	alsoTenEighty.frameRate = 30.0
	print(tenEighty.frameRate) //30.0
	print(alsoTenEighty.frameRate) //30.0
	alsoTenEighty.totalSteps = 200
	// 将 totalSteps 的值设置为 200
	// 增加了 200 步