Laravel Koleksiyonları Sadece Daha İyi Dizilerdir. TypeScript’te de %90 Var.

Bir Laravel geliştiricisi, TypeScript projesini ilk kez açıyor ve kas hafızasıyla tanıdık bir yapı yazmaya başlıyor:

$report = collect($users)
    ->where('active', true)
    ->groupBy('country')
    ->map(fn ($group) => $group->count());

Beş zincirleme çağrı. Bir cümle gibi okunuyor. PHP geliştiricisi şimdi aynı şekli TypeScript’te istiyor ve tüm Laravel’ten Node.js’e göçanların yaptığı gibi arama yapmaya başlıyor: lodash. Belgeleri açıyor, groupBy için kaydırıyor ve örneği kopyalıyor.

Bu arama altı yıl geride kalmış durumda.

Modern TypeScript dizileri, Collection‘ın yaptığı çoğu şeyi zaten yapıyor. Dizilerin yapmadığı birkaç şey, bir yöntem çağrısı mesafesindedir veya üç satırlık bir yardımcıda vardır. Zinciri dizide yazarsınız. Hiçbir sarma adımı yok.

Bu, Laravel’den TypeScript’e geçişte yaşanan daha büyük düşünce tarzı değişimlerinden biridir ve yerleştiğinde zevk alınacak daha kolaylardan biridir. PHP dizileri zayıf olduğu için Laravel Collection’ı sunmak zorunda kaldı. TypeScript dizileri zaten üzerinde yöntemlere sahiptir. Collection‘ın var olma nedeni, PHP’nin array_map/array_filter/array_reduce‘in argümanlarını tutarsız bir sırada almasıdır, yeni diziler döndürmesi ve ilişkisel dizileri listelerle birleştirmesidir. Collection bunu kapatıyordu. JavaScript, temel sorunları hiç taşımadığından, sarıcıya gerek kalmamıştır.

En yaygın kullanılan on beş Collection yöntemi, TypeScript’teki eşdeğerleri ve bir yardımcının gerektiği birkaç küçük grup.

Mapping Tablosu

Önce sıkıcı şekil. Sonra birkaç ilginç olanla derinleştireceğiz.

Post’un geri kalanı, yeni yerel cevapları olan iki yöntemi (groupBy ve unique/uniqueBy) ve gerçekten tek satırlık cevapları olmayan az sayıda yöntemi derinlemesine inceliyor.

Object.groupBy: Önceden problem yaratan

Yıllarca groupBy, her “neden lodash kullanıyorum” blog gönderisinin giriş cümlesi oldu. Vanilla JS sizden azaltmayı elle yazmanızı istedi:

// ES2024'ten önce
const byCountry = users.reduceRecordstring, User[]>>((acc, user) => {
  (acc[user.country] ??= []).push(user)
  return acc
}, {})

Fonksiyonel, ancak karmaşık. Eksik ilkenin canını hissedebiliyordunuz. ES2024 bunu düzeltti. Object.groupBy, spesifikasyonda, V8, JavaScriptCore, SpiderMonkey’de ve Node.js’te v21’den beri mevcuttur. Her ana çalışma zamanında yayınlanmaktadır: Node 21+, Bun, Deno, Chrome 117+, Firefox 119+, Safari 17.4+. (MDN tarayıcı uyumluluk tablosu için MDN‘ye bakabilirsiniz.)

Aynı sorgu, bugün:

const byCountry = Object.groupBy(users, (user) => user.country)
// Record

Artık kullandığınız tüm neden lodash kullanmak zorundaydınız. Artık Object üzerinde bir yöntem.

Bir benzeri, Map.groupBy‘dır, geri dönen Map bir dönüşüm anahtarına dayalıdır. Anahtarınız bir dizgi değilse kullanın. Object.groupBy anahtarı bir dizgiye zorlar; Map.groupBy orijinal türü korur. Bu, tarihe, sayıya, çiftlere veya herhangi bir nesne referansına göre gruplandırıyorsanız önemlidir:

// Siparişleri teslim tarihine göre grupla (bir tarih, dize değil)
const byDate = Map.groupBy(orders, (o) => o.deliveryDate)
// Map

