Swift基础教程(一)

Swift基础教程(一)

1. 集合Set

• 特点:

  • 没有顺序
  • 统一类型
  • 内容不能重复

• 集合的使用

  import Foundation
  
  // 声明方法1:
  var s:Set<Int> = [1, 2, 3, 4, 4]
  print(s) // 实际只有[1,2,3,4]
  
  // 声明方法2(推断声明):
  var s1 = Set([1, 2, 3, 4])
  
  // 集合的方法
  print(a.count) // 输出集合数量
  print(a.isEmpty) // 集合是否为空
  
  // 集合插入数据, 返回两个值, c是布尔值， 代表是否成功， d是插入的值.
  var (c, d) = a.insert(6) // (true, 6)
  
  // 插入方法2.
  a.update(with: 11) // 强行插入.
  
  // 移除
  a.remove(11)	
  
  // 移除所有:
  a.removeAll()  
  print(a)		// 
  
  
  

• 集合的运算

  • 集合的加(并)运算

    var a = Set([1,2,3,4])
    var b = Set([3,4,5,6])
    var c = a.union(b)
    print(c) 	// [1,2,3,4,5,6]
    

  • 集合的减元素

    var a = Set([1,2,3,4])
    var b = Set([3,4,5,6])
    var c = a.subtracting(b)
    print(c) 	// [1,2]
    

  • 集合的交运算

    var a = Set([1,2,3,4])
    var b = Set([3,4,5,6])
    var c = a.intersection(b)
    print(c) 	// [3,4]
    

  • 集合的异或运算

    var a = Set([1,2,3,4])
    var b = Set([3,4,5,6])
    var c = a.symmetricDifference(b)
    print(c) 	// [1,2,5,6]
    

  • 子集判断

    var a = Set([1,2,3,4])
    var b = Set([2])
    var isSub:Bool = b.isSubset(of: a) // b集合是否是a集合的子集
    print(isSub) // true
    

  • 超集判断

    var a = Set([1,2,3,4])
    var b = Set([2])
    var isSuper:Bool = a.isSuperset(of: b) // a集合是否是b集合的超集?
    print(isSuper) // true
    

  • 集合的随机数

    var a = Set([1,2,3,4])
    print(a.randomElement()) // 随机获取一个元素;
    

  • 集合的变换运算(.map())

  • 集合的排序(.sorted())

  • 集合的洗牌.shuffled()

  • 集合的遍历(同Array)

    // 直接输出.
    for item in a {
        print(item)
    }
    
    // 输出下标和值.
    for (k, v) in a.enumerated() {
        print(k, v)  //实质小标无意义
    }
    
    // 不用参数，则遍历的项可以通过$0获取
    a.forEach {
        print($0) 
    }
    a.forEach { item in
        print(item)
    }
    
    

2. 字典(Dictionary)

key-value， key不能重复, value类型需要一致

• 字典的声明, key仅仅只能有 Int, String, Bool

  var a1:Dictionary<Int, String> = [:] // 声明一个空字典
  var a2:Dictionary<Int, String> = [1:"apple", 2:"orange"] // 声明一个有内容字典
  var a3:Dictionary<String, String] = ["张三":"apple"]
  var a4:Dictionary<Bool, String> = [true:"apple", false:"orange"]
  
  // 字典类型自己推断声明
  var a5 = ["张三":"篮球", "李四":"乒乓求"]
  

• 字典的访问

  var a = ["张三":"篮球", "李四":"乒乓求"]
  var hobby = a["张三", default:""] // 直接访问key,可能没有，所有需要跟一个默认值
  
  

• 字典的属性和方法

  var a = ["张三":"篮球", "李四":"乒乓求"]
  print(a.count)
  print(a.isEmpty) 
  

• 字典的遍历

  var a = ["张三":"篮球", "李四":"乒乓求"]
  for (k, v) in a {
      print(k, v)
  }
  // 只遍历key
  for k in a.keys {
      print(k)
  }
  // 只遍历值
  for v in a.values {
      print(v)
  }
  a.forEach{
      print($0, $1)
  }
  a.forEach { k, v in
      print(k, v)
  }
  

