Dart/Flutter Liste Methodları 💫 🌌 ✨
Tags: flutter, dart, list, method
Published: 2022-03-19 19:49:11

## Liste Methodları ✨

**add method**
Parametre olarak verilen elemanı listenin sonuna ekler.

Örnek uygulama:
```
final numbers = <int>[1, 2, 3];
numbers.add(4);
print(numbers); // [1, 2, 3, 4]
```


**addAll method**
Parametre olarak verilen listeyi listenin sonuna ekler.

Örnek uygulama:

```
final numbers = <int>[1, 2, 3];
numbers.addAll([4, 5, 6]);
print(numbers); // [1, 2, 3, 4, 5, 6]
```

**any method**

Verilen koşulu listedeki her eleman için dener. Eğer bir eleman koşulu sağlarsa geriye true döndürür. Hiçbir eleman koşulu sağlamaz ise geriye false döner.

Örnek uygulama:

```
final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.any((element) => element >= 5); // true;
result = numbers.any((element) => element >= 10); // false;
```

**asMap method**
Bir listenin key ve value değerlerine erişmeyi sağlar.

Örnek uygulama:

```
var words = <String>['fee', 'fi', 'fo', 'fum'];
var map = words.asMap(); 
print(map);// {0: fee, 1: fi, 2: fo, 3: fum}
map.keys.toList(); 
print(map.keys.toList());// [0, 1, 2, 3]
print(map.values.toList());// [fee, fi, fo, fum]

```


**cast<R> method**
Bu listenin bir görünümünü R örnekler listesi olarak döndürür.

```
  var foo = [1, 2.3]; 
  print(foo.runtimeType); // JSArray<num>
  var baz = foo.cast<num>();
  print(baz.runtimeType); // CastList<num, num>
  print(baz == foo); // false
```

**clear method**
Bir listedeki tüm elemanları siler.

```
final numbers = <int>[1, 2, 3];
numbers.clear();
print(numbers.length); // 0
print(numbers); // []
```

**contains method**
Bir koleksiyonun parametre olarak verilen değeri içerip içermediğini kontrol eder.

```
final gasPlanets = <int, String>{1: 'Jupiter', 2: 'Saturn'};
final containsOne = gasPlanets.keys.contains(1); // true
final containsFive = gasPlanets.keys.contains(5); // false
final containsJupiter = gasPlanets.values.contains('Jupiter'); // true
final containsMercury = gasPlanets.values.contains('Mercury'); // false
```

**elementAt method**
Parametre olarak verilen indexdeki elemanı döndürür. İndex negatif olmamalı ve listenin eleman sayısından küçük olmalıdır.
İndex 0 ilk elemanı temsil eder.

Örnek uygulama:

```
final numbers = <int>[1, 2, 3, 5, 6, 7];
final elementAt = numbers.elementAt(4); // 6
```


**every method**

Iterable da ki her eleman için verilen koşulun sağlanıp sağlanmadığını kontrol eder. Iterable da ki tüm elemanlar koşulu sağlıyor ise true sağlamıyor ise geriye false döner.

Örnek uygulama:

```
final planetsByMass = <double, String>{0.06: 'Mercury', 0.81: 'Venus',
  0.11: 'Mars'};
// Checks whether all keys are smaller than 1.
final every = planetsByMass.keys.every((key) => key < 1.0); // true
```


**expand<T> method**
Bir iterable(yinelenebilir) öğenin her öğesini sıfır veya daha fazla öğeye genişletir.


Örnek uygulama:

```
Iterable<int> count(int n) sync* {
  for (var i = 1; i <= n; i++) {
    yield i;
   }
 }

var numbers = [1, 3, 0, 2];
print(numbers.expand(count)); // (1, 1, 2, 3, 1, 2)
```


**firstWhere method**

Liste elemanları arasında koşulu sağlayan ilk elemanı döndürür.

```
final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.firstWhere((element) => element < 5); // 1
result = numbers.firstWhere((element) => element > 5); // 6
result =
    numbers.firstWhere((element) => element > 10, orElse: () => -1); // -1
```
Hiçbir öğe testi karşılamazsa, orElse fonksiyonunun sonucu döndürülür. orElse atlanırsa, varsayılan olarak bir StateError atar.


