Wie erhalte ich die YouTube-Video-ID von einer URL?

257

Ich möchte v=iddie URL von YouTube mit JavaScript abrufen (kein jQuery, reines JavaScript).

Beispiel für YouTube-URL-Formate

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

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

Oder ein anderes YouTube-Format, das eine Video-ID in der URL enthält.

Ergebnis dieser Formate

u8nQa1cJyX8

javascript  regex  url  youtube 
— Adam
quelle
1
— Mark Byers
Diese Frage gilt nur für Formate wie mein zweites. Aber ich habe dort eine interessante Antwort gefunden, danke, dass du sie geteilt hast.
— Adam
Es gibt einen regulären Ausdruck dafür: http://pregcopy.com/exp/27
— Exos
Ich kann es nicht gutschreiben , aber ich fand das ziemlich umfangreich: gist.github.com/FinalAngel/1876898 . Es fängt sogar so unterschiedliche URLs ab wie youtube.com/watch?feature=player_embedded&v=1p3vcRhsYGo und youtube.com/v/1p3vcRhsYGo
— Simon
2
Ab 2015: Springe zu dieser Antwort . Die anderen Antworten sind veraltet.
— Lenar Hoyt

Antworten:

109

Sie müssen dafür keinen regulären Ausdruck verwenden.

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
quelle
Dies ist eine nützliche Funktion, damit sie basierend auf diesem Code dort funktioniert, wo Sie möchten. var video_url = ' youtube.com/watch?v=eOrNdBpGMv8&feature=youtube_gdata '; ytid (video_url); Funktion 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); return video_id; }
— Gino
9
verarbeitet keine eingebetteten URLs
— Serge
14
behandelt auch nicht 'teilen' generierte URLshttps://youtu.be/{{video_id}}
— hamncheez
2
Diese Regex funktioniert gut mit YouTube-Share und Watch-URL. url='https://youtu.be/{{video_id}}'; url.match(/(?:https?:\/{2})?(?:w{3}\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\?v=|\/)([^\s&]+)/);
— Dipten
410

Ich habe Regex von "jeffreypriebe" verbessert, weil er eine Art YouTube-URL benötigte. Dies ist die URL der Videos, wenn sie durch einen Kanal schauen.

Nun nein, aber das ist die Funktion, die ich bewaffnet habe.

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

Dies sind die unterstützten URL-Typen

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

Kann in [http://web.archive.org/web/20160926134334/] http://lasnv.net/foro/839/Javascript_parsear_URL_de_YouTube gefunden werden

— Lasnv
quelle
6
Die Regex enthält einen kleinen Fehler \ ?? v? =? Dies sollte nur im Watch-Teil sein, sonst würden Sie ein 'v' filtern, wenn die ID mit einem 'v' beginnt. Das sollte also den Trick machen /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\??v? =?)) ([^ # \ & \?] *). * /
— Webstrap
69
Noch sauberer: /.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]*).*/ Dann verwenden Sie match[1]statt match[7](was mir etwas willkürlich erschien). Behebt auch den von WebDev hervorgehobenen Fehler.
— Chris Nolet
3
Wie lange dauert es, bis YouTube-IDs 12 Zeichen lang sind?
— Lenar Hoyt
1
Wussten Sie, dass es nicht wirklich perfekt ist, wenn Sie irgendetwas setzen
— Gino
1
Jeder kann diese Anforderung erweitern, und daher machen Beschwerdeführer keinen Sinn.
— Lecha Bisultanov
241

Ich habe Lasnvs Antwort etwas vereinfacht.

Es behebt auch den von WebDeb beschriebenen Fehler.

Hier ist es:

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
}

Hier ist ein Regexer-Link zum Spielen: http://regexr.com/3dnqv

— Mantish
quelle
2
Nur ein Hinweis: Dies sollte nur verwendet werden, wenn Sie wissen, dass es sich um eine Youtube-URL handelt. Ich habe es (zu Unrecht) verwendet, um URLs als YouTube zu verifizieren, was zu falsch positiven Ergebnissen führte, z. B. Folgendes: 'v / 2059-9080-5437'
— fabi
3
Ich verwende jetzt einen anderen Regex, der auch nach einer YouTube-Domain sucht. Ich bin mir nicht sicher, ob ich die Antwort aktualisieren soll, da es sich um eine große Änderung handelt: /^.*(youtu.be\/|youtube(-nocookie)?.com\/(v\/|.*u\/\w \ / | eingebettet \ / |. * v =)) ([\ w -] {11}). * /
— Mantish
4
Wann wechselt YouTube für die Video-ID zu 12 Zeichen?
— Lenar Hoyt
sollte der Punkt in "youtu.be" nicht maskiert werden?
— Alex
du hast recht @jitbit Danke. Obwohl es normalerweise auch funktioniert, ohne ihm zu entkommen.
— Mantish
85

