Ta strona została przetłumaczona przez Cloud Translation API.

PlaylistItems: list

Zwraca kolekcję elementów playlisty, które pasują do parametrów żądania do interfejsu API. Możesz pobrać wszystkie elementy playlisty, które się na niej znajdują, albo jeden lub więcej elementów, podając ich unikalne identyfikatory.

Wpływ na limit: wywołanie tej metody ma koszt limitu wynoszący 1 jednostkę.

Typowe przypadki użycia

Prośba

Żądanie HTTP

GET https://www.googleapis.com/youtube/v3/playlistItems

Parametry

W tabeli poniżej znajdziesz parametry obsługiwane przez to zapytanie. Wszystkie wymienione parametry są parametrami zapytania.

Parametry
Parametry wymagane
`part`	`string` Parametr `part` określa oddzieloną przecinkami listę właściwości zasobu `playlistItem`, które będzie zawierać odpowiedź interfejsu API. Jeśli parametr wskazuje właściwość zawierającą właściwości podrzędne, w odpowiedzi zostaną uwzględnione właściwości podrzędne. Na przykład w zasobie `playlistItem` właściwość `snippet` zawiera wiele pól, w tym właściwości `title`, `description`, `position` i `resourceId`. Jeśli więc ustawisz `part=snippet`, odpowiedź interfejsu API będzie zawierać wszystkie te właściwości. Na poniższej liście znajdziesz nazwy pól `part`, które możesz uwzględnić w wartości parametru: `contentDetails` `id` `snippet` `status`
Filtry (określ dokładnie jeden z tych parametrów)
`id`	`string` Parametr `id` zawiera rozdzieloną przecinkami listę z co najmniej 1 unikalnym identyfikatorem elementu playlisty.
`playlistId`	`string` Parametr `playlistId` określa unikalny identyfikator playlisty, z której chcesz pobrać elementy playlisty. Pamiętaj, że mimo że jest to parametr opcjonalny, każde żądanie pobrania elementów playlisty musi mieć określoną wartość parametru `id` lub `playlistId`.
Parametry opcjonalne
`maxResults`	`unsigned integer` Parametr `maxResults` określa maksymalną liczbę elementów, które powinny zostać zwrócone w zbiorze wyników. Akceptowane wartości to od `0` do `50` (włącznie). Wartością domyślną jest `5`.
`onBehalfOfContentOwner`	`string` Tego parametru można używać tylko w prawidłowo autoryzowanym żądaniu. Uwaga: ten parametr jest przeznaczony wyłącznie dla dostawców treści w YouTube. Parametr `onBehalfOfContentOwner` wskazuje, że dane uwierzytelniające żądanie identyfikują użytkownika YouTube CMS działającego w imieniu właściciela treści określonego w wartości parametru. Jest on przeznaczony dla dostawców treści w YouTube, którzy mają wiele różnych kanałów w YouTube i nimi zarządzają. Dzięki niej właściciele treści mogą jednorazowo uwierzytelnić się i uzyskiwać dostęp do wszystkich swoich filmów oraz danych dotyczących kanałów bez konieczności podawania danych uwierzytelniających dla każdego kanału z osobna. Konto CMS, za pomocą którego użytkownik uwierzytelnia się, musi być powiązane z określonym właścicielem treści YouTube.
`pageToken`	`string` Parametr `pageToken` wskazuje w zestawie wyników konkretną stronę, która ma zostać zwrócona. W odpowiedzi interfejsu API właściwości `nextPageToken` i `prevPageToken` identyfikują inne strony, które można pobrać.
`videoId`	`string` Parametr `videoId` określa, że żądanie powinno zwracać tylko te elementy playlisty, które zawierają określony film.

Treść żądania

Nie podawaj treści żądania podczas wywoływania tej metody.

Odpowiedź

Jeśli operacja się uda, metoda zwróci odpowiedź o następującej strukturze:

