Jeśli mam adres URL filmu na YouTube, czy jest jakiś sposób na użycie PHP i cURL, aby uzyskać powiązaną miniaturę z API YouTube?

Każdy film na YouTube ma cztery wygenerowane obrazy. Można je sformatować w następujący sposób:

https://img.youtube.com/vi/<insert-youtube-video-id-here>/0.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/1.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/2.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/3.jpg

Pierwszy na liście to obraz w pełnym rozmiarze, a pozostałe to miniatury. Domyślna miniatura (czyli jeden z 1.jpg, 2.jpg, 3.jpg) to:

https://img.youtube.com/vi/<insert-youtube-video-id-here>/default.jpg

W przypadku wysokiej jakości wersji miniatury użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg

Istnieje również wersja miniatury o średniej jakości, wykorzystująca adres URL podobny do centrali:

https://img.youtube.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg

W wersji miniatury w standardowej rozdzielczości użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/<insert-youtube-video-id-here>/sddefault.jpg

W wersji miniatury o maksymalnej rozdzielczości użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg

Wszystkie powyższe adresy URL są również dostępne przez HTTP. Ponadto nieco krótsza nazwa hosta i3.ytimg.comdziała zamiast img.youtube.comw przykładowych adresach URL powyżej.

Alternatywnie możesz użyć interfejsu YouTube Data API (v3), aby uzyskać miniatury.

Możesz użyć YouTube Data API do pobierania miniatur wideo, podpisów, opisów, ocen, statystyk i innych. Wersja API 3 wymaga klucza *. Zdobądź klucz i utwórz film: prośba o listę :

https://www.googleapis.com/youtube/v3/videos?key=YOUR_API_KEY&part=snippet&id=VIDEO_ID

Przykładowy kod PHP

$data = file_get_contents("https://www.googleapis.com/youtube/v3/videos?key=YOUR_API_KEY&part=snippet&id=T0Jqdjbed40");
$json = json_decode($data);
var_dump($json->items[0]->snippet->thumbnails);

Wynik

object(stdClass)#5 (5) {
  ["default"]=>
  object(stdClass)#6 (3) {
    ["url"]=>
    string(46) "https://i.ytimg.com/vi/T0Jqdjbed40/default.jpg"
    ["width"]=>
    int(120)
    ["height"]=>
    int(90)
  }
  ["medium"]=>
  object(stdClass)#7 (3) {
    ["url"]=>
    string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/mqdefault.jpg"
    ["width"]=>
    int(320)
    ["height"]=>
    int(180)
  }
  ["high"]=>
  object(stdClass)#8 (3) {
    ["url"]=>
    string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/hqdefault.jpg"
    ["width"]=>
    int(480)
    ["height"]=>
    int(360)
  }
  ["standard"]=>
  object(stdClass)#9 (3) {
    ["url"]=>
    string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/sddefault.jpg"
    ["width"]=>
    int(640)
    ["height"]=>
    int(480)
  }
  ["maxres"]=>
  object(stdClass)#10 (3) {
    ["url"]=>
    string(52) "https://i.ytimg.com/vi/T0Jqdjbed40/maxresdefault.jpg"
    ["width"]=>
    int(1280)
    ["height"]=>
    int(720)
  }
}

* Nie tylko potrzebujesz klucza, ale możesz zostać poproszony o podanie informacji rozliczeniowych w zależności od liczby żądań interfejsu API, które planujesz złożyć. Jednak kilka milionów żądań dziennie jest bezpłatnych.

Artykuł źródłowy .

To, co powiedział Asaph, ma rację. Jednak nie każdy film na YouTube zawiera wszystkie dziewięć miniatur. Rozmiary obrazów miniatur zależą również od filmu wideo (poniższe liczby dotyczą jednego).

Gwarantowanych jest siedem miniatur:

| Thumbnail Name      | Size (px) | URL                                              |
|---------------------|-----------|--------------------------------------------------|
| Player Background   | 480x360   | https://i1.ytimg.com/vi/<VIDEO ID>/0.jpg         |
| Start               | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/1.jpg         |
| Middle              | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/2.jpg         |
| End                 | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/3.jpg         |
| High Quality        | 480x360   | https://i1.ytimg.com/vi/<VIDEO ID>/hqdefault.jpg |
| Medium Quality      | 320x180   | https://i1.ytimg.com/vi/<VIDEO ID>/mqdefault.jpg |
| Normal Quality      | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/default.jpg   |

