swift3-字符/字符串

swift3-字符/字符串1.String1.1字符和字符串的定义//字符vara:Character="我"//字符串常量leta="123"//字符串变量varb="123"//声明为nil,varc:String?//空字符串letd=String()//空字符串提倡用这样的字面量语法声明,类型可不指定,swift自动识别vare=""1.2判断字符串//判

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 判断字符串

此代码由Java架构师必看网-架构君整理
//判断字符串是否为空 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 拼接/添加字符串

此代码由Java架构师必看网-架构君整理
let str1 = "你好," let str2 = "明天" let char1:Character = "!" var p_str1 = str1+str2 //"你好,明天" p_str1 = String(format:"%@~%@",str1,str2) //"你好,~明天" p_str1 = String(format:"%@~%@-%d",str1,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: ["~","~","~"], at: Str.index(Str.startIndex, 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.lowerBound)
            let endIndex = 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", range: range, 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", "swift", "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,0x61,0x66,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
本文来源深海飞鸟,由架构君转载发布,观点不代表Java架构师必看的立场,转载请标明来源出处:https://javajgs.com/archives/166221
0
 

发表评论