Flutter Linter Kuralları Bölüm 2: Stil Kuralları 💫 🌌 ✨
Tags: flutter, dart, flutterdev, linterrules
Published: 2022-02-20 21:01:28

Bir önceki [bölümde ](https://dev.to/gulsenkeskin/flutter-linter-kurallari-bolum-1-hata-kurallari-3d4j)Linter kurallarının ilk grubu olan hata kurallarını öğrenmiştik. Bu bölümde ikinci grupta yer alan stil kurallarına değineceğiz. 

## Stil Kuralları:

**always_declare_return_types**

Fonksiyon veya method dönüş türlerini belirtin:

Bir method veya fonksiyon oluştururken her zaman bir dönüş türü belirtin. Fonksiyonlar için dönüş türleri bildirmek, analyzer'ın çalışma zamanı sırasında oluşabilecek hatalar için kodunuzu daha iyi bir şekilde kontrol etmesine izin vererek kod tabanınızı iyileştirmeye yardımcı olur.

Yanlış kullanım:

```
main() { }

_bar() => _Foo();

class _Foo {
  _foo() => 42;
}
```


Doğru kullanım:

```
void main() { }

_Foo _bar() => _Foo();

class _Foo {
  int _foo() => 42;
}

typedef predicate = bool Function(Object o);
```


**always_put_control_body_on_new_line**

Bir if, for, while do'nun ifade kısmını kısa olsa bile expression ile aynı satıra koymayın.

Yanlış kullanım:

```
if (notReady) return;

if (notReady)
  return;
else print('ok')

while (condition) i += 1;
```


Doğru kullanım:

```
if (notReady)
  return;

if (notReady)
  return;
else
  print('ok')

while (condition)
  i += 1;
```

**always_put_required_named_parameters_first**

Required olarak tanımladığınız parametreleri her zaman en başa koyun:


Yanlış kullanım: `m({b, c, required a}) ;`
Doğru kullanım: `m({required a, b, c}) ;`

Yanlış kullanım: `m({b, c, @required a}) ;`
Doğru kullanım: `m({@required a, b, c}) ;`


**always_specify_types**

Tip açıklamalarını belirtin. Mümkün olduğunca var kullanmaktan kaçının.
Türün bilinmediğini açıkça belirtmek istiyorsanız dynamic kullanın.


Yanlış kullanım:

```
var foo = 10;
final bar = Bar();
const quux = 20;
```


Doğru kullanım:

```
int foo = 10;
final Bar bar = Bar();
String baz = 'hello';
const int quux = 20;
```


**annotate_overrides**

Override edilen medhod ve field'lara açıklama ekleyin.

Yanlış kullanım:

```
class Cat {
  int get lives => 9;
}

class Lucky extends Cat {
  final int lives = 14;
}
```


Doğru kullanım:

```
abstract class Dog {
  String get breed;
  void bark() {}
}

class Husky extends Dog {
  @override
  final String breed = 'Husky';
  @override
  void bark() {}
}
```

**avoid_annotating_with_dynamic**

Dinamik, bir fonksiyon veya methodun varsayılan dönüş değeri olduğundan, bunu belirtmeye gerek yoktur.


Yanlış kullanım:

```
dynamic lookUpOrDefault(String name, Map map, dynamic defaultValue) {
  var value = map[name];
  if (value != null) return value;
  return defaultValue;
}
```


Doğru kullanım:

```
lookUpOrDefault(String name, Map map, defaultValue) {
  var value = map[name];
  if (value != null) return value;
  return defaultValue;
}
```

**avoid_bool_literals_in_conditional_expressions**

Koşullu ifadelerde (conditional expressions) bool kullanımından kaçının.


Yanlış kullanım:

```
condition ? true : boolExpression
condition ? false : boolExpression
condition ? boolExpression : true
condition ? boolExpression : false
```


Doğru kullanım:

```
condition || boolExpression
!condition && boolExpression
!condition || boolExpression
condition && boolExpression
```


**avoid_catches_without_on_clauses**

Yan tümce olmadan catch kullanımından kaçının.

Ön yan tümceleri olmadan catch kullanmak, kodunuzu atılamayan(thrown) (ve dolayısıyla fark edilmeyecek) beklenmedik hatalarla karşılaşmaya yatkın hale getirir.

Yanlış kullanım:

```
try {
 somethingRisky()
}
catch(e) {
  doSomething(e);
}
```

Doğru kullanım:

```
try {
 somethingRisky()
}
on Exception catch(e) {
  doSomething(e);
}
```


**avoid_catching_errors**

Hatayı veya onu implemente eden türleri açıkça yakalamayın.

Hatalar, Exception'lardan farklıdır, çünkü Hatalar çalışma zamanından önce analiz edilebilir ve önlenebilir. Çalışma zamanında bir hatayı yakalamak (catch) neredeyse hiçbir zaman gerekmez.


Yanlış kullanım:

```
try {
  somethingRisky();
} on Error catch(e) {
  doSomething(e);
}
```


Doğru kullanım:

```
try {
  somethingRisky();
} on Exception catch(e) {
  doSomething(e);
}
```

**avoid_classes_with_only_static_members**

Yalnızca statik üyeler içeren bir sınıf tanımlamaktan kaçının.

Yanlış kullanım:

```
class DateUtils {
  static DateTime mostRecent(List<DateTime> dates) {
    return dates.reduce((a, b) => a.isAfter(b) ? a : b);
  }
}

class _Favorites {
  static const mammal = 'weasel';
}
```


Doğru kullanım:

```
DateTime mostRecent(List<DateTime> dates) {
  return dates.reduce((a, b) => a.isAfter(b) ? a : b);
}

const _favoriteMammal = 'weasel';
```


**avoid_double_and_int_checks**

Double ve int kontrollerinden kaçının.

JS'ye derlendiğinde integer değerler float olarak temsil edilir. Bu durum türün int veya double olduğu yerlerde, is or is'i kullanırken bazı beklenmedik davranışlara yol açabilir.


Yanlış kullanım:

```
f(num x) {
  if (x is double) {
    ...
  } else if (x is int) {
    ...
  }
}
```


Doğru kullanım:

```
f(dynamic x) {
  if (x is num) {
    ...
  } else {
    ...
  }
}
```


**avoid_equals_and_hash_code_on_mutable_classes**

@immutable olarak işaretlenmemiş sınıflarda aşırı yükleme operatörü (overloading) == ve hashCode kullanımından kaçının.

Bir sınıf immutable (değişmez) değilse, overloading operator (aşırı yükleme operatörü) == ve hashCode, koleksiyonlarda kullanıldığında öngörülemeyen ve istenmeyen davranışlara yol açabilir.


Yanlış kullanım:

```
class B {
  String key;
  const B(this.key);
  @override
  operator ==(other) => other is B && other.key == key;
  @override
  int hashCode() => key.hashCode;
}
```
Lint, @immutable notunun kullanımını kontrol eder ve sınıf başka türlü değiştirilemez olsa bile tetiklenir. Böylece:

Yanlış kullanım:
```
class C {
  final String key;
  const C(this.key);
  @override
  operator ==(other) => other is B && other.key == key;
  @override
  int hashCode() => key.hashCode;
}
```


Doğru kullanım:

```
@immutable
class A {
  final String key;
  const A(this.key);
  @override
  operator ==(other) => other is A && other.key == key;
  @override
  int hashCode() => key.hashCode;
}
```


**avoid_escaping_inner_quotes**

Kesme işareti kullanmanız gerekiyorsa string ifadenizi " çift tırnak içerisinde yazın. Tek tırnak kullanmayın.

Yanlış kullanım: `var s = 'It\'s not fun';`
Doğru kullanım: `var s = "It's not fun";`


**avoid_field_initializers_in_const_classes**

Const sınıflarında final başlatıcılarını kullanmaktan kaçının.

Yanlış kullanım:

```
class A {
  final a = const [];
  const A();
}
```

Doğru kullanım:

```
class A {
  get a => const [];
  const A();
}
```



**avoid_final_parameters**

Parametre bildirimlerinde final kullanmaktan kaçının.

Yanlış kullanım:

```
void goodParameter(final String label) { // LINT
  print(label);
}
```

Doğru kullanım:

```
void badParameter(String label) { // OK
  print(label);
}
```


Yanlış kullanım: `void goodExpression(final int value) => print(value); // LINT`



Doğru kullanım:`void badExpression(int value) => print(value); // OK`



Yanlış kullanım:`void badExpression(int value) => print(value); // OK`



Doğru kullanım:`[1, 4, 6, 8].forEach((value) => print(value + 2)); // OK`



**avoid_function_literals_in_foreach_calls**

Function literal ile forEach kullanımından kaçının.

Yanlış kullanım:

```
people.forEach((person) {
  ...
});
```

Doğru kullanım:

```
for (var person in people) {
  ...
}

people.forEach(print);
```



**avoid_init_to_null**

Değişkenleri null ataması yaparak başlatmayın.

Dart'ta değer ataması yapılmayan bir değişken otomatik olarak null olarak başlatılır. Bu sebeple null ataması yapmak gereksizdir.

Yanlış kullanım:

```
int _nextId = null;

class LazyId {
  int _id = null;

  int get id {
    if (_nextId == null) _nextId = 0;
    if (_id == null) _id = _nextId++;

    return _id;
  }
}
```


Doğru kullanım:

```
int _nextId;

class LazyId {
  int _id;

  int get id {
    if (_nextId == null) _nextId = 0;
    if (_id == null) _id = _nextId++;

    return _id;
  }
}
```

**avoid_js_rounded_ints**

Yanlış kullanım: `int value = 9007199254740995;`

Doğru kullanım: `BigInt value = BigInt.parse('9007199254740995');`


**avoid_multiple_declarations_per_line**

Tek bir satırda birden çok değişken tanımlamayın.

Yanlış kullanım: `String? foo, bar, baz;`

Doğru kullanım:

```
String? foo;
String? bar;
String? baz;
```


**avoid_null_checks_in_equality_operators**

Null özel bir tür olduğundan, hiçbir sınıf ona eşdeğer olamaz. Bu nedenle, diğer örneğin boş olup olmadığını kontrol etmek gereksizdir.


Yanlış kullanım:

```
class Person {
  final String name;

  @override
  operator ==(other) =>
      other != null && other is Person && name == other.name;
}
```


Doğru kullanım:

```
class Person {
  final String name;

  @override
  operator ==(other) => other is Person && name == other.name;
}
```

**avoid_positional_boolean_parameters**

Konumsal bool parametrelerini kullanmaktan kaçının.Bunun yerine adlandırılmış bool parametrelerini kullanın.

Yanlış kullanım:

```
Task(true);
Task(false);
ListBox(false, true, true);
Button(false);
```


Doğru kullanım:

```
Task.oneShot();
Task.repeating();
ListBox(scroll: true, showScrollbars: true);
Button(ButtonState.enabled);
```


**avoid_private_typedef_functions**

Yalnızca bir kez kullanılan özel typedef fonksiyonlarından kaçının. Satır içi işlev sözdizimini (inline function syntax) tercih edin.


Yanlış kullanım:

```
typedef void _F();
m(_F f);
```

Doğru kullanım:`m(void Function() f);`


**avoid_redundant_argument_values**

Fonksiyon parametresinin default değerine karşılık gelen argümanlar göndermekten kaçının.


Yanlış kullanım:

```
void f({bool valWithDefault = true, bool? val}) {
  ...
}

void main() {
  f(valWithDefault: true);
}
```


Doğru kullanım:

```
void f({bool valWithDefault = true, bool? val}) {
  ...
}

void main() {
  f(valWithDefault: false);
  f();
}
```


**avoid_renaming_method_parameters**

Override edilen methodların parametrelerini yeniden adlandırmayın.

Yanlış kullanım:

```
abstract class A {
  m(a);
}

abstract class B extends A {
  m(b);  <---
}
```


Doğru kullanım:

```
abstract class A {
  m(a);
}

abstract class B extends A {
  m(a);  <----
}
```

**avoid_return_types_on_setters**

Setter'larda dönüş türü belirtmekten kaçının.

Setter'lar bir değer döndürmediğinden, dönüş türü belirtmek gereksizdir.

Yanlış kullanım: `void set speed(int ms);`

Doğru kullanım: `set speed(int ms);`



**avoid_returning_null**

Dönüş türü bool, double, int veya num olan üyelerden null döndürmekten kaçının.

bool, double, int ve num gibi primitive (ilkel) türleri döndüren işlevlerin genellikle null olmayan değerler döndürmesi beklenir. Bu nedenle, primitive bir türün beklendiği yerde null döndürmek, runtime exception'larına (çalışma zamanı istisnalarına) yol açabilir.


Yanlış kullanım: 

```
bool getBool() => null;
num getNum() => null;
int getInt() => null;
double getDouble() => null;
```


Doğru kullanım:

```
bool getBool() => false;
num getNum() => -1;
int getInt() => -1;
double getDouble() => -1.0;
```


**avoid_returning_null_for_void**

Void için null döndürmekten kaçının.

Yanlış kullanım:

```
void f1() {
  return null;
}
Future<void> f2() async {
  return null;
}
```


Doğru kullanım:

```
void f1() {
  return;
}
Future<void> f2() async {
  return;
}
```


**avoid_returning_this**

this yerine cascade operator'ünü kullanın.

Yanlış kullanım:

```
var buffer = StringBuffer()
  .write('one')
  .write('two')
  .write('three');
```

Doğru kullanım:

```
var buffer = StringBuffer()
  ..write('one')
  ..write('two')
  ..write('three');
```

**avoid_setters_without_getters**

Karşılık gelen bir getter değeri olmadan bir setter tanımlamayın.


Yanlış kullanım:

```
class Bad {
  int l, r;

  set length(int newLength) {
    r = l + newLength;
  }
}
```


Doğru kullanım:


```
class Good {
  int l, r;

  int get length => r - l;

  set length(int newLength) {
    r = l + newLength;
  }
}
```

**avoid_shadowing_type_parameters**

Shadowing tip parametrelerinden kaçının.

Yanlış kullanım:

```
class A<T> {
  void fn<T>() {}
}
```

Doğru kullanım:

```
class A<T> {
  void fn<U>() {}
}
```

**avoid_types_on_closure_parameters**

Function expression parametreleri için tür belirmek gereksizdir.


Yanlış kullanım:

```
var names = people.map((Person person) => person.name);
```

Doğru kullanım:

```
var names = people.map((person) => person.name);
```


**avoid_unnecessary_containers**

Gereksiz Container kullanımından kaçının.

Bir Widget öğesini başka hiçbir parametre seti olmadan Container ile sarmanın hiçbir etkisi yoktur ve kodu gereksiz yere daha karmaşık hale getirir.

Yanlış kullanım:

```
Widget buildRow() {
  return Container(
      child: Row(
        children: <Widget>[
          const MyLogo(),
          const Expanded(
            child: Text('...'),
          ),
        ],
      )
  );
}
```

Doğru kullanım:

```
Widget buildRow() {
  return Row(
    children: <Widget>[
      const MyLogo(),
      const Expanded(
        child: Text('...'),
      ),
    ],
  );
}
```


**avoid_unused_constructor_parameters**

Constructor'larda kullanılmayan parametre tanımlamaktan kaçının.


Yanlış kullanım:

```
class BadOne {
  BadOne(int unusedParameter, [String unusedPositional]);
}

class BadTwo {
  int c;

  BadTwo(int a, int b, int x) {
    c = a + b;
  }
}
```


**avoid_void_async**

Void döndüren asenkron fonksiyonlardan kaçının.

Asenkron fonksiyonlarda geriye Future döndürün.

Yanlış kullanım:

```
void f() async {}
void f2() async => null;
```

Doğru kullanım:

```
Future<void> f() async {}
Future<void> f2() async => null;
```


**await_only_futures**

Await'e şu türlerde izin verilir: Future<X>, FutureOr<X>, Future<X>?, FutureOr<X>? ve dynamic.

Yanlış kullanım:

```
main() async {
  print(await 23);
}
```

Doğru kulllanım:

```
main() async {
  await null; // If a delay is really intended.
  print(23);
}
```


**camel_case_extensions**

Uzantıları UpperCamelCase kullanarak adlandırın.
Uzantılar adlandırılırken, her kelimenin ilk harfin büyük yazmalı (ilk kelime dahil) ve seperator (ayırıcı) kullanmamalıdır.


Doğru kullanım:

```
extension MyFancyList<T> on List<T> { 
  // ... 
}

extension SmartIterable<T> on Iterable<T> {
  // ...
}
```


**camel_case_types**

Sınıflar ve typedef'ler isimlendirilirken her kelimenin ilk harfin (ilk kelime dahil) büyük yazmalı ve seperator kullanmamalıdır.


Doğru kullanım:

```
class SliderMenu {
  // ...
}

class HttpRequest {
  // ...
}

typedef num Adder(num x, num y);
```


**cascade_invocations**

Aynı referans üzerinde art arda methodlar çağırırken cascading (basamaklı) stili kullanın.

Yanlış kullanım:

```
SomeClass someReference = SomeClass();
someReference.firstMethod();
someReference.secondMethod();
```

Yanlış kullanım:

```
SomeClass someReference = SomeClass();
...
someReference.firstMethod();
someReference.aProperty = value;
someReference.secondMethod();
```


Doğru kullanım:

```
SomeClass someReference = SomeClass()
    ..firstMethod()
    ..aProperty = value
    ..secondMethod();
```


Doğru kullanım:

```
SomeClass someReference = SomeClass();
...
someReference
    ..firstMethod()
    ..aProperty = value
    ..secondMethod();
```


**cast_nullable_to_non_nullable**

Nullable olmayan bir türe nullable bir değer atamayın.

Yanlış kullanım:

```
class A {}
class B extends A {}

A? a;
var v = a as B;
var v = a as A;
```



Doğru kullanım:

```
class A {}
class B extends A {}

A? a;
var v = a! as B;
var v = a!;
```


**constant_identifier_names**

Constant isimlerinde lowerCamelCase kullanın.

Yanlış kullanım:
```
const PI = 3.14;
const kDefaultTimeout = 1000;
final URL_SCHEME = RegExp('^([a-z]+):');

class Dice {
  static final NUMBER_GENERATOR = Random();
}

```



Doğru kullanım:

```
const pi = 3.14;
const defaultTimeout = 1000;
final urlScheme = RegExp('^([a-z]+):');

class Dice {
  static final numberGenerator = Random();
}
```


**deprecated_consistency**


@Deprecated()'ı Tutarlı bir şekilde uygulayın :

bir sınıf kullanımdan kaldırılmışsa (deprecated), constructor'ları da kullanımdan kaldırılmalıdır.
Bir field kullanımdan kaldırılmışsa, ona işaret eden constructor parametresi de kullanımdan kaldırılmalıdır.
Bir field'a işaret eden bir constructor parametresi kullanımdan kaldırılmışsa, field da kullanımdan kaldırılmalıdır.


Yanlış kullanım:

```
@deprecated
class A {
  A();
}

class B {
  B({this.field});
  @deprecated
  Object field;
}
```

Doğru kullanım:

```
@deprecated
class A {
  @deprecated
  A();
}

class B {
  B({@deprecated this.field});
  @deprecated
  Object field;
}
```


**directives_ordering**

`dart:` importlarını diğer importlardan önce yapın.


Yanlış kullanım:

```
import 'package:bar/bar.dart';
import 'package:foo/foo.dart';

import 'dart:async';  // LINT
import 'dart:html';  // LINT
```

Doğru kullanım:

```
import 'dart:async';  // OK
import 'dart:html';  // OK

import 'package:bar/bar.dart';
import 'package:foo/foo.dart';
```

`package:` importlarını relative importlarından önce yapın.

Yanlış kullanım:

```
import 'a.dart';
import 'b.dart';

import 'package:bar/bar.dart';  // LINT
import 'package:foo/foo.dart';  // LINT
```

Doğru kullanım:

```
import 'package:bar/bar.dart';  // OK
import 'package:foo/foo.dart';  // OK

import 'a.dart';
import 'b.dart';
```

Tüm `import` 'lardan sonra `export` 'ları ayrı bir bölümde belirtin.

Yanlış kullanım:

```
import 'src/error.dart';
export 'src/error.dart'; // LINT
import 'src/string_source.dart';
```

Doğru kullanım:

```
import 'src/error.dart';
import 'src/string_source.dart';

export 'src/error.dart'; // OK
```

Alfabetik sıralamayı kullanın.

Yanlış kullanım:

```
import 'package:foo/bar.dart'; // OK
import 'package:bar/bar.dart'; // LINT

import 'a/b.dart'; // OK
import 'a.dart'; // LINT
```

Doğru kullanım:

```
import 'package:bar/bar.dart'; // OK
import 'package:foo/bar.dart'; // OK

import 'a.dart'; // OK
import 'a/b.dart'; // OK
```

**do_not_use_environment**

Environment tarafından bildirilen değişkenleri kullanmayın.

Derleme zamanında environment'dan türetilen değerlerin kullanılması, gizli global durum yaratır ve uygulamaların anlaşılmasını ve sürdürülmesini zorlaştırır.

fromEnvironment veya hasEnvironment factory constructor'larını kullanmayın.

Yanlış kullanım:

```
const loggingLevel =
  bool.hasEnvironment('logging') ? String.fromEnvironment('logging') : null;
```

**empty_catches**

Boş catch bloklarını kullanmaktan kaçının.

Genel olarak, boş catch bloklarını kullanmaktan kaçının. Bunun gerektiği durumlarda exception'ların neden yakalanıp bastırıldığını açıklamak için bir yorum yapılmalıdır. Alternatif olarak, exception tanımlayıcı (exception identifier), onu atlamak istediğimizi belirtmek için alt çizgilerle (örneğin, _) adlandırılabilir.

Yanlış kullanım:

```
try {
  ...
} catch(exception) { }
```


Doğru kullanım:

```
try {
  ...
} catch(e) {
  // ignored, really.
}

// Alternatively:
try {
  ...
} catch(_) { }

// Better still:
try {
  ...
} catch(e) {
  doSomething(e);
}
```

**empty_constructor_bodies**

Dart'ta, boş bir gövdeye sahip bir constructor yalnızca noktalı virgülle sonlandırılabilir. Bu const constructor'ları için gereklidir. 

Doğru kullanım:

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

Yanlış kullanım:

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

**eol_at_end_of_file**

Dosya sonlarına yeni bir satır koyun.
Boş olmayan dosyaların sonuna tek bir yeni satır koyun.

Yanlış kullanım:

```
a {
}
```

Doğru kullanım:

```
b {
}
    <-- newline
```


**exhaustive_cases**

Enum benzeri sınıflardaki tüm constant'lar için durum yan tümceleri (case clauses) tanımlayın.

Yanlış kullanım:

```
class EnumLike {
  final int i;
  const EnumLike._(this.i);

  static const e = EnumLike._(1);
  static const f = EnumLike._(2);
  static const g = EnumLike._(3);
}

void bad(EnumLike e) {
  // Missing case.
  switch(e) { // LINT
    case EnumLike.e :
      print('e');
      break;
    case EnumLike.f :
      print('f');
      break;
  }
}
```


Doğru kullanım:

```
class EnumLike {
  final int i;
  const EnumLike._(this.i);

  static const e = EnumLike._(1);
  static const f = EnumLike._(2);
  static const g = EnumLike._(3);
}

void ok(EnumLike e) {
  // All cases covered.
  switch(e) { // OK
    case EnumLike.e :
      print('e');
      break;
    case EnumLike.f :
      print('f');
      break;
    case EnumLike.g :
      print('g');
      break;
  }
}
```
**file_names**
Bu [makalede ](https://dev.to/gulsenkeskin/flutter-temiz-kod-prensipleri-3kg7) ayrıntılı olarak açıklandı.

**implementation_imports**

Uygulama dosyalarını başka bir paketten import etmeyin.

lib içindeki kitaplıklar herkese açıktır: diğer paketler bunları import etmekte serbesttir. Ancak bir paketin kodunun çoğu, yalnızca paketin kendisi tarafından import edilip kullanılması gereken dahili uygulama kitaplıklarıdır. Bunlar, lib'nin src adlı bir alt dizinine girer. İşleri düzenlemenize yardımcı olacaksa, orada alt dizinler oluşturabilirsiniz.

Aynı paketteki diğer Dart kodunun içinden lib/src'de yaşayan kitaplıkları içe aktarmakta özgürsünüz (lib'deki diğer kitaplıklar, bin içindeki komut dosyaları ve testler gibi) ancak asla başka bir paketin lib/src dizininden içe aktarmamalısınız. Bu dosyalar paketin genel API'sinin bir parçası değildir ve kodunuzu bozabilecek şekillerde değişebilirler.

Yanlış kullanım:
```
// In 'road_runner'
import 'package:acme/lib/src/internals.dart;
```

**join_return_with_assignment**

Mümkün olduğunda return deyimini atama ile birleştirin.

Yanlış kullanım:

```
class A {
  B _lazyInstance;
  static B get instance {
    _lazyInstance ??= B(); // LINT
    return _lazyInstance;
  }
}
```


Doğru kullanım:

```
class A {
  B _lazyInstance;
  static B get instance => _lazyInstance ??= B();
}
```

**leading_newlines_in_multiline_strings**

Çok satırlı dizeleri yeni satırla başlatın.

Çok satırlı dizeler, yeni bir satırla başladıklarında okunması daha kolaydır (çok satırlı bir dizeyi başlatan yeni satır yok sayılır).

Yanlış kullanım:

```
var s1 = '''{
  "a": 1,
  "b": 2
}''';
```

Doğru kullanım:

```
var s1 = '''
{
  "a": 1,
  "b": 2
}''';

var s2 = '''This one-liner multiline string is ok. It usually allows to escape both ' and " in the string.''';
```


**library_private_types_in_public_api**

Genel API'lerde özel türleri kullanmaktan kaçının.


Yanlış kullanım:

```
f(_Private p) { ... }
class _Private {}
```

Doğru kullanım:

```
f(String s) { ... }
```


**line_longer_than_80_chars**

80 karakterden uzun satırlardan kaçının.


## no_default_cases


Kötü kullanım:

```
  switch (testEnum) {
    case TestEnum.A:
      return '123';
    case TestEnum.B:
      return 'abc';
    default:
      return null;
  }
```

Doğru kullanım:

```
  switch (testEnum) {
    case TestEnum.A:
      return '123';
    case TestEnum.B:
      return 'abc';
  }
  // Default here.
  return null;
```

**no_runtimeType_toString**

runtimeType üzerinde "toString()" çağrısı yapmaktan kaçının.

Bir çalışma zamanı türünde toString'i çağırmak, performansı olumsuz yönde etkileyebilecek önemsiz bir işlemdir. Bundan kaçınmak daha iyidir.


Yanlış kullanım:

```
class A {
  String toString() => '$runtimeType()';
}
```

Doğru kullanım:

```
class A {
  String toString() => 'A()';
}
```

Bu durumun geçerli olmadığı performansın sorun olmadığı veya real type bilgilerinin performanstan daha önemli olduğu bazı istisnalara sahiptir:

assertion
throw expressions (atma ifadelerinde)
catch clauses (yakalama cümleciklerinde)
mixin declaration 
abstract class (soyut sınıfta)


**null_closures**

Closure (kapanmanın) beklendiği bir argüman olarak null iletmeyin.

Yanlış kullanım: `[1, 3, 5].firstWhere((e) => e.isOdd, orElse: null);`

Doğru kullanım: `[1, 3, 5].firstWhere((e) => e.isOdd, orElse: () => null);`


**omit_local_variable_types**

Local değişkenler için tür açıklamalarını atlayın.

Local değişkenler, özellikle fonksiyonların küçük olma eğiliminde olduğu modern kodda çok az kapsama sahiptir. Türün atlanması, okuyucunun dikkatini değişkenin ismine ve onun başlangıç ​​değerine odaklar.

Yanlış kullanım:

```
List<List<Ingredient>> possibleDesserts(Set<Ingredient> pantry) {
  List<List<Ingredient>> desserts = <List<Ingredient>>[];
  for (final List<Ingredient> recipe in cookbook) {
    if (pantry.containsAll(recipe)) {
      desserts.add(recipe);
    }
  }

  return desserts;
}
```


Doğru kullanım:

```
List<List<Ingredient>> possibleDesserts(Set<Ingredient> pantry) {
  var desserts = <List<Ingredient>>[];
  for (final recipe in cookbook) {
    if (pantry.containsAll(recipe)) {
      desserts.add(recipe);
    }
  }

  return desserts;
}
```

Bazen çıkarsanan tür, değişkenin sahip olmasını istediğiniz tür değildir. Örneğin, daha sonra başka türlerin değerlerini atamayı düşünebilirsin. Bu durumda, değişkene istediğiniz türde açıklama ekleyin.

```
Widget build(BuildContext context) {
  [!Widget!] result = Text('You won!');
  if (applyPadding) {
    result = Padding(padding: EdgeInsets.all(8.0), child: result);
  }
  return result;
}
```

**one_member_abstracts**
Basit bir fonksiyon kullanılacaksa tek üyeli bir abstract (soyut ) sınıf tanımlamaktan kaçının.


Yanlış kullanım:

```
abstract class Predicate {
  bool test(item);
}
```

Doğru kullanım: `typedef Predicate = bool Function(item);`


**only_throw_errors**

Yalnızca istisna (exception) veya Hata'yı genişleten (extending) sınıfların örneklerini atın.

Yalnızca dart.core.Error veya dart.core.Exception'ı genişleten sınıf örnekleri atın.

Hata veya istisna'yı extend etmeyen örnekler atmak kötü bir uygulamadır.

Yanlış kullanım:

```
void throwString() {
  throw 'hello world!'; // LINT
}
```

Doğru kullanım:

```
void throwArgumentError() {
  Error error = ArgumentError('oh!');
  throw error; // OK
}
```

**overriden_fields**

Field'ları override etmeyin.

Yanlış kullanım:

```
class Base {
  Object field = 'lorem';

  Object something = 'change';
}

class Bad1 extends Base {
  @override
  final field = 'ipsum'; // LINT
}

class Bad2 extends Base {
  @override
  Object something = 'done'; // LINT
}
```


Doğru kullanım:

```
class Base {
  Object field = 'lorem';

  Object something = 'change';
}

class Ok extends Base {
  Object newField; // OK

  final Object newFinal = 'ignore'; // OK
}
```

Doğru kullanım:
```
abstract class BaseLoggingHandler {
  Base transformer;
}

class LogPrintHandler implements BaseLoggingHandler {
  @override
  Derived transformer; // OK
}
```

**package_api_docs**
Tüm public API'ler için belge yorumları sağlayın.

Public (genel) API'ler, paketinizin lib klasöründeki her şeyden, lib/src'deki uygulama dosyalarının çıkarılması ve bir dışa aktarma yönergesiyle açıkça export edilen öğelerin eklenmesinden oluşur.

Örneğin lib/foo.dart:

```
export 'src/bar.dart' show Bar;
export 'src/baz.dart';

class Foo { }

class _Foo { }
```

Tüm public API üyeleri, ///belge-stili yorumlarla ( doc-style comments) belgelenmelidir.


Yanlış kullanım:

```
class Bar {
  void bar();
}
```

Doğru kullanım:

```
/// A Foo.
abstract class Foo {
  /// Start foo-ing.
  void start() => _start();

  _start();
}
```


**package_prefixed_library_names**

Bu kılavuz, iki kitaplık aynı ada sahip olduğunda alınan uyarılardan kaçınmanıza yardımcı olur. Önerilen kurallar:

Paket adının önüne tüm kitaplık adlarını ekleyin.
Giriş kitaplığının paketle aynı ada sahip olmasını sağlayın.
Bir paketteki diğer tüm kitaplıklar için, paket adından sonra kitaplığın Dart dosyasına noktayla ayrılmış yolu ekleyin.
lib altındaki kitaplıklar için üst dizin adını atlayın.

Örneğin, paket adının my_package olduğu paketteki çeşitli dosyalar için kitaplık adları şunlardır:

```
// In lib/my_package.dart
library my_package;

// In lib/other.dart
library my_package.other;

// In lib/foo/bar.dart
library my_package.foo.bar;

// In example/foo/bar.dart
library my_package.example.foo.bar;

// In lib/src/private.dart
library my_package.src.private;
```

**parameter_assignments**

Fonksiyon veya methodların parametrelerine yeni değerler atamayın.

??= gibi bir operatör kullanılmadığı sürece, parametrelere yeni değerler atamak genellikle kötü bir uygulamadır. Aksi takdirde, parametreleri keyfi olarak yeniden atamak bir hatadır.

Yanlış kullanım:
```
void badFunction(int parameter) { // LINT
  parameter = 4;
}
```

Yanlış kullanım:

```
void badFunction(int required, {int optional: 42}) { // LINT
  optional ??= 8;
}
```


Yanlış kullanım:

```
void badFunctionPositional(int required, [int optional = 42]) { // LINT
  optional ??= 8;
}
```

Yanlış kullanım:

```
class A {
    void badMethod(int parameter) { // LINT
    parameter = 4;
  }
}
```

Doğru kullanım:

```
void ok(String parameter) {
  print(parameter);
}
```


Doğru kullanım:

```
void actuallyGood(int required, {int optional}) { // OK
  optional ??= ...;
}
```



Doğru kullanım:

```
void actuallyGoodPositional(int required, [int optional]) { // OK
  optional ??= ...;
}
```


Doğru kullanım:

```
class A {
  void ok(String parameter) {
    print(parameter);
  }
}
```


**prefer_adjacent_string_concatenation**


**prefer_adjacent_string_concatenation**

String birleştirme için string literal'i kullanın.

Yanlış kullanım:

```
raiseAlarm(
    'ERROR: Parts of the spaceship are on fire. Other ' +
    'parts are overrun by martians. Unclear which are which.');
```


Doğru kullanım:

```
raiseAlarm(
    'ERROR: Parts of the spaceship are on fire. Other '
    'parts are overrun by martians. Unclear which are which.');
```


**prefer_asserts_with_message**

Assert'e mesaj eklemek, geliştiricinin AssertionError'ın neden oluştuğunu anlamasına yardımcı olur.

Yanlış kullanım:

```
f(a) {
  assert(a != null);
}

class A {
  A(a) : assert(a != null);
}
```


Doğru kullanım:

```
f(a) {
  assert(a != null, 'a must not be null');
}

class A {
  A(a) : assert(a != null, 'a must not be null');
}
```


**prefer_collection_literals**

Mümkün olduğunca koleksiyon literallerini kullanın.

Yanlış kullanım:

```
var points = List();
var addresses = Map();
var uniqueNames = Set();
var ids = LinkedHashSet();
var coordinates = LinkedHashMap();
```

Doğru kullanım:

```
var points = [];
var addresses = <String,String>{};
var uniqueNames = <String>{};
var ids = <int>{};
var coordinates = <int,int>{};
```


İSTİSNALAR:

LinkedHashSet veya LinkedHashMap ile, bir  literal constructor'ın  bir tür hatasını tetiklediği ve bu sebeple bunların lint'den hariç tutulduğu bazı durumlar vardır.



```
void main() {
  LinkedHashSet<int> linkedHashSet =  LinkedHashSet.from([1, 2, 3]); // OK
  LinkedHashMap linkedHashMap = LinkedHashMap(); // OK
  
  printSet(LinkedHashSet<int>()); // LINT
  printHashSet(LinkedHashSet<int>()); // OK

  printMap(LinkedHashMap<int, int>()); // LINT
  printHashMap(LinkedHashMap<int, int>()); // OK
}

void printSet(Set<int> ids) => print('$ids!');
void printHashSet(LinkedHashSet<int> ids) => printSet(ids);
void printMap(Map map) => print('$map!');
void printHashMap(LinkedHashMap map) => printMap(map);
```


**prefer_conditional_assignment**

Null testi yerine ??= kullanmayı tercih edin.

??=  >>>> ==null 

Yanlış kullanım:

```
String get fullName {
  if (_fullName == null) {
    _fullName = getFullUserName(this);
  }
  return _fullName;
}
```


Doğru kullanım:

```
String get fullName {
  return _fullName ??= getFullUserName(this);
}
```

**prefer_const_constructors**

Constant(sabit) constructor'larda const kullanın.


Yanlış kullanım:

```
class A {
  const A();
}

void accessA() {
  A a = new A();
}
```


Doğru kullanım:

```
class A {
  const A();
}

void accessA() {
  A a = const A();
}
```




Doğru kullanım:

```
class A {
  final int x;

  const A(this.x);
}

A foo(int x) => new A(x);
```


**prefer_const_constructors_in_immutables**

immutable sınıflarında const constructorları kullanın.

Yanlış kullanım:
```
@immutable
class A {
  final a;
  A(this.a);
}
```


Doğru kullanım:

```
@immutable
class A {
  final a;
  const A(this.a);
}
```

**prefer_const_declarations**

Const declaration'ları için const kullanın.

Yanlış kullanım:
```
final o = const <int>[];

class A {
  static final o = const <int>[];
}
```

Doğru kullanım:

```
const o = <int>[];

class A {
  static const o = <int>[];
}
```


**prefer_const_literals_to_create_immutables**

Immutable sınıflarında constructor paremetresi olarak literalleri kullanın.

Immutable sınıf örneklemelerinde (instantiating ) parametre olarak kullanılan list, map ve set literal'lerini başlatmak için const kullanmayı TERCİH edin.

* Not: Instantiate (fiil) ve instantiation (isim), nesne yönelimli programlama (OOP) dilinde bir nesnenin (veya belirli bir sınıfın "örneğinin") oluşturulmasına atıfta bulunur. *


Yanlış kullanım:

```
@immutable
class A {
  A(this.v);
  final v;
}

A a1 = new A([1]);
A a2 = new A({});
```


Doğru kullanım:

```
A a1 = new A(const [1]);
A a2 = new A(const {});
```



**prefer_constructors_over_static_methods**

Instanece'lar (örnekler) oluşturmak için statik methodlar yerine constructor tanımlamayı tercih edin.

Çoğu durumda, instantiation'ı  daha net hale getirdiği için statik bir method yerine adlandırılmış bir constructor kullanmak daha mantıklıdır.


Yanlış kullanım:

```
class Point {
  num x, y;
  Point(this.x, this.y);
  static Point polar(num theta, num radius) {
    return Point(radius * math.cos(theta),
        radius * math.sin(theta));
  }
}
```

Doğru kullanım:

```
class Point {
  num x, y;
  Point(this.x, this.y);
  Point.polar(num theta, num radius)
      : x = radius * math.cos(theta),
        y = radius * math.sin(theta);
}
```


**prefer_contains**
indexOf'u bir listenin bir öğeyi içerip içermediğini bulmak için kullanmayın.

Bunun yerine contains kullanın.


Yanlış kullanım:

`if (lunchBox.indexOf('sandwich') == -1) return 'so hungry...';`

Doğru kullanım:
`if (!lunchBox.contains('sandwich')) return 'so hungry...';`



**prefer_equal_for_default_values**


Adlandırılmış bir parametreyi varsayılan değerinden ayırmak için = kullanın.

Yanlış kullanım:
```
m({a: 1})
```

Doğru kullanım:

```
m({a = 1})
```




**prefer_final_fields**

Daha sonra kitaplıkta yeniden atanmamışlarsa, private alanları final  olarak bildirmeyi tercih edin.

Alanları mümkün olduğunda final olarak bildirmek iyi bir uygulamadır bu kullanım durumu yanlışlıkla yeniden atamaları önlemeye yardımcı olur ve derleyicinin optimizasyon yapmasına izin verir.


Yanlış kullanım:

```
class BadImmutable {
  var _label = 'hola mundo! BadImmutable'; // LINT
  var label = 'hola mundo! BadImmutable'; // OK
}
```


Yanlış kullanım:

```
class MultipleMutable {
  var _label = 'hola mundo! GoodMutable', _offender = 'mumble mumble!'; // LINT
  var _someOther; // LINT

  MultipleMutable() : _someOther = 5;

  MultipleMutable(this._someOther);

  void changeLabel() {
    _label= 'hello world! GoodMutable';
  }
}
```


Doğru kullanım:

```
class GoodImmutable {
  final label = 'hola mundo! BadImmutable', bla = 5; // OK
  final _label = 'hola mundo! BadImmutable', _bla = 5; // OK
}
```

Doğru kullanım:

```
class GoodMutable {
  var _label = 'hola mundo! GoodMutable';

  void changeLabel() {
    _label = 'hello world! GoodMutable';
  }
}
```


Yanlış kulanım:

```
class AssignedInAllConstructors {
  var _label; // LINT
  AssignedInAllConstructors(this._label);
  AssignedInAllConstructors.withDefault() : _label = 'Hello';
}
```

Doğru kullanım:

```
class NotAssignedInAllConstructors {
  var _label; // OK
  NotAssignedInAllConstructors();
  NotAssignedInAllConstructors.withDefault() : _label = 'Hello';
}
```


**prefer_final_in_for_each**

For-each döngüleri için değişkenleri final olarak bildirmek, yanlışlıkla yeniden atamaları önleyerek derleyicinin optimizasyon yapmasını sağlar.


Yanlış kullanım:

```
for (var element in elements) { // LINT
  print('Element: $element');
}
```


Doğru kullanım:

```
for (final element in elements) {
  print('Element: $element');
}
```

Doğru kullanım:

```
for (var element in elements) {
  element = element + element;
  print('Element: $element');
}
```



**prefer_final_locals**

Daha sonra yeni bir değer atanmayacaksa değişkenleri final olarak tanımlayın.

Yanlış kullanım:

```
void badMethod() {
  var label = 'hola mundo! badMethod'; // LINT
  print(label);
}
```

Doğru kullanım:

```
void goodMethod() {
  final label = 'hola mundo! goodMethod';
  print(label);
}
```

Doğru kullanım:

```
void mutableCase() {
  var label = 'hola mundo! mutableCase';
  print(label);
  label = 'hello world';
  print(label);
}
```

**prefer_final_parameters**

Yeniden değer atanmayacaksa parametre bildirimleri için final'ı tercih edin.


Yanlış kullanım:

```
void badParameter(String label) { // LINT
  print(label);
}
```


Doğru kullanım:

```
void goodParameter(final String label) { // OK
  print(label);
}
```


Yanlış kullanım: `void badExpression(int value) => print(value); // LINT`

Doğru kullanım: `void goodExpression(final int value) => print(value); // OK`


Yanlış kullanım:`[1, 4, 6, 8].forEach((value) => print(value + 2)); // LINT`

Doğru kullanım: `[1, 4, 6, 8].forEach((final value) => print(value + 2)); // OK`


Doğru kullanım: 

```
void mutableParameter(String label) { // OK
  print(label);
  label = 'Hello Linter!';
  print(label);
}
```



**prefer_for_elements_to_map_fromIterable**

Yanlış kullanım:

```
Map<String, WidgetBuilder>.fromIterable(
  kAllGalleryDemos,
  key: (demo) => '${demo.routeName}',
  value: (demo) => demo.buildRoute,
);
```


Doğru kullanım:

```
return {
  for (var demo in kAllGalleryDemos)
    '${demo.routeName}': demo.buildRoute,
};
```



**prefer_foreach**
Tüm elementlere yalnızca bir fonksiyon uygulamak için forEach kullanın.

Bir iterable (yinelenebilir) öğenin tüm öğelerine yalnızca bir fonksiyon veya method uygulayacaksanız, forEach'i kullanın.

Yanlış kullanım:

```
for (final key in map.keys.toList()) {
  map.remove(key);
}
```

Doğru kullanım:

```
map.keys.toList().forEach(map.remove);

```



```
for (myList'teki son v) {
   foo().f(v); // Bu kod foo()'yu birçok kez çağırır.
}

myList.forEach(foo().f); // Ama bu kod, foo()'yu yalnızca bir kez çağırır.
```


**prefer_function_declarations_over_variables**
Bir fonksiyonu bir ada bağlamak için bir function declaration (fonksiyon bildirimi) kullanın.

Dart, local fonksiyon bildirimlerine (declarations) izin verdiğinden, bunları function literal'leri yerine kullanmak iyi bir uygulamadır.


Yanlış kullanım:

```
void main() {
  var localFunction = () {
    ...
  };
}
```

Doğru kullanım:

```
void main() {
  localFunction() {
    ...
  }
}
```


**prefer_generic_function_type_aliases**

Generic fonksiyonların tanıtılmasıyla birlikte, function type takma adları (typedef void F()), kullanıcıların ifade etmek isteyebileceği tüm olası parametreleştirme türlerini ifade edemedi. Generic function type takma adları (typedef F = void Function()) bu sorunu düzeltti.

Tutarlılık ve okunabilirlik nedenleriyle, yalnızca bir sözdizimi kullanmak ve dolayısıyla Generic function type takma adlarını (aliases) tercih etmek daha iyidir.


Yanlış kullanım: `typedef void F();`

Doğru kullanım: `typedef F = void Function();`


**prefer_if_elements_to_conditional_expressions**

Mümkünse if öğelerini koşullu ifadelere tercih (conditional expressions) edin.

Koleksiyonlar oluştururken, koşul öğelerinden ziyade if öğelerinin kullanılması tercih edilir.

Yanlış kullanım:

```
Widget build(BuildContext context) {
  return Row(
    children: [
      IconButton(icon: Icon(Icons.menu)),
      Expanded(child: title),
      isAndroid ? IconButton(icon: Icon(Icons.search)) : null,
    ].where((child) => child != null).toList(),
  );
}
```


Doğru kullanım:

```
Widget build(BuildContext context) {
  return Row(
    children: [
      IconButton(icon: Icon(Icons.menu)),
      Expanded(child: title),
      if (isAndroid) IconButton(icon: Icon(Icons.search)),
    ]
  );
}
```



**prefer_if_null_operators**

Koşullu ifadelerde null kontrolleri yerine if null operatörlerini kullanmayı tercih edin.

Yanlış kullanım: `v = a == null ? b : a;`

Doğru kullanım:  `v = a ?? b;`


**prefer_initializing_formals**

Mümkün olduğunda initializing formal'lerini kullanmak, kodunuzu daha özlü hale getirir.

Yanlış kullanım:

```
class Point {
  num x, y;
  Point(num x, num y) {
    this.x = x;
    this.y = y;
  }
}
```

Doğru kullanım:

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

Yanlış kullanım:

```
class Point {
  num x, y;
  Point({num x, num y}) {
    this.x = x;
    this.y = y;
  }
}
```


Doğru kullanım:

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


NOT: Bu kural, parametre adı ve alan adı aynı olmadıkça, adlandırılmış parametreler için bir lint oluşturmaz. Bunun nedeni, böyle bir lint'i çözmenin ya alanı yeniden adlandırmayı ya da parametreyi yeniden adlandırmayı gerektireceği ve bu eylemlerin her ikisinin de potansiyel olarak bir kırılma değişikliği olacağıdır. Örneğin, aşağıdakiler bir lint oluşturmaz:

```
class Point {
  bool isEnabled;
  Point({bool enabled}) {
    this.isEnabled = enabled; // OK
  }
}
```

**prefer_inlined_adds**


Mümkün olduğunda add ve addAll methodlarını kullanmak yerine öğeleri liste literal'lerinde (değişmezlerinde) satır içi olarak bildirin.

Yanlış kullanım:
```
var l = ['a']..add('b')..add('c');
var l2 = ['a']..addAll(['b', 'c'])
```


Doğru kullanım:

```
var l = ['a', 'b', 'c'];
var 2 = ['a', 'b', 'c'];
```


**prefer_int_literals**

int literallerini double literallerine tercih edin.

Yanlış kullanım:

```
const double myDouble = 8.0;
final anotherDouble = myDouble + 7.0e2;
main() {
  someMethod(6.0);
}
```

Doğru kullanım:

```
const double myDouble = 8;
final anotherDouble = myDouble + 700;
main() {
  someMethod(6);
}
```


**prefer_interpolation_to_compose_strings**
Stringleri ve değerleri oluşturmak için enterpolasyonu kullanın.

Stringleri ve değerleri oluştururken enterpolasyonu kullanmak, genellikle birleştirmeden (concatenation) daha kolay yazılır ve okunur.

Yanlış kullanım: `'Hello, ' + name + '! You are ' + (year - birth) + ' years old.';`

Doğru kullanım:`'Hello, $name! You are ${year - birth} years old.';`




**prefer_is_empty**

Iterable'lar ve map'ler için isEmpty kullanın.

Bir koleksiyonun boş olup olmadığını görmek için length kullanmayın.

Bunun yerine, daha hızlı ve daha okunabilir getter'lar vardır: isEmpty ve isNotEmpty.


Yanlış kullanım:
```
if (lunchBox.length == 0) return 'so hungry...';
if (words.length != 0) return words.join(' ');
```


Doğru kullanım:

```
if (lunchBox.isEmpty) return 'so hungry...';
if (words.isNotEmpty) return words.join(' ');
```


**prefer_is_not_empty**

Iterable'lar ve map'ler için isNotEmpty kullanın.

Iterable veya map'in boş olup olmadığını test ederken, kodun okunabilirliğini artırmak için !isEmpty yerine isNotEmpty'i tercih edin.

Yanlış kullanım:

```
if (!sources.isEmpty) {
  process(sources);
}
```


Doğru kullanım:

```
if (todo.isNotEmpty) {
  sendResults(request, todo.isEmpty);
}
```

**prefer_is_not_operator**

Bir nesnenin belirli bir tipte olup olmadığını kontrol ederken, 'is!' operatörünü kullanın.

Yanlış kullanım:

```
if (!(foo is Foo)) {
  ...
}
```


Doğru kullanım:

```
if (foo is! Foo) {
  ...
}
```


**prefer_iterable_whereType**
iterable (yinelenebilir) durumda whereType kullanmayı tercih edin.

iterable.where((e) => e is T) yerine iterable.whereType<T>()'ı kullanın.


Yanlış kullanım: `iterable.where((e) => e is MyClass)`

Doğru kullanım: `iterable.whereType<MyClass>()`



**prefer_mixin**

Mixin'leri kullanın.

Karıştırılacak türler için her zaman mixin stili kullanılmalıdır.

Yanlış kullanım:

```
class A {}
class B extends Object with A {}
```


Doğru kullanım:

```
mixin M {}
class C with M {}
```


**prefer_null_aware_method_calls**

Bir foksiyon/method f'nin geçersizliğini(nullability), onu çağırmadan önce kontrol etmek yerine, f?.call() öğesini kullanabilirsiniz.

Yanlış kullanım:`if (f != null) f!();`

Doğru kullanım: `f?.call();`


**prefer_null_aware_operators**

Koşullu ifadelerde boş denetimler yerine null aware operator kullanmayı tercih edin.

Yanlış kullanım: `v = a == null ? null : a.b;`

Doğru kullanım: `v = a?.b;`



**prefer_spread_collections**
Mümkün olduğunda spread -yayılmış koleksiyonları kullanın.

Tek tek öğelerden yeni bir koleksiyon oluşturmak istediğinizde koleksiyon literal'leri mükemmeldir. Ancak, mevcut öğeler zaten başka bir koleksiyonda depolandığında, spread koleksiyon sözdizimi daha basit koda yol açar.


Yanlış kullanım:

```
Widget build(BuildContext context) {
  return CupertinoPageScaffold(
    child: ListView(
      children: [
        Tab2Header(),
      ]..addAll(buildTab2Conversation()),
    ),
  );
}
```

```
var ints = [1, 2, 3];
print(['a']..addAll(ints.map((i) => i.toString()))..addAll(['c']));
```

```
var things;
var l = ['a']..addAll(things ?? const []);
```

Doğru kullanım:

```
Widget build(BuildContext context) {
  return CupertinoPageScaffold(
    child: ListView(
      children: [
        Tab2Header(),
        ...buildTab2Conversation(),
      ],
    ),
  );
}
```

```
var ints = [1, 2, 3];
print(['a', ...ints.map((i) => i.toString()), 'c');
```

```
var things;
var l = ['a', ...?things];
```

**prefer_typing_uninitialized_variables**

Var ile tanımladığınız değişkenlere initial-başlangıç değeri atayın.
Bu kullanım değişkenlere başlangıçta amaçlamadığınız bir tür atamanızın önüne geçer.

Yanlış kullanım:

```
class BadClass {
  static var bar; // LINT
  var foo; // LINT

  void method() {
    var bar; // LINT
    bar = 5;
    print(bar);
  }
}
```



Yanlış kullanım:

```
void aFunction() {
  var bar; // LINT
  bar = 5;
  ...
}
```

Doğru kullanım:

```
class GoodClass {
  static var bar = 7;
  var foo = 42;
  int baz; // OK

  void method() {
    int baz;
    var bar = 5;
    ...
  }
}
```


**public_member_api_docs**

Yanlış kullanım:

```
class Bad {
  void meh() { }
}
```

Doğru kullanım:

```
/// A good thing.
abstract class Good {
  /// Start doing your thing.
  void start() => _start();

  _start();
}
```
İstisnai durum:
```
/// Base of all things.
abstract class Base {
  /// Initialize the base.
  void init();
}

/// A sub base.
class Sub extends Base {
  @override
  void init() { ... }
}
```


**recursive_getters**

Recursive (özyinelemeli) alıcılar oluşturmayın.

Recursive alıcılar, kendilerini bir değer olarak döndüren alıcılardır. Bu genellikle bir yazım hatasıdır.

Yanlış kullanım: `int get field => field; // LINT`

Yanlış kullanım:

```
int get otherField {
  return otherField; // LINT
}
```

Doğru kullanım: `int get field => _field;`



**sized_box_for_whitespace**

Bir layout'a boşluk eklemek için SizedBox kullanın.

Yanlış kullanım:

```
Widget buildRow() {
  return Row(
    children: <Widget>[
      const MyLogo(),
      Container(width: 4),
      const Expanded(
        child: Text('...'),
      ),
    ],
  );
}
```


Doğru kullanım:

```
Widget buildRow() {
  return Row(
    children: const <Widget>[
      MyLogo(),
      SizedBox(width: 4),
      Expanded(
        child: Text('...'),
      ),
    ],
  );
}
```


**size_box_shrink_expand**

Yanlış kullanım:

```
Widget buildLogo() {
  return SizedBox(
    height: 0,
    width: 0,
    child: const MyLogo(),
  );
}
```

```
Widget buildLogo() {
  return SizedBox(
    height: double.infinity,
    width: double.infinity,
    child: const MyLogo(),
  );
}
```


Doğru kullanım:

```
Widget buildLogo() {
  return SizedBox.shrink(
    child: const MyLogo(),
  );
}
```

```
Widget buildLogo() {
  return SizedBox.expand(
    child: const MyLogo(),
  );
}
```

**slash_for_doc_comments**

Doküman yorumları için /// kullanmayı tercih edin.

Doğru kullanım:

```
/// Parses a set of option strings. For each option:
///
/// * If it is `null`, then it is ignored.
/// * If it is a string, then [validate] is called on it.
/// * If it is any other type, it is *not* validated.
void parse(List options) {
  // ...
}
```


**sort_child_properties_last**

Widget örneği oluşturma işlemlerinde alt özellikleri en son sıralayın.

Yanlış kullanım:
```
return Scaffold(
  appBar: AppBar(
    title: Text(widget.title),
  ),
  body: Center(
    child: Column(
      children: <Widget>[
        Text(
          'You have pushed the button this many times:',
         ),
        Text(
          '$_counter',
          style: Theme.of(context).textTheme.display1,
         ),
      ],
      mainAxisAlignment: MainAxisAlignment.center,
    ),
    widthFactor: 0.5,
  ),
  floatingActionButton: FloatingActionButton(
    child: Icon(Icons.add),
    onPressed: _incrementCounter,
    tooltip: 'Increment',
  ),
);
```

Doğru kullanım:

```
return Scaffold(
  appBar: AppBar(
    title: Text(widget.title),
  ),
  body: Center(
    widthFactor: 0.5,
    child: Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: <Widget>[
        Text(
          'You have pushed the button this many times:',
         ),
        Text(
          '$_counter',
          style: Theme.of(context).textTheme.display1,
         ),
      ],
    ),
  ),
  floatingActionButton: FloatingActionButton(
    onPressed: _incrementCounter,
    tooltip: 'Increment',
    child: Icon(Icons.add),
  ),
);
```
İstisna: Child özelliğinden sonra bir fonksiyon ifadesi içeren parametreye izin verilir.


**sort_constructors_first**

Constructor bildirimlerini (declarations) diğer üyelerden önce sıralayın.


Yanlış kullanım:

```
abstract class Visitor {
  double value;
  visitSomething(Something s);
  Visitor();
}
```


Doğru kullanım:

```
abstract class Animation<T> {
  const Animation(this.value);
  double value;
  void addListener(VoidCallback listener);
}
```


**sort_unnamed_constructors_first**

Önce adsız constructor bildirimlerini sıralayın.

Adsız constructor bildirimlerini, adlandırılmış olanlardan önce sıralayın.


Yanlış kullanım:

```
class _PriorityItem {
  factory _PriorityItem.forName(bool isStatic, String name, _MemberKind kind) => ...
  _PriorityItem(this.isStatic, this.kind, this.isPrivate);
  ...
}
```

Doğru kullanım:

```
abstract class CancelableFuture<T> implements Future<T>  {
  factory CancelableFuture(computation()) => ...
  factory CancelableFuture.delayed(Duration duration, [computation()]) => ...
  ...
}
```

**tighten_type_of_initializing_formals**


Yanlış kullanım:

```
class A {
  A.c1(this.p) : assert(p != null);
  A.c2(this.p);
  final String? p;
}
```


Doğru kullanım:

```
class A {
  A.c1(String this.p) : assert(p != null);
  A.c2(this.p);
  final String? p;
}
```


**type_init_formals**

Bir alanı başlatmak için bir constructor parametresi kullanılıyorsa this.x, parametre türünün alanla aynı tür olduğu anlaşılır.

Yanlış kullanım:

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


Doğru kullanım:

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


**unawated_futures**
Future olarak tanımlanan methodları çağırırken await kullanmayı unutmayın.

Doğru kullanım:

```
Future doSomething() => ...;

void main() async {
  await doSomething();

  unawaited(doSomething()); // Explicitly-ignored fire-and-forget.
}
```

Yanlış kullanım:

```
void main() async {
  doSomething(); // Likely a bug.
}
```

**unnecessary_await_in_return**
Gereksiz await anahtar kelimesi kullanmayın.

Yanlış kullanım:

```
Future<int> future;
Future<int> f1() async => await future;
Future<int> f2() async {
  return await future;
}
```


Doğru kullanım:

```
Future<int> future;
Future<int> f1() => future;
Future<int> f2() {
  return future;
}
```

**unnecessary_brace_in_string_interps**

Gerekmediği zaman enterpolasyonda parantez kullanmaktan kaçının.


Yanlış kullanım: `print("Hi, ${name}!");`

Doğru kullanım: `print("Hi, $name!");`


**unnecessary_const**

Bir const bağlamında const anahtar sözcüğünü yinelemekten kaçının.

Yanlış kullanım:

```
class A { const A(); }
m(){
  const a = const A();
  final b = const [const A()];
}
```


Doğru kullanım:

```
class A { const A(); }
m(){
  const a = A();
  final b = const [A()];
}
```

**unnecessary_constructor_name**

Gereksiz new kullanımından kaçının.


Yanlış kullanım:

```
class A {
  A.new(); // LINT
}

var a = A.new(); // LINT
```

Doğru kullanım:

```
class A {
  A.ok();
}

var a = A();
var aa = A.ok();
var makeA = A.new;
```

**unnecessary_final**

Local değişkenler için final kullanmayın.
var daha kısadır ve final kodun anlamını değiştirmez.

Yanlış kullanım:

```
void badMethod() {
  final label = 'Final or var?';
  for (final char in ['v', 'a', 'r']) {
    print(char);
  }
}
```

Doğru kullanım:

```
void goodMethod() {
  var label = 'Final or var?';
  for (var char in ['v', 'a', 'r']) {
    print(char);
  }
}
```

**unnecessary_getters_setters**

Alanları yalnızca güvenli olsunlar diye getter ve setter'lara sarmaktan kaçının.

Java ve C#'da, uygulama sadece field'a iletse bile, tüm alanları getter ve setter'ların (veya C#'daki propertilerin) arkasına gizlemek yaygındır. Bunun nedeni, bir getter method'u  çağırmanın Java'da bir alana erişmekten farklı olması ve bir property'e (özelliğe) erişmenin, C#'ta raw field'a erişimle binary-compatible olmamasıdır.

Dart'ın bu sınırlaması yoktur. Field'lar ve getter/setter'lar tamamen ayırt edilemez. Bir sınıftaki bir field'ı açığa çıkarabilir ve daha sonra bu field'ı kullanan herhangi bir koda dokunmak zorunda kalmadan bir getter ve setter içine sarabilirsiniz.

Yanlış kullanım:

```
class Box {
  var _contents;
  get contents => _contents;
  set contents(value) {
    _contents = value;
  }
}
```

Doğru kullanım:

```
class Box {
  var contents;
}
```


**unnecessary_lambdas**

Tear-off işlemi yapılacaksa lambda kullanmayın.

Yanlış kullanım:

```
names.forEach((name) {
  print(name);
});
```

Doğru kullanım: `names.forEach(print);`


**unnecessary_late**

Tanımlanırken değeri atanan değişkenlerde late kullanmayın.

Yanlış kullanım: `late String badTopLevel = '';`

Doğru kullanım: `String goodTopLevel = '';`

Yanlış kullanım:

```
class BadExample {
  static late String badStatic = '';
}
```


Doğru kullanım:

```
class GoodExample {
  late String goodStatic;
}
```

**unnecessary_new**

Örnek oluşturmak için gereksiz new kullanmaktan kaçının.

Yanlış kullanım:

```
class A { A(); }
m(){
  final a = new A();
}
```


Doğru kullanım:

```
class A { A(); }
m(){
  final a = A();
}
```

**unnecessary_null_aware_assignments**

Null-aware atamasında null kullanmaktan kaçının.

Yanlış kullanım:

```
var x;
x ??= null;
```

Doğru kullanım:

```
var x;
x ??= 1;
```

**unnecessary_null_checks**

Null yapılabilir bir değer kabul edildiğinde null kontrolü uygulamayın.

Yanlış kullanım:

```
f(int? i);
m() {
  int? j;
  f(j!);
}

```


Doğru kullanım:

```
f(int? i);
m() {
  int? j;
  f(j);
}
```


**unnecessary_null_in_if_null_operators**

if null operandlarında operatör olarak null kullanmaktan kaçının.

Bir if null operatöründe null kullanılması, null'ın hangi tarafta kullanıldığına bakılmaksızın gereksizdir.

Yanlış kullanım:

```
var x = a ?? null;
var y = null ?? 1;
```

Doğru kullanım:`var x = a ?? 1;`

**unnecessary_raw_strings**

Raw string'i yalnızca gerektiğinde kullanın.

Yanlış kullanım: `var s1 = r'a';`

Doğru kullanım:

```
var s1 = 'a';
var s2 = r'$a';
var s3 = r'\a';
```


**unnecessary_string_escapes**

String'lerdeki gereksiz ters eğik çizgileri kaldırın.


Yanlış kullanım:

```
'this string contains 2 \"double quotes\" ';
"this string contains 2 \'single quotes\' ";
```

Doğru kullanım:

```
'this string contains 2 "double quotes" ';
"this string contains 2 'single quotes' ";
```


**unnecessary_string_interpolations**
İçinde yalnızca bir string ifade varsa, string enterpolasyonu kullanmayın.


Yanlış kullanım:

```
String message;
String o = '$message';
```


Doğru kullanım:

```
String message;
String o = message;
```


**unnecessary_this**

Gerekmedikçe this kullanmayın.

Yanlış kullanım:

```
class Box {
  var value;
  void update(new_value) {
    this.value = new_value;
  }
}
```


Doğru kullanım:

```
class Box {
  var value;
  void update(new_value) {
    value = new_value;
  }
}
```

Doğru kullanım:

```
class Box {
  var value;
  void update(value) {
    this.value = value;
  }
}
```


**use_decorated_box**
Container'da yalnızca bir Dekorasyon olduğunda DecoratedBox kullanın.

Bir Container, DecoratedBox'tan daha ağır bir Widget'tır ve bonus olarak, DecoratedBox'ın bir const kurucusu vardır.

Yanlış kullanım:

```
Widget buildArea() {
  return Container(
    decoration: const BoxDecoration(
      color: Colors.blue,
      borderRadius: BorderRadius.all(
        Radius.circular(5),
      ),
    ),
    child: const Text('...'),
  );
}
```



Doğru kullanım:

```
Widget buildArea() {
  return const DecoratedBox(
    decoration: BoxDecoration(
      color: Colors.blue,
      borderRadius: BorderRadius.all(
        Radius.circular(5),
      ),
    ),
    child: Text('...'),
  );
}
```


**use_full_hex_values_for_flutter_colors**

Color'ı başlatmak için 8 basamaklı bir onaltılık tamsayı (0xFFFFFFFF) tercih edin.

Yanlış kullanım:

```
Color(1);
Color(0x000001);
```

Doğru kullanım: `Color(0x00000001);`








**use_function_type_syntax_for_parameters**

Paremetreler için generic function syntax'ını (söz dizimini) kullanın.


Yanlış kullanım: `Iterable<T> where(bool predicate(T element)) {}`

Doğru kullanım: `Iterable<T> where(bool Function(T) predicate) {}`


**use_if_null_to_convert_nulls_to_bools**

Null değerleri bool'a dönüştürmek için if-null operatörlerini kullanın.


Yanlış kullanım:

```
if (nullableBool == true) {
}
if (nullableBool != false) {
}
```

Doğru kullanım:

```
if (nullableBool ?? false) {
}
if (nullableBool ?? true) {
}
```

**use_is_even_rather_than_modulo**

% 2 sonucunu kontrol etmek yerine intValue.isOdd/isEven'i kullanmayı tercih edin.

Yanlış kullanım:

```
bool isEven = 1 % 2 == 0;
bool isOdd = 13 % 2 == 1;
```

Doğru kullanım:

```
bool isEven = 1.isEven;
bool isOdd = 13.isOdd;
```

**use_late_for_private_fields_and_variables**

Null yapılamayan private üyeler için late kullanın.

_Bu kural şu anda deneyseldir._


Yanlış kullanım:

```
int? _i;
m() {
  _i!.abs();
}
```

Doğru kullanım:

```
late int _i;
m() {
  _i.abs();
}
```


**use_named_constants**

Mümkünse, önceden tanımlanmış const değerlerini kullanın.

Yanlış kullanım: `const Duration(seconds: 0);`

Doğru kullanım: `Duration.zero;`



**use_raw_strings**

Eğik çizgi \ ve dolar $ kullanmanız gerektiğinde raw string kullanın.


Yanlış kullanım: `var s = 'A string with only \\ and \$';`

Doğru kullanım: `var s = r'A string with only \ and $';`

**use_rethrow_when_possible**
Yakalanan bir istisnayı yeniden göndermek için rethrow kullanın.


Yanlış kullanım:

```
try {
  somethingRisky();
} catch(e) {
  if (!canHandle(e)) throw e;
  handle(e);
}
```

Doğru kullanım:

```
try {
  somethingRisky();
} catch(e) {
  if (!canHandle(e)) rethrow;
  handle(e);
}
```

**use_setters_to_change_properties**

Bir propertyi kavramsal olarak değiştiren işlemler için setter kullanın.

Yanlış kullanım:

```
rectangle.setWidth(3);
button.setVisible(false);
```

Doğru kullanım:

```
rectangle.width = 3;
button.visible = false;
```

**use_string_buffers**

Stringleri oluşturmak için string buffers kullanın.

Çoğu durumda, geliştirilmiş performansı nedeniyle stringleri oluşturmak için string buffer kullanılması tercih edilir.

Yanlış kullanım:

```
String foo() {
  final buffer = '';
  for (int i = 0; i < 10; i++) {
    buffer += 'a'; // LINT
  }
  return buffer;
}
```


Doğru kullanım:

```
String foo() {
  final buffer = StringBuffer();
  for (int i = 0; i < 10; i++) {
    buffer.write('a');
  }
  return buffer.toString();
}
```

**use_test_throws_matchers**

fail() ve try-catch yerine throwsA eşleştiricisini kullanın.


Yanlış kullanım:

```
// sync code
try {
  someSyncFunctionThatThrows();
  fail('expected Error');
} on Error catch (error) {
  expect(error.message, contains('some message'));
}

// async code
try {
  await someAsyncFunctionThatThrows();
  fail('expected Error');
} on Error catch (error) {
  expect(error.message, contains('some message'));
}
```


Doğru kullanım:

```
// sync code
expect(
  () => someSyncFunctionThatThrows(),
  throwsA(isA<Error>().having((Error error) => error.message, 'message', contains('some message'))),
);

// async code
await expectLater(
  () => someAsyncFunctionThatThrows(),
  throwsA(isA<Error>().having((Error error) => error.message, 'message', contains('some message'))),
);
```

**use_to_and_as_if_applicable**

Nesnenin durumunu yeni bir nesneye kopyalıyorsa, yöntemi to____() olarak adlandırmayı tercih edin.

Orijinal nesne tarafından desteklenen farklı bir temsil döndürüyorsa, yöntemi as___() olarak adlandırmayı tercih edin.


Yanlış kullanım:

```
class Bar {
  Foo myMethod() {
    return Foo.from(this);
  }
}
```



Doğru kullanım:

```
class Bar {
  Foo toFoo() {
    return Foo.from(this);
  }
}
```


Doğru kullanım:

```
class Bar {
  Foo asFoo() {
    return Foo.from(this);
  }
}
```

References:
https://dart.dev/tools/linter-rules#style-rules