Como obtenho o ID do vídeo do YouTube a partir de um URL?

257

Quero obter o v=idURL do YouTube com JavaScript (sem jQuery, JavaScript puro).

Exemplos de formatos de URL do YouTube

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

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

Ou qualquer outro formato do YouTube que contenha um ID de vídeo no URL.

Resultado desses formatos

u8nQa1cJyX8

— Adão
fonte

1

possível duplicado de valor do parâmetro Extrato de url usando expressões regulares

— Mark Byers

Essa pergunta é apenas para formatos como o meu segundo. Mas encontrei uma resposta interessante lá, obrigado por compartilhá-la.

— Adam

Há uma expressão regular para isso: http://pregcopy.com/exp/27

— Exos 15/07/12

Não posso aceitar nenhum crédito por isso, mas achei isso bastante extenso: gist.github.com/FinalAngel/1876898 . Ele ainda captura URLs tão diversos quanto youtube.com/watch?feature=player_embedded&v=1p3vcRhsYGo e youtube.com/v/1p3vcRhsYGo

— Simon

2

A partir de 2015: pule para esta resposta . As outras respostas estão desatualizadas.

— Lenar Hoyt 13/10/2015

109

Você não precisa usar uma expressão regular para isso.

var video_id = window.location.search.split('v=')[1];
var ampersandPosition = video_id.indexOf('&');
if(ampersandPosition != -1) {
  video_id = video_id.substring(0, ampersandPosition);
}

— Jacob Relkin
fonte

essa é uma função útil para fazê-la funcionar onde você deseja com base nesse código. var video_url = ' youtube.com/watch?v=eOrNdBpGMv8&feature=youtube_gdata '; ytid (video_url); função 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); } alerta (video_id); retornar video_id; }

— Gino

9

não lida com URLs embutidos

— Serge

14

Também não manipula 'share' gerado urls-https://youtu.be/{{video_id}}

— hamncheez

2

Esse regex funciona bem com o compartilhamento do YouTube e o URL de exibição.

url='https://youtu.be/{{video_id}}'; url.match(/(?:https?:\/{2})?(?:w{3}\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\?v=|\/)([^\s&]+)/);

— Dipten

410

Fiz um aprimoramento no Regex fornecido por "jeffreypriebe", porque ele precisava de um tipo de URL do YouTube, que é o URL dos vídeos quando eles estão visualizando através de um canal.

Bem, não, mas esta é a função que eu armei.

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

Estes são os tipos de URLs suportados

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

Pode ser encontrado em [http://web.archive.org/web/20160926134334/] http://lasnv.net/foro/839/Javascript_parsear_URL_de_YouTube

— Lasnv
fonte

6

O regex contém um pequeno bug \ ?? v? =? isso deve estar apenas na parte do relógio, caso contrário, você filtraria um 'v' se o ID começar com um 'v'. então isso deve funcionar /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\??v? =?)) ([^ # \ & \?] *). * /

— webstrap

69

Ainda mais limpo: /.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]*).*/ use em match[1]vez de match[7](o que me pareceu um pouco arbitrário). Também corrige o erro apontado pelo WebDev.

— 22612 Chris Nolet

3

Quanto tempo até os IDs do YouTube terem 12 caracteres?

— Lenar Hoyt 13/10/2015

1

Você sabia que ele não está realmente perfeito, se você colocar anything.com/watch?v=jn40gqhxoSY Ele acha que é uma url youtube

— Gino

1

Qualquer um pode estender esse reqex e, portanto, as pessoas reclamando não fazem nenhum sentido.

— Lecha Bisultanov 07/12/19

241

Simplifiquei um pouco a resposta de Lasnv.

Também corrige o bug descrito pelo WebDeb.

Aqui está:

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
}

Aqui está um link regexer para jogar: http://regexr.com/3dnqv

— manjar
fonte

2

apenas um aviso: isso só deve ser usado quando você sabe que está lidando com um URL do YouTube. I (indevidamente) é usado para verificar URLs como youtube, o que causou falsos positivos, por exemplo, este passa: 'v / 2059-9080-5437'

