[RUBY] Est-il facile à utiliser pour l'utilisateur lors de la mise en œuvre de fonctions à usage général? Soyons conscients de

Lors de l'écriture d'un programme, je pense que vous pouvez découper des fonctions générales en classes et méthodes et les implémenter.

Par exemple, considérez le processus consistant à faire participer plusieurs utilisateurs spécifiés à un événement spécifique.

Tout d'abord, vérifiez l'implémentation lorsque tout le traitement est dans une seule méthode. (Je l'ai écrit en Ruby, mais si vous avez utilisé d'autres langages de programmation, vous pouvez vous en faire une idée.)

def main(user_ids, event_id)
  users = User.where(id: user_ids)
  event = Event.find(event_id)

  #Exclut les utilisateurs participants
  target_users = users.reject {|user| user.events.ids.include?(event.id) }

  #Participation à l'événement
  target_users.each do |user|
    #Participation à l'événement=>Ajouter un enregistrement à EventUser
    EventUser.create!(user: user, event: event)
  end
end

Décrivons le processus de participation à l'événement comme méthode de ce qui précède. Cette fois, j'ai ajouté une méthode au modèle Event.

def main(user_ids, event_id)
  users = User.where(id: user_ids)
  event = Event.find(event_id)

  #Exclut les utilisateurs participants
  target_users = users.reject {|user| user.events.ids.include?(event.id) }

  #Participation à l'événement
  event.join(target_users)
end

app/models/event.rb

def join(users)
  users.each do |user|
    #Participation à l'événement=>Ajouter un enregistrement à EventUser
    EventUser.create!(user: user, event: event)
  end
end

Maintenant, si vous voulez exécuter le processus de rejoindre un événement depuis un autre endroit, vous pouvez l'appeler avec ʻevent.join (users) `.

Cependant, cette méthode de mise en œuvre a quelques subtilités. Le fait est que l'appelant doit passer uniquement les utilisateurs qui peuvent participer, à l'exclusion des utilisateurs qui ont déjà rejoint.

Dans le cas de cet exemple, il sera plus facile pour l'appelant de faire ce qui suit.

def main(user_ids, event_id)
  users = User.where(id: user_ids)
  event = Event.find(event_id)

  #Participation à l'événement
  #L'appelant n'a pas à s'inquiéter si les utilisateurs ont déjà rejoint. OK si vous passez l'utilisateur qui peut être la cible
  event.join(users)
end

app/models/event.rb

def join(users)
  #Exclut les utilisateurs participants
  target_users = users.reject {|user| user.events.ids.include?(event.id) }

  target_users.each do |user|
    #Participation à l'événement=>Ajouter un enregistrement à EventUser
    EventUser.create!(user: user, event: event)
  end
end

S'il est mis en œuvre de cette manière, l'appelant peut passer l'utilisateur cible sans se soucier de savoir s'il a déjà rejoint.

Si vous expliquez dans l'ordre comme cette fois, il peut sembler naturel d'implémenter le troisième, mais en réalité, vous voyez souvent celui implémenté dans le second état.

En effet, il n'y a aucun sentiment d'inconfort même si la méthode seule est dite «une méthode qui permet aux utilisateurs de participer à des événements». La deuxième partie généralisée est réimprimée ci-dessous. Que diriez-vous de regarder cette méthode seule?

app/models/event.rb

def join(users)
  users.each do |user|
    #Participation à l'événement=>Ajouter un enregistrement à EventUser
    EventUser.create!(user: user, event: event)
  end
end

En outre, lorsque vous créez une méthode générique pour la première fois, vous pouvez avoir peu (ou un seul) appelants. Dans ce cas, il ne faut pas beaucoup de temps pour vérifier auprès de l'appelant ou de l'appelé, il est donc difficile de ressentir les tracas d'avoir à tout vérifier chez l'appelant.

Et une fois qu'il est implémenté comme ça, lors de l'implémentation du processus de participation à l'événement de la même manière, la partie existante sera copiée. Dans ce cas, la dynamique de «Parce que l'existant est comme ça» fonctionnera, et elle sera considérée comme acquise plutôt que gênante.

Résumé

Lors de la mise en œuvre de fonctions générales, est-il facile à utiliser pour l'utilisateur? Soyons conscients de. Si l'utilisateur doit tenir compte de diverses restrictions ou si des processus doivent être exécutés (processus excluant les participants dans cet exemple), ces processus peuvent être incorporés dans des fonctions à usage général. Voyons si c'est là.

Cela facilitera non seulement la tâche de l'utilisateur, mais évitera également les bogues tels que les omissions.

De plus, si vous souhaitez le créer à des fins générales, il sera utilisé. S'il est difficile à utiliser, il est fort probable que seule la personne qui l'a implémenté puisse l'utiliser (la personne qui l'a implémenté ne pourra peut-être pas l'utiliser dans quelques mois) Gardons à l'esprit l'implémentation facile à utiliser et à apprécier pour les utilisateurs! !!