Ultimo segmento di URL

Come ottengo l'ultimo segmento di un URL? Ho il seguente script che mostra l'URL completo del tag anchor fatto clic:

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

Se l'URL è

http://mywebsite/folder/file

come ottengo solo per visualizzare la parte "file" dell'URL nella casella di avviso?

Puoi anche utilizzare la funzione lastIndexOf () per individuare l'ultima occorrenza del /carattere nel tuo URL, quindi la funzione substring () per restituire la sottostringa a partire da quella posizione:

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

In questo modo, eviterai di creare un array contenente tutti i segmenti di URL, come split()fa.

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

Solo un'altra soluzione con regex.

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

Javascript ha la suddivisione della funzione associata all'oggetto stringa che può aiutarti:

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

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

Le altre risposte possono funzionare se il percorso è semplice, costituito solo da semplici elementi del percorso. Ma quando contiene anche parametri di query, si rompono.

Meglio usare l' oggetto URL per questo invece di ottenere una soluzione più solida. È un'interpretazione analizzata del presente URL:

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

Produzione: 'boo'

Funziona con tutti i browser più comuni. Solo il nostro IE morente non lo supporta (e non lo farà). Tuttavia, per IE è disponibile un polyfill (se ti interessa ).

Oppure potresti usare un'espressione regolare:

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

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

Lo so, è troppo tardi, ma per altri: consiglio vivamente di usare il plugin jacquery PURL . La motivazione per PURL è che l'URL può essere segmentato anche da '#' (esempio: link angular.js), ad esempio l'URL potrebbe apparire come

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

o

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

E con PURL puoi facilmente decidere (segmento / fsegment) quale segmento vuoi ottenere.

Per l'ultimo segmento "classico" puoi scrivere:

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

Basandosi sulla risposta di Frédéric usando solo javascript:

var url = document.URL

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

Anche,

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

Se non sei preoccupato di generare gli elementi extra usando la divisione, allora il filtro potrebbe gestire il problema che menzioni della barra finale (Supponendo che tu abbia il supporto del browser per il 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 il tuo URL è simile a:

http://test.com/one/

o

http://test.com/one

o

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

Quindi loc finisce per apparire come: http://test.com/one

Ora, poiché si desidera l'ultimo elemento, eseguire il passaggio successivo per caricare il valore (targetValue) che si voleva originariamente.

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

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

Utilizzare la pathnameproprietà nativa perché è la più semplice ed è già stata analizzata e risolta dal browser. $(this).attr("href")può restituire valori come quelli ../..che non ti darebbero il risultato corretto.

Se è necessario mantenere il searche hash(ad es. foo?bar#bazDa http://quux.com/path/to/foo?bar#baz) utilizzare questo:

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

Per ottenere l'ultimo segmento della finestra corrente:

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

puoi prima rimuovere se c'è / alla fine e quindi ottenere l'ultima parte dell'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);

Restituisce l'ultimo segmento, indipendentemente dalle barre finali:

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

Copiato da questa risposta

Risposta raddevus aggiornata:

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

Stampa l'ultimo percorso dell'URL come stringa:

test.com/path-name = path-name

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

Credo che sia più sicuro rimuovere la barra ('/') prima di eseguire la sottostringa. Perché ho una stringa vuota nel mio scenario.

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

Sto usando regex e split:

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

Alla fine ignorerà #? e / end URL, che succede molto. Esempio:

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

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

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

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

Non so davvero se regex è il modo giusto per risolvere questo problema in quanto può davvero influire sull'efficienza del tuo codice, ma il regex di seguito ti aiuterà a recuperare l'ultimo segmento e ti fornirà comunque l'ultimo segmento anche se l'URL è seguito da un vuoto /. La regex che mi è venuta in mente è:

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

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

Per me va bene.

So che è vecchio ma se vuoi ottenere questo da un URL potresti semplicemente usare:

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

document.location.pathnameottiene il percorso dall'URL corrente. lastIndexOfottenere l'indice dell'ultima occorrenza del seguente Regex, nel nostro caso è /.. Il punto indica qualsiasi carattere, quindi non verrà conteggiato se /l'ultimo è nell'URL. substringtaglierà la stringa tra due indici.

se l'URL è http://localhost/madukaonline/shop.php?shop=79

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

quindi il modo più semplice è usare location.search

puoi cercare maggiori informazioni qui e qui

Puoi farlo con semplici percorsi (w / 0) stringhe di stringa ecc.

Concesso probabilmente eccessivamente complesso e probabilmente non performante, ma volevo usarlo reduceper divertirmi.

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

1. Dividi la stringa sui separatori di percorso.
2. Filtra le parti vuote del percorso della stringa (ciò potrebbe accadere con una barra finale nel percorso).
3. Ridurre l'array delle parti del percorso all'ultima.