Jak uzyskać identyfikator wideo YouTube z adresu URL?

256

Chcę uzyskać v=idz adresu URL YouTube z JavaScript (bez jQuery, czysty JavaScript).

Przykładowe formaty adresów URL YouTube

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

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

Lub dowolny inny format YouTube, który zawiera identyfikator wideo w adresie URL.

Wynik z tych formatów

u8nQa1cJyX8

javascript  regex  url  youtube 
— Adam
źródło
1
— Mark Byers,
To pytanie dotyczy tylko formatów takich jak mój drugi. Ale znalazłem tam ciekawą odpowiedź, dziękuję za udostępnienie.
— Adam,
Istnieje na to wyrażenie regularne: http://pregcopy.com/exp/27
— Exos
Nie mogę tego przypisać, ale uważam, że jest to dość obszerne: gist.github.com/FinalAngel/1876898 . Łapie nawet adresy URL tak różnorodne, jak youtube.com/watch?feature=player_embedded&v=1p3vcRhsYGo i youtube.com/v/1p3vcRhsYGo
— Simon
2
Począwszy od 2015 r .: przejdź do tej odpowiedzi . Pozostałe odpowiedzi są nieaktualne.
— Lenar Hoyt,

Odpowiedzi:

109

Nie musisz do tego używać wyrażenia regularnego.

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
źródło
jest to przydatna funkcja umożliwiająca działanie w dowolnym miejscu na podstawie tego kodu. var video_url = ' youtube.com/watch?v=eOrNdBpGMv8&feature=youtube_gdata '; ytid (video_url); funkcja 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); } alert (video_id); zwróć video_id; }
— Gino
9
nie obsługuje osadzonych adresów URL
— Serge
14
także nie obsługuje adresów URL generowanych przez „share”https://youtu.be/{{video_id}}
— hamncheez,
2
Ten regex działa dobrze z udostępnianiem youtube i oglądaniem adresu URL. url='https://youtu.be/{{video_id}}'; url.match(/(?:https?:\/{2})?(?:w{3}\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\?v=|\/)([^\s&]+)/);
— Dipten
410

Wprowadziłem ulepszenie do Regex dostarczone przez „jeffreypriebe”, ponieważ potrzebował pewnego rodzaju URL-a YouTube, który jest adresem URL filmów, gdy przeglądają kanał.

No nie, ale to jest funkcja, którą uzbroiłem.

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

Są to obsługiwane typy adresów URL

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

Można znaleźć w [http://web.archive.org/web/20160926134334/] http://lasnv.net/foro/839/Javascript_parsear_URL_de_YouTube

— Lasnv
źródło
6
Wyrażenie regularne zawiera mały błąd \ ?? v? =? powinno to być po prostu na części obserwacyjnej, w przeciwnym razie odfiltrowałbyś „v”, jeśli id ​​zaczyna się od „v”. więc to powinno załatwić sprawę / ^. =?)) ([^ # \ & \?] *). * /
— webstrap
69
Jeszcze czystsze: /.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]*).*/ użyj match[1]zamiast match[7](co wydawało mi się trochę arbitralne). Naprawiono również błąd wskazany przez WebDev.
— Chris Nolet
3
Jak długo, dopóki identyfikatory YouTube nie będą miały 12 znaków?
— Lenar Hoyt
1
Czy wiesz, że to nie jest naprawdę idealne, jeśli umieścisz cokolwiek.com/watch?v=jn40gqhxoSY Myślisz, że to adres URL youtube
— Gino
1
Każdy może przedłużyć ten reekeks, a zatem ludzie narzekający nie mają żadnego sensu.
— Lecha Bisultanov,
241

Uprościłem trochę odpowiedź Lasnv.

Naprawia również błąd opisany przez WebDeb.

Oto on:

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
}

Oto link do wyrażenia regularnego do gry: http://regexr.com/3dnqv

— mantish
źródło
2
tylko heads-up: należy tego używać tylko wtedy, gdy wiesz, że masz do czynienia z adresem URL YouTube. (Niesłusznie) użyłem go do zweryfikowania adresów URL jako youtube, co spowodowało fałszywe alarmy, na przykład: „v / 2059-9080-5437”
— fabi
3
Używam teraz innego Regexu, który sprawdza również domenę youtube. Nie jestem pewien, czy powinienem zaktualizować odpowiedź, ponieważ jest to duża zmiana: /^.*(youtu.be\/|youtube(-nocookie)?.com\/(v\/|.*u\/\w \ / | embed \ / |. * v =)) ([\ w -] {11}). * /
— mantish
4
Kiedy YouTube zmieni się na 12 znaków dla identyfikatora wideo?
— Lenar Hoyt,
nie należy unikać kropki w „youtu.be”?
— Alex
masz rację @jitbit Dziękuję. Chociaż zwykle działa również bez ucieczki.
— mantish
85

