Swift的擴(kuò)展特性杠杠的，方便對(duì)其升級(jí)打造

下面擴(kuò)展了 String 一些常用方法，方便項(xiàng)目使用

暫時(shí)升級(jí)那么多了，大家也可以根據(jù)需要進(jìn)行擴(kuò)展

其實(shí)很多新東西都是從已有的東西中混合整成的

“我們”的世界一切都不是憑空出現(xiàn)的蘑拯，所謂的創(chuàng)新也只是把已有的東西走了多幾步奋早，在淺層面就很難看出來(lái)而已娱颊，如歸根到底還是有其根源。雖說(shuō)走多幾步髓介，但是談何容易惕鼓？

extension String {
    /*
    * 判斷是否存在的字符串
    */
    //方式一 使用字符串 + 字符 + 數(shù)組等混合而成
    func hasContains(contains: String) -> Bool {
        var containsArr = [String]()
        var console = 0
        for char in contains.characters {
            containsArr.append(String(char))
        }
        for char in self.characters {
            if String(char) == containsArr[console] {
                console  += 1
                if console >= containsArr.count {
                    break
                }
            } else {
                console = 0
            }
        }
        return console == containsArr.count ? true : false
    }
    
    //方式二 艸，方式一好不容易搞出來(lái)唐础，居然還有方式二這樣家伙
    func has(str: String) -> Bool {
        return (self.rangeOfString(str) != nil) ? true : false
    }

   //方式三箱歧，人生最悲催的事，莫過(guò)到最后發(fā)現(xiàn) Swift 自身已存在解決此問(wèn)題的方法
   // - > self.containsString("str")



    //截取指定字符 返回前面部分
    func cutRetrunTheFirstPart(strCut: String) -> String {
        guard !strCut.isEmpty else { return self }
        let range = self.rangeOfString(strCut)
        let index = range?.startIndex
        let str = self.substringToIndex(index!)
        return str
    }
    //截取指定字符 返回后面部分
    func cutRetrunTheLastPart(strCut: String) -> String {
        guard !strCut.isEmpty else { return self }
        let range = self.rangeOfString(strCut)
        let index = range?.endIndex
        let str = self.substringFromIndex(index!)
        return str
    }
    //消滅到指定位的字符串 -> 返回剩下的
    mutating func cutIndexReturnB(adIndex: Int) -> String {
        guard adIndex < self.characters.count else { return self }
        self.removeRange(self.startIndex..<self.startIndex.advancedBy(adIndex))
        return self
    }
    //取到指定位的字符串 -> 消滅剩下的
    mutating func cutIndexReturnA(adIndex: Int) -> String {
        guard adIndex < self.characters.count else { return self }
        self.removeRange(self.startIndex.advancedBy(adIndex)..<self.endIndex)
        return self
    }
    // 判斷首個(gè)字符串的位置
    func charFirstIndex(str: String) -> Int? {
        guard self.containsString(str) else { return nil }
        
      return self.componentsSeparatedByString(str)[0].characters.count
    }
    
    //分割字符串 - 遇見(jiàn)多少個(gè)就分割多少個(gè)
    func split(str: String) -> [String] {
        if str.isEmpty {
            var strArr = [String]()
            for char in self.characters {
                strArr.append(String(char))
            }
            return strArr //空的話一膨、無(wú)縫分割
        }
        return self.componentsSeparatedByString(str)
    }
    //str.characters.split{$0 == "呀邢、"}.map(String.init)

    //移除前面指定個(gè)數(shù)字符- 可以繼續(xù)擴(kuò)展 移除 幾號(hào) 到幾號(hào) 或者定點(diǎn)清除
    mutating func cutIndexRetrunLastPart(index: Int) -> String {
    guard self.characters.count > index else {
            return self   } //如果超過(guò)該字符長(zhǎng)度，默認(rèn)不成功豹绪，返回自身
    self.removeRange(self.startIndex..<self.startIndex.advancedBy(index))
    return self
    }


    //顛倒字符串
    func reverse() -> String {
        let str = self.split("").reverse()
        var newStr = ""
        for s in str {
            newStr += s
        }
        return newStr
    }
    
    //統(tǒng)計(jì)字符串個(gè)數(shù)
    func howMany(str: String) -> Int {
        let strArr = str.split("")
        var console = 0 //控制字符
        var times = 0
        for char in self.characters {
            if String(char) == strArr[console] {
                console += 1
                if console >= strArr.count {
                    console = 0
                    times += 1
                }
            } else {
                console = 0
            }
        }
        return times
    }
}

字符串顛倒

extension String {
    func reverseString() -> String {
        var cchars = self.cStringUsingEncoding(NSUTF8StringEncoding)!
        for i in 0..<cchars.count/2 {
            let temp = cchars[i]
            cchars[i] = cchars[cchars.count - i  - 2]
            cchars[cchars.count - i - 2] = temp
        }
        return String(UTF8String: &cchars)!
    }
    
    
    func reverseString2() -> String {
        let cchars = self.cStringUsingEncoding(NSUTF8StringEncoding)!
        var cArray = [CChar]()
        cchars.map { cArray.insert($0, atIndex: 0) }
        cArray.removeFirst()
        cArray.append(0)
        return String(UTF8String: &cArray)!
    }
    
    func reverseString3() -> String {
        var rs = ""
        for c in self.characters {
            rs.insert(c, atIndex: rs.startIndex)
        }
        return rs
    }
}

使用:

let str = "我是誰(shuí)价淌？ 你又是誰(shuí)？ 他又是誰(shuí)瞒津？"
str.has("我是誰(shuí)蝉衣？") // = true
str.hasContains("你又是誰(shuí)？") // = true
str.split(" ") // = ["我是誰(shuí)巷蚪？", "你又是誰(shuí)病毡？", "他又是誰(shuí)？"]
str.reverse() // = "屁柏？誰(shuí)是又他 啦膜？誰(shuí)是又你 有送？誰(shuí)是我"
str.howMany("誰(shuí)") // = 3

let movie = "波多野結(jié)衣"
movie.cutRetrunTheFirstPart("野") // = "波多"
movie.cutRetrunTheLastPart("野")  // = "結(jié)衣"