Programming-Idioms.org

print("Hello World");

print("Hello\n" * 10);

for (var i = 0; i < 10; i++)
  print("Hello");

void finish(String name) {
  print("My job here is done. Goodbye $name.");
}

int square(int x) => x * x;

class Point {
  double x, y;
}

class Point {
  double x, y;
  Point(this.x, this.y);
}

items.forEach(doSomething);

for (var i = 0; i < items.length; i++) {
  print('index=$i, value=${items[i]}');
}

items.asMap().forEach((i, x) {
  print('index=$i, value=$x');
});

items.forEachIndexed((i, x) {
  print('index=$i, value=$x');
});

var x = {
	"one": 1,
	"two": 2
};

class Node<T> {
  final T value;
  Node<T> left, right;
  Node(this.value, {this.left, this.right});
}

x.shuffle();

var shuffled = x.toList()..shuffle();

x[new Random().nextInt(x.length)];

list.contains(x);

mymap.forEach((k, v) => print('Key=$k, Value=$v'));

double pick(num a, num b) => a + new Random().nextDouble() * (b - a);

int pick(int a, int b) => a + Random().nextInt(b - a + 1);

traverse(Node bt, f(value)) {
   if (bt == null) return;
   traverse(bt.left, f);
   f(bt.value);
   traverse(bt.right, f);
}

class Node<T> {
  final T value;
  final List<Node<T>> children;
  Node(this.value, this.children);
}
  

traverse(Tree node, f(value)) {
  f(node.value);
  for (var child in node.children) { 
    traverse(child, f);
  }
}

x = x.reversed.toList();

class Position {
  int i, j;
  Position(this.i, this.j);
}
Position search(List<List> m, x) {
  for (var i = 0; i < m.length; i++) {
    var line = m[i];
    for (var j = 0; j < line.length; j++) {
      if (line[j] == x) {
        return new Position(i, j);
      }
    }
  }
  return null;
}

var tmp = a;
a = b;
b = tmp;

var i = int.parse(s);

var s = x.toStringAsFixed(2);

var s = "ネコ";

sendPort.send("value");

var x = new List.generate(m, (_) => new List(n));

var x = new List.generate(m, (_) => new List.filled(n, 0));

var x = new List.generate(m, (_) => 
                new List.generate(n, (_) => 
                    new List.filled(p, 0.0), 
                    growable: false), 
                growable: false);

items.sort((a, b) => Comparable.compare(a.p, b.p));

items.sort((a, b) => (a.p).compareTo(b.p));

items.removeAt(i);

for (int i = 1; i <= 1000; i++) {
  Isolate.spawn(f,i);   
}

f(i) => (i == 0) ? 1 : i * f(i - 1);

int exp(int x, int n) {
  if (n == 0) return 1;
  if (n == 1) return x;
  var r = exp(x * x, n ~/ 2);
  if (n % 2 == 1) r *= x;
  return r;
}

int exp(int x, int n) {
  var r = 1;
  while (true) {
    if (n.isOdd) r *= x;
    n ~/= 2;
    if (n == 0) break;
    x *= x;
  }
  return r;
}

x = f(x);

var x = new Set<T>();

typedef R Func<T,R>(T arg);

Func<A,C> compose(B f(A x), C g(B x)) => (A x) => g(f(x))

compose(f, g) => (x) => g(f(x));

curry(f(a, b), a) => (b) => f(a, b);

var t = s.substring(i, j);

var ok = s.contains(word);

var t = new String.fromCharCodes(s.runes.toList().reversed);

var t = s.split('').reversed.join();

main()  {
  var a = [1, 2, 3];
  var b = [2, 3];

  outer: for (var v in a) {
    for (var w in b) {
      if (w == v) continue outer;
    }
    print(v);
  }
}

OUTER: for (var i = 0; i < m.length; i++) {
  for (var j = 0; j < m[i].length; j++) {
    if (m[i][j] < 0) {
      print("Negative value found at $i,$j: ${m[i][j]}");
      break OUTER;
    }
  }
}

s.insert(i, x);

