[Swift]字符串(String类、NSString类)常用操作

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

➤微信公众号：MindDraft
➤博主域名：https://www.zengqiang.org
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9879997.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

NS是Cocoa类对象类型的前缀，来源于乔布斯建立的另一家公司--NeXT
NSString的使用方法，和Swift语言中的String有很多相似之处。

1、字符串的定义
String类

var str1:String = "My name is strengthen"

NSString类

var nsStr1:NSString = "My name is strengthen"
var nsStr2:NSString = NSString(string: "My name is strengthen")
var nsStr3:NSString = NSString(string: str1)

String类空字符串

var strEmpty1:String = ""
var strEmpty2:String = String()
dump(strEmpty2)
//Print - ""
//判断是否为空
//方式1
print(strEmpty2.isEmpty)
//Print true

//方式2 
print(strEmpty2.count == 0)
//Print true

//方式3 已初始化，不为nil
print(strEmpty2 == nil)
//Print false

//方式4
print(strEmpty2 is NSNull )
//Print false

NSString类空字符串

var nsStrEmpty1:NSString = NSString(string: "") 
var nsStrEmpty2:NSString = NSString(string: String())

//方式1 区分大小写比较，用来判断是否为空
let check = nsStrEmpty2.caseInsensitiveCompare("") == .orderedSame
print(check)
//Print true

//方式2 已初始化，不为NSNull
print(nsStrEmpty2 is NSNull )
//Print false

String 转换为 NSString，转换需要遵循严格的类型转化。

var nsStr4: NSString = str1 as NSString

NSString 转换为String，转换需要遵循严格的类型转化。

var str2:String = nsStr2 as String 

2、字符串格式化

格式说明由“％”和格式字符组成，如％d％f等。它的作用是将输出的数据转换为指定的格式输出。

％d 整型输出，％ld长整型输出；

％o 以八进制数形式输出整数；

％x 以十六进制数形式输出整数，或输出字符串的地址；

％u 以十进制数输出unsigned型数据(无符号数)。

注意：%d与%u有无符号的数值范围，也就是极限的值，否则打印错误数值。

％c 用来输出一个字符；

％s 用来输出一个字符串；

％f 用来输出实数，以小数形式输出，默认情况下保留小数点6位；

%.10f 用来输出实数，保留小数点10位；

％e 以指数形式输出实数；

％g 根据大小自动选f格式或e格式，且不输出无意义的零。

格式化：

let nsStr = NSString(format: "%f", 66.666)
let str =String(format: "%f", 66.666)

拼接：

var str1 = NSString(string: "hello")
var str2 = str1.appending("strengthen")
var str3 = str1 + "strengthen"

格式化拼接：

let x:Int = 1
let y:Double = 0.56
let sum:Double = Double(x) + y
print(String(format: "%d + %.2f = \(sum)", x, y))
//Print 1 + 0.56 = 1.56

3、字符定义

Character转ASCII整数值：

//Character扩展方法  
extension Character  
{  
  //转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first!.value)
       }       
    }    
}

ASCII整数值转Character：

//Int扩展方法  
extension Int
{
    //属性：ASCII值(定义大写为字符值)
    var ASCII:Character 
    {
        get {return Character(UnicodeScalar(self)!)}
    }
}

CharacterSet 各个枚举类型的含义：

.controlCharacters：控制符

.whitespaces：空格

.newlines：换行符

.whitespacesAndNewlines：空格换行

.decimalDigits：小数

.letters：文字

.lowercaseLetters：小写字母

.uppercaseLetters：大写字母

.nonBaseCharacters：非基础

.alphanumerics：字母数字

.decomposables：可分解

.illegalCharacters：非法

.punctuationCharacters：标点

.capitalizedLetters：大写

.symbols：符号

4、字符串拼接

var str1 = "My name is "
var str2 = "strengthen"

//方式1
var strConnect1 = str1 + str2

//方式2
var strConnect2 = "\(str1)\(str2)"

//方式3
var str3:NSString = NSString(string: "My name is ")
var strConnect3 = str3.appending("strengthen")

