path: improve path.resolve() performance when used as process.cwd() · nodejs/node@b882148

bench.start();

for (let i = 0; i < n; i++) {

if (i % 3 === 0) {

copy[1] = `${orig}${i}`;

if (i % 5 === 0) {

copy[1] = `${orig}/${i}`;

posix.join(...copy);

} else {

posix.join(...args);

bench.start();

for (let i = 0; i < n; i++) {

if (i % 3 === 0) {

copy[1] = `${orig}${i}`;

if (i % 5 === 0) {

copy[1] = `${orig}\\${i}`;

win32.join(...copy);

} else {

win32.join(...args);

function main({ n, path }) {

bench.start();

for (let i = 0; i < n; i++) {

posix.normalize(i % 3 === 0 ? `${path}${i}` : path);

posix.normalize(i % 5 === 0 ? `${path}/${i}` : path);

}

bench.end(n);

}

function main({ n, path }) {

bench.start();

for (let i = 0; i < n; i++) {

win32.normalize(i % 3 === 0 ? `${path}${i}` : path);

win32.normalize(i % 5 === 0 ? `${path}\\${i}` : path);

}

bench.end(n);

}

const bench = common.createBenchmark(main, {

paths: [

'empty',

'',

'.',

['', ''].join('|'),

['foo/bar', '/tmp/file/', '..', 'a/../subfile'].join('|'),

['a/b/c/', '../../..'].join('|'),

['/a/b/c/', 'abc'].join('|'),

],

n: [1e5],

});

function main({ n, paths }) {

const args = paths.split('|');

const args = paths === 'empty' ? [] : paths.split('|');

const copy = [...args];

const orig = copy[0];

const orig = copy[0] ?? '';

bench.start();

for (let i = 0; i < n; i++) {

if (i % 3 === 0) {

copy[0] = `${orig}${i}`;

if (i % 5 === 0) {

copy[0] = `${orig}/${i}`;

posix.resolve(...copy);

} else {

posix.resolve(...args);

const bench = common.createBenchmark(main, {

paths: [

'empty',

'',

'.',

['', ''].join('|'),

['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'].join('|'),

['c:/blah\\blah', 'd:/games', 'c:../a'].join('|'),

});

function main({ n, paths }) {

const args = paths.split('|');

const args = paths === 'empty' ? [] : paths.split('|');

const copy = [...args];

const orig = copy[0];

const orig = copy[0] ?? '';

bench.start();

for (let i = 0; i < n; i++) {

if (i % 3 === 0) {

copy[0] = `${orig}${i}`;

if (i % 5 === 0) {

copy[0] = `${orig}\\${i}`;

win32.resolve(...copy);

} else {

win32.resolve(...args);

StringPrototypeCharCodeAt(res, res.length - 1) !== CHAR_DOT ||

StringPrototypeCharCodeAt(res, res.length - 2) !== CHAR_DOT) {

if (res.length > 2) {

const lastSlashIndex = StringPrototypeLastIndexOf(res, separator);

const lastSlashIndex = res.length - lastSegmentLength - 1;

if (lastSlashIndex === -1) {

res = '';

lastSegmentLength = 0;

return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;

}

const forwardSlashRegExp = /\//g;

const win32 = {

/**

* path.resolve([from ...], to)

}

} else if (resolvedDevice.length === 0) {

path = process.cwd();

// Fast path for current directory

if (args.length === 0 || ((args.length === 1 && (args[0] === '' || args[0] === '.')) &&

isPathSeparator(StringPrototypeCharCodeAt(path, 0)))) {

if (!isWindows) {

path = StringPrototypeReplace(path, forwardSlashRegExp, '\\');

}

return path;

}

} else {

// Windows has the concept of drive-specific current working

// directories. If we've resolved a drive letter but not yet an

* @returns {string}

*/

resolve(...args) {

if (args.length === 0 || (args.length === 1 && (args[0] === '' || args[0] === '.'))) {

const cwd = posixCwd();

if (StringPrototypeCharCodeAt(cwd, 0) === CHAR_FORWARD_SLASH) {

return cwd;

}

}

let resolvedPath = '';

let resolvedAbsolute = false;

[['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'], 'd:\\e.exe'],

[['c:/ignore', 'c:/some/file'], 'c:\\some\\file'],

[['d:/ignore', 'd:some/dir//'], 'd:\\ignore\\some\\dir'],

[[], process.cwd()],

[[''], process.cwd()],

[['.'], process.cwd()],

[['//server/share', '..', 'relative\\'], '\\\\server\\share\\relative'],

[['c:/', '//'], 'c:\\'],

[[['/var/lib', '../', 'file/'], '/var/file'],

[['/var/lib', '/../', 'file/'], '/file'],

[['a/b/c/', '../../..'], posixyCwd],

[[], posixyCwd],

[[''], posixyCwd],

[['.'], posixyCwd],

[['/some/dir', '.', '/absolute/'], '/absolute'],

[['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js'],