[NODE JS] path.resolve ile Mutlak Yol Olusturma

[Silverhand]

[NODE JS] path.resolve ile Mutlak Yol Olusturma​

Selam arkadaslar, path modulunun bir diger onemli fonksiyonu olan path.resolve'u anlatacagim bugun. path.join ile cok karistirilan bir fonksiyon ama aslinda amaci farkli. path.resolve her zaman mutlak (absolute) bir yol dondurur ve bu ozellik onu bir cok senaryoda vazgecilmez yapar.

path.resolve vs path.join​

Bu iki fonksiyon surekli birbirine karistirilir ve ben junior gelisitircilerin bu hataya dustugunu cok gordum. Temel fark su: path.join sadece verdiginiz parcalari birlestirir ve normalize eder, sonuc relative de olabilir. path.resolve ise sagdan sola parcalari isler ve mutlak bir yola ulasana kadar devam eder. Eger hicbir parca mutlak yol icermiyorsa, process.cwd() yani calisma dizinini basa ekler.

Bir ornek verelim: path.join('src', 'utils') size 'src/utils' dondurur ki bu relative bir yol. Ama path.resolve('src', 'utils') size '/mevcut/calisma/dizini/src/utils' dondurur ki bu absolute bir yol. Bu fark kucuk gorunebilir ama buyuk projelerde cok onemli.

const path = require('path');

// path.join vs path.resolve farki
console.log('=== FARK GOSTERIMI ===\n');

// Ornek 1: Basit birlestirme
console.log('join:   ', path.join('src', 'utils'));
console.log('resolve:', path.resolve('src', 'utils'));
// join sadece birlestirir, resolve cwd ekler

// Ornek 2: Mutlak yol icerdiginde
console.log('\njoin:   ', path.join('src', '/utils', 'helper.js'));
console.log('resolve:', path.resolve('src', '/utils', 'helper.js'));
// join: src/utils/helper.js (slash'i temizler)
// resolve: /utils/helper.js (mutlak yoldan yeniden baslar!)

// Ornek 3: .. ile ust dizine cikma
console.log('\njoin:   ', path.join('/proje', 'src', '..', 'config'));
console.log('resolve:', path.resolve('/proje', 'src', '..', 'config'));
// Her ikisi de: /proje/config

// Ornek 4: Bos arguman
console.log('\njoin:   ', path.join());     // .
console.log('resolve:', path.resolve());    // process.cwd()

// Ornek 5: Sagdan sola islem
console.log('\n=== RESOLVE MANTIGI ===');
// resolve sagdan sola isler
console.log(path.resolve('a', 'b', 'c'));
// cwd/a/b/c
console.log(path.resolve('a', '/b', 'c'));
// /b/c (mutlak yol buldugunda durur)
console.log(path.resolve('/a', '/b', 'c'));
// /b/c (en sagdaki mutlak yoldan baslar)

Gercek Hayat Kullanim Alanlari​

path.resolve'u en cok proje kok dizinini bulmak, konfigürasyon dosyalarinin kesin konumunu belirlemek ve webpack/babel gibi build araclarinda yol tanimlamak icin kullaniyorum. Ozellikle monorepo yapilarinda veya alt dizinlerden calistirilan script'lerde hayat kurtarici oluyor.

Ben genelde projenin basinda bir constants dosyasinda tum kritik dizinleri path.resolve ile tanimliyorum. Boylece projenin her yerinden bu dizinlere guvenli bir sekilde erisilebiliyor. Bu yaklasim ozellikle test ortaminda cok ise yariyor cunku testler farkli dizinlerden calistirilabilir.

const path = require('path');

// Proje dizinlerini tanimla
const PROJE_KOK = path.resolve(__dirname, '..');
const DIZINLER = {
    kaynak: path.resolve(PROJE_KOK, 'src'),
    config: path.resolve(PROJE_KOK, 'config'),
    public: path.resolve(PROJE_KOK, 'public'),
    uploads: path.resolve(PROJE_KOK, 'uploads'),
    logs: path.resolve(PROJE_KOK, 'logs'),
    views: path.resolve(PROJE_KOK, 'views'),
    tests: path.resolve(PROJE_KOK, 'tests')
};

console.log('Proje Dizin Yapisi:');
console.log('===================');
Object.entries(DIZINLER).forEach(([ad, yol]) => {
    console.log(`  ${ad}: ${yol}`);
});

// Webpack config ornegi
const webpackConfig = {
    entry: path.resolve(DIZINLER.kaynak, 'index.js'),
    output: {
        path: path.resolve(PROJE_KOK, 'dist'),
        filename: 'bundle.js'
    },
    resolve: {
        alias: {
            '@': path.resolve(DIZINLER.kaynak),
            '@components': path.resolve(DIZINLER.kaynak, 'components'),
            '@utils': path.resolve(DIZINLER.kaynak, 'utils'),
            '@config': path.resolve(DIZINLER.config)
        }
    }
};

console.log('\nWebpack Alias Yapisi:');
Object.entries(webpackConfig.resolve.alias).forEach(([alias, yol]) => {
    console.log(`  ${alias} -> ${yol}`);
});

// Environment bazli config yukleyici
function configYukle(ortam) {
    const configDosyasi = path.resolve(
        DIZINLER.config,
        `${ortam}.json`
    );

    console.log(`\nConfig dosyasi: ${configDosyasi}`);
    return configDosyasi;
}

configYukle(process.env.NODE_ENV || 'development');

// CLI argumani olarak verilen yolu mutlak yola cevirme
function argumaniCoz(arguman) {
    // Kullanici relative yol verdiyse cwd'ye gore coz
    // Mutlak yol verdiyse oldugu gibi kullan
    const cozulmusYol = path.resolve(arguman);
    console.log(`\nGirdi: "${arguman}"`);
    console.log(`Cozulmus: "${cozulmusYol}"`);
    return cozulmusYol;
}

argumaniCoz('./data/export.csv');
argumaniCoz('../backup/db.sql');
argumaniCoz('/var/log/app.log');

Ne Zaman Hangisini Kullanmaliyiz?​

Benim kurallim su: Eger zaten mutlak bir yoldan basliyorsaniz (mesela __dirname), path.join yeterlidir. Eger relative bir yoldan mutlak yol elde etmeniz gerekiyorsa, path.resolve kullanin. Webpack, Rollup, Babel gibi build araclari genelde path.resolve ister cunku kesin yollar bekler. Express'te route handler'larda genelde path.join yeterli olur.

Sonu olarak, path.resolve'un en buyuk avantaji tahmin edilebilirlik. Her zaman mutlak yol dondurdugu icin, sonucun ne olacagini tahmin etmek kolaydir. path.join ile bazen beklenmedik sonuclar alabilirsiniz, ozellikle argumanlarin icinde slash oldugundan. Neyse, konuyu daha fazla uzatmayalim, bir sonraki konuda basename'e bakacagiz!

 

[Best Studio]

Emeğiniz ve katkınız için teşekkür ederiz!
Konunuz gerekli incelemelerden geçerek onaylandı. Topluluğumuza katkılarınızın devamını bekliyoruz.
İyi forumlar!