Ostatni segment adresu URL

Jak uzyskać ostatni segment adresu URL? Mam następujący skrypt, który wyświetla pełny adres URL klikniętego tagu kotwicy:

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

Jeśli adres URL to

http://mywebsite/folder/file

w jaki sposób mogę tylko wyświetlać część adresu URL pliku w polu alertu?

Możesz także użyć funkcji lastIndexOf (), aby zlokalizować ostatnie wystąpienie /znaku w adresie URL, a następnie funkcji substring (), aby zwrócić podciąg zaczynający się od tej lokalizacji:

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

W ten sposób unikniesz tworzenia tablicy zawierającej wszystkie segmenty adresów URL split().

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

Kolejne rozwiązanie z regex.

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

JavaScript ma funkcję podziału skojarzoną z obiektem łańcuchowym, która może ci pomóc:

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

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

Inne odpowiedzi mogą działać, jeśli ścieżka jest prosta i składa się tylko z prostych elementów ścieżki. Ale kiedy zawiera również parametry zapytania, łamią się.

Lepiej użyj do tego celu obiektu URL, aby uzyskać bardziej niezawodne rozwiązanie. Jest to parsowana interpretacja obecnego adresu URL:

Wejście: 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);

Wynik: 'boo'

Działa to we wszystkich popularnych przeglądarkach. Tylko nasza umierająca IE nie obsługuje tego (i nie będzie). W przypadku IE dostępne są jednak wieloskładniki (jeśli w ogóle Ci zależy ).

Lub możesz użyć wyrażenia regularnego:

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

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

Wiem, że jest już za późno, ale dla innych: zdecydowanie polecam użycie wtyczki jquery PURL . Motywacją dla PURL jest to, że adres URL można również segmentować według „#” (przykład: linki angular.js), tzn. URL może wyglądać

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

lub

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

Dzięki PURL możesz łatwo zdecydować (segment / fsegment), który segment chcesz uzyskać.

Dla „klasycznego” ostatniego segmentu możesz napisać:

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

Opierając się na odpowiedzi Frédérica używając tylko javascript:

var url = document.URL

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

Również,

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

Jeśli nie martwisz się generowaniem dodatkowych elementów za pomocą podziału, filtr może rozwiązać problem, o którym wspomniałeś o ukośniku końcowym (Zakładając, że masz obsługę filtra dla przeglądarki).

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 = jeden

Jeśli Twój adres URL wygląda następująco:

http://test.com/one/

lub

http://test.com/one

lub

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

Następnie loc wygląda tak: http://test.com/one

Teraz, ponieważ chcesz ostatni element, uruchom następny krok, aby załadować wartość (targetValue), którą pierwotnie chciałeś.

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

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

Użyj pathnamewłaściwości macierzystej, ponieważ jest ona najprostsza i została już przeanalizowana i rozwiązana przez przeglądarkę. $(this).attr("href")może zwracać wartości, ../..które nie dawałyby poprawnego wyniku.

Jeśli chcesz zachować searchi hash(np. foo?bar#bazPrzed http://quux.com/path/to/foo?bar#baz) użyj tego:

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

Aby uzyskać ostatni segment bieżącego okna:

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

możesz najpierw usunąć, jeśli jest / na końcu, a następnie pobrać ostatnią część adresu 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);

Zwraca ostatni segment, niezależnie od końcowych ukośników:

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

Skopiowano z tej odpowiedzi

Zaktualizowana odpowiedź raddevus:

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);

Wyświetla ostatnią ścieżkę adresu URL jako ciąg znaków:

test.com/path-name = path-name

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

Uważam, że bezpieczniej jest usunąć ukośnik ('/') przed wykonaniem podciągów. Ponieważ w moim scenariuszu mam pusty ciąg.

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

Używam wyrażeń regularnych i dzielenia:

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

W końcu zignoruje #? i / / końcowe adresy URL, co się często zdarza. Przykład:

https://cardsrealm.com/profile/cardsRealm -> Zwraca kartyRealm

https://cardsrealm.com/profile/cardsRealm#hello -> Zwraca kartyRealm

https://cardsrealm.com/profile/cardsRealm?hello -> Zwraca kartyRealm

https://cardsrealm.com/profile/cardsRealm/ -> Zwraca kartyRealm

Naprawdę nie wiem, czy wyrażenie regularne jest właściwym sposobem rozwiązania tego problemu, ponieważ może naprawdę wpłynąć na wydajność Twojego kodu, ale poniższe wyrażenie pomoże ci pobrać ostatni segment i nadal da ci ostatni segment, nawet jeśli adres URL następuje pusta /. Wyrażenie, które wymyśliłem to:

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

// 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);

Pracuje dla mnie.

Wiem, że jest stary, ale jeśli chcesz uzyskać go z adresu URL, możesz po prostu użyć:

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

document.location.pathnamepobiera nazwę ścieżki z bieżącego adresu URL. lastIndexOfpobierz indeks ostatniego wystąpienia następującego Regex, w naszym przypadku jest /.. Kropka oznacza dowolny znak, dlatego nie będzie się liczyć, jeśli /będzie to ostatni znak w adresie URL. substringprzetnie łańcuch między dwoma indeksami.

jeśli adres URL jest http://localhost/madukaonline/shop.php?shop=79

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

więc najprostszym sposobem jest użycie location.search

możesz znaleźć więcej informacji tutaj i tutaj

Możesz to zrobić za pomocą prostych zapytań o ścieżki (w / 0) itp.

Przyznane prawdopodobnie zbyt skomplikowane i prawdopodobnie mało wydajne, ale chciałem wykorzystać to reducedla zabawy.

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

1. Podziel ciąg na separatory ścieżek.
2. Odfiltruj puste części ścieżki ciągu (może się to zdarzyć z końcowym ukośnikiem na ścieżce).
3. Zmniejsz tablicę części ścieżki do ostatniej.