Laravel’in o sorgusunun, tarihi önce bir dize anahtarı halinde biçimlendirmenizi gerektirir. TS versiyonu gerektirmez.

Set, Map ve unique() Hikayesi

->unique(), Laravel koleksiyonunda ilkel türler için doğrudan ve nesneler için küçük bir muammadır. TS hikayesi aynı şekle sahiptir, ancak ilkel türler daha hoştur.

Ilkel türler için Set yanıtıdır:

const tags = ['php', 'typescript', 'php', 'go', 'typescript']
const distinct = [...new Set(tags)]
// ['php', 'typescript', 'go']

Nesneler için, bir alan üzerinden benzersiz oluşturmanız gerekiyor, bu Laravel’de ->unique('email') olarak yazılır. TS versiyonu Map kullanır:

function uniqueByT, K>(arr: T[], key: (item: T) => K): T[] {
  return [...new Map(arr.map((item) => [key(item), item])).values()]
}
const distinctUsers = uniqueBy(users, (u) => u.email)

Bu, ->unique('email')‘den daha fazla kod, ancak bir kez yazıyorsunuz ve sonsuza dek içe aktarıyorsunuz. Bunun nedeni, Laravel’de Collection ile birlikte gelmesidir. TypeScript’te olmaması sebebi, standart kütüphanenin amaçlı olarak küçük olmasıdır ve dil size Map ve Set veriyor, böylece yardımı tek satırda oluşturabilirsiniz. Böylece, yukarıdaki alanla benzersiz olma yardımcısı bu post’un en uzun kodu.

chunk, partition, tap: Üç Satırlıklar

chunk, bir diziyi sabit boyutlu gruplara böler.

function chunkT>(arr: T[], size: number): T[][] {
  return Array.from(
    { length: Math.ceil(arr.length / size) },
    (_, i) => arr.slice(i * size, i * size + size),
  )
}
chunk([1, 2, 3, 4, 5, 6, 7], 3)
// [[1, 2, 3], [4, 5, 6], [7]]

partition, bir yargıya dayalı iki diziye böler. Collection‘in versiyonu iki koleksiyon döndürür; bizim versiyonumuz ise iki dizi döndürür.

function partitionT>(
  arr: T[],
  pred: (item: T) => boolean,
): [T[], T[]] {
  const pass: T[] = []
  const fail: T[] = []
  for (const item of arr) {
    (pred(item) ? pass : fail).push(item)
  }
  return [pass, fail]
}
const [active, inactive] = partition(users, (u) => u.active)

tap, bir yan etkisi çalıştırır ve değeri dokunulmamış olarak döndürür. Laravel kullanım durumu ->tap(fn(...) => Log::info(...))‘dır. TS’de, zincir herhangi bir işlev çağrısında kırıldığı için tap genellikle gerekli değildir. Ne zaman gereksinimiz olursa:

function tapT>(value: T, fn: (value: T) => void): T {
  fn(value)
  return value
}
const user = tap(await fetchUser(id), (u) => logger.info({ user: u.id }))

Bazı ekipler bunları ortak bir utils paketinden alır; bazıları doğrudan yazar; bazıları radash veya lodash’dan içe aktarır, eğer bağımlılık zaten varsa. Lodash toplamda yaklaşık 24 KB minify edilmiş ve gzipped (yaklaşık 70 KB unminify edilmiş) bir paket olduğundan, maliyet gerçektir, eğer ağacınızda zaten yoksa.

mapWithKeys: Bir İç İkili Çağrı

Laravel’daki ->mapWithKeys(), bir closure’ın yeni koleksiyonun hem anahtarını hem de değerini döndürmesine izin verir. TS eşdeğeri, Object.fromEntries artı map’dir:

const usersById = Object.fromEntries(
  users.map((u) => [u.id, u] as const),
)
// Record

as const, PHP göçmeni ilk denemesinde kaçırdığı bir kısımdır. Bunu kullanmazsanız, [u.id, u] türü (number | User)[] olur ve Object.fromEntries şikayet eder. Bununla, readonly [number, User] olur ve çıkarılan kayıt türü hakikati yansıtır.

Bir Map istiyorsanız, aynı şekil:

const usersById = new Map(users.map((u) => [u.id, u] as const))
// Map