Ponadto dwie pozostałe miniatury mogą, ale nie muszą istnieć. Ich obecność prawdopodobnie zależy od tego, czy wideo jest wysokiej jakości.

| Thumbnail Name      | Size (px) | URL                                                  |
|---------------------|-----------|------------------------------------------------------|
| Standard Definition | 640x480   | https://i1.ytimg.com/vi/<VIDEO ID>/sddefault.jpg     |
| Maximum Resolution  | 1920x1080 | https://i1.ytimg.com/vi/<VIDEO ID>/maxresdefault.jpg |

Możesz znaleźć skrypty JavaScript i PHP do pobierania miniatur i innych informacji z YouTube w:

• Jak uzyskać informacje o filmie YouTube z PHP
• Pobierz szczegóły filmu z YouTube za pomocą JavaScript - JSON i API v2

Możesz także użyć narzędzia YouTube Video Generator informacji , aby uzyskać wszystkie informacje o filmie YouTube, przesyłając adres URL lub identyfikator filmu.

W interfejsie API YouTube V3 możemy również używać tych adresów URL do uzyskiwania miniatur ... Są one klasyfikowane na podstawie ich jakości.

https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/default.jpg -   default
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg - medium 
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg - high
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/sddefault.jpg - standard

I dla maksymalnej rozdzielczości ..

https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg

Zaletą tych adresów URL w porównaniu z adresami URL w pierwszej odpowiedzi jest to, że te adresy URL nie są blokowane przez zapory ogniowe.

Jeśli chcesz mieć największy obraz z YouTube dla określonego identyfikatora wideo, adres URL powinien wyglądać mniej więcej tak:

http://i3.ytimg.com/vi/SomeVideoIDHere/0.jpg

Korzystając z interfejsu API, możesz wybrać domyślny obraz miniatury. Prosty kod powinien wyglądać mniej więcej tak:

//Grab the default thumbnail image
$attrs = $media->group->thumbnail[1]->attributes();
$thumbnail = $attrs['url'];
$thumbnail = substr($thumbnail, 0, -5);
$thumb1 = $thumbnail."default.jpg";

// Grab the third thumbnail image
$thumb2 = $thumbnail."2.jpg";

// Grab the fourth thumbnail image.
$thumb3 = $thumbnail."3.jpg";

// Using simple cURL to save it your server.
// You can extend the cURL below if you want it as fancy, just like
// the rest of the folks here.

$ch = curl_init ("$thumb1");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_BINARYTRANSFER,1);
$rawdata = curl_exec($ch);
curl_close($ch);

// Using fwrite to save the above
$fp = fopen("SomeLocationInReferenceToYourScript/AnyNameYouWant.jpg", 'w');

// Write the file
fwrite($fp, $rawdata);

// And then close it.
fclose($fp);

Jeśli chcesz pozbyć się „czarnych pasków” i zrobić to tak, jak robi to YouTube, możesz użyć:

https://i.ytimg.com/vi_webp/<video id>/mqdefault.webp

A jeśli nie możesz użyć .webprozszerzenia pliku, możesz to zrobić w następujący sposób:

https://i.ytimg.com/vi/<video id>/mqdefault.jpg

Ponadto, jeśli potrzebujesz wersji nieskalowanej, użyj maxresdefaultzamiast mqdefault.

Uwaga: nie jestem pewien proporcji, jeśli planujesz użyć maxresdefault.

Stworzyłem funkcję pobierania tylko istniejących obrazów z YouTube

function youtube_image($id) {
    $resolution = array (
        'maxresdefault',
        'sddefault',
        'mqdefault',
        'hqdefault',
        'default'
    );

    for ($x = 0; $x < sizeof($resolution); $x++) {
        $url = '//img.youtube.com/vi/' . $id . '/' . $resolution[$x] . '.jpg';
        if (get_headers($url)[0] == 'HTTP/1.0 200 OK') {
            break;
        }
    }
    return $url;
}

W YouTube Data API v3 można uzyskać miniatury wideo za pomocą funkcji wideo-> lista . Od snippet.thumbnails. (Klucz) możesz wybrać domyślną miniaturę o średniej lub wysokiej rozdzielczości oraz uzyskać jej szerokość, wysokość i adres URL.