{
  "kind": "youtube#playlistItemListResponse",
  "etag": etag,
  "nextPageToken": string,
  "prevPageToken": string,
  "pageInfo": {
    "totalResults": integer,
    "resultsPerPage": integer
  },
  "items": [
    playlistItem Resource
  ]
}

Właściwości

Poniższa tabela przedstawia właściwości, które pojawiają się w tym zasobie:

Właściwości
`kind`	`string` Określa typ zasobu interfejsu API. Wartością będzie `youtube#playlistItemListResponse`.
`etag`	`etag` ETag tego zasobu.
`nextPageToken`	`string` Token, który może być używany jako wartość parametru `pageToken` w celu pobrania następnej strony w zestawie wyników.
`prevPageToken`	`string` Token, który może być używany jako wartość parametru `pageToken` do pobierania poprzedniej strony w zestawie wyników.
`pageInfo`	`object` Obiekt `pageInfo` zawiera informacje o stronicowaniu zbioru wyników.
`pageInfo.totalResults`	`integer` Łączna liczba wyników w zestawie.
`pageInfo.resultsPerPage`	`integer` Liczba wyników uwzględnionych w odpowiedzi interfejsu API.
`items[]`	`list` Lista elementów playlisty, które spełniają kryteria żądania.

Przykłady

Uwaga: poniższe przykłady kodu mogą nie obejmować wszystkich obsługiwanych języków programowania. Listę obsługiwanych języków znajdziesz w dokumentacji bibliotek klienta.

Go

Ten przykładowy kod wywołuje metodę playlistItems.list interfejsu API, aby pobrać listę filmów przesłanych na kanał powiązany z żądaniem. Wywołuje on także metodę channels.list z parametrem mine ustawionym na true, aby pobrać identyfikator playlisty, który identyfikuje filmy przesłane na kanał.

W tym przykładzie korzystamy z biblioteki klienta w Go.

package main

import (
	"fmt"
	"log"

	"google.golang.org/api/youtube/v3"
)

// Retrieve playlistItems in the specified playlist
func playlistItemsList(service *youtube.Service, part string, playlistId string, pageToken string) *youtube.PlaylistItemListResponse {
	call := service.PlaylistItems.List(part)
	call = call.PlaylistId(playlistId)
	if pageToken != "" {
		call = call.PageToken(pageToken)
	}
	response, err := call.Do()
	handleError(err, "")
	return response
}

// Retrieve resource for the authenticated user's channel
func channelsListMine(service *youtube.Service, part string) *youtube.ChannelListResponse {
	call := service.Channels.List(part)
	call = call.Mine(true)
	response, err := call.Do()
	handleError(err, "")
	return response
}

func main() {
	client := getClient(youtube.YoutubeReadonlyScope)
	service, err := youtube.New(client)
	
	if err != nil {
		log.Fatalf("Error creating YouTube client: %v", err)
	}

	response := channelsListMine(service, "contentDetails")

	for _, channel := range response.Items {
		playlistId := channel.ContentDetails.RelatedPlaylists.Uploads
		
		// Print the playlist ID for the list of uploaded videos.
		fmt.Printf("Videos in list %s\r\n", playlistId)

		nextPageToken := ""
		for {
			// Retrieve next set of items in the playlist.
			playlistResponse := playlistItemsList(service, "snippet", playlistId, nextPageToken)
			
			for _, playlistItem := range playlistResponse.Items {
				title := playlistItem.Snippet.Title
				videoId := playlistItem.Snippet.ResourceId.VideoId
				fmt.Printf("%v, (%v)\r\n", title, videoId)
			}

			// Set the token to retrieve the next page of results
			// or exit the loop if all results have been retrieved.
			nextPageToken = playlistResponse.NextPageToken
			if nextPageToken == "" {
				break
			}
			fmt.Println()
		}
	}
}
my_uploads.go

.NET

Poniższy przykładowy kod wywołuje metodę playlistItems.list interfejsu API, aby pobrać listę filmów przesłanych na kanał powiązany z żądaniem. Wywołuje on także metodę channels.list z parametrem mine ustawionym na true, aby pobrać identyfikator playlisty, który identyfikuje filmy przesłane na kanał.

