swift3-字符／字符串

1. String

1.1 字符和字符串的定义

//字符
var a: Character = "我"
 
//字符串常量
let a = "123"
//字符串变量
var b = "123"
//声明为nil，
var c:String?
//空字符串
let d = String()
//空字符串 提倡用这样的字面量语法声明,类型可不指定，swift自动识别
var e = ""

1.2 判断字符串

//判断字符串是否为空
let a = " "
var c = ""
a.isEmpty   //false
c.isEmpty   //true
 
Str = "Swift很有趣interesting"
//判断在字符串中包含某个字符
if let index3 = Str.characters.index(of: "很"){
    //包含“很”字符
    index3  //5
}
 
//判断在字符串中包含某个子字符串
if let range4 = Str.range(of: "inter"){
    //包含某个子字符串"http"
    range4  //8~13
}
//是否含有前缀
Str.hasPrefix("Swift")  //true
//是否含有后缀
Str.hasSuffix("有趣") //false

1.3 遍历字符串

let words = "abc"
words.characters.count  //4 //方法1
for word in words.characters {
    print(word)
} //方法2
words.characters.forEach{print($0)} //方法3
for (index3,value) in words.characters.enumerated() {
    print("\(index3) \(value)")
}

1.4 拼接／添加字符串

let str1 = "你好，"
let str2 = "明天"
let char1:Character = "！"
 
var p_str1 = str1+str2  //"你好，明天"
p_str1 = String(format:"%@~%@",str1,str2)  //"你好，~明天"
p_str1 = String(format:"%@~%@-%d",str2,456)   "你好，~明天-456"
//这种拼接方式方便地组合多种类型
p_str1 = "123\(str1)\(str2)456" //"123你好，明天456"
 
//在后面添加字符／字符串
p_str1.append(char1)
//+=：用于在后面添加同类型的
p_str1 += str2
p_str1 += char1 //错误，字符串与字符不同类型

1.5 字符计数及字符串索引

//字符计数
let a = "abcdef"
a.characters.count  //6 //字符串索引
a.startIndex    //0
a.endIndex  //6,最后一个字符串的下一个位置
 //: - 用字符串的字符数组的index(after:Index)或index(before:Index)引用Index后一个或前一个索引
a[a.characters.index(after: a.startIndex)]  //b
a[a.characters.index(before: a.endIndex)]   //f
 //Get characters Index //索引3的元素
let index = a.index(a.startIndex,offsetBy:3)    //起始位置，偏移位
index   //3
type(of:index)  //String.CharacterView.Index.Type //确定index1的值是安全的
let index1 = a.index(a.startIndex,offsetBy:3,limitedBy:a.endIndex) //起始位置，偏移位，最后一个字符串的下一个位置
type(of:index1) //Optional<String.CharacterView.Index>.Type
a[index]    //d
a[index1!]  //d //a[index1] //错误

1.6 插入字符串

var Str = "Swift很有趣"
 
Str.characters.count    //8
 
//在开头插入一个字符，注意是字符不是字符串
Str.insert("@",at: Str.startIndex) //"@Swift很有趣"
//在末位插入一个字符
Str.insert("!",at: Str.endIndex)   //"@Swift很有趣!"
//在指定位置插入一个字符
Str.insert("~",at: Str.index(Str.startIndex,offsetBy: 9)) //"@Swift很有趣~!"
 
//在开头字符的后面插入一个字符串
Str.insert(contentsOf:"YY".characters,at: Str.index(after: Str.startIndex))    //"@YYSwift很有趣~!"
//在结尾字符的前面插入一个字符串
Str.insert(contentsOf:"MM".characters,at: Str.index(before: Str.endIndex)) //"@YYSwift很有趣~!"
//在指定位置插入一个字符串
var p_str1 = "interesting"
Str.insert(contentsOf:p_str1.characters,at: Str.startIndex)    //"interesting@YYSwift很有趣~MM!"
 
//在指定位置插入一组字符
Str.insert(contentsOf: ["~","~","~"],offsetBy: 12))  //"interesting@~~~YYSwift很有趣~MM!"

1.7 截取字符串

1.7.1 通过索引截取字符串

var Str = "Swift很有趣"
//截取字符串
String(Str.characters.prefix(3))  //prefix：返回一个序列，从开头截取指定的最大长度。//Swi
 
String(Str.characters.suffix(3))  //suffix：返回一个序列，从末尾截取指定的最大长度。//很有趣
 
//如果最大长度超过集合中元素的数目，则结果包含集合中的所有元素
String(Str.characters.prefix(10))//Swift很有趣
String(Str.characters.suffix(10))//Swift很有趣
 
