Come posso ottenere l'ID video di YouTube da un URL?

257

Voglio ottenere l' v=idURL di YouTube con JavaScript (no jQuery, puro JavaScript).

Esempi di formati URL di YouTube

http://www.youtube.com/watch?v=u8nQa1cJyX8&a=GxdCwVVULXctT2lYDEPllDR0LRTutYfW

http://www.youtube.com/watch?v=u8nQa1cJyX8

O qualsiasi altro formato YouTube che contiene un ID video nell'URL.

Risultato da questi formati

u8nQa1cJyX8

javascript  regex  url  youtube 
— Adamo
fonte
1
— Mark Byers
Questa domanda è solo per formati come il mio secondo. Ma ho trovato una risposta interessante lì, grazie per averla condivisa.
— Adam,
Esistono espressioni regolari per questo: http://pregcopy.com/exp/27
— Exos,
Non posso prendermi il merito, ma ho trovato che questo è piuttosto esteso: gist.github.com/FinalAngel/1876898 . Cattura persino URL così diversi come youtube.com/watch?feature=player_embedded&v=1p3vcRhsYGo e youtube.com/v/1p3vcRhsYGo
— Simon
2
A partire dal 2015: passa a questa risposta . Le altre risposte non sono aggiornate.
— Lenar Hoyt,

Risposte:

109

Non è necessario utilizzare un'espressione regolare per questo.

var video_id = window.location.search.split('v=')[1];
var ampersandPosition = video_id.indexOf('&');
if(ampersandPosition != -1) {
  video_id = video_id.substring(0, ampersandPosition);
}
— Jacob Relkin
fonte
questa è una funzione utile per farlo funzionare dove vuoi in base a questo codice. var video_url = ' youtube.com/watch?v=eOrNdBpGMv8&feature=youtube_gdata '; ytid (video_url); funzione ytid (video_url) {var video_id = video_url.split ('v =') [1]; var ampersandPosition = video_id.indexOf ('&'); if (ampersandPosition! = -1) {video_id = video_id.substring (0, ampersandPosition); } avviso (video_id); return video_id; }
— Gino
9
non gestisce gli URL incorporati
— Serge
14
inoltre non gestisce gli URL generati "condividi"https://youtu.be/{{video_id}}
— hamncheez l'
2
Questo regex funziona bene con la condivisione di YouTube e guarda l'URL. url='https://youtu.be/{{video_id}}'; url.match(/(?:https?:\/{2})?(?:w{3}\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\?v=|\/)([^\s&]+)/);
— Dipten
410

Ho apportato un miglioramento a Regex fornito da "jeffreypriebe" perché aveva bisogno che una specie di URL di YouTube sia l'URL dei video quando guardano attraverso un canale.

Beh no, ma questa è la funzione che ho armato.

<script type="text/javascript">
function youtube_parser(url){
    var regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
    var match = url.match(regExp);
    return (match&&match[7].length==11)? match[7] : false;
}
</script>

Questi sono i tipi di URL supportati

http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o
http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
http://www.youtube.com/embed/0zM3nApSvMg?rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg
http://youtu.be/0zM3nApSvMg

Può essere trovato in [http://web.archive.org/web/20160926134334/] http://lasnv.net/foro/839/Javascript_parsear_URL_de_YouTube

— Lasnv
fonte
6
Il regex contiene un piccolo bug \ ?? v? =? questo dovrebbe essere solo nella parte dell'orologio, altrimenti filtreresti una 'v' se l'id inizia con una 'v'. quindi questo dovrebbe fare il trucco /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\??v? =?)) ([^ # \ & \?] *). * /
— webstrap
69
Ancora più pulito: /.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]*).*/ usa match[1]invece di match[7](che mi è sembrato un po 'arbitrario). Corregge anche i bug segnalati da WebDev.
— Chris Nolet,
3
Quanto tempo prima che gli ID YouTube siano lunghi 12 caratteri?
— Lenar Hoyt,
1
Lo sapevi che non è proprio perfetto, se metti qualcosa.com/watch?v=jn40gqhxoSY Pensa che sia un URL di YouTube
— Gino,
1
Chiunque può estendere questo reqex e quindi le persone che si lamentano non hanno alcun senso.
— Lecha Bisultanov,
241

Ho semplificato un po 'la risposta di Lasnv.

Corregge anche il bug descritto da WebDeb.

Ecco qui:

var regExp = /^.*(youtu\.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]*).*/;
var match = url.match(regExp);
if (match && match[2].length == 11) {
  return match[2];
} else {
  //error
}

