JavaScript Modülleri: Kod Kalitesini ve Uygulama Verimliliğini Yükseltme Stratejileri
JavaScript, web geliştirmenin temel taşlarından biridir. Web sitelerinde etkileşimi arttırmak ve sitelere dinamizm katmak için kullanılır. JavaScript’in boyutu Web sitelerinin büyüklüğüne göre değişiklik gösterir. Büyük projelerde kullanılan JavaScript’in boyutu da büyük olacağından, kodun temiz, okunabilir ve tekrar kullanılabilir olması gerekir. Bunun için JavaScript Modülleri kullanılır. JavaScript Modül kavramının ne olduğunu, neden ihtiyaç duyulduğunu, hangi çözümler geliştirildiğini, nasıl kullanıldığını ve hangi avantajlar sunduğunu bu makalede aktaracağım.
Modül kavramı nedir?
JavaScript modülleri, kodunuzu tek bir dosyada tutmak yerine daha küçük ve yönetilebilir parçalara bölmek ve bu parçaları başka dosyalara veya projelere taşımak için kullanılır. Modüller, belirli işlevleri yerine getiren fonksiyonlar, değişkenler ve nesneleri içerebilirler. Modüller sayesinde kod karmaşıklığı azalır, kod okunurluğu ve kodun tekrar kullanılabilirliği yüksek oranda artar ve kod tekrarı en aza indirgenir.
Modüllere Neden İhtiyaç Duyuldu?
JavaScript ilk çıktığı zamanlarda, insanların web sitesindeki etkileşim senaryoları sınırlıydı, bu nedenle JavaScript dosyaları küçük ve basit kod bloklarından oluşuyordu. Fakat zamanla web siteleri büyüdü ve çok sayıda senaryo ortaya çıktı. Bu gelişmelerle birlikte JavaScript kodları da büyüdü ve karmaşık bir hal almaya başladı. Kodlar büyüdükçe geliştiricilerin takip etmesi zorlaştı. İşte bu noktada JavaScript modülleri devreye girdi. Bütün kodları tek bir dosyada yazmak yerine, kodlar modüller halinde yazılmaya başlandı.
Modül Çözümleri
JavaScript modüllerinin ilk kullanılmaya başladığı zamanlarda resmi bir standart veya yapı yoktu, bu yüzden farklı geliştiriciler kendi çözümlerini oluşturdu. CommonJS, AMD(Asynchronous Module Definition), UMD(Universal Module Definition) ve ES Modules, yaygın olarak kullanılan JavaScript modül sistemleridir. Şimdi bu modül sistemlerini inceleyelim.
CommonJS
CommonJS, özellikle server-side uygulamalar için JavaScript yazmanın standart bir yolunu sunmayı amaçlayan, Node.js tarafından benimsenmiş bir modül sistemidir. 2009 yılında Mozilla Corporation’da yazılım mühendisi olarak çalışan Kevin Dangoor tarafından geliştirilmiştir. Bir modüldeki kodları dışa aktarmak için module.exports objesini, bu kodları başka bir dosyada içe aktarmak için iserequire metodunu kullanabiliriz. Bu işlemler, modüllerin eşzamanlı (senkron) olarak yüklenmesini sağlar. Şimdi, kullanımına bir göz atalım.
//user.js
function User(fullName, phone) {
var returnObj = {
fullName : fullName,
phone : phone,
contactInfo: 'Contact Info: ' + fullName + ' ' + phone
}
return returnObj
}
module.exports = User;//main.js
const User = require('./user.js');
const person = User('James Bond', '5555555555');
console.log(person.contactInfo) -> Contact Info: James Bond 5555555555AMD (Asynchronous Module Definition)
AMD, özellikle client-side uygulamalar için tasarlanmış bir modül sistemidir. 2011 yılında Mozilla Corporation’da çalışan James Burke tarafından geliştirilmiştir (https://github.com/amdjs/amdjs-api). CommonJS’den farklı olarak, AMD’de modüller asenkron yüklenmektedir. RequireJs kütüphanesi tarafından benimsenmiş bir sistem olup asenkron yüklendiği için performans ve kullanılabilirlik açısından daha iyidir. Modülleri tanımlamak için define metodunu kullanılır. AMD’nin kullanımına göz atalım.
//user.js
define([], function() {
return {
fullName: function() {
console.log('James Bond');
},
phone: function() {
console.log('5555555555');
}
};
});//main.js
define(['user', 'otherUser'], function(user, otherUser) {
console.log(user.fullName()); -> James Bond
});UMD (Universal Module Definition)
UMD, hem client-side hem de server-side uygulamalarda kullanılabilen, AMD ve CommonJs’in özelliklerini destekleyen evrensel bir modül sistemidir. UMD, modülün çalıştırıldığı ortamı kontrol ederek hem istemci hem de sunucu tarafında kullanabilme esnekliği sağlar. 2015 yılında geliştirilen bu modül sistemini, Addy Osmani’nin reposundan inceleyebilirsiniz: https://github.com/umdjs/umd
//user.js
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
// AMD modül sistemi için
define([], factory);
} else if (typeof exports === 'object') {
// CommonJS modül sistemi için
module.exports = factory();
} else {
// Tarayıcı için
root.User = factory();
}
}(typeof self !== 'undefined' ? self : this, function () {
// Metodlar
function contactInfo(fullName, phone){
return 'Contact Info: ' + fullName + ' ' + phone;
};
// Modülün dışa aktarılacak kısmı
return {
contactInfo: contactInfo
}
}));//main.js
var User = require('./user');
var result = User.contactInfo('James Bond', '5555555555');
console.log(result); -> Contact Info: James Bond 5555555555Syntax yapısından dolayı, projelerde karmaşıklığa neden olabileceğini düşünüyorum.
ES Modules
ECMAScript (ES) Modülleri, JavaScript dünyasının daha modern bir döneme girişini temsil etmektedir. 2015 yılında ECMAScript 6 (ES6) ile birlikte JavaScript’e modül desteği eklenmiştir. Client-side ve server-side uygulamalarda kullanılabilir ve asenkron modül yükleme desteği sağlar. Syntax’ı da diğer modül çözümlerine oranla çok daha basittir. import ve export anahtar kelimelerini kullanarak modüller arasındaki veri akışını yönetir.
Modüller için sunulan çözümler arasında mevcut çözüm ES Modülleridir. Ancak bu resmi çözüme ulaşılması oldukça uzun sürmüştür, bu süreçte oluşturulan farklı modül sistemleri JavaScript ekosisteminde uyumsuzluğa ve karmaşıklığa yol açmıştır.
Get Büşra Özmen’s stories in your inbox
Join Medium for free to get updates from this writer.
Şimdi ES Modüllerinin kullanımına bir göz atalım.
//user.js
export const user = (fullName, phone) => {
var returnObj = {
fullName : fullName,
phone : phone,
contactInfo: 'Contact Info: ' + fullName + ' ' + phone
}
return returnObj
}//main.js
import { user } from './user.js'
const person = user('James Bond', '5555555555');
console.log(person.contactInfo) -> Contact Info: James Bond 5555555555ES modülleri, şu anda kullanılan mevcut yöntem olduğundan, içe ve dışa aktarma konularıyla ilgili bazı terimleri ve kullanım şekillerini alt başlıklar halinde ele almak istiyorum.
- export default: ‘export’ anahtar kelimesini kullanarak birden fazla fonksiyon, değişken veya nesneyi farklı bir dosyaya aktarabiliriz. Yukarıdaki örnekte, ‘user’ fonksiyonunun yanı sıra yaş hesaplama fonksiyonu da olsaydı, aynı şekilde bu fonksiyonun başına da ‘export’ anahtar kelimesini ekleyerek dışa aktarabilirdik. Ayrıca, iki fonksiyonu ‘export’ anahtar kelimesini kullanmadan şu şekilde export edebilirdik:
export {user, ageCalculate}İçe aktarırken de ‘import’ anahtar kelimesini kullanarak iki fonksiyonu da içe aktarabilirdik:import {user, ageCalculate} from './user.js'Birden fazla fonksiyon, değişken yada nesneyi aktarmak istediğimiz durumlarda bu kullanım şekli oldukça kullanışlıdır. Fakat, bir dosyada sadece tek bir işlevi dışarı aktarmak istiyorsak ‘export default’ anahtar kelimesi daha kullanışlı olabilir. ‘export default’ ile dışa aktardığımız fonksiyonu farklı bir isimle import edebiliriz. Aşağıdaki örnekte, ‘User’ ve ‘Profile’ çıktıları aynı olacaktır.
//user.js
export default User = (fullName, phone) => {
......
}//main.js
import User from './user.js'
//ya da
import Profile from './user.js'- alias (takma ad): Bir fonksiyonu import ederken ismini değiştirmek istediğimizde “as” anahtar kelimesini kullanabiliriz. Genellikle aynı isimdeki fonksiyonların farklı dosyalarda çakışmasını önlemek için bu yöntem kullanılır.
import {user as person} from './user.js'- namespaces: Tüm fonksiyonları tek bir nesne altında içe aktarmak için
“* as” anahtar kelimelerini kullanabiliriz. Bir dosyada export ettiğimiz tüm fonksiyonları tek bir isimle alabiliriz.
import * as profile from '/user.js'
profile.ageCalculate();
profile.user();- combine exports: Birden çok modüle tek bir dosyada ihtiyacımız olduğunda yeni bir dosya açıp kullanmak istediğimiz modülleri buraya import edebiliriz. Bir dosyada bir iki tane modüle ihtiyacımız olduğunda yeni bir dosya açmamıza gerek yoktur, fakat çok fazla modüle ihtiyacımız olduğu zaman aşağıdaki örnekteki gibi yeni bir dosyada modülleri toplayabiliriz. Ardından direkt olarak bu modülü kullanarak çok daha temiz bir kod yazabiliriz. Ben bu yöntemi sıklıkla kullanıyorum ve kodun okunurluğunu ve yeniden kullanılabilirliğini arttırdığını düşünüyorum.
// combine.js
import * as profile from 'user.js';
import * as calc from 'calc.js';
....// main.js
import * as combine from 'combine.js'
combine.profile.ageCalculate();- dynamic import: Kullanmak istediğimiz modülü sadece gerektiği anda import edebilmemiz için dynamic import özelliğinden faydalanabiliriz. Bu sayede kodu daha verimli hale getirip, ihtiyaç duyduğumuz modülleri daha iyi kontrol edebiliriz. Aşağıdaki kod bloğunda dynamic import kullanımına dair bir örnek görebilirsiniz.
//main.js
if(a == b) {
const {user} = await import('./user.js');
user('James Bond', '5555555555');
}Modüllerin Avantajları
Modüllerden bahsederken değindiğim avantajları tek bir çatı altında toplayalım.🏠
- Kodun Okunurluğu
- Tekrar Kullanılabilirlik
- Ekip Çalışması Kolaylığı
- Hata Ayıklama Kolaylığı
- Performans İyileştirmeleri
Sonuç
JavaScript modülleri, modern web geliştirmenin vazgeçilmez bir parçasıdır. Geliştiricilerin kodu küçük bağımsız parçalara bölmeleri ve bu parçaları gerektiğinde kullanmaları için tercih edilen bir araçtır. Küçük ve büyük ölçekli uygulamalarda kodun daha iyi organize edilmesini, yeniden kullanılmasını ve geliştirme sürecinin daha verimli hale gelmesini sağlarlar.
Sıklıkla kullandığım modüller, geliştirme sürecimi kolaylaştırıyor. Modüller sayesinde projelerimin daha okunaklı ve anlaşılır olmasının, projenin sürdürülebilirliği açısından önemli olduğunu düşünüyorum. Bu sebeple her geliştiricinin modüller hakkında bilgi sahibi olmasını ve projelerinde kullanmasını tavsiye ederim.🤗
Sevgiler.











