比较 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))
}

UPDATE 2 Performance Test (replace string) with 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 位整数。 因此，字符串处理仅适用于所谓的基本多语言平面

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

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

Answer 2

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