Último segmento de URL

Como obtenho o último segmento de um URL? Eu tenho o seguinte script que exibe o URL completo da marca âncora clicada:

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

Se o URL for

http://mywebsite/folder/file

como faço para exibir apenas a parte "arquivo" do URL na caixa de alerta?

Você também pode usar a função lastIndexOf () para localizar a última ocorrência do /caractere em sua URL e, em seguida, a função substring () para retornar a substring a partir desse local:

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

Dessa forma, você evitará a criação de uma matriz que contenha todos os seus segmentos de URL split().

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

Apenas outra solução com regex.

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

Javascript tem a divisão de função associada ao objeto string que pode ajudá-lo:

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

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

As outras respostas podem funcionar se o caminho for simples, consistindo apenas em elementos simples do caminho. Mas quando também contém parâmetros de consulta, eles quebram.

Melhor usar o objeto URL para isso em vez de obter uma solução mais robusta. É uma interpretação analisada do URL atual:

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

Resultado: 'boo'

Isso funciona para todos os navegadores comuns. Somente nosso IE moribundo não suporta isso (e não apoia). No entanto, para o IE, há um polyfills disponível (se você se importa ).

Ou você pode usar uma expressão regular:

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

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

Eu sei, é tarde demais, mas para os outros: I altamente recomendado o uso PURL plugin jQuery . A motivação para PURL é que o URL também pode ser segmentado por '#' (exemplo: links angular.js), ou seja, o URL pode parecer

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

ou

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

E com o PURL, você pode decidir facilmente (segmento / segmento) qual segmento você deseja obter.

Para o último segmento "clássico", você pode escrever:

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

Com base na resposta de Frédéric usando apenas javascript:

var url = document.URL

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

Além disso,

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

Se você não estiver preocupado em gerar os elementos extras usando a divisão, o filtro poderá resolver o problema mencionado na barra final (supondo que você tenha suporte do navegador para filtro).

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

Se o seu URL se parecer com:

http://test.com/one/

ou

http://test.com/one

ou

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

Em seguida, loc acaba parecendo: http://test.com/one

Agora, como você deseja o último item, execute a próxima etapa para carregar o valor (targetValue) desejado originalmente.

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

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

Use a pathnamepropriedade nativa porque é mais simples e já foi analisada e resolvida pelo navegador. $(this).attr("href")pode retornar valores como o ../..que não daria o resultado correto.

Se você precisar manter o searche hash(por exemplo, foo?bar#bazde http://quux.com/path/to/foo?bar#baz), use isto:

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

Para obter o último segmento da sua janela atual:

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

você pode remover primeiro se houver / no final e obter a última parte do 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);

Retorna o último segmento, independentemente das barras finais:

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

Copiado desta resposta

Resposta do raddevus atualizada:

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 o último caminho do URL como string:

test.com/path-name = path-name

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

Eu acredito que é mais seguro remover a barra ('/') antes de fazer a substring. Porque eu tenho uma string vazia no meu cenário.

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

Estou usando regex e split:

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

No final, ele ignorará #? & / urls finais, o que acontece muito. Exemplo:

https://cardsrealm.com/profile/cardsRealm -> Retorna cardsRealm

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

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

https://cardsrealm.com/profile/cardsRealm/ -> Retorna cardsRealm

Realmente não sei se a regex é a maneira correta de resolver esse problema, pois pode realmente afetar a eficiência do seu código, mas a regex abaixo ajudará você a buscar o último segmento e ainda fornecerá o último segmento, mesmo que o URL é seguido por um vazio /. O regex que eu criei é:

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

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

Funciona para mim.

Eu sei que é antigo, mas se você deseja obter isso de um URL, pode simplesmente usar:

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

document.location.pathnameobtém o nome do caminho da URL atual. lastIndexOfobtenha o índice da última ocorrência do seguinte Regex, no nosso caso é /.. O ponto significa qualquer caractere, portanto, ele não contará se /o último caractere no URL. substringirá cortar a string entre dois índices.

se o URL for http://localhost/madukaonline/shop.php?shop=79

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

portanto, a maneira mais simples é usar location.search

você pode procurar mais informações aqui e aqui

Você pode fazer isso com caminhos simples (w / 0), querystrings etc.

Concedido provavelmente excessivamente complexo e provavelmente não com desempenho, mas eu queria usar reducepara me divertir.

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

1. Divida a sequência nos separadores de caminho.
2. Filtre as partes vazias do caminho da string (isso pode acontecer com a barra no caminho).
3. Reduza a matriz de partes do caminho para a última.