Keines davon funktionierte ab dem 1.1.2015 am Spülbecken, insbesondere URLs ohne protokale http / s und mit Youtube-Nocookie-Domain. Hier ist eine modifizierte Version, die auf all diesen verschiedenen Youtube-Versionen funktioniert:

// 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
quelle
2
Es ist erwähnenswert, dass viele der oben genannten Lösungen diese große Menge gültiger URLs nicht abdecken. Das Testskript ist sehr hilfreich, +1!
— Blented
2
Beachten Sie, dass dies durch etwas wie "www.engadget.com/watch?v=dQw4w9WgXcQ" getäuscht wird, nicht dass es wahrscheinlich ein Problem ist
— binaryfunt
Es funktioniert, konnte aber das Problem, das bei einem Text mit mehreren YouTube- URLs auftritt, nicht beheben . Siehe diese regex101.com/r/qK5qJ5/1 . Es sollte die zweite URL nicht ersetzen.
— Ashish
2
Wenn Sie nicht möchten, dass eine leere ID übereinstimmt : ^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]+).*(dh youtube.com/watch?v=
— stimmt
Was meinst du mit "Keine davon hat am Spülbecken gearbeitet"?
— rmutalik
26 
/^.*(youtu.be\/|v\/|e\/|u\/\w+\/|embed\/|v=)([^#\&\?]*).*/

Getestet am:

  • http://www.youtube.com/v/0zM3nApSvMg?fs=1&hl=de_DE&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=de_DE&rel=0

Inspiriert von dieser anderen Antwort .

— Xronosiam
quelle
9
^. * (?: youtu.be \ / | v \ / | e \ / | u \ / \ w + \ / | einbetten \ / | v =) ([^ # \ & \?] *). * wird geben Sie das Ergebnis in Gruppe 1
— Marc
20

Angesichts der Tatsache, dass YouTube eine Vielzahl von URL-Stilen hat, halte ich Regex für eine bessere Lösung. Hier ist mein Regex:

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

Gruppe 3 hat deine YouTube-ID

Beispiel-YouTube-URLs (derzeit einschließlich "Legacy-Einbettungs-URL-Stil") - der oben genannte Regex funktioniert für alle: 

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

Hutspitze zu Lasnv

— Jeffreypriebe
quelle
9
Sie müssen wirklich mit diesem zum Zeichenbrett zurückkehren. Ja, es stimmt korrekt mit den obigen URLs überein. Aber sie paßt auch fälschlicherweise viele andere nicht-youtube-URL - Strings , wie: "domain.com/embed/file.txt", "/tv/"und "Has anyone seen my watch?". Siehe: meine Antwort auf eine ähnliche Frage für eine viel genauere Lösung.
— Ridgerunner
1
Ich verstehe Ihren Standpunkt: Der obige reguläre Ausdruck ist nutzlos, um die Frage "Ist das eine YouTube-URL?" Zu beantworten. aber das war nicht mein ziel. Ich habe YouTube-URLs - ich extrahiere lediglich eine ID. Ja, Ihre Antwort ist solide (und deckt einen Anwendungsfall ab, den meiner nicht hat).
— Jeffreypriebe
Sie haben den gleichen Fehler, den ich oben erwähnt habe, mit IDs, die mit einem 'v' beginnen
— Webstrap
Danke @WebDev - weißt du, ob YouTube jemals av in die ID einfügt (oder eine ID mit einem "v" startet)?
— Jeffreypriebe
1
Funktioniert noch heute (25.01.2013). Hier ist ein Beispiel dafür in Aktion: jsfiddle.net/bcmoney/yBP4J
— bcmoney
17

Ich habe eine Funktion erstellt, die Benutzereingaben auf Youtube-, Soundcloud- oder Vimeo-Einbettungs-IDs testet, um mit eingebetteten Medien ein kontinuierlicheres Design erstellen zu können. Diese Funktion erkennt ein Objekt mit zwei Eigenschaften: "Typ" und "ID" und gibt es zurück. Der Typ kann entweder "youtube", "vimeo" oder "soundcloud" sein und die Eigenschaft "id" ist die eindeutige Medien-ID.

Auf der Website verwende ich einen Textbereich-Speicherauszug, in den der Benutzer jede Art von Link oder Einbettungscode einfügen kann, einschließlich der iFrame-Einbettung von vimeo und 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
quelle
Gute Idee, aber bei den meisten URL-Formaten funktioniert sie nicht. Einschließlich Nichtübereinstimmung auf https-Sites.
— NickG
13

Spät zum Spiel hier, aber ich habe zwei hervorragende Antworten von Mantish und JW zusammengestellt. Zunächst die modifizierte Regex:

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

Hier ist der Testcode (ich habe die ursprünglichen Testfälle von mantish zu den fieseren von jw hinzugefügt):

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

Experimentelle Version für die in den Kommentaren genannten m.youtube- URLs:

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

Es muss in den Tests an zwei Stellen parsed[2]geändert parsed[3]werden (die dann mit m.youtubezu den Tests hinzugefügten URLs bestanden werden). Lassen Sie mich wissen, wenn Sie Probleme sehen.

— podperson
quelle
1
Sie sollten diesen in Ihren Testanzug aufnehmen, da er problematisch war und Ihr regulärer Ausdruck ihn für mich gelöst hat: youtu.be/ve4f400859I . Der Buchstabe v wurde in meinem vorherigen regulären Ausdruck
— Mark Odey
1
Ich bekomme ein falsches Postiv, http://youtu.be/wenn ich das hinzufüge, das /es als gültig markiert. Verwenden Sie es in(value) => /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/.test(value)
— Anima-t3d
Danke für die Kommentare. Ich habe mein Beispiel noch nicht aktualisiert (ich habe keine Zeit zum Testen), daher sollte jeder, der meinen Code verwendet,
— Folgendes
Was ist mit URL vom Typ = m.youtube.com
— Mehul Thakkar
@MehulThakkar ähneln sie sonst den URLs von youtube.com?
— Podperson
11

tl; dr.

Entspricht allen URL-Beispielen zu dieser und einigen weiteren Fragen.

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 wird immer in Spielgruppe 7 sein.

Live-Beispiele aller URLs, die ich aus den Antworten auf diese Frage entnommen habe : https://regexr.com/3u0d4

Vollständige Erklärung:

Da viele Antworten / Kommentare aufgetaucht sind, gibt es viele Formate für YouTube-Video-URLs. Sogar mehrere TLDs, bei denen sie als "gehostet" erscheinen können.

Sie können sich die vollständige Liste der Variationen ansehen, gegen die ich geprüft habe, indem Sie dem obigen Regexr-Link folgen.

Lassen Sie uns die RegExp aufschlüsseln.

^Sperren Sie die Zeichenfolge an den Anfang der Zeichenfolge. (https?:\/\/)?Optionale Protokolle http: // oder https: // Das ?macht das vorhergehende Element optional, so dasss und dann die gesamte Gruppe (alles, was in Klammern eingeschlossen ist) optional sind.

Ok, dieser nächste Teil ist das Fleisch davon. Grundsätzlich haben wir zwei Möglichkeiten, die verschiedenen Versionen von www.youtube.com/...[id] und die verkürzte Version 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

Schließlich haben wir die Gruppe, um die Video-ID auszuwählen. Mindestens ein Zeichen, das eine Zahl, ein Buchstabe, ein Unterstrich oder ein Bindestrich ist.

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

Sie können viel mehr Details zu jedem Teil der Regex herausfinden, indem Sie über den Regexr-Link gehen und sehen, wie jeder Teil des Ausdrucks mit dem Text in der URL übereinstimmt.

— Tsdorsey
quelle
10

Die beste Lösung (von 2019 bis 2020), die ich gefunden habe, ist folgende:

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

Ich habe es hier gefunden .

/*
* 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
quelle
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
schlägt fehl für v = nfDGK_WSFro
— Deen John
6

Da die YouTube-Video-IDs auf 11 Zeichen festgelegt sind , können substringwir die URL einfach direkt nach dem Teilen mit teilen v=. Dann sind wir am Ende nicht auf das kaufmännische Und angewiesen.

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

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

Schön und einfach :)

— Kennzeichen
quelle
Dies ist buchstäblich ein Duplikat der akzeptierten Antwort
— brasofilo
5

Ich habe alle Vorschläge zusammengefasst und hier ist die universelle und kurze Antwort auf diese Frage:

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

Java-Code: (Funktioniert für alle URLs:

  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=de_DE&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));

    }

Für 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
quelle
1
Entfernen Sie die doppelten Anführungszeichen um das Regex-Muster im JavaScript-Code, und es sollte funktionieren.
— TheDude
4

Etwas strengere Version:

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

Getestet am:

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

Sie können den folgenden Code verwenden, um die YouTube-Video-ID von einer URL abzurufen:

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
quelle
Ich hatte Probleme mit allen anderen Regex-Beispielen, aber dieses funktioniert effektiv mit den 3 Freigabeoptionen, die Benutzer auf Desktops verwenden. Eine URL aus der Adressleiste, eine URL aus der Schaltfläche "Teilen" und eine URL aus der Schaltfläche "Inline-Teilen". Vielen Dank!!!
— Maarten
2

Eine leicht veränderte Version von dem einen Mantish:

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

Dies setzt voraus, dass der Code immer 11 Zeichen umfasst. Ich verwende dies in ActionScript und bin mir nicht sicher, ob {11,11} in Javascript unterstützt wird. Unterstützung für & v = .... hinzugefügt (nur für den Fall)

— Josha
quelle
Dies war die einzige, die für eine URL funktionierte, mit der ich getestet habe: youtube.com/watch?feature=player_embedded&v=0zM3nApSvMg
— Dominic
perfekt. danke @Josha 69 Link-Kombination Ich teste alles ist für mich gearbeitet.
— Gokhan
2

Einer noch:

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

Es funktioniert mit jeder URL, die in diesem Thread angezeigt wird.

Es wird nicht funktionieren, wenn YouTube einen anderen Parameter mit 11 base64-Zeichen hinzufügt. Bis dahin ist es der einfache Weg.

— Pykiss
quelle
2

Ich habe eine kleine Funktion erstellt, um die Video-ID aus einer Youtube-URL zu extrahieren, die unten zu sehen ist.

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'));
Erweitern Sie das Snippet

Diese Funktion extrahiert die Video-ID, auch wenn die URL mehrere Parameter enthält.

— Jake
quelle
2

Dies kann Video-ID von jeder Art von YouTube-Links erhalten

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

Ich mochte Suryas Antwort. Nur ein Fall, in dem es nicht funktioniert ...

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

funktioniert nicht für

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

aktualisierte Version:

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

funktioniert für alle.

— user2200660
quelle
1

Probier diese - 

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

Chris Nolet saubereres Beispiel für eine Lasnv-Antwort ist sehr gut, aber ich habe kürzlich herausgefunden, dass Regexp weitaus mehr als nötig übereinstimmt, wenn Sie versuchen, Ihren Youtube-Link in Text zu finden und zufälligen Text nach der Youtube-URL einzufügen. Verbesserte Antwort von Chris Nolet:

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

— Mindaug
quelle
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');
    }
}

Zum Prüfen:

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

Nun, der Weg, dies mit einfachem Parsen zu tun, wäre: Alles beginnt nach dem ersten = Zeichen zum ersten & Zeichen.

Ich denke, sie hatten hier eine ähnliche Antwort:

Eine Vimeo-ID mit JavaScript analysieren?

— Karlphillip
quelle
2
Und was ist, wenn die URL nicht enthält &?
— Adam
Dann müssen Sie herausfinden, was das entsprechende Trennzeichen ist. Zum Beispiel ist die erste URL, die Sie uns gegeben haben, das & -Zeichen. Bei der zweiten URL ist das Ende der Zeichenfolge das Trennzeichen.
— Karlphillip
0

Wir wissen, dass diese Zeichen "? V =" niemals mehr als eins erscheinen können, aber 'v' kann irgendwie in der ID selbst erscheinen, also verwenden wir "? V =" als Trennzeichen. Sehen Sie, wie es hier funktioniert 

//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
quelle
0

Einfache Regex Wenn Sie die vollständige URL haben, halten Sie es einfach.

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

Ich hoffe es kann helfen

— Roderick Domondon
quelle
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;
}

Kürzeste und effizienteste

— Wasim A.
quelle
nicht richtig, scheitert gegen youtube.com/e/dQw4w9WgXcQ, also bitte den effizienten Teil
— herausnehmen
0

Wie Webstrap in einem Kommentar erwähnt :

Es hat funktioniert, wenn das Video mit "v" beginnt und von youtu.be stammt

Die Regex enthält einen kleinen Fehler, der \??v?=?sich nur im Watch-Teil befinden sollte. Andernfalls würden Sie a filtern, 'v'wenn die ID mit a beginnt 'v'. Das sollte also den Trick machen

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

— Shuher
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.