Str.endIndex    //8
let i = Str.index(Str.startIndex,offsetBy: 4)  //offsetBy:最大为endIndex //4
let j = Str.index(Str.startIndex,offsetBy: 6)  //6
 
Str[i]  //t
var Str1 = Str.substring(to: i) //substring(to:)：从开头截取到指定的索引，不包含索引所在元素。//Swif
Str1 = Str.substring(from: i) //substring(from:)：从指定的索引开始截取到末尾，包含索引所在元素。//t很有趣
Str1 = Str.substring(with: i..<j)   //substring(with:)：包含指定的索引区间 //t很
 
//通过指定字符串截取子串
let range1 = Str.range(of: "wi")
let range2 = Str.range(of: "有")
Str1 = Str.substring(from: (range1?.upperBound)!)
Str1 = Str.substring(with: (range1?.upperBound)!..<(range2?.lowerBound)!)

1.7.2 扩展String简化用法

//Str[0] //错误
//通过扩展来简化一下
extension String {
    subscript(index:Int)-> Character {
        guard let index = self.index(startIndex,offsetBy:index,limitedBy:endIndex)
            else{
                print("----1----")
                fatalError("String index out of range")
        }
        return self[index]
    }
}
Str[0]  //S
 
//Str1 = Str[0..<8] //错误
//通过扩展来简化一下
extension String {
    subscript (range: Range<Int>) -> String {
        get {
            let startIndex = self.index(self.startIndex,offsetBy: range.lowerBound)
            let endIndex = self.index(self.startIndex,offsetBy: range.upperBound)
            return self[Range(startIndex..<endIndex)]
        }
 
        set {
            let startIndex = self.index(self.startIndex,offsetBy: range.upperBound)
            let strRange = Range(startIndex..<endIndex)
            self.replaceSubrange(strRange,with: newValue)
        }
    }
}
 
Str1 = Str[0..<8]   //Swift很有趣

1.7.3 通过指定字符串截取子串

//通过指定字符串截取子串
Str = "Swift很有趣很有趣"
Str.characters.count    //11
// 正向检索,从前到后找到第一个 "很" 字符的range
var range = Str.range(of: "很")  //5~6
 
//反向检索
//options: 用来指定一个选项标记（这个标记可以作为搜索的条件）,.backwards:反向检索
range = Str.range(of: "趣",options: .backwards) //10~11
 
 
range = Str.range(of: "趣",options: .backwards,range: nil,locale: nil)    //10~11
range = Str.range(of: "趣",options: .backwards) //10~11
range = Str.range(of: "很有趣很有趣") //5~11
//range: 设置搜索的范围
//locale: 可以语言环境
var l=Locale.current    //?
var range2 = Str.range(of: "趣",range: range,locale: nil)  //7~8
Str.range(of: "S",locale: nil)   //在搜索的范围内没有找到则 返回nil
 
Str1 = Str.substring(from: (range?.upperBound)!)    //""
Str1 = Str.substring(to: (range?.lowerBound)!)  //"Swift"
var range1 = 17...23
range1.lowerBound   //17
range?.upperBound   //11
type(of:range)  //Optional<Range<String.CharacterView.Index>>.Type
type(of:range1) //CountableClosedRange<Int>.Type
 
//CountableClosedRange：可数的闭区间
//CountableRange：可数的开区间
//ClosedRange：不可数的闭区间
//Range：不可数的开居间
 
//这里的range类型要是 Range<Swift.Index> 而不能是 Range<Int>
Str1 = Str.substring(with: (range?.lowerBound)!..<(range2?.upperBound)!)    //很有趣

1.8 替换字符串

Str = "Swift很有趣"
//replaceSubrange(要替换的坐标范围,with:要替换的内容)
 
let index3 = Str.characters.index(of: "很")  //5
Str.replaceSubrange(index3! ..< Str.endIndex,with: " is interesting!") //"Swift is interesting!"
 
let range3 = Str.range(of: "Swift") //0~5
Str.replaceSubrange(range3!,with: "books") //"books is interesting!"

1.9 删除字符串

Str = "Swift很有趣interesting"
 
//在指定位置删除一个字符
let x = Str.index(Str.startIndex,offsetBy: 5)
Str.remove(at: x)   //删除"很",变为"Swift有趣interesting"
Str.remove(at: Str.startIndex)  //删除"S",变为"wift有趣interesting"
Str.remove(at: Str.index(after: Str.startIndex))    //删除"i",变为"wft有趣interesting"
Str.remove(at: Str.index(before: Str.endIndex)) //删除"g",变为"wft有趣interestin"
 
//删除指定范围的字符
let ran1 = Str.index(Str.endIndex,offsetBy: -10)..<Str.endIndex    //5~15,"interestin"
Str.removeSubrange(ran1) //删除"interestin",变为"wft有趣"
Str.removeSubrange(Str.startIndex...Str.index(Str.startIndex,offsetBy: 2)) //删除"wft",变为"有趣"

