Eesmärk on jagada programmid väiksemateks komponentideks

Last updated 9. November 2022

Inhalt

Jagage programmid väiksemateks komponentideks

Üks asi, millest programmeerijad sageli räägivad, on soov jagada programmid väiksemateks komponentideks või funktsioonideks, et neid oleks lihtsam jälgida, kergem lugeda ja siluda.

Kuid pole sugugi haruldane näha monoliitseid funktsioone, millel on palju koodikommentaare, mis aitavad programmis toimuvat selgitada.

Ma ei tõrju seda, sest ma ei tea, milliste piirangute all programmeerija töötas. See on:

Kui suur oli tema eelarve programmi koostamisel?
Kui palju aega projekti lõpuleviimiseks anti?
Kas projekti kallal töötas palju inimesi?
Kas programmeerijale anti aega koodi kirjutamiseks, et nad saaksid seda testida, ümber kujundada või lihtsalt lugeda lihtsamaks?

Lühidalt öeldes on palju põhjust – ma usun –, et me saame lugeda "halba koodi" ja see ei pea alati olema programmeerija süü (see on lihtsalt kõige loomulikum asi, mille peame lugemisel välja viskama midagi, mis meile ei meeldi).

Kas see aga tähendab, et me ei peaks püüdma koodi ümber kujundada või kirjutada sellisel viisil, et seda oleks lihtsam mõista? Muidugi mitte. Eeldades, et meil on selleks aega, kuidas saaksime seda teha?

Jagage programmid väiksemateks komponentideks

Kui rääkida sellisest teemast, eriti majanduses, mis on sama aktiivne kui e-kaubandus WordPressis, võib see olla väljakutse.

"Lähme konkreetseks, Bob."

See tähendab, et ma saan kirjutada sellest väga üksikasjalikult, kasutades pluginate komplekti, vaadates andmeid, lahkades päringuid ja näidates, kuidas seda teha. Või võin sellest kirjutada veidi kõrgemal tasemel, mille lõppeesmärk on näidata, kuidas programme väiksemateks komponentideks jagada.

Kuna esimest on võimalik saavutada nii paljudel viisidel, valin ma viimase. See tähendab, et see ei pruugi tingimata kasutada konkreetseid pistikprogramme, mis on otsesed päringud. Siiski kasutatakse kõrgetasemelisi näiteid, mis aitavad teil läbi vaadata päringute ja tsüklite jada ning jagada need väiksemateks funktsioonideks.

Üldine näide

Oletame näiteks, et töötan WordPressi pistikprogrammi funktsiooni kallal, mille lõppeesmärk on hankida kõik erinevad makseviisid, mille kasutaja on talletanud ja mis on seotud tema kontoga.

Väljakutse seisneb selles, et see teave on hajutatud mitme andmebaasi tabeli vahel (erinevate kasutatavate pistikprogrammide tõttu), nii et mõned päringud tuleb täita ja seejärel hankida.

Selliste päringute tegemise sammud võivad olla umbes sellised:

saada praeguse kasutaja kliendi ID,
hankige kõik kliendi tellimuse ID-numbrid
määrata, milliseid makseviise iga tellimuse puhul kasutati
hankige nimetatud makseviisid ja seejärel saatke kliendile andmed mark

Olenevalt sellest, kuidas andmebaas on seadistatud, olenevalt teie SQL-i oskuste tasemest ja sellest, kuidas erinevad pluginad kõigi ülaltoodud andmete töötlemiseks koos töötavad, võib selle teabe hankimiseks olla lihtne kirjutada üks suur päring.

Kuid kui olete WordPressis e-kaubanduse ja erinevate pistikprogrammidega töötanud, teate, et see pole alati nii lihtne.

Selle asemel vaatate midagi sellist nagu:

peame saama kasutaja metaandmetest kliendi profiili,
peame leidma kõik kasutaja tehtud tellimused ja seda võib sageli seostada postituse või postituse metaandmete tabeliga,
makseviise saab suure tõenäosusega salvestada nende tabelisse, mis on kasutajaga seotud teatud tüüpi märgi kaudu,
ülaltoodud märk asub tabelis ja on seotud antud teabega teises tabelis, millest peate seejärel tuletama, vaadates kogu andmebaasis olemasolevaid andmeid.

Lõppkokkuvõttes peate looma päringute komplekti ainult siis, kui mõistate kõigepealt, kuidas otsida andmeid, mida otsite. See on piisavalt keeruline, nagu see on. Kuid kui saate seda teha, oletame, et kirjutate päringud järjestikku ja kasutate seejärel soovitud väljundi saavutamiseks igaühe tulemusi.

Selle tulemuseks võib olla midagi sellist :

<?php

