Dernier segment d'URL

Comment obtenir le dernier segment d'une URL? J'ai le script suivant qui affiche l'url complète de la balise d'ancrage cliquée:

$(".tag_name_goes_here").live('click', function(event)
{
    event.preventDefault();  
    alert($(this).attr("href"));
});

Si l'url est

http://mywebsite/folder/file

comment puis-je obtenir uniquement pour afficher la partie "fichier" de l'URL dans la boîte d'alerte?

Vous pouvez également utiliser la fonction lastIndexOf () pour localiser la dernière occurrence du /caractère dans votre URL, puis la fonction substring () pour renvoyer la sous-chaîne à partir de cet emplacement:

console.log(this.href.substring(this.href.lastIndexOf('/') + 1));

De cette façon, vous éviterez de créer un tableau contenant tous vos segments d'URL, comme le split()fait.

window.location.pathname.split("/").pop()

Juste une autre solution avec regex.

var href = location.href;
console.log(href.match(/([^\/]*)\/*$/)[1]);

Javascript a la fonction split associée à l'objet chaîne qui peut vous aider:

var url = "http://mywebsite/folder/file";
var array = url.split('/');

var lastsegment = array[array.length-1];

Les autres réponses peuvent fonctionner si le chemin est simple, composé uniquement d'éléments de chemin simples. Mais quand il contient également des paramètres de requête, ils cassent.

Il vaut mieux utiliser un objet URL pour cela à la place pour obtenir une solution plus robuste. Il s'agit d'une interprétation analysée de l'URL actuelle:

Contribution: const href = 'https://stackoverflow.com/boo?q=foo&s=bar'

const segments = new URL(href).pathname.split('/');
const last = segments.pop() || segments.pop(); // Handle potential trailing slash
console.log(last);

Production: 'boo'

Cela fonctionne pour tous les navigateurs courants. Seul notre IE mourant ne prend pas en charge cela (et ne le fera pas). Pour IE, il existe cependant des polyfills (si vous vous en souciez ).

Ou vous pouvez utiliser une expression régulière:

alert(href.replace(/.*\//, ''));

var urlChunks = 'mywebsite/folder/file'.split('/');
alert(urlChunks[urlChunks.length - 1]);

Je sais, il est trop tard, mais pour d'autres: je recommande fortement d' utiliser le plugin PURL jquery . La motivation pour PURL est que l'url peut également être segmentée par '#' (exemple: liens angular.js), c'est-à-dire que l'url pourrait ressembler à

    http://test.com/#/about/us/

ou

    http://test.com/#sky=blue&grass=green

Et avec PURL, vous pouvez facilement décider (segment / fsegment) quel segment vous souhaitez obtenir.

Pour le dernier segment "classique", vous pouvez écrire:

    var url = $.url('http://test.com/dir/index.html?key=value');
    var lastSegment = url.segment().pop(); // index.html

S'appuyant sur la réponse de Frédéric en utilisant uniquement le javascript:

var url = document.URL

window.alert(url.substr(url.lastIndexOf('/') + 1));

Aussi,

var url = $(this).attr("href");
var part = url.substring(url.lastIndexOf('/') + 1);

Si vous n'êtes pas inquiet de générer les éléments supplémentaires à l'aide du fractionnement, le filtre peut gérer le problème que vous mentionnez de la barre oblique de fin (en supposant que le navigateur soit compatible avec le filtre).

url.split('/').filter(function (s) { return !!s }).pop()

// Store original location in loc like: http://test.com/one/ (ending slash)
var loc = location.href; 
// If the last char is a slash trim it, otherwise return the original loc
loc = loc.lastIndexOf('/') == (loc.length -1) ? loc.substr(0,loc.length-1) : loc.substr(0,loc.lastIndexOf('/'));
var targetValue = loc.substr(loc.lastIndexOf('/') + 1);

targetValue = un

Si votre URL ressemble à:

http://test.com/one/

ou

http://test.com/one

ou

http://test.com/one/index.htm

Ensuite, loc finit par ressembler à: http://test.com/one

Maintenant, puisque vous voulez le dernier élément, exécutez l'étape suivante pour charger la valeur (targetValue) que vous vouliez à l'origine.

var targetValue = loc.substr(loc.lastIndexOf('/') + 1);

window.alert(this.pathname.substr(this.pathname.lastIndexOf('/') + 1));

Utilisez la pathnamepropriété native car elle est la plus simple et a déjà été analysée et résolue par le navigateur. $(this).attr("href")peut renvoyer des valeurs comme celles ../..qui ne vous donneraient pas le résultat correct.

Si vous devez conserver le searchet hash(par exemple foo?bar#bazde http://quux.com/path/to/foo?bar#baz) utiliser ceci:

window.alert(this.pathname.substr(this.pathname.lastIndexOf('/') + 1) + this.search + this.hash);

Pour obtenir le dernier segment de votre fenêtre actuelle:

window.location.href.substr(window.location.href.lastIndexOf('/') +1)

vous pouvez d'abord supprimer s'il y a / à la fin, puis récupérer la dernière partie de l'URL

let locationLastPart = window.location.pathname
if (locationLastPart.substring(locationLastPart.length-1) == "/") {
  locationLastPart = locationLastPart.substring(0, locationLastPart.length-1);
}
locationLastPart = locationLastPart.substr(locationLastPart.lastIndexOf('/') + 1);

Renvoie le dernier segment, indépendamment des barres obliques de fin:

var val = 'http://mywebsite/folder/file//'.split('/').filter(Boolean).pop();

console.log(val);

var pathname = window.location.pathname; // Returns path only
var url      = window.location.href;     // Returns full URL

Copié de cette réponse

Réponse raddevus mise à jour:

var loc = window.location.href;
loc = loc.lastIndexOf('/') == loc.length - 1 ? loc.substr(0, loc.length - 1) : loc.substr(0, loc.length + 1);
var targetValue = loc.substr(loc.lastIndexOf('/') + 1);

Imprime le dernier chemin de l'url sous forme de chaîne:

test.com/path-name = path-name

test.com/path-name/ = path-name

Je pense qu'il est plus sûr de supprimer la barre oblique ('/') avant de faire la sous-chaîne. Parce que j'ai une chaîne vide dans mon scénario.

window.alert((window.location.pathname).replace(/\/$/, "").substr((window.location.pathname.replace(/\/$/, "")).lastIndexOf('/') + 1));

J'utilise regex et split:

var last_path = location.href.match (/. / (. [\ w]) /) [1] .split ("#") [0] .split ("?") [0]

Au final, il ignorera #? & / fin des URL, ce qui arrive souvent. Exemple:

https://cardsrealm.com/profile/cardsRealm -> Retours de cartesRealm

https://cardsrealm.com/profile/cardsRealm#hello -> Retours de cartesRealm

https://cardsrealm.com/profile/cardsRealm?hello -> Retours de cartesRealm

https://cardsrealm.com/profile/cardsRealm/ -> Retours de cartesRealm

Je ne sais pas vraiment si la regex est la bonne façon de résoudre ce problème car elle peut vraiment affecter l'efficacité de votre code, mais la regex ci-dessous vous aidera à récupérer le dernier segment et vous donnera toujours le dernier segment même si l'URL est suivi d'un vide /. Le regex que j'ai trouvé est:

[^\/]+[\/]?$

// https://x.com/boo/?q=foo&s=bar = boo
// https://x.com/boo?q=foo&s=bar = boo
// https://x.com/boo/ = boo
// https://x.com/boo = boo

const segment = new 
URL(window.location.href).pathname.split('/').filter(Boolean).pop();
console.log(segment);

Travaille pour moi.

Je sais que c'est vieux mais si vous voulez l'obtenir à partir d'une URL, vous pouvez simplement utiliser:

document.location.pathname.substring(document.location.pathname.lastIndexOf('/.') + 1);

document.location.pathnameobtient le chemin d'accès à partir de l'URL actuelle. lastIndexOfobtenir l'indice de la dernière occurrence de la regex suivante, dans notre cas est /.. Le point signifie n'importe quel caractère, donc, il ne comptera pas si /c'est le dernier caractère de l'URL. substringva couper la chaîne entre deux index.

si l'url est http://localhost/madukaonline/shop.php?shop=79

console.log(location.search); apportera ?shop=79

donc la manière la plus simple est d'utiliser location.search

vous pouvez rechercher plus d'informations ici et ici

Vous pouvez le faire avec des chaînes de requête de chemins simples (w / 0), etc.

Accordé probablement trop complexe et probablement pas performant, mais je voulais l'utiliser reducepour le plaisir.

  "/foo/bar/"
    .split(path.sep)
    .filter(x => x !== "")
    .reduce((_, part, i, arr) => {
      if (i == arr.length - 1) return part;
    }, "");

1. Fractionnez la chaîne sur les séparateurs de chemin.
2. Filtrez les parties de chemin de chaîne vides (cela peut arriver avec une barre oblique de fin dans le chemin).
3. Réduisez le tableau des parties de chemin au dernier.