Map, işimde şu anda her 90% zamanımdan ulaşmaya çalıştığım şeydir. Nesne özellik isimleri dizi haline getirilmiştir, bu, anahtarı bir sayı olan herhangi bir kodun sessizce kırılmasına neden olur. Map anahtarın kimliğini korur.

Effect, Lodash veya Ramda Ne Zaman Kullanılmalı

Düz dizi yöntemleri, günlük durumları kapsar. Bir kütüphane eklemenin hala mantıklı olduğu üç yer vardır ve kütüphane seçimi önceden olduğundan daha fazlası önemlidir.

Effect, tip sisteminde etkiler istediğinizde. Effect’in Array ve Stream modülleri size groupBy, partition, chunksOf, dedupeWith ve yüzlerce daha fazlasını, tüm çalışma zamanı katmanlarıyla sağlar. Servisiniz zaten Effect’i hata kanalları ve bağımlılık enjeksiyonu için kullanıyorsa, Array modülü kod tabanının geri kalanını uyar. Eğer Effect önceden bağımlılığınız yoksa atlayın; standart yöntemler yeterlidir.

Lodash, kenar durumları için: _.zipObject, _.invertBy, _.intersectionBy, _.differenceBy, özel çözücülerle derin birleştirmeler. Standart kütüphane groupBy, chunk, uniq ve arkadaşlara yetişmiştir.

Ramda, ekip veri-sonrası ve nokta-bağımsız, curry’lı her yerde kod yazıyorsa. Argüman sırası, lodash’tan terstir (veri sonrasıdır, veri öncesi değildir) ve API bileşenlemeye yönelik eğilim gösterir. Düz yöntem zincirleri mi? Ramda rahatsızlığa neden olur.

2026’da yeni bir proje için varsayılan: standart kütüphane ilk, üç satırlık bir utils.ts yazın, Effect’i zaten kullanıyorsanız ona ulaşın, gerçekten bir kenarına ihtiyacınız varsa Lodash’e erişin.

Iterator Yardımcıları (ES2025)

Bir parça daha bilmek değerli. ECMAScript 2025, iterator helpers önerisini nihai hale getirdi. Iterator.prototype artık map, filter, take, drop, flatMap, reduce, toArray, forEach, some, every ve find içeriyor (tipik Array ile aynı şekil, ancak tembel).

const firstTenActiveEmails = users
  .values()                                  // bir Iterator döner
  .filter((u) => u.active)
  .map((u) => u.email)
  .take(10)
  .toArray()

Tembellik, onları yeni yapan özelliktir. Array yöntemleri her adımda yenilenmiş bir dizi oluşturur. İteratör boru hattı, sonunu çekene kadar bir öğeyi çeker. On bin kullanıcıda ilk on aktif olanları istiyorsanız, iterator zinciri ilk on eşleşmede durur; dizi zinciri on bin kullanıcıyı iki kez işler (bir kez filter için, bir kez map için) ve ardından dilimleme yapar. Çoğu sorgu tembellik gerektirmez. Gerekli olanlar (üreticiler, sayfalanmış API’ler, dosya akışları) artık bir kütüphane olmadan ilk sınıf.

Iterator yardımcıları, V8, JavaScriptCore, SpiderMonkey ve Node.js 22+’de mevcuttur. Uygulama durumu hakkında bilgi için V8’in iterator yardımcıları postuna bakın.

Zihinsel Değişim

Bu postun tamamının bir ekranın sığmasını sağlayan sebep, PHP ve JavaScript’in dizi katmanında zıt bahisler yapmış olmalarıdır.

PHP’nin array_* fonksiyonları, geri çağrıyı yanlış pozisyonda alır. Argüman sırası, standart kütüphane içinde bile tutarsızdır: array_map($fn, $arr) ile array_filter($arr, $fn) arasındaki fark. Fonksiyonlar zincir oluşturamaz, çünkü onlar fonksiyon değil, yöntemdir. Ve dil, listeleri anahtarlı haritalardan ayırt etmez, bu yüzden array_filter sessizce anahtarları korur (bazen bunu istemiştiniz, bazen istemediniz). Collection bunun kapatılmasını sağladı. Diziyi bir nesne içinde sarmak, size zincirlenebilir bir yüzey, tutarlı argüman sırası ve dilin kurmayı reddettiği liste/anahtar haritası ayrımını verdi.