Ecco un link regexer con cui giocare: http://regexr.com/3dnqv

— mantish
fonte
2
solo un avvertimento: questo dovrebbe essere usato solo quando sai che hai a che fare con un URL di YouTube. I (ingiustamente) usato per verificare URL come youtube, che ha causato falsi positivi, ad esempio questa passaggi: 'v / 2059-9080-5437'
— fabi
3
Sto usando un Regex diverso che controlla anche un dominio di YouTube. Non sono sicuro di dover aggiornare la risposta in quanto si tratta di un grande cambiamento: /^.*(youtu.be\/|youtube(-nocookie)?.com\/(v\/|.*u\/\w \ / | embed \ / |. * v =)) ([\ w -] {11}). * /
— mantish
4
Quando YouTube passerà a 12 caratteri per l'ID video?
— Lenar Hoyt,
il punto in "youtu.be" non dovrebbe essere sfuggito?
— Alex,
hai ragione @jitbit Grazie. Anche se di solito funziona anche senza fuggire.
— mantish
85

Nessuno di questi ha funzionato sul lavello della cucina dall'1 / 1/2015, in particolare URL senza http / se protocal e con dominio youtube-nocookie. Quindi, ecco una versione modificata che funziona su tutte queste varie versioni di Youtube:

// Just the regex. Output is in [1].
/^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*/

// For testing.
var urls = [
    '//www.youtube-nocookie.com/embed/up_lNV-yoK4?rel=0',
    'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo',
    'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
    'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
    'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
    'http://www.youtube.com/user/SilkRoadTheatre#p/a/u/2/6dwqZw0j_jY',
    'http://youtu.be/6dwqZw0j_jY',
    'http://www.youtube.com/watch?v=6dwqZw0j_jY&feature=youtu.be',
    'http://youtu.be/afa-5HQHiAs',
    'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo?rel=0',
    'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
    'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
    'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
    'http://www.youtube.com/embed/nas1rJpm7wY?rel=0',
    'http://www.youtube.com/watch?v=peFZbP64dsU',
    'http://youtube.com/v/dQw4w9WgXcQ?feature=youtube_gdata_player',
    'http://youtube.com/vi/dQw4w9WgXcQ?feature=youtube_gdata_player',
    'http://youtube.com/?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
    'http://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
    'http://youtube.com/?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
    'http://youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
    'http://youtube.com/watch?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
    'http://youtu.be/dQw4w9WgXcQ?feature=youtube_gdata_player'
];

var i, r, rx = /^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*/;

