Esiste una funzione javascript integrata simile a os.path.join?

Question

Esiste una funzione javascript integrata che funziona in modo simile a Python os.path.join? So di poter unire le stringhe nel seguente modo:

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

Il problema è che se le stringhe contengono già un leader/finale "/", quindi non saranno uniti in modo corretto, per esempio:

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

Modifica: Avrei dovuto specificare che sto facendo questo lato client.

Answer 1

Attualmente non esiste un built-in che eseguirà un join evitando i separatori duplicati. Se si desidera conciso, avevo appena scrivere il proprio:

function pathJoin(parts, sep){ 
    var separator = sep || '/'; 
    var replace = new RegExp(separator+'{1,}', 'g'); 
    return parts.join(separator).replace(replace, separator); 
} 

var path = pathJoin(['a/', 'b', 'c//']) 

Answer 2

Utilizzare il modulo path. path.join è esattamente quello che stai cercando. From the docs:

path.join([path1][, path2][, ...])# unire tutti gli argomenti insieme e normalizzare il percorso risultante.

Gli argomenti devono essere stringhe. Nella v0.8, gli argomenti non stringa venivano ignorati silenziosamente. In v0.10 e versioni successive, viene generata un'eccezione.

Esempio:

path.join('/foo', 'bar', 'baz/asdf', 'quux', '..') 
// returns 
'/foo/bar/baz/asdf' 

path.join('foo', {}, 'bar') 
// throws exception 
TypeError: Arguments to path.join must be strings 

Edit:

ho pensato qui che si sta utilizzando server-side JavaScript come node.js. Se si desidera utilizzarlo nel browser, è possibile utilizzare path-browserify.

Answer 3

Il mio approccio per risolvere questo problema:

var path = ['a/','b'].map(function (i) { 
    return i.replace(/(^\/|\/$)/, ''); 
}).join('/'); 

Secondo metodo:

var path = ['a/','b'].join('/').replace(/\/{2,}/, '/') 

Answer 4

Non c'è, tuttavia, è abbastanza facile da implementare. Questo potrebbe anche essere risolto con una regex ma non è male se non lo si è.

var pathJoin = function(pathArr){ 
    return pathArr.map(function(path){ 
     if(path[0] === "/"){ 
      path = path.slice(1);   
     } 
     if(path[path.length - 1] === "/"){ 
      path = path.slice(0, path.length - 1); 
     } 
     return path;  
    }).join("/"); 
} 

http://jsfiddle.net/swoogie/gfy50cm1/

Answer 5

Si possono trovare il codice su questo succo "Simple path join and dirname functions for generic javascript" utile (cioè sia nel nodo e del browser)

// Joins path segments. Preserves initial "/" and resolves ".." and "." 
// Does not support using ".." to go above/outside the root. 
// This means that join("foo", "../../bar") will not resolve to "../bar" 
function join(/* path segments */) { 
    // Split the inputs into a list of path commands. 
    var parts = []; 
    for (var i = 0, l = arguments.length; i < l; i++) { 
    parts = parts.concat(arguments[i].split("/")); 
    } 
    // Interpret the path commands to get the new resolved path. 
    var newParts = []; 
    for (i = 0, l = parts.length; i < l; i++) { 
    var part = parts[i]; 
    // Remove leading and trailing slashes 
    // Also remove "." segments 
    if (!part || part === ".") continue; 
    // Interpret ".." to pop the last segment 
    if (part === "..") newParts.pop(); 
    // Push new path segments. 
    else newParts.push(part); 
    } 
    // Preserve the initial slash if there was one. 
    if (parts[0] === "") newParts.unshift(""); 
    // Turn back into a single string path. 
    return newParts.join("/") || (newParts.length ? "/" : "."); 
} 

// A simple function to get the dirname of a path 
// Trailing slashes are ignored. Leading slash is preserved. 
function dirname(path) { 
    return join(path, ".."); 
} 

Nota implementazioni simili (che può essere trasformato in codice js pure) esiste per php here

Answer 6

Questo su e si assicura che funzioni con i collegamenti http: // senza rimuovere la doppia barra. Taglia le barre all'inizio e alla fine di ogni parte.Poi li unisce separati da '/'

/** 
* Joins 2 paths together and makes sure there aren't any duplicate seperators 
* @param parts the parts of the url to join. eg: ['http://google.com/', '/my-custom/path/'] 
* @param separator The separator for the path, defaults to '/' 
* @returns {string} The combined path 
*/ 
function joinPaths(parts, separator) { 
    return parts.map(function(part) { return part.trim().replace(/(^[\/]*|[\/]*$)/g, ''); }).join(separator || '/'); 
} 

Answer 7

Sulla @ risposta di Berty, questa variante ES6 conserva tutte le slash, per lavorare con protocol relative url's (come //stackoverflow.com), ignora e anche eventuali parti vuote:

build_path = (...args) => { 
    return args.map((part, i) => { 
    if (i === 0){ 
     return part.trim().replace(/[\/]*$/g, '') 
    } else { 
     return part.trim().replace(/(^[\/]*|[\/]*$)/g, '') 
    } 
    }).filter(x=>x.length).join('/') 
} 

• build_path("http://google.com/", "my", "path") tornerà "http://google.com/my/path"
• build_path("//a", "", "/", "/b/") tornerà "//a/b"
• build_path() tornerà ""