2010-07-27 5 views
1

J'ai une application web où chaque utilisateur peut avoir des amis. Les utilisateurs peuvent regarder différentes pages sur mon site, comme:Lesquels de mes amis ont le même 'like'?

pizza.html 
hamburger.html 
etc.. 

Si je suis userA, et je suis à la page « pizza.html », je voudrais savoir quel de mes amis ont aussi ' aimé 'cette page. En supposant que je veux montrer quand je charge pizza.html, je pouvais le faire à la demande comme vraiment douloureusement:

User me; 
Like current = "pizza.html"; 
List<User> friendsWhoAlsoLikePageImLookingAt; 
for (User friend : me.getFriends()) { 
    for (Like like : friend.getLikes()) { 
     if (like == current) { 
      friendsWhoAlsoLikePageImLookingAt.add(friend); 
     } 
    } 
} 

// now friendsWhoAlsoLikePageImLookingAt contains all of my 
// friends that like the page I'm viewing. 

qui fonctionnerait, mais escaladeraient vraiment mal, comme le # d'amis et de leurs goûts se développe. Y at-il un algorithme que je peux examiner pour résoudre ce problème?

Une autre approche consisterait à précalculer tous les goûts pour chaque utilisateur (cela ne serait pas aussi bien que je pense). Par exemple, chaque utilisateur obtient leur propre fichier txt par intérêt comme:

userA_pizza.txt 
userB_pizza.txt 
userA_hamburger.txt 
userB_hamburger.txt 
... 

en supposant que je suis ami avec userB et userB ajoute: « pizza.html » comme nouveau comme - alors je mettre à jour le userA_pizza.txt fichier à ressembler à:

// userA_pizza.txt 
userB // latest friend to also like this interest. 
userX // previous friend likes 
userY // previous friend likes 

maintenant chaque fois que je (userA) afficher la page pizza, je peux ouvrir « userA_pizza.txt » et vider simplement tous les noms d'amis sans faire de calculs. Maintenant, chaque fois qu'un utilisateur aime une page, je dois mettre à jour N fichiers txt, où N est le nombre de leurs amis. De plus, chaque utilisateur aurait besoin d'un fichier texte par intérêt possible (et il pourrait y avoir des milliers d'intérêts). Si un utilisateur a 100k amis et ils ont chacun 1000 intérêts, cela pourrait aussi être très coûteux!

Oui si des idées ou pensées serait génial -

Merci

Répondre

0

En supposant que votre arrière-plan est une base de données, vous devriez avoir 3 tables référencées pour cette fonctionnalité

User table (Id, Name, etc) 
Page table (Id, Url, etc) 
LikedPages (UserId, PageId) 

Vous pouvez interroger la table LikedPages contre UserId pour voir une liste de tous les goûts pour un utilisateur. Vous pouvez également interroger PageId pour voir qui aime cette page. L'intersection de ces deux requêtes est le résultat que vous recherchez.

2

Ne pourriez-vous simplement garder une liste par « comme » page pour laquelle les gens ont aimé? Ensuite, au lieu d'avoir à parcourir tous les «j'aime» pour chaque ami pour l'utilisateur actuel, vous pourriez simplement passer par les utilisateurs qui ont aimé la page que l'utilisateur est actuellement sur et liste seulement ceux qui sont amis avec l'utilisateur actuel.

Toujours inefficace et pas génial pour la mise à l'échelle, mais de cette façon, quand un utilisateur aime une page, il vous suffit de mettre à jour la page "J'aime" et pas un tas de pages. Êtes-vous limité aux fichiers texte seulement? Une base de données pourrait rendre cela très facile.

1

Je voudrais utiliser une base de données pour stocker les données au lieu de fichiers texte.

Vous pouvez avoir une table d'utilisateurs contenant les utilisateurs eux-mêmes, table userFriends reliant les utilisateurs aux amis, une table de likes (une ligne par chose sympathique), un utilisateur de tableAimant les utilisateurs à ce qu'ils aiment.

Il serait alors beaucoup plus facile à maintenir et une requête de base de données pour générer un jeu d'enregistrements de ce que les amis d'un utilisateur aiment.

Questions connexes