sleep(const Duration(seconds: 5));

await new Future.delayed(const Duration(seconds : 5));

var t = s.substring(0, 5);

var n = s.length;
var t = s.substring(n-5, n);

var s = '''A
multi-line
string''';

var s = """A
multi-line
string""";

s.split(new RegExp('\\s+'))

while (true) {
  // do something
}

for (;;) {

}

m.containsKey(k)

m.containsValue(v);

y = x.join(', ');

var s = x.fold(0, (a, b) => a + b);

var s = "$i";

List<Future> tasks = [];
for (int i = 1; i <= 1000; i++) {
  tasks.add(Isolate.spawn(f, i));
}
await Future.wait(tasks);
print("finished");

var y = x.where(p).toList();

var lines = new File(f).readAsStringSync();

stderr.write("$x is negative");

main(args) {
  var x = args[0];
}

var d = DateTime.now();

var i = x.indexOf(y);

var x2 = x.replaceAll(y, z);

var x = pow(3, 247);

var s = "${(x * 100).toStringAsFixed(1)}%";

var z = pow(x, n);

int binom(int n, int k) {
  int result = 1;
  for (int i = 0; i < k; i++) {
    result = result * (n - i) ~/ (i + 1);
  }
  return result;
}

final x = FixedBitArray(n);

var r = new Random(s);

var r = new Random(new DateTime.now().millisecondsSinceEpoch);

main(List<String> args) {
  print(args.join(' '));
}

int gcd(int a, int b) {
  while (b != 0) {
    var t = b;
    b = a % t;
    a = t;
  }
  return a;
}

x = a.gcd(b);

x = lcm(a, b);

int lcm(int a, int b) => (a * b) ~/ gcd(a, b);

int gcd(int a, int b) {
  while (b != 0) {
    var t = b;
    b = a % t;
    a = t;
  }
  return a;
}

x = a.lcm(b);

extension LCM on int {
  int lcm(int other) => (this * other) ~/ this.gcd(other);
}

var s = x.toRadixString(2);

do {
  someThing();
  someOtherThing();
} while(c);

double y = x.toDouble();

int y = x.toInt()

var y = x.round();

var c = i.toRadixString(2).replaceAll('0','').length;

exit(0);

var buf = BytesBuilder().addByte(1000000);

class Foo{
  int _x = 0;
  int get x => _x;  
}

Map x = json.jsonDecode(await new File('data.json').readAsString());

Map x = json.jsonDecode(new File('data.json').readAsStringSync());

class JsonModel {
  // Create Field
  int id;
  String qrText, licen, trans, name;

//   // Constructor
//   JsonModel(
//       int idInt, String nameString, String userString, String passwordString) {
// //     id=idInt;
// // name =nameString;
// // user =userString;
// // password = passwordString;
//   }

  JsonModel(this.id, this.name, this.licen, this.trans, this.qrText);

