Imprimer la liste de lecture à partir de Google Play Music

43

Je souhaite imprimer une liste de chansons (avec l'artiste, l'album, le classement et, si possible, le nombre de lectures et la durée) à partir de mon compte Google Play Music .

Il n'y a pas de moyen facile de faire cela à partir de l'application. Faire des écrans d’impression pendant que je feuillette une longue liste de chansons n’est pas tenable.

Je serais heureux avec une exportation de données vers un format standard (texte brut, CSV, XML, etc.) que je peux manipuler moi-même.

Aucune suggestion?

ale
la source

Réponses:

17

En modifiant la réponse de darkliquid , j’ai proposé ce qui suit qui permet d’ enregistrer plusieurs listes de lecture à la fois .

Instructions:

  1. Allez à la page Vos playlists .
  2. Collez le code JavaScript ci-dessous dans votre console.
  3. Cliquez sur une liste de lecture que vous souhaitez enregistrer en texte.
  4. Une fois sur la page de la liste de lecture, faites défiler vers le bas relativement lentement.
  5. Une fois que vous avez fait défiler l'écran vers le bas, revenez à la page des listes de lecture (comme à l'étape 1) à l'aide du menu ou du bouton retour de votre navigateur.
  6. Répétez les étapes 3 à 5 pour toutes les listes de lecture que vous souhaitez enregistrer en texte.
  7. Une fois que vous avez fait cela pour toutes les listes de lecture que vous souhaitez enregistrer en texte, vous pouvez taper JSON.stringify(tracklistObj, null, '\t')(changer le '\t'en ' 'si vous voulez une indentation minimale) ou tracklistObjsi vous voulez simplement que l'objet JavaScript le manipule à votre façon. Si vous souhaitez le trier, exécutez la commande Object.values(tracklistObj).forEach(a => a.sort()) avant d' appeler la JSON.stringifycommande.

Veillez à ne pas actualiser la page avant d'avoir terminé tout ce que vous souhaitez faire, sinon vous devrez redémarrer à partir de l'étape 1.

// Setup
var tracklistObj = {},
    currentPlaylist,
    checkIntervalTime = 100,
    lastTime;

// Process the visible tracks
function getVisibleTracks() {
    var playlist = document.querySelectorAll('.song-table tr.song-row');
    for(var i = 0; i < playlist.length ; i++) { 
        var l = playlist[i];

        var title = l.querySelector('td[data-col="title"] .column-content');
        if(title !== null)
            title = title.textContent;

        var artist = l.querySelector('td[data-col="artist"] .column-content');
        if(artist !== null)
            artist = artist.textContent;

        var duration = l.querySelector('td[data-col="duration"] span');
        if(duration !== null)
            duration = duration.textContent;

        var album = l.querySelector('td[data-col="album"] .column-content');
        if(album !== null)
            album = album.textContent;

        var playCount = l.querySelector('td[data-col="play-count"] span');
        if(playCount !== null)
            playCount = playCount.textContent;

        var rating = l.querySelector('td[data-col="rating"]');
        if(rating !== null)
            rating = rating.textContent;

        // Add it if it doesn't exist already
        if(tracklistObj[currentPlaylist] && !tracklistObj[currentPlaylist].includes(artist + " - " + title)) {
            tracklistObj[currentPlaylist].push(artist + " - " + title);

            if(printTracksToConsole) {
                console.log(artist + ' - ' + title);
            }
        }
    }
}

// Listen for page changes
window.onhashchange = function(e) {
    currentPlaylist = null; 

    var doneLoading = setInterval(function() {
        var playListName = document.querySelector('.gpm-detail-page-header h2[slot="title"]');
        if(playListName != null) {
            currentPlaylist = playListName.innerText;
            if(tracklistObj[currentPlaylist] === undefined) {
                tracklistObj[currentPlaylist] = [];
            }

            console.log("===================================");
            console.log("Adding to playlist " + currentPlaylist);

            getVisibleTracks();

            clearInterval(doneLoading);
        }
    }, 100);

}

