Node.js සමඟ වත්මන් ස්ක්‍රිප්ටයට මාවත ලබා ගන්නේ කෙසේද?

Node.js හි තිර රචනය සඳහා මාවත ලබා ගන්නේ කෙසේද?

එහි ඇති බව මම දනිමි process.cwd, නමුත් එයින් අදහස් කරන්නේ ස්ක්‍රිප්ට් හැඳින්වූ නාමාවලිය මිස ස්ක්‍රිප්ට් එක නොවේ. උදාහරණයක් ලෙස, මම ඇතුළට ගොස් /home/kyle/පහත විධානය ක්‍රියාත්මක කරන බව පවසන්න :

node /home/kyle/some/dir/file.js

මම කතා කළොත් process.cwd(), මට ලැබෙනවා /home/kyle/, නැහැ /home/kyle/some/dir/. එම නාමාවලිය ලබා ගැනීමට ක්‍රමයක් තිබේද?

ප්‍රලේඛනය නැවත බැලීමෙන් පසුව මට එය හමු විය. මම හෙව්වා වූහ __filenameසහ __dirnameමොඩියුලය මට්ටමේ විචල්යයන්.

• __filenameයනු වත්මන් මොඩියුලයේ ගොනු නාමයයි. වත්මන් මොඩියුල ගොනුවේ නිරපේක්ෂ නිරපේක්ෂ මාර්ගය මෙයයි. (උදා: /home/kyle/some/dir/file.js)
• __dirnameයනු වත්මන් මොඩියුලයේ නාමාවලි නාමයයි. (උදා: /home/kyle/some/dir)

එබැවින් මූලික වශයෙන් ඔබට මෙය කළ හැකිය:

fs.readFile(path.resolve(__dirname, 'settings.json'), 'UTF-8', callback);

'/' හෝ '\' සමඟ සමපාත වීම වෙනුවට විසදුම () භාවිතා කරන්න, නැතිනම් ඔබ හරස් වේදිකා ගැටළු වලට මුහුණ දෙනු ඇත.

සටහන: __dirname යනු මොඩියුලයේ හෝ ඇතුළත් කළ ස්ක්‍රිප්ටයේ දේශීය මාර්ගයයි. ඔබ ප්‍රධාන පිටපතෙහි මාර්ගය දැනගත යුතු ප්ලගිනයක් ලියන්නේ නම් එය:

require.main.filename

හෝ, ෆෝල්ඩරයේ නම ලබා ගැනීමට:

require('path').dirname(require.main.filename)

මෙම විධානය මඟින් වත්මන් නාමාවලිය නැවත ලබා දෙයි:

var currentPath = process.cwd();

උදාහරණයක් ලෙස, ගොනුව කියවීමට මාර්ගය භාවිතා කිරීමට:

var fs = require('fs');
fs.readFile(process.cwd() + "\\text.txt", function(err, data)
{
    if(err)
        console.log(err)
    else
        console.log(data.toString());
});

__Dirname භාවිතා කරන්න !!

__dirname

වත්මන් මොඩියුලයේ නාමාවලි නාමය. මෙය path.dirname () ට සමාන වේ __filename.

උදාහරණය: / පරිශීලකයන් / mjr වෙතින් node.js ධාවනය කිරීම

console.log(__dirname);
// Prints: /Users/mjr
console.log(path.dirname(__filename));
// Prints: /Users/mjr

https://nodejs.org/api/modules.html#modules_dirname

ESModules සඳහා ඔබට භාවිතා කිරීමට අවශ්‍ය වන්නේ: import.meta.url

ප්‍රධාන පිටපත සම්බන්ධයෙන් ගත් කල එය එතරම්ම සරල ය:

process.argv[1]

සිට Node.js ප්රලේඛනය :

process.argv

විධාන රේඛා තර්ක අඩංගු අරාව. පළමු අංගය 'නෝඩ්' වනු ඇත, දෙවන අංගය ජාවාස්ක්‍රිප්ට් ගොනුවට යන මාර්ගය වේ . ඊළඟ අංග ඕනෑම අතිරේක විධාන රේඛා තර්ක වේ.

ඔබට මොඩියුල ගොනුවක මාර්ගය දැන ගැනීමට අවශ්‍ය නම් __filename භාවිතා කරන්න .

ආධාරක 10 Node.js සම්මතයන් මොඩියුල , කොහෙද __dirnameසහ __filenameතවදුරටත් ලබා ගත හැකිය .

වත්මන් ඊඑස් මොඩියුලය වෙත මාවත ලබා ගැනීම සඳහා යමෙකු භාවිතා කළ යුතුය:

import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);

වත්මන් මොඩියුලය අඩංගු නාමාවලිය සඳහා:

import { dirname } from 'path';
import { fileURLToPath } from 'url';

const __dirname = dirname(fileURLToPath(import.meta.url));

var settings = 
    JSON.parse(
        require('fs').readFileSync(
            require('path').resolve(
                __dirname, 
                'settings.json'),
            'utf8'));

සෑම Node.js වැඩසටහනකටම එහි පරිසරය තුළ ගෝලීය විචල්‍යයන් කිහිපයක් ඇත, එය ඔබගේ ක්‍රියාවලිය පිළිබඳ යම් තොරතුරු නිරූපණය කරන අතර ඉන් එකක් වේ __dirname.

