String 在Haxe中反转字符串

在Haxe中反转字符串的其他选项有哪些？ 我提出我的（简单、清晰、初学者喜欢）：

类反向限制{
公共静态函数main（）{
Sys.println（“输入一些单词：”）；
//让我们读一些输入！
var someWord=Sys.stdin（）.readLine（）；
//将字符串拆分为数组，反转字符串，然后再次联接
var stringArray:Array=someWord.split（“”）；
stringArray.reverse（）；
var reversedString=stringArray.join（“”）；
//最后，享受反向字符串：
Sys.print（“反转的单词看起来像这样：”）；
Sys.println（反向字符串）；
}
}

您可以将代码移动到单独的静态功能：

class StringUtil {
    static public function reverse(s:String):String {
        var a = s.split('');
        a.reverse();
        return a.join('');
    }
}

然后这样做：

using StringUtil;

class ReverseString {

    public static function main() {

        Sys.print("Enter some words: ");
        // Lets read some input!
        var someWord = Sys.stdin().readLine();

        // Just reverse it
        var reversedString = someWord.reverse();

        // And finally, enjoy the reversed string:
        Sys.print("Reversed word looks like this: ");
        Sys.println(reversedString);
    }
}

使评论变得相当过时，不是吗

或者，您可以向后迭代字符串的字符并将它们添加到

StringBuf

，但我猜这在大多数平台上都比较慢。

与其他一些方法相比，使用split（）比较慢，尤其是当字符串足够大时

下面的测试是在我的计算机上用Haxe2.10编译的Neko target上完成的。让我们首先测试一个6个字符的字符串（“abcdef”）

带有拆分/联接的实施A大约需要（0.030ms）：

实施方案B运行速度与解决方案A（0.032ms）相当，甚至不慢：

实现C比实现A快5倍（0.006ms）：

实现D速度最快，大约是实现A（0.002ms）的16倍：

使用6个字符的字符串对Neko的测量结果进行重述（从500000次迭代计算，并进行相应的划分）：

• A:0.030ms
• B:0.032ms（最差）
• C:0.006ms（比A快5倍）
• D:0.002ms（最佳，比A快16倍）

250个字符的字符串测量值（从500000次迭代计算并相应划分）：

• A:0.996ms
• B:1.326ms（仍然最差）
• C:0.166ms（比A快6倍）
• D:0.044ms（最佳，比A快22倍）

结果表明，随着字符串大小的增长，实现A相对于D越来越慢（这意味着它的复杂度函数O（n）更差）

---

出于这些原因，我推荐实施D

您的解决方案更优雅，因此我购买它你试过其他目标吗？

using StringUtil;

class ReverseString {

    public static function main() {

        Sys.print("Enter some words: ");
        // Lets read some input!
        var someWord = Sys.stdin().readLine();

        // Just reverse it
        var reversedString = someWord.reverse();

        // And finally, enjoy the reversed string:
        Sys.print("Reversed word looks like this: ");
        Sys.println(reversedString);
    }
}

var s = "abcdef"; 
var a = s.split(''); 
a.reverse(); 
s = a.join('');

// s contains "fedcba"

var s = "abcdef";
var s2 = ""; 
for (i in -s.length+1...1) 
    s2 += s.charAt(-i);

// s2 contains "fedcba"

import StringBuf;
using StringTools;

var s = "abcdef"; 
var s2 = new StringBuf(); 
for (i in -s.length+1...1) 
     s2.add(s.charAt(-i)); 

// s2.toString() contains "fedcba"

import StringBuf;
using StringTools;

var s = "abcdef"; 
var s2 = new StringBuf(); 
for (i in -s.length+1...1) 
     s2.addChar(s.fastCodeAt(-i)); 

// s2.toString() contains "fedcba"
// if introducing var s3 = s2.toString() it then takes from 0.003 to 0.004ms total
// so this still seems the fastest on Neko.