// Check for new tracks every so often
setInterval(function() {
    getVisibleTracks();
}, checkIntervalTime);

// Whether or not to print the tracks obtained to the console
var printTracksToConsole = false;

Vous pouvez également imprimer les noms de piste sur la console au fur et à mesure en passant printTracksToConsoleà true(vous devez le faire avant l'étape 3).

Notez que vous pouvez probablement ignorer toutes les erreurs GET et POST dans la console (celles-ci sont générées par Play Music lui-même, et non par ce script).

Notez également que la configuration actuellement de seulement donner Artist - Track name, mais vous pouvez facilement modifier la ligne qui a tracklistObj[currentPlaylist].push(artist + " - " + title);avec album, playCount, durationou rating, et / ou tout autre forme que vous voulez (y compris le format CSV si vous le s'il vous plaît).

Exemple de sortie (toutes les listes de lecture Google Play que j'ai actuellement) avec les paramètres par défaut. Il a fallu environ 5 minutes au total pour naviguer dans chacune des 32 listes de lecture, les faire défiler, puis convertir le résultat en texte.

PS Vous pourriez être intéressé par l’utilisation d’un site appelé « Régler ma musique» pour créer des listes de lecture YouTube (mais la création de listes de lecture est limitée à 10 par jour) afin que vos amis puissent écouter vos listes de lecture Google. Si vous faites cela, vous voudrez probablement utiliser quelque chose comme TextMechanic pour supprimer les guillemets et .mp3la liste en sortie.

Zach Saucier
la source
1
Si seulement il y avait un meilleur moyen de faire cela que de coller JavaScript dans la console. (J'ai aussi eu un petit problème, car Ublock Origin a bloqué le script.) Mais c'est ce dont j'ai besoin.
ale
J'ai bien peur qu'il ne soit plus à jour :( TypeError: impossible de lire la propriété 'includes' d'undefined sur getVisibleTracks (<anonymous>: 20: 43) sur <anonymous>: 49: 5 sur c ( play-music.gstatic.com/ fe / 6..e / listen__fr_gb.js: 1190: 211 )
FloriOn,
4
@FloriOn Merci d'avoir commenté! J'ai mis à jour le code afin qu'il fonctionne à nouveau maintenant.
Zach Saucier
2
@ale il y a. Vous pouvez transformer le code en bookmarklet.
David Metcalfe
Des erreurs de console apparaissent lors de l'exécution de ce code, mais il ne semble pas l'empêcher de s'exécuter
Otheus
31

(Mis à jour le 2016-05-09, plus robuste que la réponse principale actuelle)

Si vous avez juste besoin de sauvegarder quelques playlists, vous pouvez simplement utiliser mon extrait de code Javascript ci-dessous. Cet extrait de code peut enregistrer toutes les listes telles qu'elles apparaissent sur la page Web. Il fonctionne donc également pour toutes les vues de bibliothèque de chansons / albums / artistes. J'ai énuméré deux autres alternatives à la fin de cette réponse.

  1. Accédez à la page https://play.google.com/music/listen#/all (ou à votre playlist).

  2. Ouvrez une console de développeur (F12 pour Chrome). Collez le code ci-dessous dans la console.

  3. Toutes les chansons grattées sont stockées dans l' allsongsobjet et une version texte de la liste est copiée dans le Presse-papiers. Je recommande de courir songsToText("all",true)après pour obtenir toutes les informations CSV. Exécuter copy(outText)manuellement si la copie du presse-papiers ne fonctionnait pas du premier coup.

Code (dernière version le 10 mai 2016, rév. 30):

var allsongs = []
var outText = "";
var songsToText = function(style, csv, likedonly){
  if (style === undefined){
    console.log("style is undefined.");
    return;
  }
  var csv = csv || false; // defaults to false
  var likedonly = likedonly || false; // defaults to false
  if (likedonly) {
    console.log("Only selecting liked songs");
  }
  if (style == "all" && !csv){
    console.log("Duration, ratings, and playcount will only be exported with the CSV flag");
  }
  outText = "";
  if (csv) {
    if (style == "all") {
      //extra line
      outText = "artist,album,title,duration,playcount,rating,rating_interpretation" + "\n";
    } else if (style == "artist") {
    } else if (style == "artistsong") {
    } else if (style == "artistalbum") {
    } else if (style == "artistalbumsong") {
    } else {
      console.log("style not defined");
    }
  }
  var numEntries = 0;
  var seen = {};
  for (var i = 0; i < allsongs.length; i++) {
    var curr = "";
    var properTitle = allsongs[i].title.replace(/[\n\r!]/g, '').trim();
    if (!likedonly || (likedonly && allsongs[i].rating >= 5)){
      if (csv) {
        if (style == "all") {
          //extra line
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].duration.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].playcount.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].rating.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].rating_interpretation.replace(/"/g, '""').trim() + '"';
        } else if (style == "artist") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistsong") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistalbum") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistalbumsong") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"';
        } else {
          console.log("style not defined");
        }
      } else {
        if (style == "all"){
          curr = allsongs[i].artist + " - " + allsongs[i].album + " - " + properTitle + " [[playcount: " + allsongs[i].playcount + ", rating: " + allsongs[i].rating_interpretation + "]]" ;
        } else if (style == "artist"){
          curr = allsongs[i].artist;
        } else if (style == "artistalbum"){
          curr = allsongs[i].artist + " - " + allsongs[i].album;
        } else if (style == "artistsong"){
          curr = allsongs[i].artist + " - " + properTitle;
        } else if (style == "artistalbumsong"){
          curr = allsongs[i].artist + " - " + allsongs[i].album + " - " + properTitle;
        } else {
          console.log("style not defined");
        }
      }
      if (!seen.hasOwnProperty(curr)){ // hashset
        outText = outText + curr + "\n";
        numEntries++;
        seen[curr] = true;
      } else {
        //console.log("Skipping (duplicate) " + curr);
      }
    }
  }
  console.log("=============================================================");
  console.log(outText);
  console.log("=============================================================");
  try {
    copy(outText);
    console.log("copy(outText) to clipboard succeeded.");
  } catch (e) {
    console.log(e);
    console.log("copy(outText) to clipboard failed, please type copy(outText) on the console or copy the log output above.");
  }
  console.log("Done! " + numEntries + " lines in output. Used " + numEntries + " unique entries out of " + allsongs.length + ".");
};
var scrapeSongs = function(){
  var intervalms = 1; //in ms
  var timeoutms = 3000; //in ms
  var retries = timeoutms / intervalms;
  var total = [];
  var seen = {};
  var topId = "";
  document.querySelector("#mainContainer").scrollTop = 0; //scroll to top
  var interval = setInterval(function(){
    var songs = document.querySelectorAll("table.song-table tbody tr.song-row");
    if (songs.length > 0) {
      // detect order
      var colNames = {
        index: -1,
        title: -1,
        duration: -1,
        artist: -1,
        album: -1,
        playcount: -1,
        rating: -1
        };
      for (var i = 0; i < songs[0].childNodes.length; i++) {
        colNames.index = songs[0].childNodes[i].getAttribute("data-col") == "index" ? i : colNames.index;
        colNames.title = songs[0].childNodes[i].getAttribute("data-col") == "title" ? i : colNames.title;
        colNames.duration = songs[0].childNodes[i].getAttribute("data-col") == "duration" ? i : colNames.duration;
        colNames.artist = songs[0].childNodes[i].getAttribute("data-col") == "artist" ? i : colNames.artist;
        colNames.album = songs[0].childNodes[i].getAttribute("data-col") == "album" ? i : colNames.album;
        colNames.playcount = songs[0].childNodes[i].getAttribute("data-col") == "play-count" ? i : colNames.playcount;
        colNames.rating = songs[0].childNodes[i].getAttribute("data-col") == "rating" ? i : colNames.rating;
      }
      // check if page has updated/scrolled
      var currId = songs[0].getAttribute("data-id");
      if (currId == topId){ // page has not yet changed
        retries--;
        scrollDiv = document.querySelector("#mainContainer");
        isAtBottom = scrollDiv.scrollTop == (scrollDiv.scrollHeight - scrollDiv.offsetHeight)
        if (isAtBottom || retries <= 0) {
          clearInterval(interval); //done
          allsongs = total;
          console.log("Got " + total.length + " songs and stored them in the allsongs variable.");
          console.log("Calling songsToText with style all, csv flag true, likedonly false: songsToText(\"all\", false).");
          songsToText("artistalbumsong", false, false);
        }
      } else {
        retries = timeoutms / intervalms;
        topId = currId;
        // read page
        for (var i = 0; i < songs.length; i++) {
          var curr = {
            dataid: songs[i].getAttribute("data-id"),
            index: (colNames.index != -1 ? songs[i].childNodes[colNames.index].textContent : ""),
            title: (colNames.title != -1 ? songs[i].childNodes[colNames.title].textContent : ""),
            duration: (colNames.duration != -1 ? songs[i].childNodes[colNames.duration].textContent : ""),
            artist: (colNames.artist != -1 ? songs[i].childNodes[colNames.artist].textContent : ""),
            album: (colNames.album != -1 ? songs[i].childNodes[colNames.album].textContent : ""),
            playcount: (colNames.playcount != -1 ? songs[i].childNodes[colNames.playcount].textContent : ""),
            rating: (colNames.rating != -1 ? songs[i].childNodes[colNames.rating].getAttribute("data-rating") : ""),
            rating_interpretation: "",
            }
          if(curr.rating == "undefined") {
            curr.rating_interpretation = "never-rated"
          }
          if(curr.rating == "0") {
            curr.rating_interpretation = "not-rated"
          }
          if(curr.rating == "1") {
            curr.rating_interpretation = "thumbs-down"
          }
          if(curr.rating == "5") {
            curr.rating_interpretation = "thumbs-up"
          }
          if (!seen.hasOwnProperty(curr.dataid)){ // hashset
            total.push(curr);
            seen[curr.dataid] = true;
          }
        }
        songs[songs.length-1].scrollIntoView(true); // go to next page
      }
    }
  }, intervalms);
};
scrapeSongs();
// for the full CSV version you can now call songsToText("all", true);