• 字典其他方法

  • 字典随机(randomElement)

    print(a.randomElement()?? 0)
    let e1 = a.randomElement() // 返回的是可选值(Optional)
    
    使用解包方式
    let e2 = a.randomElement()! // e2将不再是可选值，而是实际值.
    
    

3. 区间

通常用在for语句和数组下标中.

for index in 1...3 {
    print(index)
}

• 区间的定义

  var a = 1...3	// 1, 2, 3    ClosedRange<Int>
  var b = 1..<3	// 1, 2		  Range<Int>
  var c = ...3    // ...到3     PartialRangeThrough<Int>
  var d = ..<3    // ...到3, 不包含3. PartialRangeUpTo<Int>
  var e = 1...    // 从1开始    PartialRangeFrom<Int>
  var f = "a"..."z"	//       ClosedRange<String>		
  var g = 0.0...10.0  //       ClosedRange<Double>
  
  var h = stride(from: 10, to: 100, by: 2) // StrideTo<Int>
  
  var g1:Range<Int> = 1..<3
  var g2:ClosedRange<Int> = 1...3
  

• 区间使用

  var a1 = ["a", "b", "c", "d", "e", "f"]
  print(a1[...3])
  

• 区间的遍历++++++++++++++++++++++++++++

  var a = 5...10
  // 只能对闭合区间，才能够进行遍历. 对 "a"..."z"也无法进行遍历.
  for i in a {
      print(i)
  }
  print(a.contains(11)) // false
  
  var c = ...5
  print(c.contains(-1000)) // true
  
  print(a.count)  // 输出区间a的长度， 如果是开区间，则会编译错误
  print(a.isEmpty) // 只对于闭区间有用
  print(a.lowerBound)	// 下标
  print(a.upperBound) // 上标
  

4. 元组

var p1 = (10, 20)
// 指定类型
var p2:(Int, Int) = (20, 20)
// 自动推断
var p3 = ("张三", 1, 29, 180)
print(type(of: p3))

// 元组另外写法
var position = (x: 30, y: 40)
print(position)

var p4 = (name:"张三", sex:1, age:29, height:180)

// 访问元素
// 1. 通过下表访问
print(p1.0, p1.1)
// 2. 通过名字
print(p4.name, p4.height)

// 元组的解包
let (x, y) = position // x和y的名字可以和position中名字一致.
// 如果只需要一个，则另一个为_, 但是个数要一致
let (x, _) = position
// 如果拥有多个元素的元组，被一个元素解包，则输出的还是那个元组
let (v) = position 
print(v)   // (x: 30, y: 40)

5. 可选项

很多对象，可能有值，也可能为空，比如一个字符串，一个数字， 或者一个对象，我们通常会判断是否为空.

var i = Int("10")   // 将字符串转换成整形，可能转换成功，也可能转换失败.
print(type(of: i)) 	// Optional<Int>
print(i) 			// Optional(10)
let v:Int = i!  	// 将可选类型进行解包成Int.
print(v)  			// 10

// 显示声明可选类型, 类型+?
var a:String? = "a"
print(type(of: a))

// 上述声明等效于
var b:Optional<String> = "b"
print(type(of: b))

// 初始化一个可选项为具体值
var n1:Int? = Optional.som(10)
print(n1!)
// 初始化一个可选项为空
var n2:Int? = Optional.none
print(n2)  // 因为n2是nil, 不能直接解包
// 判断可选是否为空
print(n2 == nil) //true

// 
var x1:Int? = 10
// 判断>10则输出
if a > 10 { 		// 因为a可能为空， 直接判断a>10会语法错误，因此不能直接这样进行比较.
    print("a > 10")
}

// if (let b = a) 这样写会有语法错误
if let b = a {
    if b > 10 {
        print("a > 10")
    }
}

// 判断字符串前缀
var s:String? = "ProductA"
if(s?.hasPrefix(prefix:"Pro")) {
    
}
if(let b = s?.hasPrefix(prefix:"Pro")) {
    if(b) {
    	print("有前缀")
    }
}
// 使用空和字符串更方便
print(s??"")