La majorité du travail d'aujourd'hui est la continuation du travail d'hier, consistant simplement à implémenter une logique métier sur les routes de mon application. J’ai donc pensé faire une pause dans mes écrits pour parler de trois fonctions que j’ai créées pour faire des choses très spécifiques dans mon application.

Qu'est-ce qu'un dossier utils ?

C'est le répertoire dans lequel vous mettez toutes vos petites fonctions qui ont du mal à trouver leur place, mais dont votre application ne pourrait pas vivre sans elles.

Un dossier utils est le dépotoir pour les héros méconnus de nombreuses applications.

Lorsque vous devez effectuer une transformation de vos données qui va prendre plus que quelques lignes de code, que vous devrez réutiliser, c'est une bonne idée de les mettre dans son propre fichier que vous pourrez exporter vers le reste de votre candidature.

Pourquoi ne faisons-nous pas simplement un copier-coller ? Eh bien, cela violerait deux principes de programmation, DRY et la séparation des préoccupations.

Ne vous répétez pas

Non seulement se répéter est monotone, mais c'est aussi difficile de changer si vous l'avez suffisamment fait tout au long de votre candidature. Imaginez un algorithme qui calcule le pourcentage de probabilité qu'il pleuve aujourd'hui.

Je ne sais pas comment les gens font ça, donc je ne peux pas vous montrer d'exemple. Mais si vous copiez tout cela tout au long de votre code aux différents endroits qui doivent avoir accès à ce calcul, vous allez être très contrarié lorsque le Comité météorologique scientifique très intelligent reviendra avec un nouvel algorithme plus précis. &&&]

Prenez des parties réutilisées de votre code et trouvez des moyens de les regrouper pour qu'elles soient utilisées à plusieurs endroits, tout en étant mises à jour au même endroit.

Toutes les fonctions de mon dossier utils sont utilisées à de nombreux endroits dans mon application !

Séparation des préoccupations

En tant que programmeurs, nous ne voulons pas non plus créer de fonctions qui font BEAUCOUP de choses différentes. Nous préférerions avoir BEAUCOUP de fonctions qui font toutes une seule chose. Pourquoi? Eh bien, cela rend ces fonctions plus réutilisables !

Qu'est-ce que cela a à voir avec un dossier utils ? Eh bien, les fonctions que je suis sur le point de passer en revue n'ont pas vraiment leur place dans les fonctions comme getRoastsById car ce n'est pas ce qu'elles font ! Lorsque nous devons faire autre chose, nous devons créer une fonction correspondante. Mais, quand nous n'avons pas de place logique pour cette fonction, parce que c'est une « aide », nous la mettons dans notre répertoire utils !

Mon dossier utils

J'ai jusqu'à présent trois utilitaires personnalisés :

insertStatement
mise à jourDéclaration
objectKeysToCamel

J'espère que leurs noms montrent clairement ce qu'ils font, mais permettez-moi de partager brièvement le problème qu'ils résolvent et comment ils fonctionnent.

insertStatement

Problème : Dans de nombreux services différents de mon application, je devrai effectuer une requête INSERT sur ma base de données. Ces instructions nécessitent que vous listiez explicitement 1) les noms des colonnes et 2) les valeurs. Je ne devrais pas avoir à les saisir dans chaque itinéraire, j'ai donc créé une fonction pour le faire pour moi.

Entrée : La fonction prend deux paramètres, table une chaîne qui correspond au nom d'une table dans la base de données et obj, un objet Javascript qui représente le modèle que l'utilisateur souhaite ajouter à la base de données.

Sortie : Un objet avec 1) une chaîne INSERT formatée par une propriété avec des valeurs d'espace réservé et 2) un tableau des valeurs à utiliser dans une requête paramétrée.

const {serpentCase } = require('change-case-commonjs'); fonction insertStatement (table, obj) { const clés = Objet.keys(obj); valeurs const = Object.values(obj); let instruction = `INSERT INTO ${table} (`; // Ajout des clés Snake_case à l'instruction const keyString = keys.map((key, i) => SnakeCase(key)).join(', '); instruction = `${keyString}) VALEURS (`; // Ajout d'espaces réservés pour les valeurs const placeholders = keys.map((_, i) => `$${i 1}`).join(', '); instruction = `${placeholders}) RETURNING *;`; // Renvoie la chaîne de requête et le tableau de valeurs retour { texte : déclaration, valeurs : valeurs } ; } module.exports = insertStatement;

const { snakeCase } = require('change-case-commonjs');

function insertStatement(table, obj) {
  const keys = Object.keys(obj);
  const values = Object.values(obj);

  let statement = `INSERT INTO ${table} (`;

  // Add snake_case keys to the statement
  const keyString = keys.map((key, i) => snakeCase(key)).join(', ');
  statement  = `${keyString}) VALUES (`;

  // Add placeholders for the values
  const placeholders = keys.map((_, i) => `$${i   1}`).join(', ');
  statement  = `${placeholders}) RETURNING *;`;

  // Return the query string and the values array
  return {
    text: statement,
    values: values
  };
}

module.exports = insertStatement;

déclaration de mise à jour

Problème : Semblable à l'instruction INSERT, l'instruction UPDATE vous oblige à indiquer explicitement les noms et les valeurs des colonnes dans votre requête. Cette syntaxe est différente d'une instruction INSERT. Grâce à la logique conditionnelle, je pourrais créer une fonction databaseQueryGenerator, mais cela semble également violer la séparation des préoccupations. Une fonction comme celle-ci déciderait-elle du type de requête que vous souhaitez ou générerait-elle une syntaxe basée sur cela ?

Entrée : La fonction prend trois paramètres. obj, un objet JavaScript qui représente l'enregistrement mis à jour. table , une chaîne qui doit correspondre à une table de la base de données. id , un entier qui correspond à l'enregistrement à mettre à jour avec les nouvelles informations.

Sortie : Un objet avec 1) une chaîne UPDATE formatée par une propriété avec des valeurs d'espace réservé et 2) un tableau des valeurs à utiliser dans une requête paramétrée.