W tym przykładzie korzystamy z biblioteki klienta.NET.

using System;
using System.IO;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;

using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
using Google.Apis.Upload;
using Google.Apis.Util.Store;
using Google.Apis.YouTube.v3;
using Google.Apis.YouTube.v3.Data;

namespace Google.Apis.YouTube.Samples
{
  /// <summary>
  /// YouTube Data API v3 sample: retrieve my uploads.
  /// Relies on the Google APIs Client Library for .NET, v1.7.0 or higher.
  /// See https://developers.google.com/api-client-library/dotnet/get_started
  /// </summary>
  internal class MyUploads
  {
    [STAThread]
    static void Main(string[] args)
    {
      Console.WriteLine("YouTube Data API: My Uploads");
      Console.WriteLine("============================");

      try
      {
        new MyUploads().Run().Wait();
      }
      catch (AggregateException ex)
      {
        foreach (var e in ex.InnerExceptions)
        {
          Console.WriteLine("Error: " + e.Message);
        }
      }

      Console.WriteLine("Press any key to continue...");
      Console.ReadKey();
    }

    private async Task Run()
    {
      UserCredential credential;
      using (var stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read))
      {
        credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
            GoogleClientSecrets.Load(stream).Secrets,
            // This OAuth 2.0 access scope allows for read-only access to the authenticated 
            // user's account, but not other types of account access.
            new[] { YouTubeService.Scope.YoutubeReadonly },
            "user",
            CancellationToken.None,
            new FileDataStore(this.GetType().ToString())
        );
      }

      var youtubeService = new YouTubeService(new BaseClientService.Initializer()
      {
        HttpClientInitializer = credential,
        ApplicationName = this.GetType().ToString()
      });

      var channelsListRequest = youtubeService.Channels.List("contentDetails");
      channelsListRequest.Mine = true;

      // Retrieve the contentDetails part of the channel resource for the authenticated user's channel.
      var channelsListResponse = await channelsListRequest.ExecuteAsync();

      foreach (var channel in channelsListResponse.Items)
      {
        // From the API response, extract the playlist ID that identifies the list
        // of videos uploaded to the authenticated user's channel.
        var uploadsListId = channel.ContentDetails.RelatedPlaylists.Uploads;

        Console.WriteLine("Videos in list {0}", uploadsListId);

        var nextPageToken = "";
        while (nextPageToken != null)
        {
          var playlistItemsListRequest = youtubeService.PlaylistItems.List("snippet");
          playlistItemsListRequest.PlaylistId = uploadsListId;
          playlistItemsListRequest.MaxResults = 50;
          playlistItemsListRequest.PageToken = nextPageToken;

          // Retrieve the list of videos uploaded to the authenticated user's channel.
          var playlistItemsListResponse = await playlistItemsListRequest.ExecuteAsync();

          foreach (var playlistItem in playlistItemsListResponse.Items)
          {
            // Print information about each video.
            Console.WriteLine("{0} ({1})", playlistItem.Snippet.Title, playlistItem.Snippet.ResourceId.VideoId);
          }

          nextPageToken = playlistItemsListResponse.NextPageToken;
        }
      }
    }
  }
}
MyUploads.cs

Ruby

Ten przykład wywołuje metodę playlistItems.list interfejsu API, aby pobrać listę filmów przesłanych na kanał powiązany z żądaniem. Wywołuje on także metodę channels.list z parametrem mine ustawionym na true, aby pobrać identyfikator playlisty, który identyfikuje filmy przesłane na kanał.

W tym przykładzie korzystamy z biblioteki klienta Ruby.

#!/usr/bin/ruby

require 'rubygems'
gem 'google-api-client', '>0.7'
require 'google/api_client'
require 'google/api_client/client_secrets'
require 'google/api_client/auth/file_storage'
require 'google/api_client/auth/installed_app'

