Wenn ich eine YouTube-Video-URL habe, gibt es eine Möglichkeit, PHP und cURL zu verwenden, um das zugehörige Miniaturbild von der YouTube-API abzurufen?
Jedes YouTube-Video enthält vier generierte Bilder. Sie sind vorhersehbar wie folgt formatiert:
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
Das erste in der Liste ist ein Bild in voller Größe und andere sind Miniaturbilder. Das Standard-Miniaturbild (d. H. Eines von 1.jpg
, 2.jpg
, 3.jpg
) ist:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/default.jpg
Verwenden Sie für die hochwertige Version des Miniaturbilds eine URL, die der folgenden ähnelt:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg
Es gibt auch eine Version des Thumbnails in mittlerer Qualität, die eine URL ähnlich der des HQ verwendet:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg
Verwenden Sie für die Standarddefinitionsversion der Miniaturansicht eine URL, die der folgenden ähnelt:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/sddefault.jpg
Verwenden Sie für die Version mit der maximalen Auflösung des Miniaturbilds eine URL, die der folgenden ähnelt:
https://img.youtube.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg
Alle oben genannten URLs sind auch über HTTP verfügbar. Darüber hinaus funktioniert der etwas kürzere Hostname i3.ytimg.com
anstelle von img.youtube.com
in den obigen Beispiel-URLs.
Alternativ können Sie YouTube Data API (v3) verwenden, um Miniaturbilder abzurufen.
Sie können die YouTube-Daten-API verwenden, um Video-Miniaturansichten, Bildunterschriften, Beschreibungen, Bewertungen, Statistiken und mehr abzurufen. API-Version 3 erfordert einen Schlüssel *. Besorgen Sie sich den Schlüssel und erstellen Sie eine -Videos: Liste -Anforderung:
https://www.googleapis.com/youtube/v3/videos?key=YOUR_API_KEY&part=snippet&id=VIDEO_ID
Beispiel PHP Code
$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);
Ausgabe
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)
}
}
* Sie benötigen nicht nur einen Schlüssel, sondern werden möglicherweise nach Zahlungsinformationen gefragt, abhängig von der Anzahl der API-Anforderungen, die Sie durchführen möchten. Einige Millionen Anfragen pro Tag sind jedoch kostenlos.
Was Asaph sagte, ist richtig. Allerdings enthält nicht jedes YouTube-Video alle neun Miniaturansichten. Die Bildgröße der Miniaturansichten hängt auch vom Video ab (die folgenden Zahlen basieren auf einer).
Es sind garantiert sieben Thumbnails vorhanden:
| 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 |
Darüber hinaus können die zwei anderen Miniaturansichten vorhanden sein oder nicht. Ihre Anwesenheit hängt wahrscheinlich davon ab, ob das Video von hoher Qualität ist.
| 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 |
Sie finden JavaScript- und PHP -Skripts zum Abrufen von Miniaturansichten und anderen YouTube-Informationen in:
Sie können auch das Tool YouTube Video Information Generator verwenden, um alle Informationen zu einem YouTube-Video abzurufen, indem Sie eine URL oder eine Video-ID eingeben.
In YouTube API V3 können wir diese URLs auch zum Abrufen von Miniaturansichten verwenden. Sie werden anhand ihrer Qualität klassifiziert.
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
Und für die maximale Auflösung ..
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg
Ein Vorteil dieser URLs gegenüber den URLs in der ersten Antwort ist, dass diese URLs nicht von Firewalls blockiert werden.
Wenn du das größte Bild von YouTube für eine bestimmte Video-ID haben möchtest, sollte die URL etwa so lauten:
http://i3.ytimg.com/vi/SomeVideoIDHere/0.jpg
Über die API können Sie das Standard-Miniaturbild abrufen. Einfacher Code sollte ungefähr so aussehen:
//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);
Wenn du die "schwarzen Balken" loswerden willst und es so machst wie YouTube, kannst du Folgendes verwenden:
https://i.ytimg.com/vi_webp/<video id>/mqdefault.webp
Und wenn Sie die Dateierweiterung .webp
nicht verwenden können, können Sie dies folgendermaßen tun:
https://i.ytimg.com/vi/<video id>/mqdefault.jpg
Wenn Sie die nicht skalierte Version benötigen, verwenden Sie maxresdefault
anstelle von mqdefault
.
Hinweis: Wenn Sie maxresdefault
verwenden möchten, bin ich mir hinsichtlich des Seitenverhältnisses nicht sicher.
Ich habe eine Funktion erstellt, um nur vorhandene Bilder von YouTube abzurufen
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;
}
In YouTube Data API v können Sie die Miniaturansichten des Videos mit der Funktion videos-> list abrufen. Aus snippet.thumbnails. (Key) können Sie das Standard-Miniaturbild mit mittlerer oder hoher Auflösung auswählen und dessen Breite, Höhe und URL abrufen.
Sie können Thumbnails auch mit der Funktion thumbnails-> set aktualisieren.
Sie können beispielsweise das Projekt YouTube-API-Beispiele auschecken. ( PHP .)
Sie können das Video Entry erhalten, das die URL zum Thumbnail des Videos enthält. Der Link enthält einen Beispielcode. Oder, wenn Sie XML analysieren möchten, gibt es Informationen hier . Die zurückgegebene XML enthält ein media:thumbnail
-Element, das die URL der Miniaturansicht enthält.
// 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 ist im Besitz von Google, und Google verfügt gern über eine angemessene Anzahl von Bildern für unterschiedliche Bildschirmgrößen. Daher werden die Bilder in unterschiedlichen Größen gespeichert. Hier ist ein Beispiel, wie Ihre Miniaturansicht aussehen wird:
Miniaturbild von geringer Qualität:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/sddefault.jpg
Miniaturbild mittlerer Qualität:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/mqdefault.jpg
Hochwertiges Vorschaubild:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/hqdefault.jpg
Miniaturbild in maximaler Qualität:
http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/maxresdefault.jpg
Wenn Sie nur YouTube durchsuchen und zugehörige Eigenschaften abrufen möchten:
Holen Sie sich eine öffentliche API - Dieser Link gibt eine gute Richtung
Verwenden Sie die folgende Abfragezeichenfolge. Die Suchabfrage (bezeichnet mit q = ) in der URL-Zeichenfolge lautet beispielsweise stackoverflow . YouTube sendet dir dann eine JSON-Antwort zurück, in der du nach Thumbnail, Snippet, Autor usw. suchen kannst.
Verwenden:
https://www.googleapis.com/youtube/v3/videoCategories?part=snippet,id&maxResults=100®ionCode=us&key=**Your YouTube ID**
Oben ist der Link. Auf diese Weise können Sie die YouTube-Eigenschaften von Videos ermitteln. Nachdem Sie Merkmale gefunden haben, können Sie Videos der ausgewählten Kategorie abrufen. Danach können Sie ausgewählte Videobilder mit Asaphs Antwort finden.
Versuchen Sie den obigen Ansatz und Sie können alles aus dem YouTube analysieren API .
Ich habe YouTube-Thumbnails folgendermaßen verwendet:
$url = 'http://img.youtube.com/vi/' . $youtubeId . '/0.jpg';
$img = dirname(__FILE__) . '/youtubeThumbnail_' . $youtubeId . '.jpg';
file_put_contents($img, file_get_contents($url));
Denken Sie daran, YouTube verhindert, dass Bilder direkt von ihrem Server aufgenommen werden.
Eine weitere gute Alternative wäre die Verwendung der oEmbed API, die von YouTube unterstützt wird.
Fügen Sie einfach Ihre YouTube-URL zur oEmbed-URL hinzu und Sie erhalten eine JSON-Datei mit einer Miniaturansicht und dem HTML-Code zum Einbetten.
Beispiel:
http://www.youtube.com/oembed?format=json&url=http%3A//youtube.com/watch%3Fv%3DDLzxrzFCyOs
Würde dir geben:
{
thumbnail_url: "https://i.ytimg.com/vi/DLzxrzFCyOs/hqdefault.jpg",
width: 459,
author_name: "AllKindsOfStuff",
version: "1.0",
author_url: "https://www.youtube.com/channel/UCLNd5EtH77IyN1frExzwPRQ",
thumbnail_width: 480,
type: "video",
provider_url: "https://www.youtube.com/",
html: "<iframe width="459" height="344" src="https://www.youtube.com/embed/DLzxrzFCyOs?feature=oembed" frameborder="0" allowfullscreen></iframe>",
title: "Some title bla bla foo bar",
thumbnail_height: 360,
provider_name: "YouTube",
height: 344
}
Lesen Sie die Dokumentation für mehr Informationen .
Um die angegebenen Lösungen hinzuzufügen/zu erweitern, ist es meines Erachtens erforderlich, zu beachten, dass ich, da ich dieses Problem selbst hatte, mehrere YouTube-Videoinhalte, in diesem Fall Miniaturansichten, mit einer HTTP-Anforderung abrufen kann:
Mit einem Rest Client, in diesem Fall HTTPFUL, können Sie Folgendes tun:
<?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);
?>
Ich habe dieses raffinierte Tool gefunden, mit dem Sie das Bild mit der YouTube-Wiedergabetaste über dem Bild erstellen können:
Eine einfache PHP -Funktion, die ich für die YouTube-Miniaturansicht und die Typen erstellt habe
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;}
Wenn Sie die öffentliche API verwenden, verwenden Sie am besten die Anweisungen if
.
Wenn das Video öffentlich oder nicht gelistet ist, legen Sie die Miniaturansicht mithilfe der URL-Methode fest. Wenn das Video privat ist, verwenden Sie die API, um das Miniaturbild abzurufen.
<?php
if($video_status == 'unlisted'){
$video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
$video_status = '<i class="fa fa-lock"></i> Unlisted';
}
elseif($video_status == 'public'){
$video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
$video_status = '<i class="fa fa-eye"></i> Public';
}
elseif($video_status == 'private'){
$video_thumbnail = $playlistItem['snippet']['thumbnails']['maxres']['url'];
$video_status = '<i class="fa fa-lock"></i> Private';
}
YouTube stellt uns die vier generierten Bilder für jedes Video über die Daten-API (Version 3) zur Verfügung.
Dazu müssen Sie Ihre URL folgendermaßen formulieren:
www.googleapis.com/youtube/v3/videos?part=snippet&id=`yourVideoId`&key=`yourApiKey`
Ändern Sie nun Ihre Video-ID und Ihren API-Schlüssel in Ihre jeweilige Video-ID und Ihren API-Schlüssel. Als Antwort erhalten Sie eine JSON-Ausgabe mit den vier Links in den Miniaturansichten der Snippet-Variablen (sofern alle verfügbar sind).
Sie können die Video-ID von der YouTube-Video-URL abrufen, indem Sie parse_url , parse_str verwenden und dann in die Vorhersage-URLs für Bilder einfügen. Vielen Dank an YouTube für die prädiktiven URLs
$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/<?php print $ytID?>/maxresdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/mqdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/hqdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/sddefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/default.jpg";
Mit diesem Tool können Sie YouTube-Miniaturansichten erstellen
https://tools.tutsplanet.com/index.php/get-youtube-video-thumbnails
Ich denke, es gibt eine Menge Antworten für die Miniaturansicht, aber ich möchte einige andere URLs hinzufügen, um die YouTube-Miniaturansicht ganz einfach zu erhalten. Ich nehme nur einen Text aus Asaphs Antwort. Hier einige URLs zum Abrufen von YouTube-Miniaturansichten:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/default.jpg
Verwenden Sie für die hochwertige Version des Miniaturbilds eine URL, die der folgenden ähnelt:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg
Es gibt auch eine Version des Thumbnails in mittlerer Qualität, die eine URL ähnlich der hohen Qualität verwendet:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg
Verwenden Sie für die Standarddefinitionsversion der Miniaturansicht eine URL, die der folgenden ähnelt:
https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/sddefault.jpg
Verwenden Sie für die Version mit der maximalen Auflösung des Miniaturbilds eine URL, die der folgenden ähnelt:
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');
Die beste Antwort ist für den manuellen Gebrauch optimiert. Das Video-ID-Token ohne Trennzeichen ermöglicht die Auswahl mit einem Doppelklick.
Jedes YouTube-Video enthält vier generierte Bilder. Sie sind vorhersehbar wie folgt formatiert:
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
Das erste in der Liste ist ein Bild in voller Größe und andere sind Miniaturbilder. Das Standard-Miniaturbild (dh eines von 1.jpg
, 2.jpg
, 3.jpg
) ist:
https://img.youtube.com/vi/YOUTUBEVIDEOID/default.jpg
Verwenden Sie für die hochwertige Version des Miniaturbilds eine URL, die der folgenden ähnelt:
https://img.youtube.com/vi/YOUTUBEVIDEOID/hqdefault.jpg
Es gibt auch eine Version des Thumbnails in mittlerer Qualität, die eine URL ähnlich der des HQ verwendet:
https://img.youtube.com/vi/YOUTUBEVIDEOID/mqdefault.jpg
Verwenden Sie für die Standarddefinitionsversion der Miniaturansicht eine URL, die der folgenden ähnelt:
https://img.youtube.com/vi/YOUTUBEVIDEOID/sddefault.jpg
Verwenden Sie für die Version mit der maximalen Auflösung des Miniaturbilds eine URL, die der folgenden ähnelt:
https://img.youtube.com/vi/YOUTUBEVIDEOID/maxresdefault.jpg
Alle oben genannten URLs sind auch über HTTP verfügbar. Darüber hinaus funktioniert der etwas kürzere Hostname i3.ytimg.com
anstelle von img.youtube.com
in den obigen Beispiel-URLs.
Alternativ können Sie YouTube Data API (v3) verwenden, um Miniaturbilder abzurufen.
Methode 1:
Sie finden alle Informationen für ein YouTube-Video mit einer JSON-Seite, die sogar "thumbnail_url" enthält. http://www.youtube.com/oembed?format=json&url= {Ihre Video-URL ist hier}
Wie die endgültige URL sehen Sie + PHP Testcode
$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);
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
Weitere Informationen finden Sie auch in https://www.youtube.com/watch?v=mXde7q59BI8 Video-Tutorial 1
Methode 2:
Verwenden Sie den YouTube-Image-Link https://img.youtube.com/vi/ "YouTube-Video-ID-hier einfügen" /default.jpg
Methode 3:
Verwenden des Browser-Quellcodes zum Abrufen von Miniaturansichten unter Verwendung des Video-URL-Links - Wechseln Sie zum Video-Quellcode und suchen Sie nach der Miniaturansicht. Jetzt können Sie diese URL in Ihren Quellcode einfügen:
{img src="https://img.youtube.com/vi/"insert-youtube-video-id-here"/default.jpg"}
Weitere Informationen finden Sie auch unter So erhalten Sie ein YouTube-Video-Miniaturbild mit id oder https://www.youtube.com/watch v = 9f6E8MeM6PI Video-Tutorial 2
Benutze img.youtube.com/vi/YouTubeID/ImageFormat.jpg
Hier unterscheiden sich die Bildformate wie default, hqdefault, maxresdefault.
Speichern Sie diesen Code in einer leeren .php-Datei und testen Sie ihn.
<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';
}
Vielen Dank.
Hier ist eine einfache Funktion, die ich erstellt habe, um die Thumbnails abzurufen. Es ist leicht zu verstehen und anzuwenden.
$ link ist der YouTube-Link, der genauso kopiert wird wie im Browser. Beispiel: 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;
}
Dies ist meine clientseitige Lösung ohne API-Schlüssel.
YouTube.parse('https://www.youtube.com/watch?v=P3DGwyl0mJQ').then(_ => console.log(_))
Der Code:
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`
Hilfsprogramm 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
})
}
Hilfsprogramm 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
},
{})
}