for (i = 0; i < urls.length; ++i) {
    r = urls[i].match(rx);
    console.log(r[1]);
}
— JW
fonte
2
Vale la pena notare che molte delle soluzioni di cui sopra non coprono questa vasta serie di URL validi, lo script di test è molto utile, +1!
— blessed
2
Si noti che questo sarà ingannato da qualcosa come "www.engadget.com/watch?v=dQw4w9WgXcQ", non che probabilmente sia un problema
— binaryfunt
Funziona, ma non è stato possibile risolvere il problema derivante da un testo con più URL di YouTube Vedi questo regex101.com/r/qK5qJ5/1 . Non dovrebbe sostituire il secondo URL.
— Ashish,
2
Se non desideri che un ID vuoto corrisponda : ^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]+).*(ad esempio, youtube.com/watch?v= non corrisponderà)
— zurfyx,
Cosa intendi con "Nessuno di questi ha funzionato sul lavello della cucina"?
— rmutalik,
26 
/^.*(youtu.be\/|v\/|e\/|u\/\w+\/|embed\/|v=)([^#\&\?]*).*/

Testato su:

  • http://www.youtube.com/v/0zM3nApSvMg?fs=1&hl=en_US&rel=0
  • http://www.youtube.com/embed/0zM3nApSvMg?rel=0
  • http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
  • http://www.youtube.com/watch?v=0zM3nApSvMg
  • http://youtu.be/0zM3nApSvMg
  • http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
  • http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/KdwsulMb8EQ
  • http://youtu.be/dQw4w9WgXcQ
  • http://www.youtube.com/embed/dQw4w9WgXcQ
  • http://www.youtube.com/v/dQw4w9WgXcQ
  • http://www.youtube.com/e/dQw4w9WgXcQ
  • http://www.youtube.com/watch?v=dQw4w9WgXcQ
  • http://www.youtube.com/?v=dQw4w9WgXcQ
  • http://www.youtube.com/watch?feature=player_embedded&v=dQw4w9WgXcQ
  • http://www.youtube.com/?feature=player_embedded&v=dQw4w9WgXcQ
  • http://www.youtube.com/user/IngridMichaelsonVEVO#p/u/11/KdwsulMb8EQ
  • http://www.youtube-nocookie.com/v/6L3ZvIMwZFM?version=3&hl=en_US&rel=0

Ispirato da questa altra risposta .

— xronosiam
fonte
9
^. * (?: youtu.be \ / | v \ / | e \ / | u \ / \ w + \ / | embed \ / | v =) ([^ # \ & \?] *). * darà tu il risultato nel gruppo 1
— Marc
20

Dato che YouTube ha una varietà di stili di URL, penso che Regex sia una soluzione migliore. Ecco il mio Regex:

^.*(youtu.be\/|v\/|embed\/|watch\?|youtube.com\/user\/[^#]*#([^\/]*?\/)*)\??v?=?([^#\&\?]*).*

Il gruppo 3 ha il tuo ID YouTube

URL di esempio di YouTube (attualmente, incluso "stile URL di incorporamento legacy") - il precedente Regex funziona su tutti: 

http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0
http://www.youtube.com/embed/0zM3nApSvMg?rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
http://www.youtube.com/watch?v=0zM3nApSvMg
http://youtu.be/0zM3nApSvMg
http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o

Punta del cappello a Lasnv

— jeffreypriebe
fonte
9
Hai davvero bisogno di tornare al tavolo da disegno con questo. Sì, corrisponde correttamente agli URL sopra. Ma anche corrisponde erroneamente molte altre corde non youtube-url come ad esempio: "domain.com/embed/file.txt", "/tv/"e "Has anyone seen my watch?". Vedi: la mia risposta a una domanda simile per una soluzione molto più precisa.
— ridgerunner,
1
Vedo il tuo punto: la regex sopra è inutile per rispondere alla domanda "È un URL di YouTube?" ma quello non era il mio obiettivo. Ho gli URL di YouTube: sto semplicemente estraendo un ID. Sì, la tua risposta è solida (e copre un caso d'uso che la mia non ha).
— jeffreypriebe,
hai lo stesso bug che ho menzionato sopra con id che iniziano con una 'v'
— webstrap il
Grazie @WebDev: sai se YouTube inserisce mai av nell'ID (o avvia un ID con una "v")?
— jeffreypriebe,
1
Funziona ancora oggi (25-01-2013). Ecco un esempio in azione: jsfiddle.net/bcmoney/yBP4J
— bcmoney
17

Ho creato una funzione che verifica l'input di un utente per gli ID di incorporamento Youtube, Soundcloud o Vimeo, per essere in grado di creare un design più continuo con i media incorporati. Questa funzione rileva e restituisce un oggetto con due proprietà: "tipo" e "id". Il tipo può essere "youtube", "vimeo" o "soundcloud" e la proprietà "id" è l'id multimediale univoco.

Sul sito utilizzo un dump textarea, in cui l'utente può incollare qualsiasi tipo di collegamento o codice di incorporamento, incluso l'incorporamento iFrame sia di vimeo che di youtube.

function testUrlForMedia(pastedData) {
var success = false;
var media   = {};
if (pastedData.match('http://(www.)?youtube|youtu\.be')) {
    if (pastedData.match('embed')) { youtube_id = pastedData.split(/embed\//)[1].split('"')[0]; }
    else { youtube_id = pastedData.split(/v\/|v=|youtu\.be\//)[1].split(/[?&]/)[0]; }
    media.type  = "youtube";
    media.id    = youtube_id;
    success = true;
}
else if (pastedData.match('http://(player.)?vimeo\.com')) {
    vimeo_id = pastedData.split(/video\/|http:\/\/vimeo\.com\//)[1].split(/[?&]/)[0];
    media.type  = "vimeo";
    media.id    = vimeo_id;
    success = true;
}
else if (pastedData.match('http://player\.soundcloud\.com')) {
    soundcloud_url = unescape(pastedData.split(/value="/)[1].split(/["]/)[0]);
    soundcloud_id = soundcloud_url.split(/tracks\//)[1].split(/[&"]/)[0];
    media.type  = "soundcloud";
    media.id    = soundcloud_id;
    success = true;
}
if (success) { return media; }
else { alert("No valid media id detected"); }
return false;
}
— Joakim
fonte
Bella idea, ma non funziona sulla stragrande maggioranza dei formati URL. Compreso il non abbinamento su alcun sito https.
— NickG
13

In ritardo al gioco qui, ma ho raccolto due eccellenti risposte da Mantish e Jw. Innanzitutto, la regex modificata:

const youtube_regex = /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/

Ecco il codice di test (ho aggiunto i casi di test originali di Mantish a quelli più cattivi di jw):

 var urls = [
      'http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index',
      'http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o',
      'http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0',
      'http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s',
      'http://www.youtube.com/embed/0zM3nApSvMg?rel=0',
      'http://www.youtube.com/watch?v=0zM3nApSvMg',
      'http://youtu.be/0zM3nApSvMg',
      '//www.youtube-nocookie.com/embed/up_lNV-yoK4?rel=0',
      'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo',
      'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
      'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
      'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
      'http://www.youtube.com/user/SilkRoadTheatre#p/a/u/2/6dwqZw0j_jY',
      'http://youtu.be/6dwqZw0j_jY',
      'http://www.youtube.com/watch?v=6dwqZw0j_jY&feature=youtu.be',
      'http://youtu.be/afa-5HQHiAs',
      'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo?rel=0',
      'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
      'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
      'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
      'http://www.youtube.com/embed/nas1rJpm7wY?rel=0',
      'http://www.youtube.com/watch?v=peFZbP64dsU',
      'http://youtube.com/v/dQw4w9WgXcQ?feature=youtube_gdata_player',
      'http://youtube.com/vi/dQw4w9WgXcQ?feature=youtube_gdata_player',
      'http://youtube.com/?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtube.com/?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtube.com/watch?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtu.be/dQw4w9WgXcQ?feature=youtube_gdata_player'
  ];

  var failures = 0;
  urls.forEach(url => {
    const parsed = url.match(youtube_regex);
    if (parsed && parsed[2]) {
      console.log(parsed[2]);
    } else {
      failures++;
      console.error(url, parsed);
    }
  });
  if (failures) {
    console.error(failures, 'failed');
  }

Versione sperimentale per gestire gli URL di m.youtube citati nei commenti:

const youtube_regex = /^.*((m\.)?youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/

Deve parsed[2]essere modificato parsed[3]in due punti nei test (che poi passa con gli m.youtubeURL aggiunti ai test). Fammi sapere se vedi problemi.

— podperson
fonte
1
Dovresti aggiungere questo nella tua tuta di prova poiché era problematico e il tuo regexp lo ha risolto per me: youtu.be/ve4f400859I . La lettera v è stata cancellata nel mio regexp precedente
— Mark Odey, il
1
Ottengo falsi postivi http://youtu.be/se aggiungo che /lo contrassegna come valido. Usandolo in(value) => /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/.test(value)
— Anima-t3d
Grazie per i commenti Non ho ancora aggiornato il mio esempio (non ho tempo per testare) quindi chiunque usi il mio codice per favore prendi nota :-)
— podperson
che dire dell'URL di tipo = m.youtube.com
— Mehul Thakkar,
@MehulThakkar sono altrimenti simili agli URL di YouTube?
— podperson
11

tl; dr.

Abbina tutti gli esempi di URL su questa domanda e poi alcuni.

let re = /^(https?:\/\/)?((www\.)?(youtube(-nocookie)?|youtube.googleapis)\.com.*(v\/|v=|vi=|vi\/|e\/|embed\/|user\/.*\/u\/\d+\/)|youtu\.be\/)([_0-9a-z-]+)/i;
let id = "https://www.youtube.com/watch?v=l-gQLqv9f4o".match(re)[7];

L'ID sarà sempre nel gruppo di partite 7.

Esempi live di tutti gli URL che ho preso dalle risposte a questa domanda: https://regexr.com/3u0d4

Spiegazione completa:

Come molte risposte / commenti hanno sollevato, ci sono molti formati per gli URL dei video di YouTube. Anche più TLD in cui possono apparire come "ospitati".

Puoi vedere l'elenco completo delle varianti che ho verificato seguendo il link regexr sopra.

Consente di suddividere RegExp.

^ Blocca la stringa all'inizio della stringa. (https?:\/\/)?Protocolli opzionali http: // o https: // ?Rende facoltativo l'elemento precedente, squindi l'intero gruppo (tutto racchiuso tra parentesi) è facoltativo.

Ok, questa parte successiva ne è la carne. Fondamentalmente abbiamo due opzioni, le varie versioni di www.youtube.com/...[id] e il collegamento abbreviato youtu.be/[id] versione.

(                                                  // Start a group which will match everything after the protocol and up to just before the video id.
  (www\.)?                                         // Optional www.
  (youtube(-nocookie)?|youtube.googleapis)         // There are three domains where youtube videos can be accessed. This matches them.
  \.com                                            // The .com at the end of the domain. 
  .*                                               // Match anything 
  (v\/|v=|vi=|vi\/|e\/|embed\/|user\/.*\/u\/\d+\/) // These are all the things that can come right before the video id. The | character means OR so the first one in the "list" matches.
  |                                                // There is one more domain where you can get to youtube, it's the link shortening url which is just followed by the video id. This OR separates all the stuff in this group and the link shortening url.
  youtu\.be\/                                      // The link shortening domain
)                                                  // End of group

Finalmente abbiamo il gruppo per selezionare l'ID video. Almeno un carattere che è un numero, una lettera, un trattino basso o un trattino.

([_0-9a-z-]+)

Puoi scoprire molti più dettagli su ciascuna parte del regex andando sul link regexr e vedendo come ogni parte dell'espressione corrisponde al testo nell'URL.

— tsdorsey
fonte
10

La migliore soluzione (dal 2019-2020) che ho trovato è che:

function YouTubeGetID(url){
   url = url.split(/(vi\/|v=|\/v\/|youtu\.be\/|\/embed\/)/);
   return (url[2] !== undefined) ? url[2].split(/[^0-9a-z_\-]/i)[0] : url[0];
}

L'ho trovato qui .

/*
* Tested URLs:
var url = 'http://youtube.googleapis.com/v/4e_kz79tjb8?version=3';
url = 'https://www.youtube.com/watch?feature=g-vrec&v=Y1xs_xPb46M';
url = 'http://www.youtube.com/watch?feature=player_embedded&v=Ab25nviakcw#';
url = 'http://youtu.be/Ab25nviakcw';
url = 'http://www.youtube.com/watch?v=Ab25nviakcw';
url = '<iframe width="420" height="315" src="http://www.youtube.com/embed/Ab25nviakcw" frameborder="0" allowfullscreen></iframe>';
url = '<object width="420" height="315"><param name="movie" value="http://www.youtube-nocookie.com/v/Ab25nviakcw?version=3&amp;hl=en_US"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube-nocookie.com/v/Ab25nviakcw?version=3&amp;hl=en_US" type="application/x-shockwave-flash" width="420" height="315" allowscriptaccess="always" allowfullscreen="true"></embed></object>';
url = 'http://i1.ytimg.com/vi/Ab25nviakcw/default.jpg';
url = 'https://www.youtube.com/watch?v=BGL22PTIOAM&feature=g-all-xit';
url = 'BGL22PTIOAM';
*/
— Vlad
fonte
TypeScript: const youTubeGetID = (url: string) => {const [a,, b] = url .replace (/ (> | <) / gi, '') .split (/ (vi \ / | v = | \ /v\/|youtu\.be\/|\/embed\/)/); if (b! == undefined) {return b.split (/ [^ 0-9a-z _-] / i) [0]; } else {restituisce a; }};
— Vlad
non riesce per v = nfDGK_WSFro
— Deen John
6

Poiché gli ID video di YouTube sono impostati su 11 caratteri , possiamo semplicemente substringdopo aver diviso l'URL con v=. Quindi non dipendiamo dalla e commerciale alla fine.

var sampleUrl = "http://www.youtube.com/watch?v=JcjoGn6FLwI&asdasd";

var video_id = sampleUrl.split("v=")[1].substring(0, 11)

Bello e semplice :)

— marchio
fonte
Questo è letteralmente un duplicato della risposta accettata
— brasofilo,
5

Ho riassunto tutti i suggerimenti ed ecco la risposta universale e breve a questa domanda:

if(url.match('http://(www.)?youtube|youtu\.be')){
    youtube_id=url.split(/v\/|v=|youtu\.be\//)[1].split(/[?&]/)[0];
}
— romaninsh
fonte
5

Codice Java: (Funziona per tutti gli URL:

  1. http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
  2. http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o
  3. http://youtube.googleapis.com/v/0zM3nApSvMg?fs=1&hl=en_US&rel=0
  4. http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
  5. http://www.youtube.com/embed/0zM3nApSvMg?rel=0 "
  6. http://www.youtube.com/watch?v=0zM3nApSvMg
  7. http://youtu.be/0zM3nApSvMg
  8. http://www.youtube.com/watch?v=0zM3nApSvMg/
  9. http://www.youtube.com/watch?feature=player_detailpage&v=8UVNT4wvIGY

)

    String url = "http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index";

    String regExp = "/.*(?:youtu.be\\/|v\\/|u/\\w/|embed\\/|watch\\?.*&?v=)";
    Pattern compiledPattern = Pattern.compile(regExp);
    Matcher matcher = compiledPattern.matcher(url);
    if(matcher.find()){
        int start = matcher.end();
        System.out.println("ID : " + url.substring(start, start+11));

    }

Per DailyMotion:

String url = "http://www.dailymotion.com/video/x4xvnz_the-funny-crash-compilation_fun";

    String regExp = "/video/([^_]+)/?";
    Pattern compiledPattern = Pattern.compile(regExp);
    Matcher matcher = compiledPattern.matcher(url);
    if(matcher.find()){
        String match = matcher.group();
        System.out.println("ID : " + match.substring(match.lastIndexOf("/")+1));

    }
— surya
fonte
1
Rimuovi le virgolette doppie attorno al modello Regex nel codice JavaScript e dovrebbe funzionare.
— TheDude,
4

Versione leggermente più rigida:

^https?://(?:www\.)?youtu(?:\.be|be\.com)/(?:\S+/)?(?:[^\s/]*(?:\?|&)vi?=)?([^#?&]+)

Testato su:

http://www.youtube.com/user/dreamtheater#p/u/1/oTJRivZTMLs
https://youtu.be/oTJRivZTMLs?list=PLToa5JuFMsXTNkrLJbRlB--76IAOjRM9b
http://www.youtube.com/watch?v=oTJRivZTMLs&feature=youtu.be
https://youtu.be/oTJRivZTMLs
http://youtu.be/oTJRivZTMLs&feature=channel
http://www.youtube.com/ytscreeningroom?v=oTJRivZTMLs
http://www.youtube.com/embed/oTJRivZTMLs?rel=0
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/vi/oTJRivZTMLs&feature=channel
http://youtube.com/?v=oTJRivZTMLs&feature=channel
http://youtube.com/?feature=channel&v=oTJRivZTMLs
http://youtube.com/?vi=oTJRivZTMLs&feature=channel
http://youtube.com/watch?v=oTJRivZTMLs&feature=channel
http://youtube.com/watch?vi=oTJRivZTMLs&feature=channel
— m4tx
fonte
4

Puoi utilizzare il seguente codice per ottenere l'ID video di YouTube da un URL:

url = "https://www.youtube.com/watch?v=qeMFqkcPYcg"
VID_REGEX = /(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/
alert(url.match(VID_REGEX)[1]);
— K. Ayoub
fonte
Ho avuto problemi con tutti gli altri esempi di regex ma questo funziona efficacemente con le 3 opzioni di condivisione utilizzate dalle persone sui desktop. un URL dalla barra degli indirizzi, un URL dal pulsante di condivisione e un URL dal pulsante di condivisione in linea. Grazie!!!
— Maarten,
2

Una versione leggermente modificata rispetto all'unico mantish pubblicato:

var regExp = /^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]{11,11}).*/;
var match = url.match(regExp);
if (match) if (match.length >= 2) return match[2];
// error

Ciò presuppone che il codice contenga sempre 11 caratteri. Sto usando questo in ActionScript, non sono sicuro che {11,11} sia supportato in Javascript. Aggiunto anche il supporto per & v = .... (per ogni evenienza)

— Josha
fonte
questo è stato l'unico che ha funzionato per un url con cui stavo testando: youtube.com/watch?feature=player_embedded&v=0zM3nApSvMg
— Dominic
Perfetto. grazie alla combinazione di link @Josha 69 ho testato che tutto ha funzionato per me.
— Gokhan,
2

Ancora uno:

var id = url.match(/(^|=|\/)([0-9A-Za-z_-]{11})(\/|&|$|\?|#)/)[2]

Funziona con qualsiasi URL mostrato in questo thread.

Non funzionerà quando YouTube aggiunge qualche altro parametro con 11 caratteri base64. Fino ad allora è il modo più semplice.

— pykiss
fonte
2

Ho fatto una piccola funzione per estrarre l'ID video da un URL di Youtube che può essere visto sotto.

var videoId = function(url) {
   var match = url.match(/v=([0-9a-z_-]{1,20})/i);
   return (match ? match['1'] : false);
};

console.log(videoId('https://www.youtube.com/watch?v=dQw4w9WgXcQ'));
console.log(videoId('https://www.youtube.com/watch?t=17s&v=dQw4w9WgXcQ'));
console.log(videoId('https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=17s'));
Espandi frammento

Questa funzione estrae l'ID video anche se ci sono più parametri nell'URL.

— Jake
fonte
2

Questo può ottenere l'ID video da qualsiasi tipo di link di YouTube

var url= 'http://youtu.be/0zM3nApSvMg';
var urlsplit= url.split(/^.*(youtu.be\/|v\/|embed\/|watch\?|youtube.com\/user\/[^#]*#([^\/]*?\/)*)\??v?=?([^#\&\?]*).*/);
console.log(urlsplit[3]);
— Praveen Kumar
fonte
1

Mi è piaciuta la risposta di Surya .. Solo un caso in cui non funzionerà ...

String regExp = "/.*(?:youtu.be\\/|v\\/|u/\\w/|embed\\/|watch\\?.*&?v=)";

non funziona per

youtu.be/i4fjHzCXg6c  and  www.youtu.be/i4fjHzCXg6c

versione aggiornata:

String regExp = "/?.*(?:youtu.be\\/|v\\/|u/\\w/|embed\\/|watch\\?.*&?v=)";

funziona per tutti.

— user2200660
fonte
1

Prova questo - 

function getYouTubeIdFromURL($url) 
{
  $pattern = '/(?:youtube.com/(?:[^/]+/.+/|(?:v|e(?:mbed)?)/|.*[?&]v=)|youtu.be/)([^"&?/ ]{11})/i';
  preg_match($pattern, $url, $matches);

  return isset($matches[1]) ? $matches[1] : false;
}
— Rohit Suthar
fonte
1

L'esempio più pulito di Chris Nolet della risposta di Lasnv è molto buono, ma di recente ho scoperto che se stai cercando di trovare il tuo link di YouTube nel testo e inserisci del testo casuale dopo l'URL di YouTube, regexp corrisponde molto più del necessario. Migliorata risposta di Chris Nolet:

/^.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]{11,11}).*/
Espandi frammento

— mindaug
fonte
1 
function parser(url){
    var regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\/)|(\?v=|\&v=))([^#\&\?]*).*/;
    var match = url.match(regExp);
    if (match && match[8].length==11){
            alert('OK');
    }else{
            alert('BAD');
    }
}

Per i test:

https://www.youtube.com/embed/vDoO_bNw7fc - attention first symbol «v» in «vDoO_bNw7fc»

http://www.youtube.com/user/dreamtheater#p/u/1/oTJRivZTMLs
https://youtu.be/oTJRivZTMLs?list=PLToa5JuFMsXTNkrLJbRlB--76IAOjRM9b
http://www.youtube.com/watch?v=oTJRivZTMLs&feature=youtu.be
https://youtu.be/oTJRivZTMLs
http://youtu.be/oTJRivZTMLs&feature=channel
http://www.youtube.com/ytscreeningroom?v=oTJRivZTMLs
http://www.youtube.com/embed/oTJRivZTMLs?rel=0
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/vi/oTJRivZTMLs&feature=channel
http://youtube.com/?v=oTJRivZTMLs&feature=channel
http://youtube.com/?feature=channel&v=oTJRivZTMLs
http://youtube.com/?vi=oTJRivZTMLs&feature=channel
http://youtube.com/watch?v=oTJRivZTMLs&feature=channel
http://youtube.com/watch?vi=oTJRivZTMLs&feature=channel
— Agafonov
fonte
0

Bene, il modo per farlo con un semplice analisi sarebbe: ottenere tutto a partire dal primo = segno al primo & segno.

Penso che abbiano avuto una risposta simile qui:

Analizzare un ID Vimeo usando JavaScript?

— karlphillip
fonte
2
E se l'URL non contiene &?
— Adam,
Quindi devi trovare qual è il delimitatore equivalente. Ad esempio, il primo URL che ci hai fornito è il segno &. Nel secondo URL, la fine della stringa è il delimitatore.
— karlphillip,
0

Sappiamo che questi caratteri "? V =" non possono mai apparire più di uno ma 'v' può apparire in qualche modo nell'Id stesso, quindi usiamo "? V =" come delimitatore. Vedi che funziona qui 

//Get YouTube video Id From Its Url

     $('button').bind('click',function(){
var 
url='http://www.youtube.com/watch?v=u8nQa1cJyX8',
videoId = url.split('?v='),//Split data to two
YouTubeVideoId=videoId[1];
alert(YouTubeVideoId);return false;

});

<button>Click ToGet VideoId</button>
— ShapCyber
fonte
0

Regex semplice se hai l'URL completo, mantienilo semplice.

results = url.match("v=([a-zA-Z0-9]+)&?")
videoId = results[1] // watch you need.
— Gubatron
fonte
0 
var video_url = document.getElementById('youtubediv').value;
        if(video_url!=""){
        ytid(video_url);
        document.getElementById("youtube").setAttribute("src","http://www.youtube.com/embed/"+ytid(video_url));
        }
        function ytid(video_url){
            var video_id = video_url.split('v=')[1];
            var ampersandPosition = video_id.indexOf('&');
            if(ampersandPosition != -1) {
                video_id = video_id.substring(0, ampersandPosition);
            }
            return video_id;
        }

spero che possa essere d'aiuto

— Roderick Domondon
fonte
0 
function youtube_parser(url){
    var match = url.match(/^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#\&\?]*).*/);
    return (match&&match[7].length==11)?match[7]:false;
}

Più breve ed efficiente

— Wasim A.
fonte
non giusto, non riesce vs youtube.com/e/dQw4w9WgXcQ quindi per favore prendi la parte efficiente :)
— alecellis1985
0

Come webstrap menzionato in un commento :

Ha funzionato se il video inizia con "v" ed è da youtu.be

Il regex contiene un piccolo bug che \??v?=?dovrebbe essere solo nella parte dell'orologio, altrimenti filtreresti a 'v'se l'id inizia con a 'v'. quindi questo dovrebbe fare il trucco

/^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\??v?=?))([^#\&\?]*).*/

— Shuher
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.