Możesz także aktualizować miniatury za pomocą zestawu miniaturek> .

Na przykład możesz sprawdzić projekt YouTube API Samples . ( PHP ).

Możesz uzyskać wpis wideo, który zawiera adres URL miniatury filmu. W linku znajduje się przykładowy kod. Lub, jeśli chcesz parsować XML, znajdziesz tutaj informacje . Zwrócony XML zawiera media:thumbnailelement, który zawiera adres URL miniatury.

// Get image form video URL
$url = $video['video_url'];

$urls = parse_url($url);

//Expect the URL to be http://youtu.be/abcd, where abcd is the video ID
if ($urls['host'] == 'youtu.be') :

    $imgPath = ltrim($urls['path'],'/');

//Expect the URL to be http://www.youtube.com/embed/abcd
elseif (strpos($urls['path'],'embed') == 1) :

    $imgPath = end(explode('/',$urls['path']));

//Expect the URL to be abcd only
elseif (strpos($url,'/') === false):

    $imgPath = $url;

//Expect the URL to be http://www.youtube.com/watch?v=abcd
else :

    parse_str($urls['query']);

    $imgPath = $v;

endif;

YouTube jest własnością Google, a Google lubi mieć rozsądną liczbę obrazów dla różnych rozmiarów ekranu, dlatego jego obrazy są przechowywane w różnych rozmiarach. Oto przykład tego, jak będzie wyglądać Twoja miniatura:

Miniatura niskiej jakości:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/sddefault.jpg

Miniatura średniej jakości:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/mqdefault.jpg

Miniatura wysokiej jakości:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/hqdefault.jpg

Miniatura najwyższej jakości:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/maxresdefault.jpg

YouTube API wersja 3 uruchomiona i uruchomiona za 2 minuty

Jeśli wszystko, co chcesz zrobić, to przeszukać YouTube i uzyskać powiązane właściwości:

1. Uzyskaj publiczny interfejs API - ten link daje dobry kierunek

2. Użyj poniższego ciągu zapytania. Wyszukiwane (oznaczone P = ) w ciągu URL jest StackOverflow dla celów przykładowych. YouTube prześle następnie odpowiedź JSON, w której można przeanalizować miniaturę, fragment kodu, autora itp.

   https://www.googleapis.com/youtube/v3/search?part=id%2Csnippet&maxResults=50&q=stackoverflow&key=YOUR_API_KEY_HERE

Inną dobrą alternatywą byłoby użycie oEmbed interfejsu API obsługiwanego przez YouTube.

Po prostu dodajesz adres URL YouTube do adresu URL oEmbed, a otrzymasz JSON zawierający miniaturę i kod HTML do osadzenia.

Przykład:

http://www.youtube.com/oembed?format=json&url=http%3A//youtube.com/watch%3Fv%3DxUeJdWYdMmQ

Dałby ci:

{
  "height":270,
  "width":480,
  "title":"example video for 2020",
  "thumbnail_width":480,
  "html":"...",
  "thumbnail_height":360,
  "version":"1.0",
  "provider_name":"YouTube",
  "author_url":"https:\/\/www.youtube.com\/channel\/UCza6VSQUzCON- AzlsrOLwaA",
  "thumbnail_url":"https:\/\/i.ytimg.com\/vi\/xUeJdWYdMmQ\/hqdefault.jpg",
  "author_name":"Pokics",
  "provider_url":"https:\/\/www.youtube.com\/",
  "type":"video"
}

Przeczytaj dokumentację, aby uzyskać więcej informacji .

Posługiwać się:

https://www.googleapis.com/youtube/v3/videoCategories?part=snippet,id&maxResults=100&regionCode=us&key=**Your YouTube ID**

Powyżej znajduje się link. Korzystając z tego, możesz znaleźć cechy YouTube filmów. Po znalezieniu cech można uzyskać filmy z wybranej kategorii. Następnie możesz znaleźć wybrane obrazy wideo, korzystając z odpowiedzi Asapha .

Wypróbuj powyższe podejście i możesz przeanalizować wszystko z interfejsu API YouTube .

Użyłem miniaturek YouTube w ten sposób:

$url = 'http://img.youtube.com/vi/' . $youtubeId . '/0.jpg';
$img = dirname(__FILE__) . '/youtubeThumbnail_'  . $youtubeId . '.jpg';
file_put_contents($img, file_get_contents($url));

Pamiętaj, że YouTube uniemożliwia dołączanie zdjęć bezpośrednio z ich serwera.

Znalazłem to fajne narzędzie, które pozwala utworzyć obraz z przyciskiem odtwarzania YouTube umieszczonym nad obrazem:

• Zainstalowany na serwerze do skryptów: https://github.com/halgatewood/youtube-thumbnail-enhancer

Aby dodać / rozwinąć podane rozwiązania, uważam, że należy zauważyć, że ponieważ sam miałem ten problem, faktycznie można pobrać wiele filmów z YouTube'a, w tym przypadku miniatur, z jednym żądaniem HTTP:

Korzystając z Rest Client, w tym przypadku HTTPFUL, możesz zrobić coś takiego:

<?php
header("Content-type", "application/json");

//download the httpfull.phar file from http://phphttpclient.com
include("httpful.phar");

$youtubeVidIds= array("nL-rk4bgJWU", "__kupr7KQos", "UCSynl4WbLQ", "joPjqEGJGqU", "PBwEBjX3D3Q");


$response = \Httpful\Request::get("https://www.googleapis.com/youtube/v3/videos?key=YourAPIKey4&part=snippet&id=".implode (",",$youtubeVidIds)."")

->send();

print ($response);

?>

YouTube Data API

YouTube udostępnia nam cztery generowane obrazy dla każdego filmu wideo za pośrednictwem interfejsu API Data (v3), na przykład:

1. https://i.ytimg.com/vi/V_zwalcR8DU/maxresdefault.jpg

2. https://i.ytimg.com/vi/V_zwalcR8DU/sddefault.jpg

3. https://i.ytimg.com/vi/V_zwalcR8DU/hqdefault.jpg

4. https://i.ytimg.com/vi/V_zwalcR8DU/mqdefault.jpg

Uzyskiwanie dostępu do obrazów za pośrednictwem interfejsu API

1. Najpierw zdobądź swój publiczny klucz API w Google API Console .
2. Zgodnie z miniaturą YouTube w dokumentacji interfejsu API musisz uzyskać dostęp do zasobów na snippet.thumbnails.

3. W związku z tym musisz sformułować swój adres URL w ten sposób -

   www.googleapis.com/youtube/v3/videos?part=snippet&id=`yourVideoId`&key=`yourApiKey`

Teraz zmień identyfikator wideo i klucz API na odpowiedni identyfikator wideo i klucz API, a jego odpowiedzią będzie wyjście JSON zapewniające cztery linki w miniaturach zmiennej fragmentu kodu (jeśli wszystkie są dostępne).

Identyfikator wideo można uzyskać z adresu URL filmu na YouTube, używając parse_url , parse_str, a następnie wstawić go do predykcyjnych adresów URL obrazów. Dzięki YouTube za przewidywane adresy URL

$videoUrl = "https://www.youtube.com/watch?v=8zy7wGbQgfw";
parse_str( parse_url( $videoUrl, PHP_URL_QUERY ), $my_array_of_vars );
$ytID = $my_array_of_vars['v']; //gets video ID

print "https://img.youtube.com/vi/$ytID/maxresdefault.jpg";
print "https://img.youtube.com/vi/$ytID/mqdefault.jpg";
print "https://img.youtube.com/vi/$ytID/hqdefault.jpg";
print "https://img.youtube.com/vi/$ytID/sddefault.jpg";
print "https://img.youtube.com/vi/$ytID/default.jpg";

Możesz użyć tego narzędzia do generowania miniatur YouTube

https://tools.tutsplanet.com/index.php/get-youtube-video-thumbnails

Prostą funkcję PHP, którą utworzyłem dla miniatury YouTube i są to typy

• domyślna
• hqdefault
• mqdefault
• sddefault
• maxresdefault