Le dernier code sur Github (Gist) ici: https://gist.github.com/jmiserez/c9a9a0f41e867e5ebb75

  • Si vous souhaitez que la sortie soit au format texte, vous pouvez appeler la fonction songsToText (). Vous pouvez sélectionner un style, choisir le format et, si seuls les morceaux appréciés / optimisés doivent être exportés. La liste résultante sera ensuite collée dans le presse-papier. Les styles sont all, artist, artistalbum, artistsong, artistalbumsong. CSV donnera un fichier CSV et peut être omis (faux par défaut). Likedonly peut être omis (par défaut, false) ou défini sur true, et filtrera toutes les chansons ayant une note supérieure ou égale à 5. Par exemple:

    • songsToText("all",true,false) exportera toutes les chansons au format csv.
    • songsToText("all",true,true) exportera uniquement les chansons préférées au format csv.
    • songsToText("artistsong",false,false) exportera toutes les chansons sous forme de texte.
  • Vous pouvez ensuite coller les données où bon vous semble, par exemple http://www.ivyishere.org/ si vous souhaitez ajouter les chansons ou les albums à votre compte Spotify. Pour que Ivy reconnaisse les albums complets, utilisez le style "artistalbum". Pour les chansons, utilisez le style "artistes".

À propos de l'extrait: Ceci est basé sur la réponse originale de Michael Smith, mais est un peu plus robuste. J'ai apporté les améliorations suivantes:

  • Fonctionne sur les playlists ainsi que sur la bibliothèque. Toutes les colonnes manquantes sont ignorées et l'ordre est déterminé. Il devrait donc fonctionner sur presque toutes les listes de chansons de Google Music.

  • Il s'arrête lorsqu'il atteint le bas (détecte la position du défilement) ou après le délai spécifié. Le délai d'attente est là pour empêcher une boucle sans fin au cas où le code de détection de défilement serait désactivé de quelques pixels.

  • Il est beaucoup plus rapide (intervalle toutes les 1 ms), mais attend si les données ne sont pas prêtes (jusqu’à l’expiration du délai spécifié, actuellement de 3 secondes).

  • Effectue la déduplication en cours de fonctionnement et sur la sortie.

  • Gathers ratings: "undefined" n'est jamais noté, "0" n'est pas noté (c.-à-d. Une fois noté, puis supprimé), "1" correspond au pouce vers le bas et "5" au pouce levé.