— fabi

3

Estou usando agora um Regex diferente que também verifica um domínio do youtube. Não tenho certeza se devo atualizar a resposta, pois é uma grande mudança: /^.*(youtu.be\/|youtube(-nocookie)?.com\/(v\/|.*u\/\w \ / | embed \ / |. * v =)) ([\ w -] {11}). * /

— mantish

4

Quando o YouTube mudará para 12 caracteres para o ID do vídeo?

— Lenar Hoyt 13/10/2015

o ponto em "youtu.be" não deveria ser escapado?

— Alex #

você está certo @jitbit Obrigado. Embora geralmente funcione bem sem escapar.

— mantish

85

Nenhum deles funcionou na pia da cozinha a partir de 1/1/2015, principalmente URLs sem http / se protocal e com domínio youtube-nocookie. Então, aqui está uma versão modificada que funciona em todas essas várias versões do Youtube:

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

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

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

for (i = 0; i < urls.length; ++i) {
    r = urls[i].match(rx);
    console.log(r[1]);
}

— JW
fonte

2

Vale ressaltar que muitas das soluções acima não cobrem esse amplo lote de URLs válidos, o script de teste é muito útil, +1!

— blended

2

Note-se que esta será enganado por algo como "www.engadget.com/watch?v=dQw4w9WgXcQ", não que isso é provável que seja um problema embora

— binaryfunt

Funciona, mas não foi possível corrigir o problema decorrente de um texto com vários URLs do youtube. Veja este regex101.com/r/qK5qJ5/1 . Não deve substituir o segundo URL.

— Ashish

2

Se você não quer que um vazio partidas ID : ^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]+).*(ie youtube.com/watch?v= não irá corresponder)

— zurfyx

O que você quer dizer com "Nada disso funcionou na pia da cozinha"?

— rmutalik

26

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

Testado em:

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

Inspirado por essa outra resposta .

— xronosiam
fonte

9