# This OAuth 2.0 access scope allows for read-only access to the authenticated
# user's account, but not other types of account access.
YOUTUBE_READONLY_SCOPE = 'https://www.googleapis.com/auth/youtube.readonly'
YOUTUBE_API_SERVICE_NAME = 'youtube'
YOUTUBE_API_VERSION = 'v3'

def get_authenticated_service
  client = Google::APIClient.new(
    :application_name => $PROGRAM_NAME,
    :application_version => '1.0.0'
  )
  youtube = client.discovered_api(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION)

  file_storage = Google::APIClient::FileStorage.new("#{$PROGRAM_NAME}-oauth2.json")
  if file_storage.authorization.nil?
    client_secrets = Google::APIClient::ClientSecrets.load
    flow = Google::APIClient::InstalledAppFlow.new(
      :client_id => client_secrets.client_id,
      :client_secret => client_secrets.client_secret,
      :scope => [YOUTUBE_READONLY_SCOPE]
    )
    client.authorization = flow.authorize(file_storage)
  else
    client.authorization = file_storage.authorization
  end

  return client, youtube
end

def main
  client, youtube = get_authenticated_service

  begin
    # Retrieve the "contentDetails" part of the channel resource for the
    # authenticated user's channel.
    channels_response = client.execute!(
      :api_method => youtube.channels.list,
      :parameters => {
        :mine => true,
        :part => 'contentDetails'
      }
    )

    channels_response.data.items.each do |channel|
      # From the API response, extract the playlist ID that identifies the list
      # of videos uploaded to the authenticated user's channel.
      uploads_list_id = channel['contentDetails']['relatedPlaylists']['uploads']

      # Retrieve the list of videos uploaded to the authenticated user's channel.
      next_page_token = ''
      until next_page_token.nil?
        playlistitems_response = client.execute!(
          :api_method => youtube.playlist_items.list,
          :parameters => {
            :playlistId => uploads_list_id,
            :part => 'snippet',
            :maxResults => 50,
            :pageToken => next_page_token
          }
        )

        puts "Videos in list #{uploads_list_id}"

        # Print information about each video.
        playlistitems_response.data.items.each do |playlist_item|
          title = playlist_item['snippet']['title']
          video_id = playlist_item['snippet']['resourceId']['videoId']

          puts "#{title} (#{video_id})"
        end

        next_page_token = playlistitems_response.next_page_token
      end

      puts
    end
  rescue Google::APIClient::TransmissionError => e
    puts e.result.body
  end
end

main
my_uploads.rb

Błędy

W tabeli poniżej znajdziesz komunikaty o błędach, które interfejs API może zwrócić w odpowiedzi na wywołanie tej metody. Więcej szczegółów znajdziesz w dokumentacji komunikatów o błędach.

Typ błędu	Szczegóły błędu	Opis
`forbidden (403)`	`playlistItemsNotAccessible`	Żądanie nie jest prawidłowo autoryzowane do pobrania określonej playlisty.
`forbidden (403)`	`watchHistoryNotAccessible`	Danych historii oglądania nie można pobrać przez interfejs API.
`forbidden (403)`	`watchLaterNotAccessible`	Elementów z playlist „Do obejrzenia” nie można pobierać przez interfejs API.
`notFound (404)`	`playlistNotFound`	Nie udało się znaleźć playlisty określonej za pomocą parametru `playlistId` żądania.
`notFound (404)`	`videoNotFound`	Nie udało się znaleźć filmu określonego za pomocą parametru `videoId` żądania.
`required (400)`	`playlistIdRequired`	W żądaniu subskrypcji nie określono wartości wymaganej właściwości `playlistId`.
`invalidValue (400)`	`playlistOperationUnsupported`	Interfejs API nie obsługuje wyświetlania listy filmów ze wskazanej playlisty. Nie możesz na przykład umieścić filmu na playliście Do obejrzenia.

Wypróbuj

Użyj interfejsu APIs Explorer, aby wywołać ten interfejs API i wyświetlić żądanie oraz odpowiedź interfejsu API.