**fold<T> method**

Listenin her bir öğesini mevcut bir değerle yinelemeli olarak birleştirerek listeyi tek bir değere indirger

Başlangıç ​​değeri olarak initialValue öğesini kullanır, ardından öğeler arasında yinelenir ve combine(birleştirme) fonksiyonunu kullanarak değeri her öğeyle şu şekilde günceller:


```
var value = initialValue;
for (E element in this) {
  value = combine(value, element);
}
return value;
```

Örnek uygulama:

```
final numbers = <double>[10, 2, 5, 0.5];
const initialValue = 100.0;
final result = numbers.fold<double>(
    initialValue, (previousValue, element) => previousValue + element);
print(result); // 117.5
```


**followedBy method**
Bir listeyle parametre olarak verilmiş olan listenin birleştirilmiş halini döndürür.

Örnek uygulama:
```
var planets = <String>['Earth', 'Jupiter'];
var updated = planets.followedBy(['Mars', 'Venus']);
print(updated); // (Earth, Jupiter, Mars, Venus)
```

**forEach method**
Listenin her bir elemanını gezer.

Örnek uygulama:
```
final numbers = <int>[1, 2, 6, 7];
numbers.forEach(print);
// 1
// 2
// 6
// 7
```

**join method**

Her öğeyi bir string'e dönüştürür ve bu string'leri parametre olarak verilen ifade ile birleştirir.

Örnek uygulama:

```
final planetsByMass = <double, String>{0.06: 'Mercury', 0.81: 'Venus',
  0.11: 'Mars'};
final joinedNames = planetsByMass.values.join('-'); // Mercury-Venus-Mars
```

**lastWhere method**

Verilen koşulu sağlayan listenin son elemanını verir.

Örnek uygulama:

```
final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.lastWhere((element) => element < 5); // 3
result = numbers.lastWhere((element) => element > 5); // 7
result = numbers.lastWhere((element) => element > 10,
    orElse: () => -1); // -1
```

Hiçbir öğe testi karşılamazsa, orElse işlevinin çağrılmasının sonucu döndürülür. orElse atlanırsa, varsayılan olarak bir StateError atar.


**map<T> method**

Örnek uygulama:

```
var products = jsonDecode('''
[
  {"name": "Screwdriver", "price": 42.00},
  {"name": "Wingnut", "price": 0.50}
]
''');
var values = products.map((product) => product['price'] as double);
var totalPrice = values.fold(0.0, (a, b) => a + b); // 42.5.
```

**noSuchMethod method**

Var olmayan bir yönteme veya özelliğe erişildiğinde çağrılır.

```
class MockList<T> implements List<T> {
  noSuchMethod(Invocation invocation) {
    log(invocation);
    super.noSuchMethod(invocation); // Will throw.
  }
}
void main() {
  MockList().add(42);
}
```
MockList sınıfının List arabirim yöntemlerinden herhangi birinin somut bir uygulaması olmamasına rağmen, bu kodun derleme zamanı uyarıları veya hataları yoktur.

List yöntemlerine yapılan çağrılar noSuchMethod'a iletilir, bu nedenle bu kod Invocation.method(#add, [42])'ye benzer bir çağrıyı günlüğe kaydeder ve ardından throw atar.

noSuchMethod'dan bir değer döndürülürse, orijinal çağrının sonucu olur. Değer, orijinal çağırma tarafından döndürülebilecek türden değilse, çağırma sırasında bir type error oluşur.

Varsayılan davranış, bir NoSuchMethodError atmaktır.

**reduce method**

Sağlanan fonksiyonu kullanarak listenin öğelerini yinelemeli olarak birleştirir ve listeyi tek bir değere indirger.

Liste en az bir öğeye sahip olmalıdır yalnızca bir öğesi varsa o öğe döndürülür.

```
final numbers = <double>[10, 2, 5, 0.5];
final result = numbers.reduce((value, element) => value + element);
print(result); // 17.5
```

**singleWhere method**
Testi karşılayan tek öğeyi döndürür.

test(element) öğesinin doğru olup olmadığını görmek için öğeleri kontrol eder. Tam olarak bir öğe testi karşılarsa, o öğe döndürülür. Birden fazla eşleşen öğe bulunursa, StateError atar. Eşleşen bir öğe bulunamazsa, orElse sonucunu döndürür. orElse atlanırsa, varsayılan olarak bir StateError atar.