^. * (?: youtu.be \ / | v \ / | e \ / | u \ / \ w + \ / | embed \ / | v =) ([^ # \ & \?] *). * dará você o resultado no grupo 1

— Marc

20

Dado que o YouTube tem uma variedade de estilos de URL, acho que o Regex é uma solução melhor. Aqui está o meu Regex:

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

O grupo 3 tem seu ID do YouTube

Exemplos de URLs do YouTube (atualmente, incluindo "estilo de URL incorporado herdado") - o Regex acima funciona em todos eles:

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

Gorjeta de chapéu para Lasnv

— jeffreypriebe
fonte

9

Você realmente precisa voltar para a prancheta com esta. Sim, ele corresponde aos URLs acima corretamente. Mas também corresponde erroneamente muitas outras cordas não-youtube-url, tais como: "domain.com/embed/file.txt", "/tv/"e "Has anyone seen my watch?". Veja: minha resposta a uma pergunta semelhante para uma solução muito mais precisa.

— precisa saber é o seguinte

1

Entendo o seu argumento: a regex acima é inútil para responder à pergunta "Este é um URL do YouTube?" mas esse não era meu objetivo. Eu tenho URLs do YouTube - estou apenas extraindo um ID. Sim, sua resposta é sólida (e abrange um caso de uso que o meu não).

— 51111 jeffreypriebe

você tem o mesmo bug que eu mencionei acima com os IDs começando com um 'v'

— webstrap

Obrigado @WebDev - você sabe se o YouTube coloca um av no ID (ou inicia um ID com um "v")?

— jeffreypriebe

1

Ainda funciona a partir de hoje (25/01/2013). Aqui está um exemplo disso em ação: jsfiddle.net/bcmoney/yBP4J

— bcmoney

17

Criei uma função que testa as entradas de usuários para o YouTube, o Soundcloud ou o Vimeo incorporam IDs, para poder criar um design mais contínuo com a mídia incorporada. Esta função detecta e retorna um objeto com duas propriedades: "type" e "id". O tipo pode ser "youtube", "vimeo" ou "soundcloud" e a propriedade "id" é o ID de mídia exclusivo.

No site, uso um despejo de área de texto, onde o usuário pode colar qualquer tipo de link ou código de incorporação, incluindo a incorporação por iFrame do vimeo e do youtube.

function testUrlForMedia(pastedData) {
var success = false;
var media   = {};
if (pastedData.match('http://(www.)?youtube|youtu\.be')) {
    if (pastedData.match('embed')) { youtube_id = pastedData.split(/embed\//)[1].split('"')[0]; }
    else { youtube_id = pastedData.split(/v\/|v=|youtu\.be\//)[1].split(/[?&]/)[0]; }
    media.type  = "youtube";
    media.id    = youtube_id;
    success = true;
}
else if (pastedData.match('http://(player.)?vimeo\.com')) {
    vimeo_id = pastedData.split(/video\/|http:\/\/vimeo\.com\//)[1].split(/[?&]/)[0];
    media.type  = "vimeo";
    media.id    = vimeo_id;
    success = true;
}
else if (pastedData.match('http://player\.soundcloud\.com')) {
    soundcloud_url = unescape(pastedData.split(/value="/)[1].split(/["]/)[0]);
    soundcloud_id = soundcloud_url.split(/tracks\//)[1].split(/[&"]/)[0];
    media.type  = "soundcloud";
    media.id    = soundcloud_id;
    success = true;
}
if (success) { return media; }
else { alert("No valid media id detected"); }
return false;
}

— Joakim
fonte

Boa ideia, mas não funciona na grande maioria dos formatos de URL. Incluindo a não correspondência em sites https.

— 25917 NickG

13

Tarde para o jogo aqui, mas juntei duas excelentes respostas de mantish e jw. Primeiro, o regex modificado:

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

Aqui está o código de teste (eu adicionei os casos de teste originais do mantish aos mais desagradáveis do 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');
  }

Versão experimental para lidar com os URLs do m.youtube mencionados nos comentários:

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

Ele precisa parsed[2]ser alterado para parsed[3]em dois locais nos testes (que passam com os m.youtubeURLs adicionados aos testes). Deixe-me saber se você encontrar problemas.

— podperson
fonte

1

Você deve adicionar este no seu traje de teste, pois era problemático e seu regexp o resolveu para mim: youtu.be/ve4f400859I . A letra v foi arrancada no meu regexp anterior

— Mark Odey

1

Eu recebo postive falso, http://youtu.be/se eu adicionar o /que marca como válido. Utilizando-o em(value) => /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/.test(value)

— Anima-t3d 5/09/18

Obrigado pelos comentários. Eu não atualizei meu exemplo ainda (não têm tempo para teste) para que qualquer pessoa usando o meu código por favor, tome nota :-)

— podperson

que tal url do tipo = m.youtube.com

— Mehul Thakkar

@MehulThakkar são semelhantes aos URLs do youtube.com?

— precisa saber é

11

tl; dr.

Corresponde a todos os exemplos de URL nesta questão e mais alguns.

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

O ID estará sempre no grupo de correspondência 7.

Exemplos ao vivo de todos os URLs que peguei nas respostas a esta pergunta: https://regexr.com/3u0d4

Explicação completa:

Como muitas respostas / comentários surgiram, existem muitos formatos para URLs de vídeo do youtube. Até vários TLDs em que eles podem parecer "hospedados".

Você pode ver a lista completa de variações contra as quais eu verifiquei, seguindo o link regexr acima.

Vamos quebrar o RegExp.

^Bloqueie a string no início da string. (https?:\/\/)?Protocolos opcionais http: // ou https: // ?Torna o item anterior opcional para que stodo o grupo (qualquer coisa entre parênteses) entre parênteses seja opcional.

Ok, esta próxima parte é a carne disso. Basicamente, temos duas opções, as várias versões do www.youtube.com/...[id] e o link abreviado 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

Finalmente, temos o grupo para selecionar o ID do vídeo. Pelo menos um caractere que é um número, letra, sublinhado ou traço.

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

Você pode descobrir muito mais detalhes sobre cada parte da regex, encabeçando o link regexr e vendo como cada parte da expressão corresponde ao texto no URL.

— tsdorsey
fonte

10

A melhor solução (de 2019-2020) que encontrei é a seguinte:

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

Encontrei aqui .

/*
* Tested URLs:
var url = 'http://youtube.googleapis.com/v/4e_kz79tjb8?version=3';
url = 'https://www.youtube.com/watch?feature=g-vrec&v=Y1xs_xPb46M';
url = 'http://www.youtube.com/watch?feature=player_embedded&v=Ab25nviakcw#';
url = 'http://youtu.be/Ab25nviakcw';
url = 'http://www.youtube.com/watch?v=Ab25nviakcw';
url = '<iframe width="420" height="315" src="http://www.youtube.com/embed/Ab25nviakcw" frameborder="0" allowfullscreen></iframe>';
url = '<object width="420" height="315"><param name="movie" value="http://www.youtube-nocookie.com/v/Ab25nviakcw?version=3&amp;hl=en_US"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube-nocookie.com/v/Ab25nviakcw?version=3&amp;hl=en_US" type="application/x-shockwave-flash" width="420" height="315" allowscriptaccess="always" allowfullscreen="true"></embed></object>';
url = 'http://i1.ytimg.com/vi/Ab25nviakcw/default.jpg';
url = 'https://www.youtube.com/watch?v=BGL22PTIOAM&feature=g-all-xit';
url = 'BGL22PTIOAM';
*/

— Vlad
fonte

TypeScript: const youTubeGetID = (url: string) => {const [a,, b] = url .replace (/ (> | <) / gi, '') .split (/ (vi \ / | v = | \ /v\/|youtu\.be\/|\/embed\/)/); if (b! == indefinido) {return b.split (/ [^ 0-9a-z _-] / i) [0]; } else {retornar a; }};

— Vlad

Falha para v = nfDGK_WSFro

— Deen John

6

Como os IDs de vídeo do YouTube estão definidos para 11 caracteres , podemos simplesmente logo substringapós dividirmos o URL v=. Então não somos dependentes do e comercial no final.

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

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

Agradável e simples :)

— Marca
fonte

Este é literalmente um duplicado da resposta aceita

— brasofilo

5

Resumi todas as sugestões e aqui está a resposta universal e curta a esta pergunta:

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

— romaninsh
fonte

5

Código Java: (Funciona para todos os URLs:

)

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

    }

Para DailyMotion:

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

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

    }

— surya
fonte

1

Remova as aspas duplas ao redor do padrão Regex no código JavaScript e deve funcionar.

— TheDude 27/05

4

Versão ligeiramente mais rigorosa:

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

Testado em:

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

— m4tx
fonte

4

Você pode usar o código a seguir para obter o ID do vídeo do YouTube a partir de um URL:

url = "https://www.youtube.com/watch?v=qeMFqkcPYcg"
VID_REGEX = /(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/
alert(url.match(VID_REGEX)[1]);

— K. Ayoub
fonte

Eu tive problemas com todos os outros exemplos de regex, mas este funciona efetivamente nas 3 opções de compartilhamento que as pessoas nos desktops usam. um URL da barra de endereço, um URL do botão de compartilhamento e um URL do botão de compartilhamento embutido. Obrigado!!!

— Maarten

2

Uma versão ligeiramente alterada da mantish postada:

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

Isso pressupõe que o código tenha sempre 11 caracteres. Estou usando isso no ActionScript, não tenho certeza se {11,11} é suportado em Javascript. Também foi adicionado suporte para & v = .... (apenas no caso)

— Josha
fonte

esse foi o único que funcionou para um URL que eu estava testando: youtube.com/watch?feature=player_embedded&v=0zM3nApSvMg

— Dominic

perfeito. obrigado @Josha 69 combinação de links eu testei tudo foi trabalhado para mim.

— Gokhan

2

Definitivamente, isso requer regex:

Copie para Ruby IRB:

var url = "http://www.youtube.com/watch?v=NLqASIXrVbY"
var VID_REGEX = /(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/
url.match(VID_REGEX)[1]

Consulte para todos os casos de teste: https://gist.github.com/blairanderson/b264a15a8faaac9c6318

— Blair Anderson
fonte

2

Mais um:

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

Funciona com qualquer URL mostrado neste tópico.

Não funcionará quando o YouTube adicionar outro parâmetro com 11 caracteres base64. Até então, é o caminho mais fácil.

— pykiss
fonte

2

Eu criei uma pequena função para extrair o ID do vídeo de um URL do Youtube, que pode ser visto abaixo.

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

Expandir snippet

Essa função extrairá o ID do vídeo, mesmo que haja vários parâmetros no URL.

— Jake
fonte

2

Isso pode obter o ID do vídeo a partir de qualquer tipo de link 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
fonte

1

Gostei da resposta da Surya .. Apenas um caso em que não vai funcionar ...

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

não funciona para

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

versão atualizada:

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

funciona para todos.

— user2200660
fonte

1

Tente este -

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

  return isset($matches[1]) ? $matches[1] : false;
}

— Rohit Suthar
fonte

1

O exemplo mais limpo de Chris Nolet da resposta Lasnv é muito bom, mas recentemente descobri que se você está tentando encontrar o link do youtube no texto e colocar algum texto aleatório após o URL do youtube, o regexp corresponde muito mais do que o necessário. Resposta melhorada de Chris Nolet:

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

Expandir snippet

— mindaug
fonte

1

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

Para teste:

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

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

— Agafonov
fonte

0

Bem, a maneira de fazer isso com a análise simples seria: começar tudo depois do primeiro sinal = para o primeiro & sinal.

Eu acho que eles tiveram uma resposta semelhante aqui:

Analisando um ID do Vimeo usando JavaScript?

— karlphillip
fonte

2

E se o URL não contiver &?

— Adam

Então você deve encontrar qual é o delimitador equivalente. Por exemplo, o primeiro URL que você nos deu é o sinal &. No segundo URL, o final da sequência é o delimitador.

— karlphillip

0

Sabemos que esses caracteres "? V =" nunca podem aparecer mais que um, mas 'v' pode aparecer de alguma forma no próprio Id, então usamos "? V =" como delimitador. Veja trabalhando aqui

//Get YouTube video Id From Its Url

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

});

<button>Click ToGet VideoId</button>

— ShapCyber
fonte

0

Regex simples, se você tiver o URL completo, mantenha-o simples.

results = url.match("v=([a-zA-Z0-9]+)&?")
videoId = results[1] // watch you need.

— Gubatron
fonte

0

var video_url = document.getElementById('youtubediv').value;
        if(video_url!=""){
        ytid(video_url);
        document.getElementById("youtube").setAttribute("src","http://www.youtube.com/embed/"+ytid(video_url));
        }
        function ytid(video_url){
            var video_id = video_url.split('v=')[1];
            var ampersandPosition = video_id.indexOf('&');
            if(ampersandPosition != -1) {
                video_id = video_id.substring(0, ampersandPosition);
            }
            return video_id;
        }

espero que possa ajudar

— Roderick Domondon
fonte

0

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

Menor e eficiente

— Wasim A.
fonte

não é certo, não vs youtube.com/e/dQw4w9WgXcQ então por favor tire a parte eficiente :)

— alecellis1985

0

Como webstrap mencionado em um comentário :

Funcionou se o vídeo começar com "v" e for de youtu.be

O regex contém um pequeno bug, que \??v?=?deve estar apenas na parte do relógio, caso contrário, você filtraria a 'v'se o id começar com a 'v'. então isso deve fazer o truque

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

— Shuher
fonte