Gibt es eine integrierte JavaScript-Funktion, die os.path.join ähnlich ist?

Question

Gibt es eine integrierte JavaScript-Funktion, die ähnlich wie Pythons funktioniert? Ich weiß, dass ich Strings in der folgenden Art und Weise verbinden kann:

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

Das Problem ist, dass, wenn die Strings enthalten bereits eine Vorder-/Hinter „/“, dann werden sie nicht richtig angeschlossen werden, zB:

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

Edit: Sollte angegeben haben, dass ich diese Client-Seite mache.

Answer 1

Derzeit gibt es keine integrierte Funktion, die einen Join durchführt und gleichzeitig doppelte Separatoren verhindert. Wenn Sie prägnante wollen, würde ich schreiben Sie einfach Ihren eigenen:

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

Verwenden Sie das Modul path. path.join ist genau das, was Sie suchen. From the docs:

path.join([path1][, path2][, ...])# alle Argumente zusammen Join und den resultierenden Weg normalisieren.

Argumente müssen Strings sein. In Version 0.8 wurden Argumente ohne Zeichenfolgen ignoriert. In v0.10 und höher wird eine Ausnahme ausgelöst.

Beispiel:

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:

ich hier davon ausgegangen, dass Sie serverseitige Javascript wie node.js. verwenden Wenn Sie es im Browser verwenden möchten, können Sie path-browserify verwenden.

Answer 3

Mein Ansatz, um dieses Problem zu lösen:

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

Zweite Methode:

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

Answer 4

Es ist nicht, aber es ist ist ziemlich einfach zu implementieren. Dies könnte auch mit einer Regex gelöst werden, aber es ist nicht ohne eine.

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

Sie können den Code auf diesem Kern "Simple path join and dirname functions for generic javascript" nützlich (dh sowohl in Knoten und Browser) finden

// 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, ".."); 
} 

Hinweis ähnliche Implementierungen (die js Code transformiert werden können auch) existieren für php here

Answer 6

Diese on e stellt sicher, dass es mit http: // Links funktioniert, ohne den doppelten Schrägstrich zu entfernen. Es schneidet die Schrägstriche am Anfang und Ende jedes Teils.Dann sie durch ‚/‘

/** 
* 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

Aufbauend auf @ Berty Antwort getrennt beitritt, erhält diese ES6 Variante alle Schrägstriche, mit zu arbeiten protocol relative url's (wie //stackoverflow.com) und ignoriert auch alle leeren Teile:

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") kehrt "http://google.com/my/path"
• build_path("//a", "", "/", "/b/") kehrt "//a/b"
• build_path() wird ""