Örnek uygulama:

```
final numbers = <int>[2, 2, 10];
var result = numbers.singleWhere((element) => element > 5); // 10
```

Eşleşen bir öğe bulunmadığında, bunun yerine orElse çağrısının sonucu döndürülür.

```
result = numbers.singleWhere((element) => element == 1,
    orElse: () => -1); // -1
```

Birden fazla eşleşen öğe olmamalıdır.

`result = numbers.singleWhere((element) => element == 2); // Throws Error.`

**skip method**
Verilen index'ten itibaren elamanları döndürür.

```
final numbers = <int>[1, 2, 3, 5, 6, 7];
final result = numbers.skip(4); // (6, 7)
final result = numbers.skip(5); //(7)
final result = numbers.skip(1); //(2, 3, 5, 6, 7)
final skipAll = numbers.skip(100); // () - no elements.
```

**skipWhile method**

Verilen koşulu sağlayan elemandan sonraki elemanları döndürür. Koşulu sağlayan hiçbir eleman yoksa geriye bir değer dönmez.


```
final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.skipWhile((x) => x < 5); // (5, 6, 7)
result = numbers.skipWhile((x) => x != 3); // (3, 5, 6, 7)
result = numbers.skipWhile((x) => x != 4); // ()
result = numbers.skipWhile((x) => x.isOdd); // (2, 3, 5, 6, 7)
```


**take method**
Parametre olarak aldığı sayı kadar listeden eleman döndürür.

Örnek uygulama:
```
final numbers = <int>[1, 2, 3, 5, 6, 7];
final result = numbers.take(2); // (1, 2)
final result2 = numbers.take(4); // (1, 2, 3, 5)
final takeAll = numbers.take(100); // (1, 2, 3, 5, 6, 7)
```


**takeWhile method**

Verilen koşul sağlanıncaya kadar listeyi dolaşır ve sonuç olarak koşul sağlanıncaya kadar dolaştığı tüm elemanları döndürür. Koşul hiç bir zaman sağlanmazsa sonuç olarak listedeki tüm elemanları döndürür.

Örnek uygulama:

```
final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.takeWhile((x) => x < 5); // (1, 2, 3)
result = numbers.takeWhile((x) => x != 3); // (1, 2)
result = numbers.takeWhile((x) => x != 4); // (1, 2, 3, 5, 6, 7)
result = numbers.takeWhile((x) => x.isOdd); // (1)
```

**toList method**

Verilen listenin öğelerini içeren yeni bir liste oluşturur.

```
final planets = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Mars'};
final keysList = planets.keys.toList(growable: false); // [1, 2, 3]
final valuesList =
    planets.values.toList(growable: false); // [Mercury, Venus, Mars]
```

**toSet method**

Yinelenebilir öğeyle aynı öğeleri içeren bir küme(set) oluşturur.

Yinelenebilir öğe birden fazla öğe içeriyorsa veya eşit olan bir veya daha fazla öğe içeriyorsa, küme yinelenebilir öğeden daha az öğe içerebilir. Kümedeki öğelerin sırasının yinelenebilir öğeyle aynı olması garanti edilmez.

```
final planets = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Mars'};
final valueSet = planets.values.toSet(); // {Mercury, Venus, Mars}
```

**where method**

Parametre olarak verilen koşulu sağlayan tüm elemanları döndürür.

```
final numbers = <int>[1, 2, 3, 5, 6, 7];
var result = numbers.where((x) => x < 5); // (1, 2, 3)
result = numbers.where((x) => x > 5); // (6, 7)
result = numbers.where((x) => x.isEven); // (2, 6)
```

**whereType<T> method**

T türüne sahip tüm öğelerle birlikte yeni bir lazy Iterable döndürür.

**not: Iterable<E> class:** Sırayla erişilebilen bir değerler topluluğu veya "öğeler".



resources:
https://api.flutter.dev/flutter/dart-core/Iterable-class.html#instance-methods
https://api.dart.dev/stable/2.16.1/dart-core/dart-core-library.html
https://www.codegrepper.com/code-examples/dart/cast+variable+flutter