Żadne z nich nie działało na zlewie kuchennym od 1 stycznia 2015 r., W szczególności adresy URL bez protokołów http / si z domeną youtube-nocookie. Oto zmodyfikowana wersja, która działa na wszystkich różnych wersjach 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
źródło
2
Warto zauważyć, że wiele z powyższych rozwiązań nie obejmuje tej szerokiej partii prawidłowych adresów URL, skrypt testowy jest bardzo pomocny, +1!
— pobłogosławił
2
Zauważ, że zostanie to oszukane przez coś takiego jak „www.engadget.com/watch?v=dQw4w9WgXcQ”, ale nie że to prawdopodobnie będzie problem
— binaryfunt
Działa, ale nie można rozwiązać problemu z tekstem z wieloma adresami URL youtube Zobacz to regex101.com/r/qK5qJ5/1 . Nie powinien zastępować drugiego adresu URL.
— Ashish,
2
Jeśli nie chcesz, aby pusty identyfikator pasował : ^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]+).*(tzn. Youtube.com/watch?v= nie będzie pasował)
— zurfyx
Co rozumiesz przez „Żaden z nich nie działał na zlewie kuchennym”?
— rmutalik
26 
/^.*(youtu.be\/|v\/|e\/|u\/\w+\/|embed\/|v=)([^#\&\?]*).*/

Testowane na:

  • 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

Zainspirowany inną odpowiedzią .

— Xronosiam
źródło
9
^. * (?: youtu.be \ / | v \ / | e \ / | u \ / \ w + \ / | embed \ / | v =) ([^ # \ & \?] *). * da wynik w grupie 1
— Marc
19

Biorąc pod uwagę, że YouTube ma wiele stylów adresów URL, myślę, że Regex jest lepszym rozwiązaniem. Oto mój Regex:

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

Grupa 3 ma Twój identyfikator YouTube

Przykładowe adresy URL YouTube (obecnie, w tym „starszy styl osadzania adresów URL”) - powyższy Regex działa na wszystkich: 

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

Porada dla Lasnv

— jeffreypriebe
źródło
9
Naprawdę musisz wrócić do tablicy kreślarskiej. Tak, poprawnie pasuje do powyższych adresów URL. Ale także błędnie pasuje wiele innych ciągów non-youtube-url takich jak: "domain.com/embed/file.txt", "/tv/"i "Has anyone seen my watch?". Zobacz: moja odpowiedź na podobne pytanie w celu uzyskania bardziej precyzyjnego rozwiązania.
— ridgerunner
1
Rozumiem twój punkt widzenia: powyższe wyrażenie regularne jest bezużyteczne, aby odpowiedzieć na pytanie „Czy to adres URL YouTube?” ale to nie był mój cel. Mam adresy URL na YouTube - wydobywam tylko identyfikator. Tak, twoja odpowiedź jest solidna (i obejmuje przypadek użycia, którego moja nie ma).
— jeffreypriebe
masz ten sam błąd, o którym wspomniałem powyżej, z identyfikatorami zaczynającymi się od „v”
— pasek sieciowy
Dzięki @WebDev - czy wiesz, czy YouTube kiedykolwiek umieścił av w identyfikatorze (lub zaczyna identyfikator od „v”)?
— jeffreypriebe
1
Nadal działa na dziś (25.01.2013). Oto przykład tego działania: jsfiddle.net/bcmoney/yBP4J
— bcmoney 25.01.2013
17

Stworzyłem funkcję, która testuje dane wejściowe użytkowników dla identyfikatorów Youtube, Soundcloud lub Vimeo, aby móc stworzyć bardziej ciągły projekt z osadzonymi multimediami. Ta funkcja wykrywa i zwraca obiekt o dwóch właściwościach: „type” i „id”. Typem może być „youtube”, „vimeo” lub „soundcloud”, a właściwość „id” jest unikalnym identyfikatorem multimediów.

Na stronie korzystam ze zrzutu tekstowego, w którym użytkownik może wkleić dowolny typ linku lub kodu osadzania, w tym osadzanie iFrame zarówno vimeo, jak i 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
źródło
Fajny pomysł, ale nie działa na większości formatów adresów URL. W tym niepasujące do żadnych witryn https.
— NickG
13

Późno do gry tutaj, ale zebrałem dwie doskonałe odpowiedzi od mantish i jw. Po pierwsze, zmodyfikowane wyrażenie regularne:

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

Oto kod testowy (dodałem oryginalne przypadki testowe Mantisha do nieprzyjemnych przypadków 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');
  }

Wersja eksperymentalna do obsługi adresów URL m.youtube wspomnianych w komentarzach:

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

Wymaga parsed[2]zmiany parsed[3]w dwóch miejscach w testach (które następnie przechodzi z m.youtubeadresami URL dodanymi do testów). Daj mi znać, jeśli zobaczysz problemy.

— podperson
źródło
1
Powinieneś dodać ten do kombinezonu testowego, ponieważ był problematyczny, a wyrażenie regularne rozwiązało go dla mnie: youtu.be/ve4f400859I . Litera v została rozebrana w moim poprzednim
— wyrażeniu regularnym
1
Dostaję fałszywy wynik, http://youtu.be/jeśli po dodaniu /oznaczę to jako prawidłowe. Korzystanie z niego w(value) => /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/.test(value)
— Anima-t3d
Dziękuję za komentarze. Nie zaktualizowałem jeszcze mojego przykładu (nie mam czasu na testowanie), więc każdy, kto używa mojego kodu, pamiętaj :-)
— podperson
co z url typu = m.youtube.com
— Mehul Thakkar
@MehulThakkar, czy w przeciwnym razie są podobne do adresów URL youtube.com?
— podperson
11

tl; dr.

Pasuje do wszystkich przykładów adresów URL dla tego pytania, a następnie niektórych.

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

ID zawsze będzie w grupie 7 meczów.

Żywe przykłady wszystkich adresów URL, które pobrałem z odpowiedzi na to pytanie: https://regexr.com/3u0d4

Pełne wyjaśnienie:

Ponieważ pojawiło się wiele odpowiedzi / komentarzy, istnieje wiele formatów adresów URL filmów z YouTube. Nawet wiele TLD, w których mogą się wydawać „hostowane”.

Możesz zobaczyć pełną listę odmian, z którymi sprawdziłem, klikając powyższy link regexr.

Pozwala rozbić RegExp.

^Zablokuj ciąg do początku łańcucha. (https?:\/\/)?Opcjonalne protokoły http: // lub https: // To ?sprawia, że ​​poprzedni element jest opcjonalny, więcs a następnie cała grupa (wszystko zawarte w zestawie nawiasów) jest opcjonalna.

Ok, ta kolejna część jest jego mięsem. Zasadniczo mamy dwie opcje, różne wersje www.youtube.com/...[id] i link skróconą wersję youtu.be/[id].

(                                                  // 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

Wreszcie mamy grupę do wybrania identyfikatora wideo. Co najmniej jeden znak, który jest liczbą, literą, podkreśleniem lub myślnikiem.

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

Możesz dowiedzieć się o wiele więcej szczegółów na temat każdej części wyrażenia regularnego, przechodząc nad linkiem wyrażenia regularnego i sprawdzając, jak każda część wyrażenia pasuje do tekstu w adresie URL.

— tsdorsey
źródło
10

Najlepsze rozwiązanie (z lat 2019-2020), które znalazłem, to:

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];
}

Znalazłem to tutaj .

/*
* 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
źródło
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 {return a; }};
— Vlad
kończy się niepowodzeniem dla v = nfDGK_WSFro
— Deen John
6

Ponieważ identyfikatory filmów na YouTube mają 11 znaków , możemy po prostu substringpodzielić adres URL v=. Wtedy nie jesteśmy uzależnieni od ampersand na końcu.

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

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

Ładnie i prosto :)

— znak
źródło
Ten jest dosłownie duplikatem przyjętej odpowiedzi
— brasofilo
5

Podsumowałem wszystkie sugestie i oto uniwersalna i krótka odpowiedź na to pytanie:

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

Kod Java: (Działa dla wszystkich adresów 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));

    }

W przypadku 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
źródło
1
Usuń podwójne cudzysłowy z wzorca Regex w kodzie JavaScript i powinno to działać.
— TheDude
4

Nieco bardziej rygorystyczna wersja:

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

Testowane na:

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
źródło
4

Możesz użyć następującego kodu, aby uzyskać identyfikator wideo YouTube z adresu 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
źródło
Miałem problemy ze wszystkimi innymi przykładami wyrażeń regularnych, ale ten skutecznie działa na 3 opcjach udostępniania używanych przez użytkowników na komputerach. adres URL z paska adresu, adres URL z przycisku udostępniania i adres URL z wbudowanego przycisku udostępniania. Dzięki!!!
— Maarten
2

Nieznacznie zmieniona wersja z tej opublikowanej przez Mantisha:

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

Zakłada się, że kod ma zawsze 11 znaków. Używam tego w ActionScript, nie jestem pewien, czy {11,11} jest obsługiwany w JavaScript. Dodano także obsługę & v = .... (na wszelki wypadek)

— Josha
źródło
był to jedyny, który działał dla adresu URL, z którym testowałem: youtube.com/watch?feature=player_embedded&v=0zM3nApSvMg
— Dominic
idealny. dzięki @Josha 69 kombinacja linków i test wszystko działa dla mnie
— gokhan
2

Jeszcze jeden:

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

Działa z dowolnym adresem URL pokazanym w tym wątku.

Nie zadziała, gdy YouTube doda jakiś inny parametr z 11 znakami base64. Do tego czasu jest to prosty sposób.

— pykiss
źródło
2

Zrobiłem małą funkcję, aby wyodrębnić identyfikator wideo z adresu URL Youtube, który można zobaczyć poniżej.

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'));
Rozwiń fragment kodu

Ta funkcja wyodrębni identyfikator wideo, nawet jeśli adres URL zawiera wiele parametrów.

— Jake
źródło
2

Może to uzyskać identyfikator wideo z dowolnego rodzaju linków do 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
źródło
1

Podobała mi się odpowiedź Suryi .. Tylko przypadek, w którym nie zadziała ...

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

nie działa dla

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

zaktualizowana wersja:

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

działa dla wszystkich.

— użytkownik2200660
źródło
1

Spróbuj tego - 

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
źródło
1

Przykład Chrisa Noleta z odpowiedzią Lasnv jest bardzo dobry, ale ostatnio dowiedziałem się, że jeśli próbujesz znaleźć link do youtube w tekście i wstawić losowy tekst za adresem URL youtube, regexp pasuje o wiele bardziej niż to konieczne. Poprawiona odpowiedź Chrisa Noleta:

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

— mindaug
źródło
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');
    }
}

Dla testów:

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
— Agafonow
źródło
0

Cóż, sposobem na zrobienie tego z prostą analizą byłoby: zacznij wszystko od pierwszego = znak do pierwszego i znak.

Myślę, że mieli podobną odpowiedź tutaj:

Analizujesz identyfikator Vimeo za pomocą JavaScript?

— karlphillip
źródło
2
A co jeśli adres URL nie zawiera &?
— Adam,
Następnie musisz znaleźć odpowiednik separatora. Na przykład pierwszy adres URL, który nam podałeś, to znak &. W drugim adresie URL końcem ciągu jest separator.
— karlphillip,
0

Wiemy, że te znaki „? V =” nigdy nie mogą pojawiać się więcej niż jedynki, ale „v” może pojawić się jakoś w samym Id, więc używamy „? V =” jako separatora. Zobacz, jak działa tutaj 

//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
źródło
0

Proste wyrażenie regularne, jeśli masz pełny adres URL, zachowaj prostotę.

results = url.match("v=([a-zA-Z0-9]+)&?")
videoId = results[1] // watch you need.
— Gubatron
źródło
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;
        }

mam nadzieję, że to może pomóc

— Roderick Domondon
źródło
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;
}

Najkrótszy i wydajny

— Wasim A.
źródło
nie dobrze, kończy się niepowodzeniem w stosunku do youtube.com/e/dQw4w9WgXcQ, więc proszę wyjmij część efektywną :)
— alecellis1985
0

Jak wspomniano w komentarzu do paska :

Działa, jeśli wideo zaczyna się od „v” i pochodzi z youtu.be

Wyrażenie regularne zawiera mały błąd, który \??v?=?powinien znajdować się w części obserwacyjnej, w przeciwnym razie odfiltrowałbyś a, 'v'gdyby identyfikator zaczynał się od 'v'. więc to powinno załatwić sprawę

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

— Shuher
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.