比较 Objective-C 和 Swift 的大量字符串操作的性能

Question

我有很多字符串操作，例如连接，替换，查找大文本（10000个字符）的索引...

操作太慢。在Java/Android中完全相同是更快的。

我问的是Objective-C中是否同样更快。

我是一个 iOS 新手，到目前为止只知道 Swift（所以我不能简单地尝试），这就是为什么我问带有 swift-bridging 的 Objective-C 是否可以更快？

更新我在一个循环中有很多子字符串操作（也替换），它连接一个新的字符串。NewText 和 sText 的类型是 String，sText 大约有 10000 个字符，循环大约有 100 次迭代：

NewText=NewText + sText.substring(istart,endIndex: iend);
func substring(startIndex: Int, endIndex: Int) -> String
{
    //println("substring" + self);
    var start = advance(self.startIndex, startIndex)
    var end = advance(self.startIndex, endIndex)
    return self.substringWithRange(Range<String.Index>(start: start, end: end))
}

更新 2 性能测试（替换字符串）与字符串、NSString、CFString

从你们提供的信息来看，Objective-C 和 Swift 之间似乎没有区别。更多的是使用哪种字符串类型。我用以下类型进行了性能测试：字符串，NSString和CFString

 func performance_test_with_strings(){
    var sTextNSString:NSString="<1000 character> searchstring end";
    var sTextString=String(sTextNSString);
    //var sTextCFString:CFMuString=sTextNSString as CFString;
    var stoReplace="searchstring";
    var sTextCFString:CFMutableStringRef=CFStringCreateMutable(nil, 0);
    CFStringAppend(sTextCFString, sTextString as! CFMutableStringRef);
    var stoReplaceCFString="searchstring" as CFString;
    var stoReplaceCFString2="mynewstring" as CFString;
    var chrono1:Chronometer=Chronometer();
    chrono1.start();
    for var i=0;i<10000;i++ {
        var newText=sTextNSString.stringByReplacingOccurrencesOfString(stoReplace, withString: "mynewstring");
    }
    chrono1.zwischenstand("after replacing with a NSString");
    for var i=0;i<10000;i++ {
        var newText=sTextString.stringByReplacingOccurrencesOfString(stoReplace, withString: "mynewstring");
    }
    chrono1.zwischenstand("after replacing with a String");
    //CFShow(cfmutablestring);
    for var i=0;i<5000;i++ {
        // To compare this correct I'll have to do 2 replacments in a loop of only 5000 iterations
        specialreplace(&sTextCFString,sWhat: "searchstring",sTo: "mynewstring");
        specialreplace(&sTextCFString,sWhat: "mynewstring",sTo: "searchstring");
    }
    chrono1.zwischenstand("after replacing with a CFString");
    chrono1.showMeasures();
    exit(0);
}
func specialreplace(inout sText:CFMutableStringRef,sWhat:String, sTo:String){
    var cfRange = CFStringFind(sText, sWhat as CFString, nil);
    CFStringReplace(sText, cfRange, sTo as CFString);
}
class Chronometer: NSObject {
    var mearures:[(String,Double)]=[(String,Double)]();
    var starttime = NSDate();   // <<<<<<<<<<   end time
    var lasttime:Double=0;
    func start(){
        starttime = NSDate();   // <<<<<<<<<<   end time
    }
    func zwischenstand(mytext:String){
        var zwischenzeit = NSDate();
        let timeInterval: Double = zwischenzeit.timeIntervalSinceDate(starttime);
        let actualtimeconsumed=timeInterval-lasttime;
        mearures.append((mytext,actualtimeconsumed));
        var textshow=mytext + " actual : " + String(stringInterpolationSegment: actualtimeconsumed);
        textshow=textshow + " total :" + String(stringInterpolationSegment: timeInterval);
        println(textshow);
        lasttime=timeInterval;
    }
    func showMeasures(){
        var total:Double=0;
        for var i=0 ; i < mearures.count ; i++ {
            let text=mearures[i].0;
            let measure=mearures[i].1;
            println(text + " : " + String(stringInterpolationSegment: measure));
            total = total + measure;
        }
        println("total : " + String(stringInterpolationSegment: total));
    }
}

替换为 NSString 后 实际 ： 1.15460801124573

合计 ：1.15460801124573

替换为字符串后 实际：1.15148597955704 总计：2.30609399080276

更换后 CFString 实际 ： 0.323610007762909 合计：2.62970399856567

替换为 NSString 后：1.15460801124573

替换为字符串后：1.15148597955704

更换后 CFString ： 0.323610007762909

总数 ： 2.62970399856567

所以我的结论是最好使用 CFString。

这个测试正确吗？

Answer 1

关于 Swift 需要注意的一点是，它试图正确地处理 Unicode。 Java和Cocoa的NSString不这样做。 它们都假定字符串以 UTF-16 编码，每个字符仅取一个 16 位整数。因此，字符串处理仅适用于所谓的基本多语言平面

使用 NSString 和 Java 中，找到第 n 个"字符"很容易，您只需索引到数组中的第 n 项，但这很容易成为代理项对的第二部分。 您也无法判断这是否真的是第 n 个字符，除非扫描所有以前的字符以确保它们都不是两个单词字符。

Swift 正确地做到了这一点，但代价是大量线性（也就是慢）扫描字符串。

Answer 2

我会使用Core Foundation的CFMutableString操作。我通常倾向于发现它们比它们的可可变体快得多。