En plus des améliorations de base, il formate également le texte et le copie dans le presse-papiers. Vous pouvez également obtenir les données au format CSV si vous le souhaitez, en exécutant la songsToTextfonction une seconde fois.

Alternatives:

  1. Si vous avez besoin d'une API Python, consultez le projet non officiel d'API Google Music .

  2. Si vous avez des tonnes de listes de lecture et que vous souhaitez toutes les exporter en une seule fois, essayez l' exportateur de listes de lecture gmusic-scripts qui peut le faire (Python utilise le projet d'API non officiel).

jmiserez
la source
Juste un suivi pour le code: cela ne fait que copier les 30 dernières chansons, et quand je fais songsToText ("artistsong"), il affiche la durée en minutes: secondes et le numéro de piste dans la liste de lecture. les détails des chansons sont dans tous les chants de toute façon, mais ils ne sont que 30 (j'ai des listes de lecture avec des centaines)
mkln
tant pis pour le nombre de chansons, il n’est pas bloqué à 30. Mais sur une autre liste de lecture contenant 130 chansons, il n’exporte que la première 117.
mkln
@mkln J'ai mis à jour le code. Il gère désormais la bibliothèque, les listes de lecture ainsi que toutes les autres listes de chansons de Google Music. Il suffit de tout lancer pour copier la liste de lecture / bibliothèque / liste sous forme de liste de texte dans le presse-papiers. Si vous avez besoin d’une version CSV qui inclut tout (lecture, durée, classification), lancez-la songsToText("all", true)ensuite.
jmiserez
ça marche très bien, merci. J'essaie d'écrire un script python qui enregistre toutes les listes de lecture. comment voudriez-vous cliquer sur les différentes listes de lecture via javascript? serait-il possible d'avoir un sélecteur de playlist au début de la fonction?
mardi
1
@mkln Eh bien, ce gars l'a déjà fait: github.com/soulfx/gmusic-playlist Probablement plus facile si vous utilisez simplement son script Python! Honnêtement, je ne l'avais pas vu jusqu'à présent, mais c'est probablement la meilleure option si vous avez besoin de plus d'une playlist.
Jmiserez
18

Si cela ne vous dérange pas d'exécuter un peu de code javascript dans la console de développement de votre navigateur, vous pouvez extraire des informations de la page de la manière suivante (testé uniquement dans Chrome):

var playlist = document.querySelectorAll('.song-table tr.song-row');
for(var i =0; i<playlist.length ; i++) { 
  var l = playlist[i]; 
  var title = l.querySelector('td[data-col="title"] .column-content').textContent;
  var artist = l.querySelector('td[data-col="artist"] .column-content').textContent;
  var album = l.querySelector('td[data-col="album"] .column-content').textContent;
  console.log(artist + ' --- ' + title + ' --- ' + album); 
}

Ceci imprimera sur la console une liste de la plupart des chansons actuellement visibles dans la fenêtre. Vous aurez besoin de faire défiler et réexécutez-le pour obtenir plus. Pour le moment, je n'ai pas encore trouvé de moyen convenable de saisir l'info dans son intégralité, mais ce rapide piratage de 5 minutes est mieux que rien.

darkliquid
la source
Cela semble prometteur. Je vais essayer.
ale
2
Merci beaucoup pour cette réponse. Tu m'as économisé des heures et des heures. Ce que j'ai fait est d'exécuter votre script à plusieurs reprises dans la playlist que je voulais copier. Collez les résultats dans une application Mac appelée Text Soap. Transformé en ",". Suppression des doublons et exportation en tant que txt. Ensuite, je l'ai changé en CSV, enlevé les colonnes non modifiées et importé dans Spotify à l'aide de: ivyishere.org En tout, cela m'a pris environ 8 minutes. J'en ai pris l'
Pas de problème, heureux de vous aider.
darkliquid
Cela semble faire l'affaire. Mon plus gros problème est la taille de mes listes de lecture - 180 sur celle que j'essaie d'exporter. J'ai un peu contourné cela en maximisant ma fenêtre Chrome, puis en effectuant un zoom arrière autant que possible. Si je pouvais simplement convaincre Chrome de zoomer à 10%, je l’aurais sur un seul écran ... à 25%, il fallait deux tours et un peu plus. (Toute chance que vous puissiez zoomer de JS?)
RobertB
1
FYI, si vous ne voulez qu'un élément, utilisez à la querySelector(...)place dequerySelectorAll(...)[0]
ThiefMaster
3

À l'aide de la réponse principale (à l'époque) et à la recherche d'une solution complète, j'ai créé le code suivant, qui fait défiler la liste de musique vers le bas et ajoute des objets JSON à un tableau au fur et à mesure.

