Swift的扩展特性杠杠的，方便对其升级打造

下面扩展了 String 一些常用方法，方便项目使用

暂时升级那么多了，大家也可以根据需要进行扩展

其实很多新东西都是从已有的东西中混合整成的

“我们”的世界一切都不是凭空出现的，所谓的创新也只是把已有的东西走了多几步，在浅层面就很难看出来而已，如归根到底还是有其根源。虽说走多几步，但是谈何容易？

extension String {
    /*
    * 判断是否存在的字符串
    */
    //方式一 使用字符串 + 字符 + 数组等混合而成
    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
    }
    
    //方式二 艹，方式一好不容易搞出来，居然还有方式二这样家伙
    func has(str: String) -> Bool {
        return (self.rangeOfString(str) != nil) ? true : false
    }

   //方式三，人生最悲催的事，莫过到最后发现 Swift 自身已存在解决此问题的方法
   // - > 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
    }
    // 判断首个字符串的位置
    func charFirstIndex(str: String) -> Int? {
        guard self.containsString(str) else { return nil }
        
      return self.componentsSeparatedByString(str)[0].characters.count
    }
    
    //分割字符串 - 遇见多少个就分割多少个
    func split(str: String) -> [String] {
        if str.isEmpty {
            var strArr = [String]()
            for char in self.characters {
                strArr.append(String(char))
            }
            return strArr //空的话、无缝分割
        }
        return self.componentsSeparatedByString(str)
    }
    //str.characters.split{$0 == "、"}.map(String.init)

    //移除前面指定个数字符- 可以继续扩展 移除 几号 到几号 或者定点清除
    mutating func cutIndexRetrunLastPart(index: Int) -> String {
    guard self.characters.count > index else {
            return self   } //如果超过该字符长度，默认不成功，返回自身
    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
    }
    
    //统计字符串个数
    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 = "我是谁？ 你又是谁？ 他又是谁？"
str.has("我是谁？") // = true
str.hasContains("你又是谁？") // = true
str.split(" ") // = ["我是谁？", "你又是谁？", "他又是谁？"]
str.reverse() // = "？谁是又他 ？谁是又你 ？谁是我"
str.howMany("谁") // = 3

let movie = "波多野结衣"
movie.cutRetrunTheFirstPart("野") // = "波多"
movie.cutRetrunTheLastPart("野")  // = "结衣"