Merge pull request #39 from leemhoon00/main

add 5 examples

Author: neochief

src/Memento/Book/index.ts

@@ -0,0 +1,66 @@
+export interface Memento {
+  getName(): string;
+  getSnapshotDate(): Date;
+  getText(): string;
+}
+
+class Editor {
+  private text: string;
+
+  constructor(private name: string) {
+    this.text = "";
+  }
+
+  makeSnapshot(): Memento {
+    return new Snapshot(this.name, this.text);
+  }
+
+  restore(memento: Memento) {
+    this.text = memento.getText();
+  }
+
+  editText(newText: string) {
+    this.text = newText;
+  }
+
+  displayText() {
+    console.log("Current Text: " + this.text);
+  }
+}
+
+class Snapshot implements Memento {
+  private name: string;
+  private text: string;
+  private date: Date;
+
+  constructor(name: string, text: string) {
+    this.name = name;
+    this.text = text;
+    this.date = new Date();
+  }
+
+  getName(): string {
+    return this.name;
+  }
+
+  getSnapshotDate(): Date {
+    return this.date;
+  }
+
+  getText(): string {
+    return this.text;
+  }
+}
+
+const editor = new Editor("Document 1");
+
+editor.editText("This is the initial text");
+editor.displayText();
+
+const snapshot1 = editor.makeSnapshot();
+
+editor.editText("Text after editing");
+editor.displayText();
+
+editor.restore(snapshot1);
+editor.displayText();

src/State/Book/index.ts

@@ -0,0 +1,70 @@
+export interface State {
+  render(): void;
+  publish(): void;
+}
+
+class Document {
+  private state: State;
+
+  constructor() {
+    this.state = new DraftState(this);
+  }
+
+  changeState(state: State) {
+    this.state = state;
+  }
+
+  render() {
+    this.state.render();
+  }
+
+  publish() {
+    this.state.publish();
+  }
+}
+
+class DraftState implements State {
+  constructor(private document: Document) {}
+
+  render() {
+    console.log("Rendering the document in Draft state");
+  }
+
+  publish() {
+    console.log("Moving the document to Moderation state");
+    this.document.changeState(new ModerationState(this.document));
+  }
+}
+
+class ModerationState implements State {
+  constructor(private document: Document) {}
+
+  render() {
+    console.log("Rendering the document in Moderation state");
+  }
+
+  publish() {
+    console.log("Making the document public in Published state");
+    this.document.changeState(new PublishedState(this.document));
+  }
+}
+
+class PublishedState implements State {
+  constructor(private document: Document) {}
+
+  render() {
+    console.log("Rendering the document in Published state");
+  }
+
+  publish() {
+    console.log("The document is already in Published state. Nothing to do.");
+  }
+}
+
+const document = new Document();
+
+document.render();
+document.publish();
+document.publish();
+document.render();
+document.publish();

src/Strategy/Book/index.ts

@@ -0,0 +1,48 @@
+export interface RouteStrategy {
+  buildRoute(origin: string, destination: string): string;
+}
+
+class RoadStrategy implements RouteStrategy {
+  buildRoute(origin: string, destination: string): string {
+    return `Road route from ${origin} to ${destination}`;
+  }
+}
+
+class WalkingStrategy implements RouteStrategy {
+  buildRoute(origin: string, destination: string): string {
+    return `Walking route from ${origin} to ${destination}`;
+  }
+}
+
+class PublicTransportStrategy implements RouteStrategy {
+  buildRoute(origin: string, destination: string): string {
+    return `Public transport route from ${origin} to ${destination}`;
+  }
+}
+
+class Navigator {
+  private routeStrategy: RouteStrategy;
+
+  setRouteStrategy(strategy: RouteStrategy) {
+    this.routeStrategy = strategy;
+  }
+
+  buildRoute(origin: string, destination: string): string {
+    if (this.routeStrategy) {
+      return this.routeStrategy.buildRoute(origin, destination);
+    } else {
+      return "No route strategy set.";
+    }
+  }
+}
+
+const navigator = new Navigator();
+
+navigator.setRouteStrategy(new RoadStrategy());
+console.log(navigator.buildRoute("City A", "City B"));
+
+navigator.setRouteStrategy(new WalkingStrategy());
+console.log(navigator.buildRoute("Park X", "Museum Y"));
+
+navigator.setRouteStrategy(new PublicTransportStrategy());
+console.log(navigator.buildRoute("Station P", "Station Q"));