Faute de savoir exactement quelles chansons sont visibles, le code les ajoute toutes, puis se dédoublent à la fin. (Testé uniquement dans Chrome.)

Pour utiliser: allez dans votre bibliothèque, où vous voyez votre liste complète de chansons, et lancez

var total = [];
var interval = setInterval(function(){
    var songs = document.querySelectorAll("table.song-table tbody tr.song-row");
    for (var i = 0; i < songs.length; i++) {
        total.push({name: songs[i].childNodes[0].textContent,
        length: songs[i].childNodes[1].textContent,
        artist: songs[i].childNodes[2].textContent,
        album: songs[i].childNodes[3].textContent,
        plays: songs[i].childNodes[4].textContent
        });
        songs[i].scrollIntoView(true);
    }
}, 800);

Quand cela arrive au bas de la page, lancez-le pour arrêter le défilement, dé-dupliquer le tableau et copier JSON dans le Presse-papiers.

clearInterval(interval);
for (var i = 0; i < total.length; i++) {
    for (var j = i + 1; j < total.length; j++) {
        if (total.hasOwnProperty(i) && total.hasOwnProperty(j) && total[i].name == total[j].name && total[j].artist == total[i].artist) {
            total.splice(j,1);
        }
    }
}
copy(total);
Michael Smith
la source
3