// First, read the user ID and meta value to get authorization information
global $wpdb;
$results = $wpdb->get_results(
    $wpdb->prepare(
        "
        SELECT
            user_id, meta_value
        FROM $wpdb->usermeta
        WHERE meta_key LIKE %s
        AND user_id = %d
        ",
        '%customer_profile_id%',
        filter_input(INPUT_GET, 'customer_id')
    ),
    ARRAY_A
);

$result = isset($results[0])? array_column($results[0], 'meta_value'): [];
if (empty($result)) {
    return $result;
}

// Get the ID of the current customer.
$customers = $wpdb->get_results(
    $wpdb->prepare(
        "", // Your custom query goes here.
        filter_input(INPUT_GET, 'customer_id')
    ),
    ARRAY_A
);

$customer = isset($customers[0])? array_column($customers[0], 'customer_id'): [];
if (empty($customer)) {
    return $customer;
}

// Get all of the order IDs from the set of orders returned from the previous query.
$orderIds = $wpdb->get_results(
    $wpdb->prepare(
        "", // Your custom query goes here.
        $customer
    ),
    ARRAY_A
);

return $orderIds;

// Finally, get all of the payment methods for the orders based on their Ids.
$orders = [];
foreach ($orderIds as $orderId) {
    $results = $wpdb->get_results(
        $wpdb->prepare(
            "" // The query for retrieving various payment method information based on the $orderId
        ),
        ARRAY_A
    );

    if (empty($results)) {
        continue;
    }

    $orders[$orderId] = $results;
}

// Now send the information back to the user.
wp_send_json_success($orders);

Kuid see ei pea nii olema.

Esiteks on need kõik sõltumatud päringud sõltumatute tulemuste komplektidega, kuigi neid tuleb kasutada paralleelselt. See tähendab, et saame need osadeks lahutada ja hinnata igaühe tulemusi, enne kui järgmise sammuga edasi liigume.

Lisaks võimaldab see meil kirjutada väiksemaid sidusamaid funktsioone. Kuigi need võivad üksteisest sõltuda, saame seadistada iga funktsiooni aktsepteerima argumenti (või argumentide komplekti, millest saame kogu teabe hankida.

Võib-olla näeb lõpptulemus välja umbes selline :

<?php

public function getPaymentMethods()
{
  $authInfo = $this->getAuthorizationInformation();
  $currentCustomerId = $this->getCurrentCustomerId($authInfo);
  $orders = $this->getCustomerOrders($currentCustomerId);
  $paymentMethods = $this->getPaymentMethodsFromOrders($orders);
  wp_send_json_success($orders);
}

private function getAuthorizationInformation()
{
  global $wpdb;
  $authInfo = $wpdb->get_results(
      $wpdb->prepare(
          "
          SELECT
              user_id, meta_value
          FROM $wpdb->usermeta
          WHERE meta_key LIKE %s
          AND user_id = %d
          ",
          '%customer_profile_id%',
          filter_input(INPUT_GET, 'customer_id')
      ),
      ARRAY_A
  );

  return isset($authInfo[0])? array_column($authInfo[0], 'meta_value'): [];
}

private function getCurrentCustomerIdFromAuthInfo($authInfo)
{
  global $wpdb;
  $customers = $wpdb->get_results(
      $wpdb->prepare(
          "", // Your custom query goes here.
          $authInfo;
      ),
      ARRAY_A
  );

  return isset($customerId[0])? array_column($customerId[0], 'meta_value'): [];
}

private function getCustomerOrders($customerId)
{
  global $wpdb;
  $orderIds = $wpdb->get_results(
      $wpdb->prepare(
          "", // Your custom query goes here.
          $customerId
      ),
      ARRAY_A
  );

  return empty($orderIds)? []: $orderIds;
}

private function getPaymentMethodsFromOrders($orderIds)
{
  $paymentMethods = [];
  foreach ($orderIds as $orderId) {
      $results = $wpdb->get_results(
          $wpdb->prepare(
              "" // The query for retrieving various payment method information based on the $orderId
          ),
          ARRAY_A
      );

      if (empty($results)) {
          continue;
      }

      $paymentMethods[$orderId] = $results;
  }

  return $paymentMethods;
}

Muidugi ei saa ma näidata tegelikku SQL-i – noh, vähemalt mitte igal pool –, sest ma ei tea üldist seadistust ega ka täpselt, milliste pistikprogrammide või skeemidega te töötate.

Kuid see pole kunagi olnud selle postituse mõte.

Selle asemel püüan öelda järgmist: kuigi me töötame väga piiratud piirangute all, saame siiski jagada programmid väiksemateks komponentideks, mis aitavad meil toimuvat kirjeldada, mõista, kuidas seda tehakse ja seejärel andmeid saata. edasi-tagasi erinevate funktsioonide vahel ning kasutajale ja tagasi.

: tommcfarlin.com