[Swift5]常用字符串扩展方法String Extension，类似Java里的String方法

前言

Swift里关于String的方法，着实要吐槽下，很多方法又臭又长又复杂（比如Index、Range等等），不实用，一些常用的方法，又没有现成的实现，平时习惯了Java里的String方法，开发Swift很不习惯（这里说明下，我主业是Java程序员，也开发Android程序，后来也开始开发iOS程序，好多思维习惯是Java带过来的，可能并不怪Swift，怪我咯，但是相信也有一部分朋友也有和我一样的感受，那么请看下面我的扩展方法），好在Swift里有Extension可以扩展自用的方法，这边整理了一下自用String扩展的方法（有length、indexOf、lastIndexOf、substring、replace等，都是Java里常用的string类方法）说明我写在注释里了

干货代码实现

import Foundation

extension String {
    // 获得字符串的长度，其实就是swift的count方法，只不过我习惯了Java里的length方法
    var length: Int {
        get {
            return self.count
        }
    }

    /**
    /* 下标用法 这样用:str[1...3] str[1..< 4]
    */
    subscript(_ range: CountableRange<Int>) -> String {
        let start = index(startIndex, offsetBy: max(0, range.lowerBound))
        let end = index(start, offsetBy: min(self.count - range.lowerBound,
            range.upperBound - range.lowerBound))
        return String(self[start..<end])
    }

    subscript(_ range: CountablePartialRangeFrom<Int>) -> String {
        let start = index(startIndex, offsetBy: max(0, range.lowerBound))
        return String(self[start...])
    }

    subscript (_ r: CountableClosedRange<Int>) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: r.lowerBound)
        let endIndex = self.index(startIndex, offsetBy: r.upperBound - r.lowerBound)
        return String(self[startIndex...endIndex])
    }

    // 返回某个字符在字符串中出现的位置，返回-1表示没有出现
    func indexOf(_ string: String) -> Int {
        guard let index = range(of: string) else { return -1 }
        return self.distance(from: self.startIndex, to: index.lowerBound)
    }

    // 从startIndex开始查找，返回某个字符在字符串中出现的位置，返回-1表示没有出现
    func indexOf(target: String, startIndex: Int) -> Int {
        let substring = self.substring(startIndex)
        let idx = substring.indexOf(target)
        if idx == -1 {
            return -1
        }
        return idx + startIndex
    }

    // 返回某个字符在字符串中出现的位置(从末尾开始检查)，返回-1表示没有出现
    func lastIndexOf(_ string: String) -> Int {
        guard let index = range(of: string, options: .backwards) else { return -1 }
        return self.distance(from: self.startIndex, to: index.lowerBound)
    }

    // 返回从from开始的子字符串
    func substring(_ from: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: from)
        return String(self[startIndex..<self.endIndex])
    }

    // 返回从from开始，到to结束的子字符串
    func substring(from: Int, to: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: from)
        let endIndex = self.index(self.startIndex, offsetBy: to)
        return String(self[startIndex..<endIndex])
    }

    // 检查本字符串是否全是数字
    var containsOnlyDigits: Bool {
        let notDigits = NSCharacterSet.decimalDigits.inverted
        return rangeOfCharacter(from: notDigits, options: String.CompareOptions.literal, range: nil) == nil
    }
    
    // 检查本字符串是否全是字母
    var containsOnlyLetters: Bool {
        let notLetters = NSCharacterSet.letters.inverted
        return rangeOfCharacter(from: notLetters, options: String.CompareOptions.literal, range: nil) == nil
    }

    // 替换字符串中含有target的替换为withString
    func replace(target: String, withString: String) -> String {
        return self.replacingOccurrences(of: target, with: withString, options: .literal, range: nil)
    }

}

测试代码

let s = "hello world"

s.lastIndexOf("abc") // -1
s.indexOf("l") // 2
s.indexOf(target: "l", startIndex: 4) // 9
s.substring(from: 4, to: 5) // o
s.substring(3) // lo world
s.containsOnlyDigits // false
s.contains("or") // true
s.replace(target: "o", withString: "O") // hellO wOrld