Пирамида судьбы (программирование)

В компьютерном программировании пирамида гибели — распространенная проблема, возникающая, когда программа использует множество уровней вложенных отступов для управления доступом к функции. Это обычно наблюдается при проверке нулевых указателей или обработке обратных вызовов . Два примера термина относятся к определенному стилю программирования в JavaScript : и вложенность операторов if , которая возникает в объектно-ориентированных языках программирования, когда один из объектов может быть нулевым указателем.

Примеры

В большинстве современных объектно-ориентированных языков программирования используется стиль кодирования, известный как точечная запись, который позволяет записывать несколько вызовов методов в одной строке кода, причем каждый вызов отделяется точкой. Например:

theWidth = windows("Main").views(5).size().width();

Этот код содержит четыре разные инструкции; сначала он ищет в коллекции окон окно с именем «Основное», затем ищет в коллекции представлений этого окна пятое подпредставление внутри него, а затем вызывает метод size метод для возврата структуры с размерами представления и, наконец, вызывает метод width метод этой структуры для получения результата, присвоенного имени переменной theWidth.

Проблема этого подхода в том, что код предполагает, что все эти значения существуют. Хотя разумно ожидать, что окно будет иметь размер, а этот размер будет иметь ширину, совершенно неразумно предполагать, что будет существовать окно с именем «Main» или что оно будет иметь пять подпредставлений. Если какое-либо из этих предположений неверно, один из методов будет вызван с нулевым значением, что приведет к ошибке нулевого указателя.

Чтобы избежать этой ошибки, программист должен проверять каждый вызов метода, чтобы убедиться, что он возвращает значение. Более безопасная версия того же кода:

if windows.contains("Main") {
    if windows("Main").views.contains(5) {
        theWidth = windows("Main").views(5).size().width();
        //more code that works with theWidth
    }
}

Если программист желает использовать это значение в зависимости от того, существует оно или нет и является ли оно допустимым, функциональный код внутри if все операторы сдвинуты вправо, что затрудняет чтение длинных строк. Это часто приводит к попыткам «сгладить» код:

if windows.contains("Main") { theWindow = windows("Main") }
if theWindow != null && theWindow.views.contains(5) { theView = theWindow.views(5) }
if theView != null {
    theWidth = theView.size().width();
    //additional code
}

Или альтернативно:

if !windows.contains("Main") {
    // handle error
} else if !windows("Main").views.contains(5) {
    // handle error
} else {
    theWidth = windows("Main").views(5).size().width();
    //more code that works with theWidth
}

Подобные конструкции программирования очень распространены, и в ряде языков программирования для решения этой проблемы добавлен своего рода синтаксический сахар . Например, Swift от Apple добавил концепцию необязательной цепочки в операторы if. в то время как в Microsoft C# 6.0 и Visual Basic 14 добавлены с нулевым условием операторы ?. и ?[ для доступа к членам и индексирования соответственно. Основная идея состоит в том, чтобы позволить строке вызовов методов немедленно возвращать значение NULL, если какой-либо из ее членов имеет значение NULL, например:

theWidth = windows("Main")?.views(5)?.size.width;

присвоил бы ноль theWidth если отсутствует «Основное» или пятое подпредставление, или завершите оператор и верните ширину, если они оба действительны. Во многих случаях программисту требуется выполнить разные действия в этих двух случаях, поэтому Swift добавляет для этой роли еще одну форму синтаксического сахара — if let оператор, также известный как «необязательная привязка»:

if let theView = windows("Main")?.views(5) {
    //do things knowing the view exists...
    theWidth = theView.size.width
}

Разрешение

Pyramid of Doom обычно можно решить на любом языке, просто разбив код на несколько вложенных функций (или других групп). Например, вместо:

main() {
	aaaaa() {
		bbbbb() {

			ccccc() {
				ddddd() {
					// do something now
				}
			}

		}
	}
}

Вы можете разбить функциональность следующим образом:

doSomething() {
	// do something now
}

CC() {
	ccccc() {
		ddddd() {
			doSomething()
		}
	}
}

main() {
	aaaaa() {
		bbbbb() {
			CC()
		}
	}
}

Аналогичным образом структуры данных могут быть разбиты по уровням, когда возникают подобные пирамиды.

Пирамида Судьбы не только решена, но и лучше не использовать большие и сложные функции; меньшие легче понять, их легче прочитать и проверить работу. Выбор названий функций для каждого из этих уровней также поможет автору разъяснить читателям, что и где делается. Обычно каждому уровню не требуется много соединений с удаленными уровнями, поэтому их легко отделить. Если такие связи есть, автор может переосмыслить свою конструкцию на что-то более надежное, ведь это благодатный источник ошибок.

См. также

• Обещания — метод, позволяющий избежать пирамиды гибели, например, используемый в JavaScript.
• Закон Деметры
• Оператор безопасной навигации — оператор языка программирования, позволяющий избежать пирамиды гибели.