Express’te req Nesnesi Nasıl Kullanılır? Kapsamlı Bir Rehber
Giriş: req Nesnesine Genel Bakış
Express.js, Node.js için minimalist ve esnek bir web uygulama çerçevesidir. Express ile bir web uygulaması veya API geliştirirken, gelen HTTP isteklerini işlemek için req (request) nesnesi merkezi bir rol oynar. Her bir HTTP isteği, Express tarafından otomatik olarak bir req nesnesine dönüştürülür ve bu nesne, ilgili rota işleyici (route handler) veya ortakatman (middleware) fonksiyonlarına argüman olarak geçirilir.
req nesnesi, istemciden gelen istek hakkında her türlü bilgiyi barındıran bir JavaScript objesidir. Bu bilgiler arasında istek parametreleri, sorgu dizisi (query string) verileri, istek gövdesi (request body), HTTP başlıkları, istemci IP adresi ve daha fazlası bulunur. Bir geliştirici olarak, req nesnesini kullanarak gelen isteği analiz edebilir, kullanıcı girişini işleyebilir, güvenlik kontrolleri yapabilir ve uygulamanızın mantığını bu bilgilere göre şekillendirebilirsiniz.
Bu makalede, req nesnesinin çeşitli özelliklerini ve metotlarını detaylı bir şekilde inceleyeceğiz. Her bir özelliğin ne anlama geldiğini, nasıl kullanıldığını ve gerçek dünya senaryolarında nasıl faydalı olabileceğini örneklerle açıklayacağız. Ayrıca, req nesnesini güvenli ve etkin bir şekilde kullanmak için en iyi uygulamalara ve sıkça yapılan hatalara da değineceğiz. Express uygulamalarınızda req nesnesinin gücünden tam olarak yararlanmak için bu kapsamlı rehber size yol gösterecektir.
req Nesnesinin Temel Özellikleri
req nesnesi, gelen HTTP isteğine dair birçok temel bilgiyi barındıran zengin bir yapıya sahiptir. Bu bölümde, en sık kullanılan ve kritik özelliklerini detaylıca inceleyeceğiz.
req.params: URL Parametreleri
req.params nesnesi, URL’deki dinamik segmentleri yakalamak için kullanılır. Özellikle RESTful API’lerde belirli bir kaynağın kimliğini belirtmek için çok yaygın olarak kullanılır. Örneğin, /users/:id gibi bir rotada :id, dinamik bir parametredir.
app.get('/users/:userId/posts/:postId', (req, res) => {
const userId = req.params.userId; // Örneğin: '123'
const postId = req.params.postId; // Örneğin: '456'
res.send(Kullanıcı ID: ${userId}, Gönderi ID: ${postId});
});Yukarıdaki örnekte, /users/123/posts/456 adresine yapılan bir istekte req.params objesi { userId: '123', postId: '456' } şeklinde olacaktır. Bu parametreler genellikle string formatında gelir ve sayısal değerler için dönüştürme yapılması gerekebilir (örn. parseInt(userId)).
req.query: Sorgu Dizisi Parametreleri
req.query nesnesi, URL’nin sorgu dizisinde (query string) yer alan parametreleri içerir. Bu parametreler, genellikle filtreleme, sıralama, sayfalama gibi isteğe bağlı verileri iletmek için kullanılır. Sorgu dizisi, URL’de ? işaretinden sonra başlar ve parametreler anahtar=değer çiftleri şeklinde, & ile ayrılarak belirtilir.
app.get('/products', (req, res) => {
const category = req.query.category; // Örneğin: 'elektronik'
const sortBy = req.query.sortBy; // Örneğin: 'price'
const limit = req.query.limit; // Örneğin: '10'
if (category) {
res.send(Kategoriye göre ürünler: ${category}. Sıralama: ${sortBy || 'yok'}. Limit: ${limit || 'tüm'});
} else {
res.send('Tüm ürünler listeleniyor.');
}
});/products?category=elektronik&sortBy=price&limit=10 adresine yapılan bir istekte req.query objesi { category: 'elektronik', sortBy: 'price', limit: '10' } şeklinde olacaktır. req.query içindeki tüm değerler de string olarak gelir.
req.body: İstek Gövdesi Verileri
req.body nesnesi, POST, PUT veya PATCH gibi isteklerde istemciden gönderilen verileri içerir. Bu veriler genellikle HTML formlarından (URL kodlu veya çok parçalı form verisi) veya JSON/XML formatında API isteklerinden gelir. req.body‘ye erişebilmek için Express uygulamanızda uygun bir body parser ortakatmanının (middleware) yapılandırılmış olması gerekir. Express’in 4.16.0 sürümünden itibaren express.json() ve express.urlencoded() yerleşik olarak gelmektedir.
// app.js dosyasının başında
const express = require('express');
const app = express();
// JSON istek gövdelerini ayrıştırmak için
app.use(express.json());
// URL-encoded istek gövdelerini ayrıştırmak için
app.use(express.urlencoded({ extended: true }));
app.post('/register', (req, res) => {
const { username, email, password } = req.body;
if (username && email && password) {
res.status(201).send(Kullanıcı kaydedildi: ${username}, ${email});
} else {
res.status(400).send('Eksik bilgi.');
}
});Bir JSON isteği (Content-Type: application/json) { "username": "ali", "email": "ali@example.com", "password": "123" } gönderildiğinde, req.body bu objeyi içerecektir.
req.headers: İstek Başlıkları
req.headers nesnesi, istemci tarafından gönderilen tüm HTTP başlıklarını içerir. Bu başlıklar, isteğin içeriği, istemci bilgileri, kimlik doğrulama belirteçleri (token) ve önbellekleme talimatları gibi çeşitli meta verileri taşır. Başlık anahtarları genellikle küçük harfe dönüştürülür.
app.get('/info', (req, res) => {
const userAgent = req.headers['user-agent'];
const contentType = req.headers['content-type'];
const authorization = req.headers['authorization'];
res.send(User-Agent: ${userAgent}\nContent-Type: ${contentType || 'Yok'}\nAuthorization: ${authorization || 'Yok'});
});User-Agent başlığı, isteği yapan istemcinin (tarayıcı, mobil uygulama vb.) türünü ve sürümünü belirtir. Authorization başlığı ise genellikle JWT (JSON Web Token) gibi kimlik doğrulama belirteçlerini taşır.
req.method: İstek Metodu
req.method özelliği, gelen HTTP isteğinin metodunu (fiilini) bir string olarak döndürür. Örneğin, GET, POST, PUT, DELETE gibi. Bu özellik, rotaları daha genel hale getirmek veya belirli bir isteğe özel mantık uygulamak için kullanılabilir.
app.all('/data', (req, res) => { // 'app.all' tüm HTTP metotlarını yakalar
res.send(Bu istek bir ${req.method} isteğidir.);
});req.url / req.originalUrl: İstek URL’si
* req.url: Gelen isteğin URL yolunu döndürür. Bu yol, temel URL’den sonraki kısmı ve sorgu dizisini içerir, ancak ana bilgisayar adını (hostname) ve protokolü içermez. Express’in yönlendirme mekanizması tarafından işlendikten sonra değişebilir.
* req.originalUrl: req.url‘dan farklı olarak, gelen isteğin orijinal URL yolunu döndürür. Bu, yönlendirme veya ara yazılımlar tarafından yapılan değişikliklerden etkilenmez. Genellikle, isteğin ilk geldiği haliyle URL’yi görmek istendiğinde kullanılır.
app.get('/admin/*', (req, res, next) => {
console.log('Original URL:', req.originalUrl); // Örn: /admin/users?page=1
console.log('URL:', req.url); // Örn: /users?page=1 (eğer bir router kullanılıyorsa değişebilir)
next();
});
app.get('/admin/users', (req, res) => {
res.send(Admin kullanıcıları sayfası. Orijinal URL: ${req.originalUrl});
});req.path: İstek Yolu
req.path özelliği, istek URL’sinin yol kısmını döndürür. Sorgu dizisi veya karma (hash) kısmı içermez. Sadece yolu gösterir.
app.get('/items/search?q=kitap', (req, res) => {
res.send(İstek yolu: ${req.path}); // Çıktı: /items/search
});req.protocol: İstek Protokolü
req.protocol özelliği, isteğin yapıldığı protokolü (örn. http veya https) bir string olarak döndürür.
app.get('/', (req, res) => {
res.send(Bu bağlantı ${req.protocol} üzerinden yapıldı.);
});req.hostname / req.ip: Ana Bilgisayar Adı ve IP Adresi
* req.hostname: İsteğin yapıldığı ana bilgisayar adını döndürür. Örneğin, example.com.
* req.ip: İstemcinin IP adresini döndürür. Bir proxy arkasından gelen isteklerde, proxy’nin IP’si yerine gerçek istemci IP’sini almak için app.set('trust proxy', true) ayarını yapmak gerekebilir.
app.get('/whoami', (req, res) => {
res.send(Ana bilgisayar: ${req.hostname}, IP adresiniz: ${req.ip});
});req.secure: Güvenli Bağlantı Kontrolü
req.secure özelliği, isteğin bir SSL/TLS güvenli bağlantısı (HTTPS) üzerinden mi yapıldığını belirten bir boolean değeridir. true ise HTTPS, false ise HTTP’dir. Proxy arkasından gelen isteklerde doğru sonuç almak için app.set('trust proxy', true) ayarı önemlidir.
app.get('/secure-check', (req, res) => {
if (req.secure) {
res.send('Bu istek güvenli (HTTPS) bir bağlantı üzerinden yapıldı.');
} else {
res.send('Bu istek güvenli değil (HTTP).');
}
});req.fresh / req.stale: Önbellek Durumu
Bu özellikler, istemcinin önbelleği ile sunucudaki kaynak arasında bir karşılaştırma yaparak önbellek durumunu kontrol eder. If-None-Match ve If-Modified-Since gibi HTTP başlıklarına dayanır.
* req.fresh: İstemcinin önbelleğe aldığı yanıtın hala güncel (fresh) olup olmadığını belirten boolean değeridir. true ise günceldir ve 304 Not Modified yanıtı gönderilebilir.
* req.stale: İstemcinin önbelleğe aldığı yanıtın artık güncel olmadığını (stale) belirten boolean değeridir. true ise sunucunun yeni bir yanıt göndermesi gerekir.
app.get('/data-cache', (req, res) => {
// Örnek bir ETag veya Last-Modified başlığı ayarlayın
res.set('ETag', 'some-unique-hash');
// res.set('Last-Modified', new Date().toUTCString());
if (req.fresh) {
res.status(304).send(); // Veri güncel, yeni içerik gönderme
} else {
res.status(200).send('Yeni veri gönderiliyor.'); // Veri güncel değil, yeni içerik gönder
}
});req.subdomains: Alt Alan Adları
req.subdomains özelliği, isteğin yapıldığı ana bilgisayar adının alt alan adlarını (subdomain) bir dizi olarak döndürür. Örneğin, app.example.com için ['app'] döndürür.
// app.set('subdomain offset', 2); // Varsayılan 2'dir, ihtiyaca göre ayarlanabilir
app.get('/', (req, res) => {
res.send(Alt alan adları: ${req.subdomains.join(', ') || 'Yok'});
});blog.users.example.com adresine yapılan bir istekte req.subdomains değeri ['blog', 'users'] olacaktır (eğer subdomain offset ayarı varsayılan olarak bırakılırsa).
req Nesnesinin Metotları
req nesnesi, sadece özellikler değil, aynı zamanda gelen isteği daha dinamik bir şekilde sorgulamak için kullanılabilecek bir dizi metoda da sahiptir.
req.accepts(): Kabul Edilen İçerik Türleri
req.accepts() metodu, istemcinin Accept HTTP başlığına göre belirli içerik türlerinden hangilerini kabul ettiğini kontrol eder. Bu, sunucunun istemciye en uygun yanıt formatını (örn. JSON, HTML, XML) göndermesine olanak tanır. Bir veya daha fazla MIME türü, dosya uzantısı veya bir dizi olarak argüman alır.
app.get('/content', (req, res) => {
if (req.accepts('html')) {
res.send('');
} else if (req.accepts('json')) {
res.json({ message: 'Merhaba JSON!' });
} else {
res.status(406).send('Kabul edilebilir bir içerik türü bulunamadı.');
}
});req.accepts(['json', 'html']) şeklinde bir dizi de verebilirsiniz. Metot, kabul edilen ilk türü döndürür veya hiçbirini kabul etmiyorsa false döndürür.
req.acceptsCharsets(): Kabul Edilen Karakter Kümeleri
req.acceptsCharsets() metodu, istemcinin Accept-Charset başlığına göre hangi karakter kümelerini (örn. utf-8, iso-8859-1) kabul ettiğini kontrol eder.
app.get('/charset', (req, res) => {
if (req.acceptsCharsets('utf-8')) {
res.set('Content-Type', 'text/plain; charset=utf-8');
res.send('UTF-8 karakter kümesi kabul edildi.');
} else {
res.status(406).send('UTF-8 kabul edilmiyor.');
}
});req.acceptsEncodings(): Kabul Edilen Kodlamalar
req.acceptsEncodings() metodu, istemcinin Accept-Encoding başlığına göre hangi kodlamaları (örn. gzip, deflate, br) kabul ettiğini kontrol eder. Bu, yanıtın sıkıştırılıp sıkıştırılmayacağını belirlemek için kullanılır.
app.get('/compressed', (req, res) => {
if (req.acceptsEncodings('gzip')) {
res.set('Content-Encoding', 'gzip');
// Gerçekte burada yanıtı gzip ile sıkıştırmalısınız
res.send('Gzip kodlaması kabul edildi.');
} else {
res.send('Sıkıştırılmamış yanıt.');
}
});req.acceptsLanguages(): Kabul Edilen Diller
req.acceptsLanguages() metodu, istemcinin Accept-Language başlığına göre hangi dilleri (örn. tr, en-US) kabul ettiğini kontrol eder. Çok dilli uygulamalarda kullanıcının tercih ettiği dili belirlemek için çok kullanışlıdır.
app.get('/hello', (req, res) => {
if (req.acceptsLanguages('tr')) {
res.send('Merhaba dünya!');
} else if (req.acceptsLanguages('en')) {
res.send('Hello world!');
} else {
res.send('Welcome!');
}
});req.get(): İstek Başlığı Alma
req.get() metodu, belirli bir HTTP başlığının değerini küçük/büyük harf duyarlılığı olmadan almak için kullanılır. req.headers['header-name'] ile aynı işlevi görür ancak daha esnektir.
app.get('/header-check', (req, res) => {
const host = req.get('Host');
const referer = req.get('Referer'); // Yanlış yazım bile olsa düzeltir
res.send(Host: ${host}, Referer: ${referer || 'Yok'});
});req.is(): İstek İçerik Türü Kontrolü
req.is() metodu, gelen isteğin Content-Type başlığının belirli bir MIME türüyle eşleşip eşleşmediğini kontrol eder. Özellikle POST veya PUT isteklerinde gönderilen veri türünü doğrulamak için kullanışlıdır.
app.post('/upload', (req, res) => {
if (req.is('json')) {
res.send('JSON formatında veri alındı.');
} else if (req.is('multipart/form-data')) {
res.send('Form verisi (multipart) alındı.');
} else {
res.status(415).send('Desteklenmeyen içerik türü.');
}
});req Nesnesi ile Gelişmiş Kullanım Senaryoları
req nesnesinin temel özellikleri ve metotları, Express uygulamalarının bel kemiğini oluşturur. Ancak bu nesne, daha karmaşık ve güçlü senaryolar için de genişletilebilir ve kullanılabilir.
Kullanıcı Kimlik Doğrulaması ve Yetkilendirme
Kimlik doğrulama (authentication) ve yetkilendirme (authorization) genellikle ortakatmanlar (middleware) aracılığıyla yapılır. Başarılı bir kimlik doğrulamasının ardından, kullanıcıya ait bilgiler genellikle req nesnesine eklenerek sonraki rota işleyicileri veya diğer ortakatmanlar tarafından kolayca erişilebilir hale getirilir.
// Kimlik doğrulama ortakatmanı (middleware)
function authenticateUser(req, res, next) {
const token = req.headers['authorization'];
if (!token) {
return res.status(401).send('Kimlik doğrulama belirteci eksik.');
}
// Token'ı doğrula ve kullanıcı bilgilerini al
try {
const user = verifyToken(token.split(' ')[1]); // Bearer token'ı ayrıştırma
req.user = user; // Kullanıcı bilgilerini req nesnesine ekle
next();
} catch (error) {
res.status(403).send('Geçersiz kimlik doğrulama belirteci.');
}
}
// Rota işleyici
app.get('/profile', authenticateUser, (req, res) => {
// req.user artık kimliği doğrulanmış kullanıcı bilgilerini içeriyor
res.send(Merhaba, ${req.user.username}! Profil bilgileriniz.);
});Bu sayede, req.user özelliği uygulamanın herhangi bir yerinde oturum açmış kullanıcıya erişim sağlar.
Middleware Kullanımı ve req Nesnesini Genişletme
Express’in ortakatman yapısı, req nesnesini isteğe özel verilerle genişletmek için mükemmel bir mekanizma sunar. Kendi özel özelliklerinizi req nesnesine ekleyerek, bir isteğin yaşam döngüsü boyunca veri taşıyabilirsiniz.
// Özel bir ortakatman
app.use((req, res, next) => {
req.requestTime = new Date().toISOString(); // İstek zamanını ekle
req.requestId = Math.random().toString(36).substring(7); // Benzersiz bir istek ID'si ekle
next();
});
app.get('/log', (req, res) => {
res.send(Bu istek ${req.requestTime} tarihinde yapıldı. İstek ID: ${req.requestId});
});Bu yöntem, istek izleme, performans ölçümü veya genel bir işlem kimliği atamak gibi senaryolarda oldukça faydalıdır.
Dosya Yükleme (Multer ile req.file / req.files)
Dosya yükleme, genellikle multipart/form-data içerik türüyle gerçekleştirilir. Express’in yerleşik body-parser‘ı bu tür verileri ayrıştırmaz. multer gibi üçüncü taraf ortakatmanlar, gelen dosyaları ayrıştırır ve bunları req.file (tek dosya için) veya req.files (çoklu dosya için) özelliklerine ekler.
const multer = require('multer');
const upload = multer({ dest: 'uploads/' }); // Dosyaların yükleneceği dizin
app.post('/upload-single', upload.single('myFile'), (req, res) => {
if (req.file) {
res.send(Dosya başarıyla yüklendi: ${req.file.originalname});
console.log(req.file); // Yüklenen dosya hakkında detaylı bilgi
} else {
res.status(400).send('Dosya yüklenemedi.');
}
});
app.post('/upload-multiple', upload.array('myFiles', 5), (req, res) => {
if (req.files && req.files.length > 0) {
res.send(${req.files.length} dosya başarıyla yüklendi.);
console.log(req.files); // Yüklenen dosyalar hakkında detaylı bilgi
} else {
res.status(400).send('Dosya yüklenemedi.');
}
});req.file veya req.files nesneleri, yüklenen dosyanın adı, boyutu, MIME türü ve geçici depolama yolu gibi bilgileri içerir.
API Sürümleme (req.headers veya req.accepts() ile)
Büyük API’lerde, geriye dönük uyumluluğu korumak için API sürümleme önemlidir. İstemcinin hangi API sürümünü istediğini belirtmek için req nesnesini kullanabilirsiniz.
* Custom Header (Özel Başlık): X-API-Version gibi özel bir HTTP başlığı kullanmak yaygın bir yöntemdir.
app.get('/api/users', (req, res) => {
const apiVersion = req.get('X-API-Version');
if (apiVersion === '2') {
res.json({ version: '2.0', users: ['Alice', 'Bob'] });
} else { // Varsayılan veya v1
res.json({ version: '1.0', users: ['Alice'] });
}
});* Accept Header (Kabul Başlığı): Accept başlığında özel bir MIME türü kullanmak (application/vnd.myapi.v1+json).
app.get('/api/products', (req, res) => {
if (req.accepts('application/vnd.myapi.v2+json')) {
res.json({ version: '2.0', products: [{id: 1, name: 'Product A'}] });
} else if (req.accepts('application/vnd.myapi.v1+json')) {
res.json({ version: '1.0', products: [{name: 'Product A'}] });
} else {
res.status(406).send('Desteklenmeyen API sürümü.');
}
});Çok Dilli Uygulamalar (req.acceptsLanguages() ile)
Uluslararası uygulamalarda, kullanıcının tercih ettiği dili tespit etmek ve içeriği buna göre sunmak önemlidir. req.acceptsLanguages() metodu, istemcinin Accept-Language başlığını analiz ederek en uygun dili belirlemenize yardımcı olur.
const messages = {
'en': 'Hello, world!',
'tr': 'Merhaba dünya!',
'es': '¡Hola mundo!'
};
app.get('/greeting', (req, res) => {
const preferredLanguage = req.acceptsLanguages(['tr', 'en', 'es']);
if (preferredLanguage && messages[preferredLanguage]) {
res.send(messages[preferredLanguage]);
} else {
res.send(messages['en']); // Varsayılan dil
}
});Bu sayede, kullanıcının tarayıcı ayarlarından gelen dil tercihi dikkate alınarak daha kişiselleştirilmiş bir deneyim sunulabilir.
Güvenlik ve req Nesnesi
req nesnesi, istemciden gelen tüm verileri içerdiğinden, güvenlik açısından dikkatli kullanılması gereken kritik bir kaynaktır. Güvenlik açıklarını önlemek için req nesnesinden alınan verilerin her zaman doğrulanması ve temizlenmesi (sanitizasyon) gerekir.
Giriş Doğrulama ve Sanitizasyon
req.params, req.query ve req.body üzerinden gelen tüm kullanıcı girişleri, uygulamanızın güvenliği için potansiyel risk taşır. Bu verilerin her zaman beklenilen format, tip ve sınırlar içinde olup olmadığını doğrulamak (validation) ve zararlı karakterlerden arındırmak (sanitization) hayati öneme sahiptir.
* Doğrulama (Validation): Gelen verilerin uygulamanızın beklediği kurallara uygunluğunu kontrol etmek. Örneğin, bir e-posta adresinin geçerli bir formatta olup olmadığını, bir yaş değerinin sayısal ve belirli bir aralıkta olup olmadığını kontrol etmek. express-validator veya Joi gibi kütüphaneler bu konuda yardımcı olur.
const { body, validationResult } = require('express-validator');
app.post('/user', [
body('username').isLength({ min: 3 }).trim().escape(),
body('email').isEmail().normalizeEmail(),
body('password').isLength({ min: 6 })
], (req, res) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(400).json({ errors: errors.array() });
}
// Veriler geçerli, güvenli bir şekilde kullanılabilir
res.status(201).send('Kullanıcı oluşturuldu.');
});* Sanitizasyon (Sanitization): Gelen verilerden potansiyel olarak zararlı karakterleri veya kodları kaldırmak. Örneğin, HTML etiketlerini veya SQL enjeksiyonu girişimlerini temizlemek. express-validator‘daki escape() gibi metotlar XSS saldırılarına karşı koruma sağlar.
XSS (Cross-Site Scripting) ve CSRF (Cross-Site Request Forgery) Koruması
req nesnesinden alınan veriler doğrudan HTML çıktısına yerleştirildiğinde XSS saldırılarına yol açabilir. Bu nedenle, kullanıcı tarafından sağlanan herhangi bir metni HTML’e dönüştürmeden önce her zaman temizlemek veya kaçış karakterlerini kullanmak (escaping) önemlidir.
CSRF saldırıları, kimliği doğrulanmış bir kullanıcının bilgisi dışında istek göndermesini hedefler. req.headers ve req.body kullanılarak CSRF belirteçleri (token) kontrol edilerek bu tür saldırılar önlenebilir. csurf gibi ortakatmanlar bu korumayı otomatik olarak sağlar.
Rate Limiting (İstek Sınırlama)
req.ip özelliğini kullanarak belirli bir IP adresinden gelen isteklerin sayısını sınırlayabilirsiniz. Bu, kaba kuvvet saldırılarını veya hizmet reddi (DoS) saldırılarını önlemeye yardımcı olur. express-rate-limit gibi kütüphaneler bu işlevi kolayca entegre etmenizi sağlar.
const rateLimit = require('express-rate-limit');
const limiter = rateLimit({
windowMs: 15 60 1000, // 15 dakika
max: 100, // Her IP'den 15 dakika içinde maksimum 100 istek
message: 'Çok fazla istek, lütfen daha sonra tekrar deneyin.'
});
// Belirli rotalara rate limiter uygula
app.use('/api/', limiter);
app.get('/api/data', (req, res) => {
res.send('API verileri.');
});Sıkça Yapılan Hatalar ve Çözümleri
req nesnesini kullanırken geliştiricilerin sıkça yaptığı bazı hatalar vardır. Bu hataları bilmek ve önlemek, daha sağlam ve güvenli Express uygulamaları geliştirmenize yardımcı olacaktır.
Body Parser Olmadan req.body’ye Erişmeye Çalışmak
Hata: POST veya PUT isteklerinde req.body‘ye erişmeye çalışmak, ancak uygun bir body parser ortakatmanını uygulamanıza eklememiş olmak. Bu durumda req.body undefined olacaktır.
Çözüm: Express 4.16.0 ve üzeri sürümlerinde express.json() ve express.urlencoded() ortakatmanlarını kullanın.
const express = require('express');
const app = express();
// Çözüm: Bu satırları ekleyin
app.use(express.json()); // JSON istek gövdeleri için
app.use(express.urlencoded({ extended: true })); // URL-encoded form verileri için
app.post('/data', (req, res) => {
// Şimdi req.body'ye erişebilirsiniz
console.log(req.body);
res.send('Veri alındı.');
});Dosya yüklemeleri için multer gibi özel bir ortakatman kullanmanız gerektiğini unutmayın.
Parametre ve Sorgu Dizisi Arasındaki Farkı Karıştırmak
Hata: URL’deki dinamik segmentler (/users/:id) ile sorgu dizisi parametrelerini (/users?status=active) karıştırmak. Örneğin, bir dinamik parametre için req.query.id kullanmaya çalışmak veya sorgu dizisi parametresi için req.params.status kullanmaya çalışmak.
Çözüm:
* Dinamik URL segmentleri için req.params kullanın.
* Rota: /products/:productId
* URL: /products/123
* Erişim: req.params.productId
* Sorgu dizisi parametreleri için req.query kullanın.
* Rota: /search
* URL: /search?q=kitap&page=2
* Erişim: req.query.q, req.query.page
Güvenlik Açıklarını Göz Ardı Etmek
Hata: req nesnesinden gelen kullanıcı girişlerini doğrulamadan veya temizlemeden doğrudan veritabanına kaydetmek, HTML çıktısına basmak veya diğer işlemler için kullanmak. Bu, SQL enjeksiyonu, XSS veya diğer güvenlik açıklarına yol açabilir.
Çözüm:
* Her zaman req.params, req.query, req.body‘den gelen tüm kullanıcı girişlerini doğrulayın (validate) ve temizleyin (sanitize).
* Kullanıcı girişini veritabanına kaydetmeden önce parametreli sorgular veya ORM’ler kullanın.
* Kullanıcı girişini HTML çıktısına basmadan önce uygun kaçış (escaping) mekanizmalarını kullanın.
* Kimlik doğrulama ve yetkilendirme için güçlü ortakatmanlar kullanın.
* Rate limiting ve diğer güvenlik önlemlerini uygulayın.
Sonuç
req nesnesi, Express.js çerçevesinin kalbinde yer alan, gelen HTTP isteği hakkında zengin ve kapsamlı bilgi sağlayan temel bir yapıdır. Bu makalede, req.params, req.query, req.body, req.headers gibi temel özelliklerden req.accepts(), req.get(), req.is() gibi metotlara kadar birçok yönünü ele aldık. Ayrıca, kimlik doğrulama, dosya yükleme, API sürümleme ve çok dilli uygulamalar gibi gelişmiş kullanım senaryolarında req nesnesinin nasıl kullanılabileceğini gösterdik.
Unutulmamalıdır ki, req nesnesinden alınan tüm kullanıcı girişleri potansiyel güvenlik riski taşır. Bu nedenle, giriş doğrulama, sanitizasyon ve diğer güvenlik en iyi uygulamalarını titizlikle uygulamak, sağlam ve güvenli Express uygulamaları geliştirmenin anahtarıdır. req nesnesini doğru ve bilinçli bir şekilde kullanarak, her türlü gelen isteği etkin bir şekilde işleyebilir, uygulamanızın mantığını esnek bir şekilde kurabilir ve kullanıcılarınıza daha iyi bir deneyim sunabilirsiniz. Express’in gücünü tam anlamıyla kullanmak için req nesnesinin derinlemesine anlaşılması vazgeçilmezdir.