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

Question

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

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

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

我是 iOS 新手，目前只知道 Swift（所以我不能简单地尝试），这就是为什么我问 Objective-C 与 swift-bridging 是否会更快？

更新 我在一个循环中有很多子字符串操作（也是替换），它连接了一个新的字符串。 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))
}

UPDATE 2 性能测试（替换字符串）用 String、NSString、CFString

从你们提供的信息来看，Objective-C 和 Swift 之间似乎没有区别。更多的是使用哪种 Stringtype。 我对以下类型进行了性能测试：String、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 位整数。因此，字符串处理仅适用于所谓的Basic Multilingual Plane

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

Swift 正确地做到了这一点，但代价是对字符串进行大量线性（又名缓慢）扫描。

Answer 2

我会使用Core Foundation's CFMutableString 操作。我通常倾向于比它们的 Cocoa 变体更快地找到它们。