J'ai un JavaScript beaucoup plus court que vous pouvez coller dans la console. Au lieu de ré-exécuter le code, vous pouvez simplement faire défiler l'écran vers le bas et tous les albums qui apparaissent sont ajoutés. Ensuite, vous pouvez télécharger la liste de lecture sous forme de feuille de calcul.

Instructions

  1. Allez ici: https://play.google.com/music/listen#/ap/auto-playlist-thumbs-up

  2. Ouvrez les outils de développement (F12) et collez le code ci-dessous dans l' onglet Console .

  3. Faites défiler pour que chaque album de la liste de lecture soit visible au moins une fois

  4. Double-cliquez quelque part sur la page pour télécharger export-google-play.csv

  5. Ouvrir export-google-play.csvdans Excel.

Code

alert("Please scroll through the playlist so that each album is visible once.\n" + 
      "Then double-click the page to export a spreadsheet.");
var albums = ["Artist,Album,Purchased"];

var addVisibleAlbums = function(){
    [].forEach.call(document.querySelectorAll(".song-row"), function(e){ 
        var albumNodes = [e.querySelector("td[data-col='artist']"), 
              e.querySelector("td[data-col='album']"),
              e.querySelector("td[data-col='title'] .title-right-items")];

        var albumString = albumNodes.map(function(s){ 
            return s.innerText.trim().replace(/,/g,""); 
        }).join(",");

        if(albums.indexOf(albumString) === -1){
            albums.push(albumString); console.log("Added: " + albumString)
        }
    });
}