JavaScript’in Array.prototype ise, kazara tüm bu üç problemi çözmekteydi. Yöntemler dizinin üzerinde çağrıldığı için zincir, doğal şekildedir. Geri çağrı için tek bir pozisyon vardır, bu yüzden argüman sırası kayamaz. Listeler diziler ve anahtarlandırılmış kayıtlar düz nesneler olduğu için, ikisi asla çakışmaz.

Yaptığınız değişim, o yüzden, PHP’nin dizi fonksiyonlarına değil, Collection‘ın sarıcı ve açma dansından, yöntemlerin zaten mevcut olduğu yere geçiştir: dizinin üzerinde, nesnenin üzerinde, iteratörün üzerinde. collect($users)->where(...)->groupBy(...)->map(...)->values()->all() ile yazdığınız şey, users.filter(...), Object.groupBy(...), .map(...) şeklindedir ve hiç açma adımını atlıyorsunuz çünkü açmak için bir şey yok.

Sarımı bırakın. Kas hafızasıyla sarı sınıfı aramayı bırakın. Yöntemler dizinin üzerinde düz olarak bulunur. Olmayanlar ise Object, Map, Set veya iteratörün üzerinde düz olarak bulunur. Daha az kod yazacaksınız, daha fazla değil.

İleri Hareket

Collection‘dan sonra çevrilecek bir sonraki şey Eloquent’tir. TypeScript’teki en yakın benzetim Drizzle‘dır ve eşleştirme daha karmaşık çünkü ilişkilisel modelleme varsayımları ayrışır: Eloquent dinamik ilişkilere ve tembel yüklemeye dayanırken; Drizzle açık birleştirilmişler ve statik türde sorgu yapıcılarına dayanır. O geçiş ayrı bir post, ancak dizisel yöntemlerin ardından tırmanmayı seçtiğiniz bir sonraki tepe bu.

Bu arada, gerçek bir sorgu deneyin. Laravel kod tabanınızdaki en son Collection-ağır yöntemi alın, yalnızca yukarıdaki standart kütüphane ile yapın ve lodash‘ı bir kez bile arayıp aramadığınıza bakın. Cevap, ekibinizin gerçekten ona ihtiyaç duyup duymayacağını size söyleyecektir.

Bu yeniden çerçeveleme ile ilgisi var ise, PHP’den TypeScript’e kitabı, bunun geldiği yerdir. Koleksiyonlardan dizilere bölümü, bu gönderinin atladığı kenar durumlar da dahil olmak üzere tam eşleştirmeyi kapsar: keyBy, flatMap, zip, takeUntil, ve üreticileri tüketen iteratör-yardımcı sorguları. Ayrıca Eloquent’tan Drizzle’a, senkron’dan asenkron’a ve PHP’nin sizi hazırlamadığı jenerikler bölümleri de var.

Beş kitaplık bir set: The TypeScript Library:

1. TypeScript Essentials — giriş noktası. Türler, daraltma, modüller, asenkron, günlük sürücü aracı.
2. The TypeScript Type System — derin dalış. Jenerikler, haritalı/koşullu türler, çıkarım, şablon dizeleri, markalı türler.
3. Kotlin ve Java’dan TypeScript’e — JVM geliştiricileri için köprü. Varyans, null güvenliği, mühürlü→birleşim, coroutine→asenkron/await.
4. PHP’den TypeScript’e — PHP 8+ geliştiricileri için köprü. Senkron→asenkron paradigma, jenerikler, ayrımcı birleşimler.
5. TypeScript in Production — üretim katmanı. tsconfig, oluşturma araçları, monorepo’lar, kütüphane yazımı, ikiye bölünmüş ESM/CJS, JSR.

Kitap 1 ve 2 ana yol. Kitap 3 ve 4, JVM veya PHP’yi konuşuyorsanız onların yerine geçer. Kitap 5, işte TS olan herkes için geçerlidir.

Beş kitap da elektronik kitap, ciltli ve sert kapak olarak gönderilmektedir.