මෙය තරමක් පැරණි බව මම දනිමි. මා පිළිතුරු දුන් මුල් ප්‍රශ්නය අනුපිටපතක් ලෙස සලකුණු කොට මෙහි යොමු කර ඇත, නමුත් මම ජැස්මින්-වාර්තාකරුවන් වැඩට ගැනීමට උත්සාහ කරන ගැටලුවකට මුහුණ දුන් අතර මා පහත හෙලීමට ඇති අදහසට අකමැති විය එය ක්‍රියාත්මක වීමට ඇණවුම් කරන්න. ජැස්මින්-වාර්තාකරුවන් විසින් සේව්පාත් නිවැරදිව නිරාකරණය නොකරන බවත්, ඇත්ත වශයෙන්ම මා ගොල්ප් ධාවනය කළ ස්ථානයේ මූල නාමාවලිය වෙනුවට වාර්තා ෆෝල්ඩරයේ ප්‍රතිදානය ජැස්මින්-වාර්තාකරුවන්ගේ නාමාවලියෙහි තබන බවත් මම දැන ගතිමි. මෙම කාර්යය නිවැරදිව සිදු කිරීම සඳහා මම ආරම්භක වත්මන් වැඩ නාමාවලිය ලබා ගැනීම සඳහා process.env.INIT_CWD භාවිතා කර අවසන් වූ අතර එය ඔබ ගුල්ප් ධාවනය කළ නාමාවලිය විය යුතුය. මෙය යමෙකුට උපකාරී වේ යැයි සිතමි.

var reporters = require('jasmine-reporters');
var junitReporter = new reporters.JUnitXmlReporter({
  savePath: process.env.INIT_CWD + '/report/e2e/',
  consolidateAll: true,
  captureStdout: true
 });

වත්මන් යෙදුම් ෆෝල්ඩරයේ මාර්ගය ලබා ගැනීමට ඔබට process.env.PWD භාවිතා කළ හැකිය.

pkgඔබගේ යෙදුම ඇසුරුම් කිරීමට ඔබ භාවිතා කරන්නේ නම් , මෙම ප්‍රකාශනය ඔබට ප්‍රයෝජනවත් වනු ඇත:

appDirectory = require('path').dirname(process.pkg ? process.execPath : (require.main ? require.main.filename : process.argv[0]));

• process.pkgයෙදුම ඇසුරුම් කර ඇත්දැයි කියයි pkg.

• process.execPath/usr/bin/nodeස්ක්‍රිප්ට් ( node test.js) හෝ ඇසුරුම් කරන ලද යෙදුමේ සෘජු ආයාචනා සඳහා හෝ සමාන වන ක්‍රියාත්මක කළ හැකි සම්පූර්ණ මාර්ගය දරයි .

• require.main.filename ප්‍රධාන ස්ක්‍රිප්ටයේ සම්පූර්ණ මාර්ගය දරයි, නමුත් නෝඩ් අන්තර්ක්‍රියාකාරී ආකාරයෙන් ක්‍රියාත්මක වන විට එය හිස් ය.

• __dirnameවත්මන් ස්ක්‍රිප්ටයේ සම්පූර්ණ මාවත දරයි , එබැවින් මම එය භාවිතා නොකරමි (එය OP ඉල්ලන දේ විය හැකි නමුත් appDirectory = process.pkg ? require('path').dirname(process.execPath) : (__dirname || require('path').dirname(process.argv[0]));අන්තර්ක්‍රියාකාරී ආකාරයෙන් __dirnameහිස් බව සඳහන් කිරීම වඩා හොඳය .

• අන්තර්ක්‍රියාකාරී ප්‍රකාරය සඳහා, එක්කෝ process.argv[0]Node ක්‍රියාත්මක කළ හැකි process.cwd()මාර්ගය ලබා ගැනීමට හෝ වත්මන් නාමාවලිය ලබා ගැනීමට භාවිතා කරන්න.

මොඩියුලයේ basenameක්‍රමය භාවිතා කරන්න path:

var path = require('path');
var filename = path.basename(__filename);
console.log(filename);

මෙහිඉහත උදාහරණයෙන් ලබාගත් ලියකියවිලි .

ඩෑන් පෙන්වා දුන් පරිදි, නෝඩ් "- පරීක්ෂණාත්මක-මොඩියුල" ධජය සමඟ ECMAScript මොඩියුල මත ක්‍රියා කරයි. Node එකක් මතම ඊට අදාල 12 තවමත් සහාය __dirnameසහ__filename ඉහත සඳහන් ලෙස.

ඔබ --experimental-modulesධජය භාවිතා කරන්නේ නම්, විකල්ප ප්‍රවේශයක් ඇත.

විකල්පය වන්නේ වත්මන් ඊඑස් මොඩියුලයට මාර්ගය ලබා ගැනීමයි :

const __filename = new URL(import.meta.url).pathname;

වත්මන් මොඩියුලය අඩංගු නාමාවලිය සඳහා:

import path from 'path';

const __dirname = path.dirname(new URL(import.meta.url).pathname);

ෂෙල් ස්ක්‍රිප්ට් එකක $ 0 වැනි දෙයක් ඔබට අවශ්‍ය නම්, මෙය උත්සාහ කරන්න:

var path = require('path');

var command = getCurrentScriptPath();

console.log(`Usage: ${command} <foo> <bar>`);

function getCurrentScriptPath () {
    // Relative path from current working directory to the location of this script
    var pathToScript = path.relative(process.cwd(), __filename);

    // Check if current working dir is the same as the script
    if (process.cwd() === __dirname) {
        // E.g. "./foobar.js"
        return '.' + path.sep + pathToScript;
    } else {
        // E.g. "foo/bar/baz.js"
        return pathToScript;
    }
}