Comment puis-je obtenir l'ID de vidéo YouTube à partir d'une URL?

257

Je veux obtenir l' v=idURL de YouTube avec JavaScript (pas de jQuery, pur JavaScript).

Exemples de formats d'URL YouTube

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

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

Ou tout autre format YouTube contenant un identifiant vidéo dans l'URL.

Résultat de ces formats

u8nQa1cJyX8

javascript  regex  url  youtube 
— Adam
source
1
— Mark Byers
Cette question ne concerne que les formats comme le deuxième. Mais j'ai trouvé là une réponse intéressante, merci de la partager.
— Adam
Il existe une expression régulière pour cela: http://pregcopy.com/exp/27
— Exos
Je ne peux pas m'en attribuer le mérite, mais j'ai trouvé que c'était assez étendu: gist.github.com/FinalAngel/1876898 . Il capture même des URL aussi diverses que youtube.com/watch?feature=player_embedded&v=1p3vcRhsYGo et youtube.com/v/1p3vcRhsYGo
— Simon
2
À partir de 2015: passez à cette réponse . Les autres réponses sont obsolètes.
— Lenar Hoyt

Réponses:

109

Vous n'avez pas besoin d'utiliser une expression régulière pour cela.

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
source
il s'agit d'une fonction utile pour le faire fonctionner où vous le souhaitez en fonction de ce code. var video_url = ' youtube.com/watch?v=eOrNdBpGMv8&feature=youtube_gdata '; ytid (video_url); fonction 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
ne gère pas les URL intégrées
— Serge
14
ne gère pas non plus les URL générées par «part»https://youtu.be/{{video_id}}
— hamncheez
2
Cette expression régulière fonctionne bien avec le partage YouTube et l'URL de lecture. url='https://youtu.be/{{video_id}}'; url.match(/(?:https?:\/{2})?(?:w{3}\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\?v=|\/)([^\s&]+)/);
— Dipten
410

J'ai apporté une amélioration à Regex fournie par "jeffreypriebe" car il avait besoin d'une sorte d'URL YouTube qui est l'URL des vidéos quand elles regardent sur une chaîne.

Eh bien non, mais c'est la fonction que j'ai armée.

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

Ce sont les types d'URL pris en charge

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

Peut être trouvé dans [http://web.archive.org/web/20160926134334/] http://lasnv.net/foro/839/Javascript_parsear_URL_de_YouTube

— Lasnv
source
6
L'expression régulière contient un petit bug \ ?? v? =? cela devrait être juste à la partie montre, sinon vous filtreriez un «v» si l'id commence par un «v». donc cela devrait faire l'affaire /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\??v? =?)) ([^ # \ & \?] *). * /
— webstrap
69
Encore plus propre: /.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]*).*/ utilisez ensuite match[1]au lieu de match[7](ce qui m'a paru un peu arbitraire). Corrige également un bug signalé par WebDev.
— Chris Nolet
3
Combien de temps les identifiants YouTube contiennent-ils 12 caractères?
— Lenar Hoyt
1
Saviez-vous que ce n'est pas vraiment parfait, si vous mettez quoi que ce
— Gino
1
N'importe qui peut étendre ce reqex et donc les gens qui se plaignent n'ont aucun sens.
— Lecha Bisultanov
241

J'ai un peu simplifié la réponse de Lasnv.

Il corrige également le bogue décrit par WebDeb.

C'est ici:

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
}

Voici un lien regexer pour jouer avec: http://regexr.com/3dnqv

— mantish
source
2
juste un avertissement: cela ne doit être utilisé que lorsque vous savez que vous avez affaire à une URL YouTube. Je l'ai (à tort) utilisé pour vérifier les URL comme YouTube, ce qui a provoqué de faux positifs, par exemple, cela passe: 'v / 2059-9080-5437'
— fabi
3
J'utilise maintenant un Regex différent qui vérifie également un domaine youtube. Je ne sais pas si je dois mettre à jour la réponse car c'est un grand changement: /^.*(youtu.be\/|youtube(-nocookie)?.com\/(v\/|.*u\/\w \ / | embed \ / |. * v =)) ([\ w -] {11}). * /
— mantish
4
Quand YouTube passera-t-il à 12 caractères pour l'ID vidéo?
— Lenar Hoyt
le point dans "youtu.be" ne doit-il pas être échappé?
— Alex
vous avez raison @jitbit Merci. Bien que cela fonctionne généralement aussi bien sans y échapper.
— mantish
85