function get_youtube_thumb($link,$type){

    $video_id = explode("?v=", $link);

    if (empty($video_id[1])){
        $video_id = explode("/v/", $link);
        $video_id = explode("&", $video_id[1]);
        $video_id = $video_id[0];
    }
    $thumb_link = "";

    if($type == 'default'   || $type == 'hqdefault' ||
       $type == 'mqdefault' || $type == 'sddefault' ||
       $type == 'maxresdefault'){

        $thumb_link = 'http://img.youtube.com/vi/'.$video_id.'/'.$type.'.jpg';

    }elseif($type == "id"){
        $thumb_link = $video_id;
    }
    return $thumb_link;}

Jeśli używasz publicznego interfejsu API, najlepszym sposobem na to jest użycie ifinstrukcji.

Jeśli film jest publiczny lub niepubliczny, ustawiasz miniaturę za pomocą metody URL. Jeśli film jest prywatny, użyj interfejsu API, aby uzyskać miniaturę.

<?php
    if($video_status == 'unlisted'){
        $video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
        $video_status = '<i class="fa fa-lock"></i>&nbsp;Unlisted';
    }
    elseif($video_status == 'public'){
        $video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
        $video_status = '<i class="fa fa-eye"></i>&nbsp;Public';
    }
    elseif($video_status == 'private'){
        $video_thumbnail = $playlistItem['snippet']['thumbnails']['maxres']['url'];
        $video_status = '<i class="fa fa-lock"></i>&nbsp;Private';
    }

Myślę, że są to odpowiedzi na wiele miniatur, ale chcę dodać inne adresy URL, aby bardzo łatwo uzyskać miniaturę YouTube. Właśnie pobieram tekst z odpowiedzi Asapha. Oto kilka adresów URL, aby uzyskać miniatury YouTube:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/default.jpg

W przypadku wysokiej jakości wersji miniatury użyj adresu URL podobnego do tego:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg

Istnieje również wersja miniatury o średniej jakości, wykorzystująca adres URL podobny do wysokiej jakości:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg

W wersji miniatury w standardowej rozdzielczości użyj adresu URL podobnego do tego:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/sddefault.jpg

W wersji miniatury o maksymalnej rozdzielczości użyj adresu URL podobnego do tego:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg

    function get_video_thumbnail( $src ) {
            $url_pieces = explode('/', $src);
            if( $url_pieces[2] == 'dai.ly'){
                $id = $url_pieces[3];
                $hash = json_decode(file_get_contents('https://api.dailymotion.com/video/'.$id.'?fields=thumbnail_large_url'), TRUE);
                $thumbnail = $hash['thumbnail_large_url'];
            }else if($url_pieces[2] == 'www.dailymotion.com'){
                $id = $url_pieces[4];
                $hash = json_decode(file_get_contents('https://api.dailymotion.com/video/'.$id.'?fields=thumbnail_large_url'), TRUE);
                $thumbnail = $hash['thumbnail_large_url'];
            }else if ( $url_pieces[2] == 'vimeo.com' ) { // If Vimeo
                $id = $url_pieces[3];
                $hash = unserialize(file_get_contents('http://vimeo.com/api/v2/video/' . $id . '.php'));
                $thumbnail = $hash[0]['thumbnail_large'];
            } elseif ( $url_pieces[2] == 'youtu.be' ) { // If Youtube
                $extract_id = explode('?', $url_pieces[3]);
                $id = $extract_id[0];
                $thumbnail = 'http://img.youtube.com/vi/' . $id . '/mqdefault.jpg';
            }else if ( $url_pieces[2] == 'player.vimeo.com' ) { // If Vimeo
                $id = $url_pieces[4];
                $hash = unserialize(file_get_contents('http://vimeo.com/api/v2/video/' . $id . '.php'));
                $thumbnail = $hash[0]['thumbnail_large'];
            } elseif ( $url_pieces[2] == 'www.youtube.com' ) { // If Youtube
                $extract_id = explode('=', $url_pieces[3]);
                $id = $extract_id[1];
                $thumbnail = 'http://img.youtube.com/vi/' . $id . '/mqdefault.jpg';
            } else{
                $thumbnail = tim_thumb_default_image('video-icon.png', null, 147, 252);
            }
            return $thumbnail;
        }

get_video_thumbnail('https://vimeo.com/154618727');
get_video_thumbnail('https://www.youtube.com/watch?v=SwU0I7_5Cmc');
get_video_thumbnail('https://youtu.be/pbzIfnekjtM');
get_video_thumbnail('http://www.dailymotion.com/video/x5thjyz');