var createCsv = function(){
    var csv = "data:text/csv;charset=utf-8,";
    albums.forEach(function(row){ csv += row + "\n"; }); 

    var uri = encodeURI(csv);
    var link = document.createElement("a");
    link.setAttribute("href", uri);
    link.setAttribute("download", "export-google-play.csv");
    document.body.appendChild(link);
    link.click(); 
    alert("Download beginning!")
}

document.body.addEventListener("DOMNodeInserted", addVisibleAlbums, false);
document.body.addEventListener("dblclick", createCsv, false);

Sortie

entrez la description de l'image ici

GitHub

Charles Clayton
la source
2

J'ai modifié un peu l'approche de la réponse principale. Cela fonctionnait mieux pour moi avec la méthode copier / coller d'Ivy ( http://www.ivyishere.org/ivy ):

Étape 1 Ouvrez la liste de lecture de Google Music dans Chrome que vous souhaitez et collez-la dans la console:

document.querySelector('body.material').style.height = (document.querySelector('table.song-table tbody').getAttribute('data-count') * 100) + 'px';

Cela devrait entraîner le rendu de toute votre liste de lecture plutôt que seulement une partie.

Étape 2 Collez ce script dans la console:

var i, j, playlistString = '', playlist = document.querySelectorAll('.song-table tr.song-row');
for (i = 0, j = playlist.length; i < j; i++) {
    var track = playlist[i]; 
    var artist = track.querySelector('[href][aria-label]').textContent;
    var title = track.querySelector('td[data-col="title"]').textContent;
    playlistString += ('"' + artist + '", "' + title + '"\n');
}
console.log(playlistString);

Étape 3 Allez à Ivy et lorsque vous arrivez à l'étape 2, sélectionnez l'onglet Copier / Coller et collez la sortie de la console à cet endroit.

MODIFIER

Script mis à jour proposé par Alex Pedersen

Itérant sur le raffinement de samurauturetskys (je n'ai pas encore assez de réputation pour commenter son post). Je pense que le style de Googleplay a été mis à jour et que le script ci-dessous donne encore une jolie sortie.

var i, j, playlistString = '', playlist = document.querySelectorAll('.song-table tr.song-row');
for (i = 0, j = playlist.length; i < j; i++) {
    var track = playlist[i]; 
    var artist = track.querySelector('[href][aria-label]').textContent;
    var title = track.querySelector('span[class="column-content fade-out tooltip"]').textContent;
    playlistString += ('"' + artist + '", "' + title + '"\n');
}
console.log(playlistString);
samuraituretsky
la source
-1

Il vous suffit de faire Ctrl+ jusqu'à ce que le texte soit très petit, puis de tout sélectionner. Cela fonctionne comme un charme sans scripts et applications.

La maîtresse d'adolescent d'Obama
la source
-2

Je viens de tomber sur cette question à la recherche de quelque chose de similaire.

Je suppose que votre meilleure option est de:

  1. installer une application comme "Playlist Backup"
  2. Exportez la liste de lecture Google Music vers un fichier texte avec cette application.
  3. Renommez-le en .m3u avec une application FileManager (comme Ghost Commander)
  4. Ouvrez la liste de lecture avec une autre application disposant de plus d'options (comme MusiXMatch).
Oliver Hoffmann
la source
1
Je suppose que vous voulez dire cette application . Pas bien. Même si j’ai un appareil Android, je ne cherche pas de solution Android. De plus, j'ai essayé cette application et elle ne peut pas exporter de données sur des pistes qui ne sont pas sur le périphérique, donc cela m'est inutile.
ale
1
Oliver, étant des applications Web, nous préférons les réponses qui ne nécessitent pas d'applications natives.
Vidar S. Ramdal