How do I reverse a String in Dart?

Here's one way to reverse an ASCII String in Dart:

input.split('').reversed.join('');

1. split the string on every character, creating an List
2. generate an iterator that reverses a list
3. join the list (creating a new string)

Note: this is not necessarily the fastest way to reverse a string. See other answers for alternatives.

Note: this does not properly handle all unicode strings.

I've made a small benchmark for a few different alternatives:

String reverse0(String s) {
  return s.split('').reversed.join('');
}

String reverse1(String s) {
  var sb = new StringBuffer();
  for(var i = s.length - 1; i >= 0; --i) {
    sb.write(s[i]);
  }
  return sb.toString();
}

String reverse2(String s) {
  return new String.fromCharCodes(s.codeUnits.reversed);
}

String reverse3(String s) {
  var sb = new StringBuffer();
  for(var i = s.length - 1; i >= 0; --i) {
    sb.writeCharCode(s.codeUnitAt(i));
  }
  return sb.toString();
}

String reverse4(String s) {
  var sb = new StringBuffer();

  var i = s.length - 1;

  while (i >= 3) {
    sb.writeCharCode(s.codeUnitAt(i-0));
    sb.writeCharCode(s.codeUnitAt(i-1));
    sb.writeCharCode(s.codeUnitAt(i-2));
    sb.writeCharCode(s.codeUnitAt(i-3));
    i -= 4;
  }

  while (i >= 0) {
    sb.writeCharCode(s.codeUnitAt(i));
    i -= 1;
  }

  return sb.toString();
}

String reverse5(String s) {
  var length = s.length;
  var charCodes = new List(length);
  for(var index = 0; index < length; index++) {
    charCodes[index] = s.codeUnitAt(length - index - 1);
  }

  return new String.fromCharCodes(charCodes);
}
main() {
  var s = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";

  time('reverse0', () => reverse0(s));
  time('reverse1', () => reverse1(s));
  time('reverse2', () => reverse2(s));
  time('reverse3', () => reverse3(s));
  time('reverse4', () => reverse4(s));
  time('reverse5', () => reverse5(s));
}

Here is the result:

reverse0: => 331,394 ops/sec (3 us) stdev(0.01363)
reverse1: => 346,822 ops/sec (3 us) stdev(0.00885)
reverse2: => 490,821 ops/sec (2 us) stdev(0.0338)
reverse3: => 873,636 ops/sec (1 us) stdev(0.03972)
reverse4: => 893,953 ops/sec (1 us) stdev(0.04089)
reverse5: => 2,624,282 ops/sec (0 us) stdev(0.11828)

A fairly simple way (without taking into account the sorting direction) is to use information about Unicode mapping sequences.

import 'package:sequence_processor/sequence_processor.dart';
import 'package:unicode/decomposers/canonical.dart';
import 'package:unicode/emoji/emoji.dart';

void main(List<String> args) {
  var str = 'hello🇵🇬你们😀😀👨‍👩‍👦';
  print('"$str"');
  print(_reverse(str));

  str = 'I 💗 you! ❤️‍🔥 ';
  print('"$str"');
  print(_reverse(str));

  str = 'Amélie';
  print(str);
  print('${_reverse(str)} <= it seems to work');

  print(
      '${String.fromCharCodes(str.runes.toList().reversed)} <= does not work');
}

String _reverse(String text) {
  if (text.isEmpty) {
    return '';
  }

  final result = _processor.process(text.runes.toList());
  if (result.isEmpty) {
    return '';
  }

  return result.reversed
      .map((e) => e.data == null
          ? String.fromCharCode(e.element!)
          : String.fromCharCodes(e.sequence!))
      .join();
}

// Should be stored in a static member for performance reasons.
final _processor = () {
  final emojis = getUnicodeEmojiList();
  final processor = SequenceProcessor<int, Object>();
  for (final emoji in emojis) {
    processor.addSequence(emoji.sequence, emoji);
  }

  const decomposer = CanonicalDecomposer();
  final mappingList = decomposer.getMappingList();
  for (var i = 0; i < mappingList.length; i++) {
    final mapping = mappingList[i];
    final sequence = mapping.$2;
    if (sequence.length > 1) {
      if (!processor.hasSequence(sequence)) {
        processor.addSequence(mapping.$2, mapping.$1);
      }
    }
  }

  return processor;
}();

Output:

"hello🇵🇬你们😀😀👨‍👩‍👦"
👨‍👩‍👦😀😀们你🇵🇬olleh
"I 💗 you! ❤️‍🔥 "
 ❤️‍🔥 !uoy 💗 I
Amélie
eilémA <= it seems to work
eiĺemA <= does not work

Try this function

String reverse(String s) {
  var chars = s.splitChars();
  var len   = s.length - 1;
  var i     = 0;

  while (i < len) {
    var tmp = chars[i];
    chars[i] = chars[len];
    chars[len] = tmp;
    i++;
    len--;
  }

  return Strings.concatAll(chars);
}

void main() {
  var s = "Hello , world";
  print(s);
  print(reverse(s));
}

(or)

String reverse(String s) {
  StringBuffer sb=new StringBuffer();
  for(int i=s.length-1;i>=0;i--) {
    sb.add(s[i]);
  }
  return sb.toString();
}

main() {
  print(reverse('Hello , world'));
}

The library More Dart contains a light-weight wrapper around strings that makes them behave like an immutable list of characters:

import 'package:more/iterable.dart';

void main() {
  print(string('Hello World').reversed.join());
}

There is a utils package that covers this function. It has some more nice methods for operation on strings.

Install it with :

dependencies:
  basic_utils: ^1.2.0

Usage :

String reversed = StringUtils.reverse("helloworld");

Github:

https://github.com/Ephenodrom/Dart-Basic-Utils

Create this extension:

extension Ex on String {
  String get reverse => split('').reversed.join();
}

Usage:

void main() {
  String string = 'Hello World';
  print(string.reverse); // dlroW olleH
}

Reversing "Hello World"

Here is a function you can use to reverse strings. It takes an string as input and will use a dart package called Characters to extract characters from the given string. Then we can reverse them and join again to make the reversed string.

String reverse(String string) {
  if (string.length < 2) {
    return string;
  }

  final characters = Characters(string);
  return characters.toList().reversed.join();
}

** Here is a function you can use to reverse strings. It takes an string as input and will use a dart package called split() to extract characters from the given string. Then we can reverse them and join again to make the reversed string. **

 String? stringReverse(String? string) {
      if (string != null) {
        final output = string.split('').reversed.join();
        return output;
      }
    }

    void main() {
      String? string = stdin.readLineSync();
      print(stringReverse(string));
    }

With StringBuffer:

String firstReverse(String str) {
      StringBuffer reversedStr = StringBuffer();
    
      for (int i = str.length - 1; i >= 0; i--) {
        reversedStr.write(str[i]);
      }
    
      return reversedStr.toString();
    }

With CodeUnits:

String firstReverse(String str) {
  var stringToNumList = [];
  String reverseStr = '';

  for (var i = 0; i < str.length; i++) {
    stringToNumList.add(str[i].codeUnitAt(0));
  }

  int start = 0, last = stringToNumList.length - 1;

  while (start < last) {
    var temp = stringToNumList[start];
    stringToNumList[start] = stringToNumList[last];
    stringToNumList[last] = temp;
    start++;
    last--;
  }

  for (var i = 0; i < stringToNumList.length; i++) {
    reverseStr += String.fromCharCode(stringToNumList[i]);
  }

  return reverseStr;
}