2.字符串的转换

2.1 大小写字母转换

Str = "Swift很有趣"
//转换为大写
Str = Str.uppercased()  //"SWIFT很有趣"
//转换为小写
Str = Str.lowercased()  //"swift很有趣"

2.2 字符串与数组的转换

//字符串与数组的转换
var strArray = ["hello","swift","3.0"]
var p_str1 = strArray.joined(separator: "-")//数组通过指定字符拼接    //"hello-swift-3.0"
strArray = p_str1.components(separatedBy: "-")//拆分为数组   //["hello","3.0"]

2.3 NSString和String类型转换

let Str1 = "123"
let Str2=NSString(string: Str1) //定义NSString，String->NSString
type(of:Str2)   //__NSCFString.Type
 
let Str3:NSString = Str1 as NSString
type(of:Str3)   //_NSContiguousString.Type
let Str4 = Str3 as String    //类型推导，:String可省略
type(of:Str4)   //String.Type

3. 特殊字符

Unicode: 一种国际化文字编码标准. 几乎可以兼容所有语言的文字和书写系统.除了可以直接打出Unicode字符,还可以使用数字化的量,叫Unicode标量.\u{1F425}
汉字Unicode一览
 Unicode字符编码表

3.1 unicode编码，String与NSString的差别

//------unicode编码------ //Café
let cafe = "Caf\u{00e9}"    //"Café"
 // é U00e9 "LATIN SMALL LETTER E WITH ACUTE"－>é // e U0065 "LATIN SMALL LETTER E" 拉丁文小写字母E // ' U0301 "CONBINING ACUTE ACCENT" 结合语音
 
let cafe2 = "Caf\u{0065}\u{0301}"   //"Café"
 //------String与NSString的差别------ //Swift中字符串类型使用String表示，而 String 则由一系列的 Character 类型的字符组成
cafe2.characters.count  //可识别Character字符个数,4
cafe.characters.count   //4
 
/*utf8时： é: C3 A9 e: 65 ': CC 81 */
cafe.utf8.count     //5
cafe2.utf8.count    //6
/*utf16时： é: C3A9 e: 65 ': CC81 */
cafe.utf16.count    //4
cafe2.utf16.count   //5
 
cafe == cafe2    //true,String类型时，相等
 
let nsCafe = NSString(characters:[0x43,0x61,0x66,0xe9],length:4)
nsCafe.length
let nsCafee = NSString(characters:[0x43,0x65,0x0301],length:5)
nsCafee.length
 
nsCafe == nsCafee   //false,NSString类型时，不相等
 //------忽略大小写 比较两个字符串------
let result = nsCafe.compare(nsCafee as String)//nsCafe与nsCafee类型不变，都是__NSCFString.Type
result == .orderedSame  //true
let result1 = nsCafee.compare(nsCafe as String)
result1 == .orderedSame //true
 
cafe.characters.count    //4
let circleCafee = cafe + "\u{20dd}" //"Café⃝"
circleCafee.characters.count    //字符个数不变

3.2 不同表情的字符数不同

//------不同表情的字符数不同------
//Emoji 表情键盘的呼出快捷键组合：Command + Control + Spacebar（空格）

4. 其它

4.1 可选变量:

可选变量一般用在类或结构体中，就是说在创建对象时，不想或不能为该数据成员赋值，将其设置为可选。
可选就是可为nil，在构造函数中，如果是可选变量，就可以先不对其进行赋值，其他非可选变量，则必须赋值或者在生命时，要有初始值；否则报错。
可选变量在使用前，必须赋值，否则也报错。
在使用可选变量时，系统都需要先确定这个变量不为nil，有两种方式：
1.直接使用!，人为的为系统打包票，说这个可选变量不为nil; 比较简单粗暴；
2.使用if else，判断是否为nil，作为不出错得保证。

4.2 声明变量的?和!的区别

例如

var amiteLbl :UILabel?
 
 self.amiteLbl = UILabel(frame:CGRectMake(50,100,200,40))
 self.amiteLbl!.text = "I love mixBox"
 self.view?.addSubview(self.amiteLbl)

由于amiteLbl是可选变量，所以可能有值，也可能为nil。

使用self.amiteLbl!是明确声明此时self.amiteLbl里一定有值，无论什么情况都调用后面的.text赋值方法。

而使用self.view?是声明此时并不确定self.view里是否有值，所以只在view有值时调用后面.addSubview方法。

这样做的目的：
一是让代码更明确，
二是给编译器提供更多线索，在编译时发现更多潜在错误。

另：

a ?? b  //表示如果a=nil,则 a的值为b