//方式4 字符数组转字符串
let arrayStr = ["s","t","r","e","n","g","t","h","e","n","!"]
//方式4.1
let str1 = arrayStr.joined(separator: "")
let str2 = arrayStr.joined(separator: "-")
print("\(str1) ", terminator: "")
print("\(str2) ", terminator: "")
//strengthen! 
//s-t-r-e-n-g-t-h-e-n-!

//方式4.2：注意与方式4.1比较，方式4.2只在首位添加"-"
let str3 = arrayStr.reduce("", {$0 + $1})
let str4 = arrayStr.reduce("-", {$0 + $1})
print("\(str3) ", terminator: "")
print("\(str4) ", terminator: "")
//strengthen!
//-strengthen!

//方式5：整数数组转字符串
let arrayInt = [0,1,2,3,4,5,6,7,8,9]
let dataInt = arrayInt.map(String.init)
let strInt = dataInt.joined(separator: "-")
print("\(strInt) ", terminator: "")
//0-1-2-3-4-5-6-7-8-9

5、获取字符串中指定索引处的字符

每个String值都有一个关联的索引类型，String.Index它对应Character于字符串中每个值的位置。

不同的字符可能需要不同的内存量来存储，因此为了确定哪个Character位于特定位置，您必须从开头或结尾迭代每个Unicode标量String。

因此，Swift字符串不能用整数值索引。可以使用index(before:)和index(after:)方法访问给定索引之前和之后的索引String。

要访问远离给定索引的索引，可以使用该index(_:offsetBy:)方法而不是多次调用其中一种方法。

let str = "Strengthen"

print(str[str.startIndex])
//Print S
print(str[str.index(before: str.endIndex)])
//Print n

let index = str.index(str.startIndex, offsetBy: 0)
print(str[index])
//Print S

//endIndex属性是a中最后一个字符后的位置String。
//因此endIndex属性不是字符串下标的有效参数。
str[str.endIndex]
// Error

str[str.index(after: str.endIndex)]
// Error

扩展String类

//String扩展
extension String {        
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
        
        //修改字符
        set
        {
            if newValue is Character
            {
                //转换为字符数组
                var arr:[Character] = Array(self) 
                arr[i] = newValue
                self = String(arr)
            }        
        }
    }
}

6、字符串插入

var str = "Strengthen"

若要将单个字符插入到指定索引处的字符串中，请使用该insert(_:at:)方法

str.insert("!", at: str.endIndex)
print(str)
//Print Strengthen!

指定索引处插入另一个字符串的内容，请使用该insert(contentsOf:at:)方法。

str.insert(contentsOf: " hello", at: str.index(before: str.endIndex))
print(str)
//Print Strengthe hellon

7、字符串删除

var str = "Strengthen"

要从指定索引处的字符串中删除单个字符，请使用remove(at:)方法

str.remove(at: str.index(before: str.endIndex))
print(str)
//Print Strengthe

删除指定范围内的子字符串，请使用removeSubrange(_:)方法
注意下方代码从后往前用负数的方式

let range = str.index(str.endIndex, offsetBy: -5)..<str.endIndex
str.removeSubrange(range)
print(str)
//Print Stren

注意（总结6、字符串插入和7、字符串删除）：

使用insert(_:at:)，insert(contentsOf:at:)，remove(at:)，和removeSubrange(_:)，对符合任何类型的方法RangeReplaceableCollection的协议。

这包括String以及集合类型，如Array，Dictionary和Set。

8、获取字符串长度

var str = "Strengthen"
print(str.count)
//Print 10

9、字符串比较
Swift提供了三种比较文本值的方法：字符串和字符相等，前缀相等和后缀相等。

注意：Swift中的字符串和字符比较不是区域设置敏感的。

let str1="hello,"
let str2="strengthen"
let str3="hello,strengthen"

let compare1 = str1==str2 
//false

let compare2 = str1+str2 == str3
//true

let compare3 = str1 < str2 
//true

let compare4 = str1 != str2 
//true