  JsonModel.fromJson(Map<String, dynamic> parseJSON) {
    id = int.parse(parseJSON['id']);
    licen = parseJSON['Li

control(Function f) => f();

print(x.runtimeType);

final x = (await File(path).readAsBytes()).length;

var x = File(path).lengthSync();

var b = s.startsWith(prefix);

var b = s.endsWith(suffix);

var d = new DateTime.fromMillisecondsSinceEpoch(ts, isUtc: true);

x = DateFormat('YYYY-MM-DD').format(d);

items.sort(c);

var s = File(Platform.resolvedExecutable).uri.pathSegments.last;

final blank = s == null || s.trim() == '';

bool blank = s?.trim()?.isEmpty ?? true;

var sortedKeys = myMap.keys.toList()..sort();
for (var k in sortedKeys) {
  print("Key=$k Value=${myMap[k]}");
}

mymap.entries.toList()
    ..sort((a, b) => a.value.compareTo(b.value))
    ..forEach(print);

bool b = d1.isBefore(d2);

var s2 = s1.replaceAll(w,"");

int n = x.length;

var y = x.toSet();

x = x.toSet().toList();

String? s = stdin.readLineSync();  
int? n = int.tryParse(s ?? "");

enum Suit {
    SPADES,
    HEARTS,
    DIAMONDS,
    CLUBS,
}

assert(isConsistent);

a.binarySearch(x);

var t = Stopwatch();
t.start();
foo();
t.stop();
print(t.elapsedMicroseconds * 1000);

foo() => ['a string', true];

if (c1) {
  f1;
} else if (c2) {
  f2;
} else if (c3) {
  f3;
}

var s = Stopwatch()..start();
f();
s.stop();
print(s.elapsed);

bool ok = s.toUpperCase().contains(word.toUpperCase());

var items = [a, b, c];

items.remove(x);

items.removeWhere((y)=>y==x);

final b = RegExp(r'^[0-9]+$').hasMatch(s);

Map myMap = {};
myMap.remove(key)

items1.forEach(print);
items2.forEach(print);

var s = x.toRadixString(16);

var b = await File(fp).exists();

print('${DateTime.now()} msg');

f = num.parse(s);

var t = '';
for(var c in s.runes) {
  if(c < 128){
    t = t + String.fromCharCode(c);
  }
}

if (p.endsWith("/")) p = p.substring(0, p.length - 1);

if (p.endsWith(path.separator)) p = p.substring(0, p.length - 1);

var s=c;

var t = '$s$i';

File(filepath).deleteSync();

var s = i.toString().padLeft(3,'0');

const String _planet = "Earth";

elements = [for (var e in elements) e * c];

elements = elements.map((e) => e * c).toList();

if (args.contains("b")) bat();
if (args.contains("f")) fox();

for(int i = 0; i < list.length; i += 2) {
  print("${list[i]}, ${list[i + 1]}");
}

x = items.last;

var ab = a + b;

var t = s.startsWith(p) ? s.replaceFirst(p,"") : s;

var t = s.startsWith(p) ? s.substring(p.length, s.length) : s;

int n = s.length;

var n = mymap.length;

s.add(x);

m[k] = v;

await post(u, body: body, headers: headers);

var s = a.buffer
    .asUint8List()
    .map((e) => e.toRadixString(16).padLeft(2, '0'))
    .join();

var a = hex.decode(s);

var extensions = [".jpg", "jpeg", ".png"];
var L = Directory(D)
    .listSync(recursive: true)
    .where((file) => extensions.contains(p.extension(file.path)))
    .toList();

var r = Rectangle.fromPoints(Point(x1,y1),Point(x2,y2));
var b = r.containsPoint(Point(x,y));

var r = MutableRectangle.fromPoints(Point(x1, y1), Point(x2, y2));
var center = Point(r.width / 2, r.height / 2);

var x = Directory(d).listSync();

var now = new DateTime.now();
var t = now.add(new Duration(days: 1));

Future.delayed(const Duration(seconds: 30), () => f(42));

exit(0);

var y = x.where(P).map(T).toList();

if (a.any((value) => value > x)) f();

var a = List.filled(n,0);
foo(a.take(m).toList());
foo(List<int> a) {
  a.fillRange(0, a.length, 42);
}

var lines = File(path).readAsLinesSync();

exit(x);

File(F).openSync(mode: FileMode.write).truncateSync(position);

var h = sqrt(x * x + y * y);

var s = data.map((v) => v * v).reduce((sum, v) => sum + v);

var foo = Platform.environment["FOO"] ?? "none";

var myProc = {"foo": foo, 
              "bar": bar, 
              "baz": baz, 
              "barfl": barfl};

myProc[str]?.call();

Directory(path).create();

var b = await Directory(path).exists();

s = s.padRight(m, c);

s = s.padLeft(m, c);

var t = s.replaceAll(RegExp(r"\s+"), " ");

var t = String.fromCharCodes(
	s.codeUnits.where((x) => (x ^ 0x30) <= 9) );

i=items.indexOf(x)

print(items.any((element) => element == "baz")
    ? "found it"
    : "did not find it");

items = [x, ...items];

void f({int? x}) => print(x == null ? "Not present" : "Present");

items.removeLast();

y = [...x];

File(src).copySync(dst);

print("verbose is ${args.contains("-v")}");

var s = base64.encode(data);

var bytes = base64Decode(s);

var c = a ^ b;

x.forEach(f);

print(a);

print(m);

print(x);

var c = items.toSet().length;

x.retainWhere((e) => p);

var a = 42, b = "Hello", c = 5.0;

var x = m.values.toList()[Random().nextInt(m.length)];

var i = int.parse(s, radix: 2);

var x = condition() ? "a" : "b";

x = x.map((e) => e == 'foo' ? 'bar' : e).toList();

for (var i = 0; i < x.length; i++) {
  if (x[i] == 'foo') x[i] = 'bar';
}

print(x);

for (int i = 5; i >= 0; i--) {
  print(i);
}

var i = items.length ;
for (var e in items.reversed) {
  i--;
  print("$i, $e");
}

var b = a.map(int.parse).toList();

var parts = s.split( RegExp(r"[,-_]") );

var items = <String>[];

List<String> items = [];

var t = 0;
while (n.isEven && n != 0) {
  t++;
  n = n >> 1;
}

t = n.toRadixString(2)
	.split('')
	.reversed
	.takeWhile((e) => e == '0')
	.length;

t = n.bitLength - 1 - n.toRadixString(2).lastIndexOf('1');

foo(List<List<int>> a) => print("${a.length} ${a[0].length}");
var a = [
    [1, 2],
    [3, 4],
    [5, 6]
  ];
foo(a);

var s = v * n;

foo(x) => print(x is String ? x : 'Nothing.');

foo('Hello, world!');
foo(42);

class Vector {
  final double x, y, z;

  Vector(this.x, this.y, this.z);

  Vector operator *(other) {
    return Vector(y * other.z - z * other.y, 
                  z * other.x - x * other.z,
                  x * other.y - y * other.x);
  }
}

var e = t.bike;
var s = e.name;
print(s);

if (r1.isNaN) {
  print("This is a quiet NaN.");
} else {
  print("This is a number.");
}

tst(x) {
  if (x.runtimeType == Foo) {
    print("Same Type.");
  } else if (x is Foo) {
    print("Extends type.");
  } else {
    print("Not related.");
  }
}

for (int i = 1; i <= 100; i++) {
  var s = StringBuffer();
  if (i % 3 == 0) s.write("Fizz");
  if (i % 5 == 0) s.write("Buzz");
  if (s.isEmpty) s.write(i);
  print(s);
}

var b = await Directory(p).list().isEmpty;

x.add(e);

x.remove(e);

Map<Point, String> m = {};
m[Point(42, 5)] = "Hello";

class Foo{};
Map<Foo, int> m = {};

var parts = s.split(sep);

var a = List.filled(n, 0);

s.split('').asMap().forEach((i, c) => print('Char $i is $c'));

var n = utf8.encode(s).length;

var b = x.contains(e);

var s = '$a$b';

var s = a + b;

items.setRange(i, j, items.sublist(i, j)..sort(c));

items.removeRange(i, j);

var s = [];
s.add(x);
var y = s.removeLast();

print(a.join(", "));

T.values.byName(s);

var position = x.lastIndexOf(y).clamp(0, x.length);
var x2 = x.replaceFirst(y, z, position);

data.sort((a, b) => a.toUpperCase().compareTo(b.toUpperCase()));

var y = Map.of(x);

// This is a comment

int fibonacci(int n) => n <= 2 ? 1 : fibonacci(n - 2) + fibonacci(n - 1);

var s = "Our sun has $x planets";

List<int> g(int start) sync* {
  while (true) {
    yield start;
    start++;
  }
}

final b = s.isEmpty;

m.clear()

final k = m.keys;

var encoded = const JsonEncoder.withIndent('  ').convert(x);
print(encoded);

final c = {...a, ...b};

final m = {
  for (final e in a) e.id: e,
};

final x = b ** n;

final c = s[s.length - 1];

final thisYear = DateTime.now().year;
final isLeap = DateTime(year, 2, 29).month == 2;