Oto najlepsza odpowiedź zoptymalizowana do użycia ręcznego. Token identyfikatora wideo bez separatorów umożliwia wybranie podwójnym kliknięciem.

Każdy film na YouTube ma cztery wygenerowane obrazy. Można je sformatować w następujący sposób:

https://img.youtube.com/vi/YOUTUBEVIDEOID/0.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/1.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/2.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/3.jpg

Pierwszy na liście to obraz w pełnym rozmiarze, a pozostałe to miniatury. (Tj. Jeden z domyślnym miniatura 1.jpg, 2.jpg, 3.jpg) to:

https://img.youtube.com/vi/YOUTUBEVIDEOID/default.jpg

W przypadku wysokiej jakości wersji miniatury użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/YOUTUBEVIDEOID/hqdefault.jpg

Istnieje również wersja miniatury o średniej jakości, wykorzystująca adres URL podobny do centrali:

https://img.youtube.com/vi/YOUTUBEVIDEOID/mqdefault.jpg

W wersji miniatury w standardowej rozdzielczości użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/YOUTUBEVIDEOID/sddefault.jpg

W wersji miniatury o maksymalnej rozdzielczości użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/YOUTUBEVIDEOID/maxresdefault.jpg

Wszystkie powyższe adresy URL są również dostępne przez HTTP. Dodatkowo nieco krótsza nazwa hostai3.ytimg.comdziała zamiast img.youtube.comw przykładowych adresach URL powyżej.

Alternatywnie możesz użyć interfejsu YouTube Data API (v3), aby uzyskać miniatury.

Metoda 1:

Możesz znaleźć wszystkie informacje na temat filmu na YouTube ze stroną JSON, która ma nawet „thumbnail_url”, http://www.youtube.com/oembed?format=json&url= {URL twojego filmu tutaj}

Jak wygląd końcowego adresu URL + kod testowy PHP

$data = file_get_contents("https://www.youtube.com/oembed?format=json&url=https://www.youtube.com/watch?v=_7s-6V_0nwA");
$json = json_decode($data);
var_dump($json);

Wynik

object(stdClass)[1]
  public 'width' => int 480
  public 'version' => string '1.0' (length=3)
  public 'thumbnail_width' => int 480
  public 'title' => string 'how to reminder in window as display message' (length=44)
  public 'provider_url' => string 'https://www.youtube.com/' (length=24)
  public 'thumbnail_url' => string 'https://i.ytimg.com/vi/_7s-6V_0nwA/hqdefault.jpg' (length=48)
  public 'author_name' => string 'H2 ZONE' (length=7)
  public 'type' => string 'video' (length=5)
  public 'author_url' => string 'https://www.youtube.com/channel/UC9M35YwDs8_PCWXd3qkiNzg' (length=56)
  public 'provider_name' => string 'YouTube' (length=7)
  public 'height' => int 270
  public 'html' => string '<iframe width="480" height="270" src="https://www.youtube.com/embed/_7s-6V_0nwA?feature=oembed" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>' (length=171)
  public 'thumbnail_height' => int 360

Aby uzyskać szczegółowe informacje, możesz także zobaczyć Jak uzyskać miniaturę filmu z YouTube za pomocą identyfikatora lub https://www.youtube.com/watch?v=mXde7q59BI8 film instruktażowy 1

Metoda 2:

Za pomocą linku do obrazu YouTube, https://img.youtube.com/vi/ „insert-youtube-video-id-here” /default.jpg

Metoda 3:

Używanie kodu źródłowego przeglądarki w celu uzyskania miniatury za pomocą linku URL wideo - przejdź do kodu źródłowego wideo i wyszukaj thumbnailurl. Teraz możesz użyć tego adresu URL w kodzie źródłowym:

{img src="https://img.youtube.com/vi/"insert-youtube-video-id-here"/default.jpg"}

Aby uzyskać szczegółowe informacje, zobacz także Jak uzyskać miniaturę wideo YouTube za pomocą identyfikatora lub https://www.youtube.com/watch?v=9f6E8MeM6PI samouczek wideo 2

Posługiwać się img.youtube.com/vi/YouTubeID/ImageFormat.jpg

Tutaj formaty obrazów są różne, takie jak default, hqdefault, maxresdefault.

