iTranslated by AI

The content below is an AI-generated translation. This is an experimental feature, and may contain errors. View original article
🥺

OOP FizzBuzz in TypeScript

に公開
2022/11/25

What is FizzBuzz?

Count numbers from 1 to 100 in order,
if it's a multiple of 3, output Fizz
if it's a multiple of 5, output Buzz
if it's a multiple of both 3 and 5, output FizzBuzz
otherwise, output the number as it is.

Some companies seem to use it in coding interviews.

Common Answer

for (let i = 1; i <= 100; i++) {
  if (i % 3 == 0 && i % 5 == 0) {
    console.log('FizzBuzz');
  } else if (i % 3 == 0) {
    console.log('Fizz');
  } else if (i % 5 == 0) {
    console.log('Buzz');
  } else {
    console.log(i);
  }
}

Making the Ultimate FizzBuzz with OOP

It's boring to write code that looks like a common answer.
Let's use our OOP knowledge to the fullest to create the ultimate FizzBuzz and surprise the recruiters.

If you want to see the code right away, click here:
https://github.com/Karibash/fizz-buzz-well-architected/blob/master/src/object-oriented-programming.ts

Defining classes to represent specifications

Define an interface with a method that returns a boolean indicating whether a value satisfies the specification.

interface Specification<Input> {
  isSatisfiedBy(value: Input): boolean;
}

To check FizzBuzz specifications, define several classes that implement Specification.

class TypeSpecification implements Specification<any> {
  constructor(
    private readonly type: string,
  ) {}

  public isSatisfiedBy(value: unknown): boolean {
    return typeof value === this.type;
  }
}

class DivisibleSpecification implements Specification<number> {
  constructor(
    private readonly divisor: number,
  ) {}

  public isSatisfiedBy(value: number): boolean {
    return value % this.divisor === 0;
  }
}

Now we can check the type and whether a number is divisible.

const typeSpecification = new TypeSpecification('number');

console.log(typeSpecification.isSatisfiedBy(1));
// => true

console.log(typeSpecification.isSatisfiedBy('1'));
// => false

const divisibleSpecification = new DivisibleSpecification(3);

console.log(divisibleSpecification.isSatisfiedBy(3));
// => true

console.log(divisibleSpecification.isSatisfiedBy(5));
// => false

Define CompositeSpecification to allow combining multiple specifications.

class CompositeSpecification<Input> implements Specification<Input> {
  private constructor(
    private readonly predicate: (value: Input) => boolean,
  ) {}

  public static when<Input>(specification: Specification<Input>): CompositeSpecification<Input> {
    return new CompositeSpecification(value => specification.isSatisfiedBy(value));
  }

  public isSatisfiedBy(value: Input): boolean {
    return this.predicate(value);
  }

  public and(specification: Specification<Input>): CompositeSpecification<Input> {
    return new CompositeSpecification(value => this.predicate(value) && specification.isSatisfiedBy(value));
  }

  public or(specification: Specification<Input>): CompositeSpecification<Input> {
    return new CompositeSpecification(value => this.predicate(value) || specification.isSatisfiedBy(value));
  }
}

By using method chaining as shown below, you can evaluate multiple conditions.

const fizzBuzzSpecification = CompositeSpecification
  .when(new TypeSpecification('number'))
  .and(new DivisibleSpecification(3))
  .and(new DivisibleSpecification(5)),

console.log(fizzBuzzSpecification.isSatisfiedBy(1));
// => false

console.log(fizzBuzzSpecification.isSatisfiedBy(15));
// => true

Defining a class to convert numbers to strings

Define a NumberToStringOperation class that converts numbers to strings.

interface Operation<Input, Output> {
  invoke(value: Input): Output;
}

class NumberToStringOperation implements Operation<number, string> {
  constructor(
    private readonly converter: (value: number) => string,
  ) {}

  public invoke(value: number): string {
    return this.converter(value);
  }
}

Use it as follows.

const numberToStringOperation = new NumberToStringOperation(value => value.toString());

console.log(numberToStringOperation.invoke(1);
// -> 1

const fizzOperation = new NumberToStringOperation(() => 'Fizz');

console.log(fizzOperation.invoke(3));
// => Fizz

Defining a class that executes an Operation satisfying a Specification

Define an interface that indicates the presence of a Specification, and a class that executes an Operation if the Specification is met.

interface HasSpecification<Input> {
  readonly specification: Specification<Input>;
}

class Operator<Input, Output> {
  constructor(
    private readonly operations: Array<Operation<Input, Output> & HasSpecification<Input>>,
  ) {}

  public invoke(value: Input): Output {
    const operation = this.operations.find(operation => operation.specification.isSatisfiedBy(value));
    if (!operation) throw new Error('Operation does not found');
    return operation.invoke(value);
  }
}

Implement HasSpecification in NumberToStringOperation so it can be used with Operator.

- class NumberToStringOperation implements Operation<number, string> {
+ class NumberToStringOperation implements Operation<number, string>, HasSpecification<number> {
  constructor(
    private readonly converter: (value: number) => string,
+   public readonly specification: Specification<number>,
  ) {}

  public invoke(value: number): string {
    return this.converter(value);
  }
}

Completion

Implement the Operator with the FizzBuzz specifications to complete the code.
Now you are safe even if the FizzBuzz specifications change suddenly.

const operator = new Operator([
  new NumberToStringOperation(() => 'FizzBuzz',
    CompositeSpecification
      .when(new TypeSpecification('number'))
      .and(new DivisibleSpecification(3))
      .and(new DivisibleSpecification(5)),
  ),
  new NumberToStringOperation(() => 'Fizz',
    CompositeSpecification
      .when(new TypeSpecification('number'))
      .and(new DivisibleSpecification(3)),
  ),
  new NumberToStringOperation(() => 'Buzz',
    CompositeSpecification
      .when(new TypeSpecification('number'))
      .and(new DivisibleSpecification(5)),
  ),
  new NumberToStringOperation(value => value.toString(),
    CompositeSpecification
      .when(new TypeSpecification('number')),
  ),
]);

for (let i = 1; i <= 100; i++) {
  console.log(operator.invoke(i));
}

Bonus (Sekai no Nabeatsu)

Create a version that "goes crazy" on multiples of 3 and numbers containing the digit 3.
Simply add a Specification to check if the number contains the digit 3.

class NumberIncludesSpecification implements Specification<number> {
  constructor(
    private readonly value: number,
  ) {}

  public isSatisfiedBy(value: number): boolean {
    return value.toString().indexOf(this.value.toString()) !== -1;
  }
}

Just by changing the FizzBuzz logic part, Nabeatsu is complete.

const operator = new Operator([
  new NumberToStringOperation(value => `( ᐛ ) > ${value}`,
    CompositeSpecification
      .when(new TypeSpecification('number'))
      .and(new IncludesSpecification(3)),
  ),
  new NumberToStringOperation(value => `( ᐛ ) > ${value}`,
    CompositeSpecification
      .when(new TypeSpecification('number'))
      .and(new DivisibleSpecification(3)),
  ),
  new NumberToStringOperation(value => `( ˙-˙ ) > ${value}`,
    CompositeSpecification
      .when(new TypeSpecification('number')),
  ),
]);

for (let i = 1; i <= 100; i++) {
  console.log(operator.invoke(i));
}

Discussion