Swift 数据类型的使用（一）

数组、字符串、元组

数组-###

• 数组的创建

var testArray1: Array<Int> = Array<Int>()
var testArray2: [Int] = []
var testArray3 = [Int]()
var testArray4 = testArray3

• 数组遍历

1.最普通的遍历

let testArray = ["one","two","three","four","five","six"]
for vaule in testArray {
   print(vaule)
}

2.遍历的时候，同时获得索引和值
//使用数组对象的enumerated()方法，它会返回一个Sequence对象，包含了每个成员的索引和值。

let testArray = ["one","two","three","four","five","six"]
for (index, value) in testArray.enumerated() {
   print("\(index): \(value)")
}

3.通过闭包closure，我们可以使用Array的forEach方法来遍历数组

let testArray = ["one","two","three","four","five","six"]
   testArray.forEach { (vaule) in
       print(vaule)
}

4.map 、compactMap、 filter 遍历数组

///map 数组中的值经过一系列变换输出新数组
let fractionArray: [Int] = [40,53,59,43,56,54,33,55,66,70,22,69]
let finallyArray: [Int] = fractionArray.map {
   return $0 + 30
}
// [70, 83, 89, 73, 86, 84, 63, 85, 96, 100, 52, 99]

///compactMap方法是map的升级版,在遍历数组的同时，去除其中的nil值。
let lsArray: [Int] = testList.compactMap { (num) -> Int? in
   return num
}
///filter 数组通过筛选返回新数组
let arr = [1,5,6,7,10,0]
//写法1
let arr1 = arr.filter { (item) -> Bool in
   return item % 2 == 0
}       
//写法2
let resultArray = arr.filter { return $0%2 == 0 } 
//写法3
let arr2 = arr.filter({return $0%2 == 0})

• index(符合条件的索引)：返回int值

let arr = [1,5,6,7,10,0]
//写法1：swift 4.0
let index = arr.index(where: {$0 == 1})
               
//swift4.2  firstIndex:从前往后遍历

let index2 = arr.firstIndex(where:{$0 == 1})

let index3 = arr.firstIndex { (item) -> Bool in
       return item == 1
}
               
//lastIndex:c从后往前遍历
let index4 = arr.lastIndex(where:{$0 == 1})
               
let index5 = arr.lastIndex(of: 5)
if index5 != nil{
       print("打印一下")
}

• contains(包含)：返回bool值

let arr = [1,5,6,7,10,0]
//写法1
let isContains = arr.contains(where: {$0 == 3})
//写法2
let isContains1 = arr.contains { (item) -> Bool in
       return item == 100
}
//写法3 直接调用函数
arr.contains(10)
print(arr.contains(3))

• 数组的简易操作

finallyArray.reduce(0, +)//Int类型数组之和
finallyArray.min() // 52
finallyArray.max() // 100

• 按条件把数组中的数据分类

let pass = mixArray.partition(by: {
 $0 > 60
})
let failedArray = mixArray[0 ..< pass] // 不及格的 [52]
let passArray = mixArray[pass ..< mixArray.endIndex] // 及格的 [63, 70, 73, 83, 84, 85, 86, 89, 96, 99, 100]

字符串-###

• 字符串创建

//类型推断
var str = “hello word”
//指定类型
var str : String = “hello word”

• 字符串拼接

var stringA = "hell0 "
stringA += "word"
print( stringA )
//hell0 word

• 字符串追加

var stringA = "hello "
stringA.append("word")
print( stringA )
////hell0 word

• 字符串全部大写/小写
  使用 String.lowercased()将字符串中字母全部转化为小写字母；使用String.uppercased()将字符串中字母全部转化为大写字母。

let stringBase = "aBcDefG"
print(stringBase.lowercased())  //abcdefg
print(stringBase.uppercased())  //ABCDEFG

• 字符串分割和拼接
  使用String.components(separatedBy:)将字符(串)按照特定的分割符分割，分割后的结果放在数组中；使用Array.joined(separator:)将数组中字符(串)组合成一个字符串。

let strNumber = "0,1,2,3,4,5,6,7,8,9"
let strArray = strNumber.components(separatedBy: ",")
print(strArray)  //["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
       
let strJoin = strArray.joined(separator: " - ")
print(strJoin)  //0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9

• 字符串截取
  String.prefix(_:)或String.suffix(_:)截取开始或结尾的某些字符串，相当于index(_:offsetBy:)

let stringSub = "abcdefghijklmnopqrstuvwxyz"
       
//获取第一个到第十个字符串
print(String(stringSub.prefix(10)))
let index_start = stringSub.index(stringSub.startIndex, offsetBy: 10)
print(String(stringSub[..<index_start]))
       
//获取倒数十个字符
print(String(stringSub.suffix(10)))
let index_end = stringSub.index(stringSub.endIndex, offsetBy: -10)
print(String(stringSub[index_end..<stringSub.endIndex]))
       
//获取区间字符串
print(cutOutString(str: stringSub, range: 1..<5))

func cutOutString(str:String, range:Range<Int>) -> String
{
   if range.lowerBound < 0 || range.upperBound > str.count || str.count == 0
   {
       return ""
   }
   let start_index = str.index(str.startIndex, offsetBy: range.lowerBound)
   let end_index = str.index(str.startIndex, offsetBy: range.upperBound)
       
   return String(str[start_index..<end_index])
}