To jest moje rozwiązanie tylko po stronie klienta bez klucza API.

YouTube.parse('https://www.youtube.com/watch?v=P3DGwyl0mJQ').then(_ => console.log(_))

Kod:

import { parseURL, parseQueryString } from './url'
import { getImageSize } from './image'

const PICTURE_SIZE_NAMES = [
    // 1280 x 720.
    // HD aspect ratio.
    'maxresdefault',
    // 629 x 472.
    // non-HD aspect ratio.
    'sddefault',
    // For really old videos not having `maxresdefault`/`sddefault`.
    'hqdefault'
]

// - Supported YouTube URL formats:
//   - http://www.youtube.com/watch?v=My2FRPA3Gf8
//   - http://youtu.be/My2FRPA3Gf8
export default
{
    parse: async function(url)
    {
        // Get video ID.
        let id
        const location = parseURL(url)
        if (location.hostname === 'www.youtube.com') {
            if (location.search) {
                const query = parseQueryString(location.search.slice('/'.length))
                id = query.v
            }
        } else if (location.hostname === 'youtu.be') {
            id = location.pathname.slice('/'.length)
        }

        if (id) {
            return {
                source: {
                    provider: 'YouTube',
                    id
                },
                picture: await this.getPicture(id)
            }
        }
    },

    getPicture: async (id) => {
        for (const sizeName of PICTURE_SIZE_NAMES) {
            try {
                const url = getPictureSizeURL(id, sizeName)
                return {
                    type: 'image/jpeg',
                    sizes: [{
                        url,
                        ...(await getImageSize(url))
                    }]
                }
            } catch (error) {
                console.error(error)
            }
        }
        throw new Error(`No picture found for YouTube video ${id}`)
    },

    getEmbeddedVideoURL(id, options = {}) {
        return `https://www.youtube.com/embed/${id}`
    }
}

const getPictureSizeURL = (id, sizeName) => `https://img.youtube.com/vi/${id}/${sizeName}.jpg`

Utility image.js:

// Gets image size.
// Returns a `Promise`.
function getImageSize(url)
{
    return new Promise((resolve, reject) =>
    {
        const image = new Image()
        image.onload = () => resolve({ width: image.width, height: image.height })
        image.onerror = reject
        image.src = url
    })
}

Utility url.js:

// Only on client side.
export function parseURL(url)
{
    const link = document.createElement('a')
    link.href = url
    return link
}

export function parseQueryString(queryString)
{
    return queryString.split('&').reduce((query, part) =>
    {
        const [key, value] = part.split('=')
        query[decodeURIComponent(key)] = decodeURIComponent(value)
        return query
    },
    {})
}

Oto prosta funkcja, którą stworzyłem, aby uzyskać miniatury. Jest łatwy do zrozumienia i użycia.

$ link to link do YouTube skopiowany dokładnie tak, jak w przeglądarce, na przykład https://www.youtube.com/watch?v=BQ0mxQXmLsk

function get_youtube_thumb($link){
    $new = str_replace('https://www.youtube.com/watch?v=', '', $link);
    $thumbnail = 'https://img.youtube.com/vi/' . $new . '/0.jpg';
    return $thumbnail;
}

Zapisz ten kod w pustym pliku .php i przetestuj go.

<img src="<?php echo youtube_img_src('9bZkp7q19f0', 'high');?>" />
<?php
// Get a YOUTUBE video thumb image's source url for IMG tag "src" attribute:
// $ID = YouYube video ID (string)
// $size = string (default, medium, high or standard)
function youtube_img_src ($ID = null, $size = 'default') {
    switch ($size) {
        case 'medium':
            $size = 'mqdefault';
            break;
        case 'high':
            $size = 'hqdefault';
            break;
        case 'standard':
            $size = 'sddefault';
            break;
        default:
            $size = 'default';
            break;
    }
    if ($ID) {
        return sprintf('https://img.youtube.com/vi/%s/%s.jpg', $ID, $size);
    }
    return 'https://img.youtube.com/vi/ERROR/1.jpg';
}

Dzięki.

public const string tubeThumb = "http://i.ytimg.com/vi/[id]/hqdefault.jpg";
vid.Thumbnail = tubeThumb.Replace("[id]", vid.VideoID);