Aucun de ceux-ci ne fonctionnait sur l'évier de la cuisine au 1/1/2015, notamment les URL sans protocole http / s et avec le domaine youtube-nocookie. Voici donc une version modifiée qui fonctionne sur toutes ces différentes versions de 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
source
2
Il convient de noter que la plupart des solutions ci-dessus ne couvrent pas ce large lot d'URL valides, le script de test est très utile, +1!
— blended
2
Notez que cela sera trompé par quelque chose comme "www.engadget.com/watch?v=dQw4w9WgXcQ", pas que cela soit susceptible d'être un problème
— binaryfunt
Cela fonctionne, mais n'a pas pu résoudre le problème résultant d'un texte avec plusieurs URL YouTube Voir cette regex101.com/r/qK5qJ5/1 . Il ne doit pas remplacer la deuxième URL.
— Ashish
2
Si vous ne voulez pas qu'une ID vide corresponde : ^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]+).*(c'est-à-dire que youtube.com/watch?v= ne correspondra pas)
— zurfyx
Qu'entendez-vous par «aucun de ces éléments n'a fonctionné sur l'évier de la cuisine»?
— rmutalik
26 
/^.*(youtu.be\/|v\/|e\/|u\/\w+\/|embed\/|v=)([^#\&\?]*).*/

Testé sur:

  • 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

Inspiré par cette autre réponse .

— xronosiam
source
9
^. * (?: youtu.be \ / | v \ / | e \ / | u \ / \ w + \ / | embed \ / | v =) ([^ # \ & \?] *). * donnera vous le résultat dans le groupe 1
— Marc
20

Étant donné que YouTube a une variété de styles d'URL, je pense que Regex est une meilleure solution. Voici mon Regex:

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

Le groupe 3 a votre identifiant YouTube

Exemples d'URL YouTube (actuellement, y compris le "style d'URL intégré hérité") - le Regex ci-dessus fonctionne sur chacun d'eux: 

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

Pointe du chapeau à Lasnv

— jeffreypriebe
source
9
Vous devez vraiment retourner à la planche à dessin avec celui-ci. Oui, il correspond correctement aux URL ci-dessus. Mais elle correspond aussi à tort beaucoup d' autres chaînes non-youtube-url tels que: "domain.com/embed/file.txt", "/tv/"et "Has anyone seen my watch?". Voir: ma réponse à une question similaire pour une solution beaucoup plus précise.
— ridgerunner
1
Je vois votre point: l'expression régulière ci-dessus est inutile pour répondre à la question "Est-ce une URL YouTube?" mais ce n'était pas mon objectif. J'ai des URL YouTube - j'extrais simplement un identifiant. Oui, votre réponse est solide (et couvre un cas d'utilisation que le mien ne fait pas).
— jeffreypriebe
vous avez le même bogue que j'ai mentionné ci-dessus avec des identifiants commençant par un 'v'
— webstrap
Merci @WebDev - savez-vous si YouTube met jamais av dans l'ID (ou commence un ID avec un "v")?
— jeffreypriebe
1
Fonctionne toujours à ce jour (25/01/2013). En voici un exemple en action: jsfiddle.net/bcmoney/yBP4J
— bcmoney
17

J'ai créé une fonction qui teste une entrée utilisateur pour les identifiants intégrés Youtube, Soundcloud ou Vimeo, afin de pouvoir créer une conception plus continue avec des médias intégrés. Cette fonction détecte et retourne un objet avec deux propriétés: "type" et "id". Le type peut être "youtube", "vimeo" ou "soundcloud" et la propriété "id" est l'identifiant unique du média.

Sur le site, j'utilise un vidage de la zone de texte, où l'utilisateur peut coller n'importe quel type de lien ou de code d'intégration, y compris l'intégration iFrame de Vimeo et de 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
source
Bonne idée, mais cela ne fonctionne pas sur la grande majorité des formats d'URL. Y compris ne correspondant à aucun site https.
— NickG
13

Tard dans le jeu ici, mais j'ai mélangé deux excellentes réponses de mantish et jw. Tout d'abord, l'expression rationnelle modifiée:

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

Voici le code de test (j'ai ajouté les cas de test originaux de mantish aux plus méchants de 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');
  }

Version expérimentale pour gérer les URL m.youtube mentionnées dans les commentaires:

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

Il doit parsed[2]être changé parsed[3]en deux endroits dans les tests (qu'il passe ensuite avec des m.youtubeURL ajoutées aux tests). Faites-moi savoir si vous voyez des problèmes.

— podperson
source
1
Vous devez ajouter celui-ci dans votre combinaison de test car il était problématique et votre expression rationnelle l'a résolu pour moi: youtu.be/ve4f400859I . La lettre v a été supprimée dans mon expression rationnelle précédente
— Mark Odey
1
Je reçois un faux message car http://youtu.be/si j'ajoute le, /il le marque comme valide. L'utiliser dans(value) => /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/.test(value)
— Anima-t3d
Merci pour les commentaires. Je n'ai pas encore mis à jour mon exemple (je n'ai pas le temps de tester) donc toute personne utilisant mon code doit prendre note :-)
— podperson
Qu'en est-il de l'URL de type = m.youtube.com
— Mehul Thakkar
@MehulThakkar sont-ils par ailleurs similaires aux URL youtube.com?
— podperson
11

tl; dr.

Correspond à tous les exemples d'URL sur cette question, puis à certains.

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 sera toujours dans le groupe de correspondance 7.

Exemples en direct de toutes les URL que j'ai extraites des réponses à cette question: https://regexr.com/3u0d4

Explication complète:

Comme de nombreuses réponses / commentaires ont été évoqués, il existe de nombreux formats pour les URL de vidéos YouTube. Même plusieurs TLD où ils peuvent sembler être "hébergés".

Vous pouvez consulter la liste complète des variantes avec lesquelles j'ai vérifié en suivant le lien regexr ci-dessus.

Permet de décomposer le RegExp.

^Verrouillez la chaîne au début de la chaîne. (https?:\/\/)?Protocoles facultatifs http: // ou https: // Le ?rend l'élément précédent facultatif de sorte que les puis l'ensemble du groupe (tout ce qui est enfermé dans un ensemble de parenthèses) sont facultatifs.

Ok, cette partie suivante en est la viande. Fondamentalement, nous avons deux options, les différentes versions de www.youtube.com/...[id] et la version raccourcie de 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

Enfin, nous avons le groupe pour sélectionner l'ID vidéo. Au moins un caractère qui est un nombre, une lettre, un trait de soulignement ou un tiret.

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

Vous pouvez découvrir beaucoup plus de détails sur chaque partie de l'expression régulière en vous dirigeant sur le lien de l'expression régulière et en voyant comment chaque partie de l'expression correspond au texte de l'url.

— tsdorsey
source
10

La meilleure solution (de 2019-2020) que j'ai trouvée est que:

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

Je l'ai trouvé ici .

/*
* 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
source
TypeScript: const youTubeGetID = (url: string) => {const [a,, b] = url .replace (/ (> | <) / gi, '') .split (/ (vi \ / | v = | \ /v\/|youtu\.be\/|\/embed\/)/); if (b! == indéfini) {return b.split (/ [^ 0-9a-z _-] / i) [0]; } else {return a; }};
— Vlad
échoue pour v = nfDGK_WSFro
— Deen John
6

Étant donné que les identifiants vidéo YouTube sont définis sur 11 caractères , nous pouvons simplement substringaprès avoir divisé l'URL avec v=. Ensuite, nous ne dépendons pas de l'esperluette à la fin.

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

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

Agréable et simple :)

— marque
source
Celui-ci est littéralement un double de la réponse acceptée
— brasofilo
5

J'ai résumé toutes les suggestions et voici la réponse universelle et courte à cette question:

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

Code Java: (Fonctionne pour toutes les 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));

    }

Pour 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
source
1
Supprimez les guillemets doubles autour du modèle Regex dans le code JavaScript et cela devrait fonctionner.
— TheDude
4

Version légèrement plus stricte:

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

Testé sur:

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

Vous pouvez utiliser le code suivant pour obtenir l'ID de vidéo YouTube à partir d'une 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
source
J'ai eu des problèmes avec tous les autres exemples d'expressions régulières, mais celui-ci fonctionne efficacement sur les 3 options de partage utilisées par les utilisateurs sur les ordinateurs de bureau. une URL de la barre d'adresse, une URL du bouton de partage et une URL du bouton de partage en ligne. Merci!!!
— Maarten
2

Une version légèrement modifiée de la seule mantish publiée:

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

Cela suppose que le code comporte toujours 11 caractères. J'utilise ceci dans ActionScript, je ne sais pas si {11,11} est pris en charge en Javascript. Ajout de la prise en charge de & v = .... (juste au cas où)

— Josha
source
c'était le seul qui fonctionnait pour une URL avec laquelle je testais
— Dominic
parfait. merci @Josha 69 link combination je teste tout fonctionne pour moi.
— gokhan
2

Un de plus:

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

Cela fonctionne avec n'importe quelle URL affichée dans ce fil.

Cela ne fonctionnera pas lorsque YouTube ajoute un autre paramètre avec 11 caractères base64. Jusque-là, c'est la voie facile.

— pykiss
source
2

J'ai fait une petite fonction pour extraire l'identifiant vidéo d'une URL Youtube qui peut être vue ci-dessous.

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'));
Développer l'extrait

Cette fonction extraira l'identifiant vidéo même s'il y a plusieurs paramètres dans l'url.

— Jake
source
2

Cela peut obtenir l'identifiant vidéo de tout type de liens 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
source
1

J'ai aimé la réponse de Surya .. Juste un cas où cela ne fonctionnera pas ...

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

ne fonctionne pas pour

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

Version mise à jour:

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

fonctionne pour tous.

— user2200660
source
1

Essaye celui-là - 

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

Exemple de nettoyeur Chris Nolet de réponse Lasnv est très bon, mais j'ai récemment découvert que si vous essayez de trouver votre lien youtube dans du texte et de mettre du texte aléatoire après l'url youtube, l'expression rationnelle correspond bien plus que nécessaire. Amélioration de la réponse de Chris Nolet:

/^.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]{11,11}).*/
Développer l'extrait

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

Pour tester:

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

Eh bien, la façon de le faire avec une analyse simple serait: obtenir tout en commençant après le premier signe = au premier signe & .

Je pense qu'ils ont eu une réponse similaire ici:

Analyser un ID Vimeo à l'aide de JavaScript?

— karlphillip
source
2
Et si l'URL ne contient pas &?
— Adam
Ensuite, vous devez trouver quel est le délimiteur équivalent. Par exemple, la première URL que vous nous avez donnée est le signe &. Sur la deuxième URL, la fin de la chaîne est le délimiteur.
— karlphillip
0

Nous savons que ces caractères "? V =" ne peuvent jamais apparaître plus d'un, mais "v" peut apparaître d'une manière ou d'une autre dans l'Id lui-même, nous utilisons donc "? V =" comme délimiteur. Voyez-le travailler ici 

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

Regex simple si vous avez l'URL complète, restez simple.

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

j'espère que ça peut aider

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

Le plus court et le plus efficace

— Wasim A.
source
pas bien, échoue vs youtube.com/e/dQw4w9WgXcQ alors veuillez retirer la partie efficace :)
— alecellis1985
0

Comme webstrap l'a mentionné dans un commentaire :

Cela a fonctionné si la vidéo commence par "v" et qu'elle provient de youtu.be

Le regex contient un petit bug qui \??v?=?devrait juste être au niveau de la montre, sinon vous filtreriez a 'v'si l'id commence par a 'v'. donc cela devrait faire l'affaire

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

— Shuher
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.