Test Driven Development (TDD) – Was steckt wirklich dahinter? – Seite 4

Mehr als zwei Faktoren

Gegen den nächsten Test hat unser Code natürlich keine Chance. Er produziert aktuell höchstens zwei Faktoren und die 8 besteht aus drei.

$this->assertSame([2, 2, 2], $primeFactors->of(8));

1	$this->assertSame([2, 2, 2], $primeFactors->of(8));

Wer jetzt glaubt, wir müssten nun wirklich den richtigen Algorithmus entwickeln, wird leider enttäuscht. Wir folgen hier lediglich wieder dem Prinzip der Verallgemeinerung und machen aus einem „if“ eine „while“.

public function of($n)
{
	$factors = [];

	if ($n > 1) {
		while ($n % 2 == 0) {
			$factors[] = 2;
			$n /= 2;
		}
		if ($n > 1) {
			$factors[] = $n;
		}
	}

	return $factors;
}

public function of($n)

{

$factors = [];

if ($n > 1) {

while ($n % 2 == 0) {

$factors[] = 2;

$n /= 2;

}

if ($n > 1) {

$factors[] = $n;

}

return $factors;

}

OK (1 test, 8 assertions)

1	OK (1 test, 8 assertions)

Wenn das alles war, dann kann unser Code doch gar nicht so hässlich gewesen sein. Es fühlte sich nur so an. Mal sehen, ob wir überhaupt noch mehr tun müssen, als zu verallgemeinern.

Schritt für Schritt

$this->assertSame([3, 3], $primeFactors->of(9));

1	$this->assertSame([3, 3], $primeFactors->of(9));

Unser Code hat nichts was eine 3 produzieren könnte, er kennt bisher nur die 2.

Spontan fällt uns natürlich diese Lösung ein:

public function of($n)
{
	$factors = [];

	if ($n > 1) {
		while ($n % 2 == 0) {
			$factors[] = 2;
			$n /= 2;
		}
		while ($n % 3 == 0) {
			$factors[] = 3;
			$n /= 3;
		}

		if ($n > 1) {
			$factors[] = $n;
		}
	}

	return $factors;
}

public function of($n)

{

$factors = [];

if ($n > 1) {

while ($n % 2 == 0) {

$factors[] = 2;

$n /= 2;

}

while ($n % 3 == 0) {

$factors[] = 3;

$n /= 3;

}

if ($n > 1) {

$factors[] = $n;

}

return $factors;

}

Sie erfüllt alle Tests, hält sich aber nicht an das DRY-Prinzip (Don’t Repeat Yourself). Wir haben hier offensichtlich doppelten Code und bei der nächsten Primzahl (5) geht es wieder nicht weiter. Wir können hier aber sehr schön die Verallgemeinerung erkennen. Die korrekte Lösung ist somit:

public function of($n)
{
	$factors = [];
	$divisor = 2;

	while ($n > 1) {
		while ($n % $divisor == 0) {
			$factors[] = $divisor;
			$n /= $divisor;
		}
		$divisor++;
	}

	if ($n > 1) {
		$factors[] = $n;
	}

	return $factors;
}

public function of($n)

{

$factors = [];

$divisor = 2;

while ($n > 1) {

while ($n % $divisor == 0) {

$factors[] = $divisor;

$n /= $divisor;

}

$divisor++;

}

if ($n > 1) {

$factors[] = $n;

}

return $factors;

}

OK (1 test, 9 assertions)

1	OK (1 test, 9 assertions)

Wir haben also die 2 zu einer Variable verallgemeinert und gehen nun solange mögliche Faktoren durch wie $n größer 1 ist.

Fertig

Wir sind an dieser Stelle jetzt fertig. Wir können keinen Test im Sinne der Aufgabenstellung mehr schreiben, der noch fehlschlagen würde.

$this->assertSame([2, 2, 3, 7, 11, 13, 17], $primeFactors->of(2*2*3*7*11*13*17));

1	$this->assertSame([2, 2, 3, 7, 11, 13, 17], $primeFactors->of(2237111317));

OK (1 test, 10 assertions)

1	OK (1 test, 10 assertions)

Aufräumarbeiten

Das könnte der Zeitpunkt für einen Refactor sein. Die letzte if-Bedingung kann beispielsweise nicht mehr eintreten und ist daher überflüssig. Wer mag, kann auch noch auf for-Schleifen umsteigen und ein paar weitere Zeilen sparen. Ich genüge mich aber mit dieser Lösung.

public function of($n)
{
	$factors = [];
	$divisor = 2;

	while ($n > 1) {
		while ($n % $divisor == 0) {
			$factors[] = $divisor;
			$n /= $divisor;
		}
		$divisor++;
	}

	return $factors;
}

public function of($n)

{

$factors = [];

$divisor = 2;

while ($n > 1) {

while ($n % $divisor == 0) {

$factors[] = $divisor;

$n /= $divisor;

}

$divisor++;

}

return $factors;

}

OK (1 test, 10 assertions)

1	OK (1 test, 10 assertions)

Wir haben Tests. Refactoring ist also einfach. Solange die Tests weiterhin erfolgreich verlaufen, haben wir auch nichts kaputt gemacht.

Seiten: 1234