• 字符串是否为空

// 使用字符串字面量创建空字符串
var stringA = ""

if stringA.isEmpty {
   print( "stringA 是空的" )
} else {
   print( "stringA 不是空的" )
}
       
// 实例化 String 类来创建空字符串
let stringB = String()
       
if stringB.isEmpty {
   print( "stringB 是空的" )
} else {
   print( "stringB 不是空的" )
}
///输出
//stringA 是空的
//stringB 是空的

• 判断字符串是否全为空格

//判断字符串是否全为空格
func isAllEmpty(str:String?) -> Bool{
   var isEmpty = false
   let tempString = str ?? ""
       
   if tempString.count == 0{
       isEmpty = true
   }else{
       // 创建一个字符集对象, 包含所有的空格和换行字符
       let characterSet = NSCharacterSet.whitespacesAndNewlines
       // 从字符串中过滤掉首尾的空格和换行, 得到一个新的字符串
       let trimedString = tempString.trimmingCharacters(in: characterSet)
       // 判断新字符串的长度是否为0
       if trimedString.count == 0{
           isEmpty = true
       }
   }
       return isEmpty
}

• 去掉首尾空格

//去掉首尾空格,lineFeed:true 表示包含换行符
func removeHeadAndTailSpace(str:String?, lineFeed:Bool) -> String{
     let tempString = str ?? ""
     var whitespace = CharacterSet()
     if lineFeed == true{
           whitespace = NSCharacterSet.whitespacesAndNewlines
     }else{
           whitespace = NSCharacterSet.whitespaces
     }
     return tempString.trimmingCharacters(in: whitespace)
}

• 去掉所有空格

//去掉所有空格,lineFeed:true 表示包含换行符
func removeAllSpace(str:String?, lineFeed:Bool) -> String{
   let tempString = str ?? ""
   if tempString.count == 0{
       return tempString
   }
   if lineFeed == false{
       return tempString.replacingOccurrences(of: " ", with: "")  
   }else{
       let characterSet = NSCharacterSet.whitespacesAndNewlines
       let trimedString = tempString.trimmingCharacters(in: characterSet)
       return trimedString.replacingOccurrences(of: " ", with: "")
   }
}

• 字符串比较
  ==和!= 判断字符串和字符的相等性
  hasPrefix(_:)前缀相等性
  hasSuffix(_:)后缀相等性

var welcome = "hello world"
var welcome1 = "hello"
print(welcome == welcome1) // false
print(welcome.hasPrefix("hello")) // true
print(welcome.hasSuffix("world")) // true

• 字符串包含

var str = "hello world"
var str1 = "hello"
let rec = str.contains(str1)
print(rec)
// 结果: true

元组-###

• 定义使用

//定义元组变量，并指定初始值，系统推断该元组类型为（String,Int,bool）
let student = ("张三", 19, true)
//定义元组变量,并为元组中的元素指定名字和指定值
let student = (name:"李四",age:20,male:true)
//使用元组类型来定义元组变量，并为元组所有元素指定值
let student:(name: String, age: Int, male: Bool) = ("王五", 20, true)
//将元组拆分成多个常量
let (name,age,male) = ("Davie", 20, true)
//使用元组类型来定义元组变量
var student : (String , Int , Bool)
//为元组变量赋值时必须为所有成员都指定值
student = ("张三 , 21 ,true)

print("student元组的值为：\(student)")
输出结果： (name: "张三", age: 20, male: true)

///
print("name is \(student.name)")
print("age is \(student.age)")
print("sex is male \(student.male)")

name is 张三
age is 20
sex is male true

///
print("name is \(student.0)")
print("age is \(student.1)")
print("sex is male \(student.2)")

索引取值 name is 张三
索引取值 age is 20
索引取值 sex is male true

• 例：元组类型数组实现多个button 字体图标的赋值

定义
var metagroup = [(UIButton,String,String)]()
//初始化
self.metagroup= [(btn_questionOrder,"\u{e6f5}是","\u{e6f4}是"),
                     (btn_questionUnOrder,"\u{e6f5}否","\u{e6f4}否"),
                     (btn_optionOrder,"\u{e6f5}是","\u{e6f4}是"),
                     (btn_optionUnOrder,"\u{e6f5}否","\u{e6f4}否"),
                     (btn_showIsRight,"\u{e6f5}是","\u{e6f4}是"),
                     (btn_notShowIsRight,"\u{e6f5}否","\u{e6f4}否"),
                     (btn_showAnswer,"\u{e6f5}是","\u{e6f4}是"),
                     (btn_notShowAnswer,"\u{e6f5}否","\u{e6f4}否"),
                     (btn_scoringType,"\u{e7db}","\u{e7db}"),
                     (btn_setQuestionType,"\u{e7db}","\u{e7db}"),
                     (btn_delete,"\u{e6d3}","\u{e6d3}"),
                     (btn_minus,"\u{e7a4}","\u{e7a4}"),
                     (btn_add,"\u{e6a4}","\u{e6a4}")]
//使用
for v in self.metagroup{
   v.0.titleLabel?.font = UIFont.Iconfont(size: 18)
   v.0.setTitle(v.1, for: .normal)
   v.0.setTitle(v.2, for: .selected)
}