const {serpentCase } = require('change-case-commonjs'); fonction updateStatement (obj, table, identifiant) { const clés = Objet.keys(obj); valeurs const = Object.values(obj); let instruction = `UPDATE ${table} SET `; clés.forEach((clé, index) => { instruction = `${snakeCase(key)} = $${index 1}, `; }); // Supprime la dernière virgule et l'espace instruction = instruction.slice(0, -2); // Détermine la colonne ID correcte en fonction de la table const idColumn = table === 'utilisateurs' ? 'nom d'utilisateur' : table === 'rôtis' ? 'roast_id' : ''; // Finalise l'instruction avec la clause WHERE instruction = ` OÙ ${idColumn} = $${keys.length 1} RETURNING *;`; retour { texte : déclaration, valeurs : [...valeurs, identifiant] } ; } module.exports = updateStatement

const { snakeCase } = require('change-case-commonjs');

function insertStatement(table, obj) {
  const keys = Object.keys(obj);
  const values = Object.values(obj);

  let statement = `INSERT INTO ${table} (`;

  // Add snake_case keys to the statement
  const keyString = keys.map((key, i) => snakeCase(key)).join(', ');
  statement  = `${keyString}) VALUES (`;

  // Add placeholders for the values
  const placeholders = keys.map((_, i) => `$${i   1}`).join(', ');
  statement  = `${placeholders}) RETURNING *;`;

  // Return the query string and the values array
  return {
    text: statement,
    values: values
  };
}

module.exports = insertStatement;

objectKeysToCamel

Problème : Le style de ma base de données est différent du style de mon JavaScript. Cependant, je ne suis prêt à faire aucun compromis dans aucun des deux domaines. Dans mes fichiers JS, ma convention de dénomination utilise camelCase, alors que dans ma base de données, elle utilise Snake_case. Tous les noms de propriété des objets renvoyés sont identiques, mais formatés différemment. Pour maintenir ce standard de cas, je devrais accéder aux propriétés de mon JS en utilisant Snake_case, mais je n'aime pas ça.

Entrée : La fonction ne prend qu'un seul paramètre, un objet JavaScript obj dont les clés doivent être transformées au format camelCase.

Sortie : Le même objet, avec des clés au format camelCase.

const { camelCase } = require('change-case-commonjs'); fonction objetKeysToCamel(obj) { // Extrait les clés et les valeurs const clés = Objet.keys(obj); valeurs const = Object.values(obj); soit chameau = {} // Change le formatage de chaque clé en lui attribuant la valeur appropriée clés.forEach((clé, i) => { const camelKey = camelCase(clé); chameau[camelKey] = valeurs[i] }) // Renvoie le nouvel objet retourner le chameau ; } module.exports = objectKeysToCamel ;

const { camelCase } = require('change-case-commonjs');

function objectKeysToCamel(obj) {
  // Extract the keys and values
  const keys = Object.keys(obj);
  const values = Object.values(obj);
  let camel = {}

  // Change the formatting of each key, assigning it the proper value
  keys.forEach((key, i) => {
    const camelKey = camelCase(key);
    camel[camelKey] = values[i]
  })

  // Return the new object
  return camel;
}

module.exports = objectKeysToCamel;

---

Découvrez le projet

Si vous souhaitez suivre les modifications, créer et exécuter localement, ou même suggérer des modifications de code, voici un lien vers le dépôt GitHub !

https://github.com/nmiller15/roast

L'application frontend est actuellement déployée sur Netlify ! Si vous souhaitez découvrir certaines fonctionnalités et les voir en action, visualisez-les sur un appareil mobile ci-dessous.

https://knowyourhomeroast.netlify.app

Remarque : Ce déploiement n'a pas d'API backend, donc les comptes et les rôtis ne sont pas réellement enregistrés entre les sessions.