字符串比较的方法：isEqual

let str = "Hello World!"
print(str.isEqual("Hello World!"))
//true

10、检查字字符串前缀
检查字符串是否具有特定的字符串前缀调用字符串hasPrefix(_:)，其采用类型的单个参数String并返回布尔值

let romeoAndJuliet = [
    "Act 1 Scene 1: Verona, A public place",
    "Act 1 Scene 2: Capulet's mansion",
    "Act 1 Scene 3: A room in Capulet's mansion",
    "Act 1 Scene 4: A street outside Capulet's mansion",
    "Act 1 Scene 5: The Great Hall in Capulet's mansion",
    "Act 2 Scene 1: Outside Capulet's mansion",
    "Act 2 Scene 2: Capulet's orchard",
    "Act 2 Scene 3: Outside Friar Lawrence's cell",
    "Act 2 Scene 4: A street in Verona",
    "Act 2 Scene 5: Capulet's mansion",
    "Act 2 Scene 6: Friar Lawrence's cell"
]

hasPrefix(_:)方法与romeoAndJuliet数组一起使用来计算播放的第1幕中的场景数量：

var act1SceneCount = 0
for scene in romeoAndJuliet {
    if scene.hasPrefix("Act 1 ") {
        act1SceneCount += 1
    }
}
print("There are \(act1SceneCount) scenes in Act 1")
// Prints "There are 5 scenes in Act 1"

11、检查字符串后缀
检查字符串是否具有特定的字符串后缀调用字符串hasSuffix(_:)，其用类型的单个参数String并返回布尔值

let romeoAndJuliet = [
    "Act 1 Scene 1: Verona, A public place",
    "Act 1 Scene 2: Capulet's mansion",
    "Act 1 Scene 3: A room in Capulet's mansion",
    "Act 1 Scene 4: A street outside Capulet's mansion",
    "Act 1 Scene 5: The Great Hall in Capulet's mansion",
    "Act 2 Scene 1: Outside Capulet's mansion",
    "Act 2 Scene 2: Capulet's orchard",
    "Act 2 Scene 3: Outside Friar Lawrence's cell",
    "Act 2 Scene 4: A street in Verona",
    "Act 2 Scene 5: Capulet's mansion",
    "Act 2 Scene 6: Friar Lawrence's cell"
]

使用该hasSuffix(_:)方法计算在Capulet的mansion和Friar Lawrence的单元格内或周围发生的场景数量：

var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet {
    if scene.hasSuffix("Capulet's mansion") {
        mansionCount += 1
    } else if scene.hasSuffix("Friar Lawrence's cell") {
        cellCount += 1
    }
}
print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
// Prints "6 mansion scenes; 2 cell scenes"    

12、字符串包含

let str = "strengthen";
let exist1 = (str as NSString).contains("stren")
let exist2 = str.contains("stren")
print(exist1)
print(exist2)
//Print true

13、查找字符

let str = "strengthen"
print(str.index(of: "r")?.encodedOffset)
//Print Optional(2)
print(str.index(of: "z")?.encodedOffset)
//Print nil

14、截取字符串
字符串和子字符串之间的区别在于，作为性能优化，子字符串可以重用用于存储原始字符串的部分内存，或者用于存储另一个子字符串的内存的一部分。

let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..<index]
// beginning is "Hello"

// Convert the result to a String for long-term storage.
let newString = String(beginning)

15、Trim字符串:trimmingCharacters
(1)、删除前后多余的空格

//原始字符串
let str1 = " strengthen "
//除去前后空格
let str2 = str1.trimmingCharacters(in: .whitespaces)
print(str2)
//Print strengthen

(2)、删除前后指定的字符

//原始字符串
let str3 = "((strengthen))"
//删除前后()
let characterSet = CharacterSet(charactersIn: "()")
let str4 = str1.trimmingCharacters(in: characterSet)
print(str4)
//Print strengthen

16、字符串分割

