Strings in Python intelligent machen

Gute Architekturideen eignen sich nicht nur für große und komplizierte Projekte. Egal, ob Sie schon einmal von Domain-Driven Design gehört haben oder nicht, ich zeige Ihnen, wie Sie Ihr Projekt, ob groß oder klein, verbessern können, indem Sie die Grundprinzipien auf die Strings anwenden, die Sie herumgereicht haben. Es ist Zeit, die verstreuten Teile des Validierungs- und Parsing-Codes, die Sie überall verstreut haben, zu sammeln und in einer schönen, wiederverwendbaren Einheit zusammenzufassen.

Wir werden hier nur an der Oberfläche des domänengesteuerten Designs kratzen. Am Ende dieses Artikels sollten Sie sich ein Exemplar des gleichnamigen Buches von Eric Evans besorgen. Das Kernkonzept besteht darin, dass Ihr Objektmodell am besten mit der Sprache der Geschäftsdomäne entwickelt wird. Die Geschäftsregeln sind im Modell kodiert. Dies wird vom Anwendungs- und Infrastrukturcode getrennt gehalten. Wir bleiben bei einem einfachen Beispiel, wie Sie diese Idee auf Zeichenfolgen in Ihrem Code anwenden können.

Ich habe festgestellt, dass Saiten zunächst einmal ein einfaches Ziel sind, und wenn das alles ist, was Sie tun, werden Sie die Vorteile genießen. Heutzutage verfügen wir über eine Methode, um den Terminalstandort eines Fluges anhand seiner Flugnummer zu ermitteln, z. B. LA8165. Wir können die Flugnummer als Zeichenfolge behandeln:

def getTerminal(flight_number): 
  return db.getTerminal(flight_number)

def getTerminal(flight_number): 
  # Normalize input to a clean string
  flight_number = str(flight_number).upper().strip()
  if not flight_number:
    raise ValueError(“Flight Number can not be empty.”)

  return db.getTerminal(flight_number)

class FlightNumber(object):
  def __init__(self, flight_number):
    # Normalize input to a clean string
    flight_number = str(flight_number).upper().strip()
    if not flight_number:
      raise ValueError(“Flight Number can not be empty.”)
    self.flight_number = flight_number

  # The value when this is cast to a string or used in a formatted string
  def __str__(self):
    return self.flight_number

def getTerminal(flight_number): 
  flight_number = FlightNumber(flight_number)
  return db.getTerminal(str(flight_number))

Wir werden nun alle subtilen Vorteile dieser Denkweise untersuchen:

1. Unsere neue Klasse ist unglaublich einfach zu testen, da sie keine Dateisysteme, Netzwerke oder irgendetwas berührt, das wir verspotten müssen.
2. Wir haben einen einzigen Ort, an dem Sie Dokumentation hinzufügen können.
3. Wir können dies mit allen Regeln und Parsing vollpacken, die wir benötigen, um es zu vervollständigen.
4. Jeder, der neu im Projekt ist, wird ganz einfach lernen, was eine Flugnummer ist.
5. Alle diese Objekte können in einem Domänenordner abgelegt werden, um sie wiederverwendbar und auffindbar zu machen.
6. Der aufrufende Code ist einfacher zu lesen und Pull-Anfragen sind einfacher.
7. Fehler werden im Stapel früher erkannt

class FlightNumber(object):
  """
  Represents an International Air Transport Association flight number. Ex — LA8165
  The format is two uppercase letters for the airline followed by up to four digits. 
  """
  def __init__(self, flight_number):
  # Normalize input to a clean string
  flight_number = str(flight_number).upper().strip()
  if not flight_number:
    raise ValueError("Flight Number can not be empty.")
  self.airline_code = flight_number[0:2].strip()
  if not self.airline_code.isalpha():
    raise ValueError(f"Airline Code {self.airline_code} must be two letters.")
  # Throws ValueError already if not a valid int
  self.numeric_part = int(flight_number[2:])
  if self.numeric_part < 1 or self.numeric_part > 9999:
    raise ValueError(f”Flight Number {self.numeric_part} must be from 1 to 9999.”)
  if self.numeric_part == 666:
    raise ValueError(f"Seriously, airlines don’t use this flight number.")

  def __str__(self):
    return f"{self.airline_code}{self.numeric_part}"

Verweise

• Domänengesteuertes Design