iTranslated by AI
OOP FizzBuzz in TypeScript
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:
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