let str = "s、t、r、e、n、g、t、h、e、n"
//方法1：使用components(separatedBy:" ")方法
//字符串转数组
let array1 = str.components(separatedBy:"、")
print("\(array1) ", terminator: "")
//Print ["s", "t", "r", "e", "n", "g", "t", "h", "e", "n"] 

//方法2：使用characters.split()方法
let str = "s、t、r、e、n、g、t、h、e、n"
print("原始字符串：\(str)")
//Print 原始字符串：s、t、r、e、n、g、t、h、e、n
let splitedArray = str.characters.split{$0 == "、"}.map(String.init)
print("拆分后的数组：\(splitedArray)")
//Print 拆分后的数组：["s", "t", "r", "e", "n", "g", "t", "h", "e", "n"]

字符串转字符数组：

let str = "I am Strengthen"
let array2 = str.components(separatedBy:" ")
print("\(array2) ", terminator: "")
//["I", "am", "Strengthen"]

字符数组转字符串：

let arrayStr = ["s","t","r","e","n","g","t","h","e","n","!"]

//方式1
let str1 = arrayStr.joined(separator: "")
let str2 = arrayStr.joined(separator: "-")
print("\(str1) ", terminator: "")
print("\(str2) ", terminator: "")
//strengthen! 
//s-t-r-e-n-g-t-h-e-n-!

//方式2：注意与方式1比较，方式2只在首位添加"-"
let str3 = arrayStr.reduce("", {$0 + $1})
let str4 = arrayStr.reduce("-", {$0 + $1})
print("\(str3) ", terminator: "")
print("\(str4) ", terminator: "")
//strengthen!
//-strengthen!

/*整数数组转字符串*/
let arrayInt = [0,1,2,3,4,5,6,7,8,9]
let dataInt = arrayInt.map(String.init)
let strInt = dataInt.joined(separator: "-")
print("\(strInt) ", terminator: "")
//0-1-2-3-4-5-6-7-8-9

17、字符串替换replacingOccurrences
(1)、简单替换

//原始字符串
let str1 = "strengthen"
//替换后的字符串
let str2 = str1.replacingOccurrences(of: "en", with: "ne")
print(str2)
//Print strnegthne

(2)、使用正则表达式替换

extension String {
    //使用正则表达式替换
    func pregReplace(pattern: String, with: String,options: NSRegularExpression.Options = []) -> String {
        let regex = try! NSRegularExpression(pattern: pattern, options: options)
        return regex.stringByReplacingMatches(in: self, 
                                         options: [],
                                           range:NSMakeRange(0, self.count),
                                    withTemplate: with)
    }
}

18、string转换为Int/Long/Float/Double/Bool等

var str1="100"
var num1=(str1 as NSString).integerValue
print(num1)
//Print 100
var num2=(str1 as NSString).intValue
print(num2)
//Print 100
var num3=(str1 as NSString).longLongValue
print(num3)
//Print 100
var str2="10.8888888"
var num4=(str2 as NSString).floatValue
print(num4)
//Print 10.888889
var num5=(str2 as NSString).doubleValue
print(num5)
//Print 10.8888888
var str3="true"
var num6=(str3 as NSString).boolValue
print(num6)
//Print true

19、反转字符串

var str = "strengthen"
//不修改原字符串
str.reversed()
print(str)
//Print strengthen

//注意转换为字符串
//str.reversed()为ReversedCollection<String>(_base: "strengthen")
print(String(str.reversed()))
//Print nehtgnerts

20、字符串遍历，枚举字符
请参考本博客另一篇技术博文：《[Swift]遍历字符串》

21、首字母大写、转换为大写字母、转换为小写字母
请参考本博客另一篇技术博文：《[Swift]字符串大小写转换，同时实现本地化或设置语言环境》

22、使用NSString对字符串进行各种操作
请参考本博客另一篇技术博文：《[Swift5.2实际操作]七、常见概念-(5)使用NSString对字符串进行各种操作》

 

23、添加指定个数的字符

字符串本身就是字符的数组，所以可以利用数组的定义形式去定义字符串。

var str:String = String()
str.append(String(repeating:"S",count:10))
print(str)
//Print SSSSSSSSSS