src/TemplateMethod/Book/index.ts

@@ -0,0 +1,89 @@
+abstract class DataMiner {
+  // Template method: Define the overall data mining process
+  mine(path: string): void {
+    this.openFile(path);
+    this.extractData();
+    this.parseData();
+    this.analyzeData();
+    this.sendReport();
+    this.closeFile();
+  }
+
+  // Abstract methods: Subclasses must implement these
+  abstract openFile(path: string): void;
+  abstract extractData(): void;
+  abstract closeFile(): void;
+  abstract parseData(): void;
+
+  // Optional methods: Default implementations are provided and can be overridden
+  analyzeData() {
+    console.log("Analyzing data... (Default implementation)");
+  }
+
+  sendReport() {
+    console.log("Sending report... (Default implementation)");
+  }
+}
+
+class DocDataMiner extends DataMiner {
+  openFile(path: string) {
+    console.log(`Opening DOC file: ${path}`);
+  }
+
+  extractData() {
+    console.log("Extracting data from DOC file");
+  }
+
+  closeFile() {
+    console.log("Closing DOC file");
+  }
+
+  parseData() {
+    console.log("Parsing data from DOC file");
+  }
+}
+
+class CSVDataMiner extends DataMiner {
+  openFile(path: string) {
+    console.log(`Opening CSV file: ${path}`);
+  }
+
+  extractData() {
+    console.log("Extracting data from CSV file");
+  }
+
+  closeFile() {
+    console.log("Closing CSV file");
+  }
+
+  parseData() {
+    console.log("Parsing data from CSV file");
+  }
+}
+
+class PDFDataMiner extends DataMiner {
+  openFile(path: string) {
+    console.log(`Opening PDF file: ${path}`);
+  }
+
+  extractData() {
+    console.log("Extracting data from PDF file");
+  }
+
+  closeFile() {
+    console.log("Closing PDF file");
+  }
+
+  parseData() {
+    console.log("Parsing data from PDF file");
+  }
+}
+
+// Client code
+const docDataMiner = new DocDataMiner();
+const csvDataMiner = new CSVDataMiner();
+const pdfDataMiner = new PDFDataMiner();
+
+docDataMiner.mine("data.doc");
+csvDataMiner.mine("data.csv");
+pdfDataMiner.mine("data.pdf");

src/Visitor/Book/index.ts

@@ -0,0 +1,51 @@
+export interface Visitor {
+  doForCity(city: City): void;
+  doForIndustry(industry: Industry): void;
+  doForSightSeeing(sightSeeing: SightSeeing): void;
+}
+
+abstract class Node {
+  abstract accept(visitor: Visitor): void;
+}
+
+class City extends Node {
+  accept(visitor: Visitor) {
+    visitor.doForCity(this);
+  }
+}
+
+class Industry extends Node {
+  accept(visitor: Visitor) {
+    visitor.doForIndustry(this);
+  }
+}
+
+class SightSeeing extends Node {
+  accept(visitor: Visitor) {
+    visitor.doForSightSeeing(this);
+  }
+}
+
+class ExportVisitor implements Visitor {
+  doForCity(city: City) {
+    console.log(`Exporting City node to XML: ${city}`);
+  }
+
+  doForIndustry(industry: Industry) {
+    console.log(`Exporting Industry node to XML: ${industry}`);
+  }
+
+  doForSightSeeing(sightSeeing: SightSeeing) {
+    console.log(`Exporting SightSeeing node to XML: ${sightSeeing}`);
+  }
+}
+
+const graph: Node[] = [];
+
+graph.push(new City());
+graph.push(new Industry());
+graph.push(new SightSeeing());
+
+const xmlExportVisitor = new ExportVisitor();
+
+graph.forEach((node) => node.accept(xmlExportVisitor));