Почему дизайнеры ColdFusion решили индексировать массивы с 1, а не 0?

Ответ 1

@Cory: Вы будете удивлены, узнав, кто скрывается в StackOverflow.: -)

Ты очень прав. Оригинальный дизайн CFML заключался в том, чтобы позволить программистам не создавать сложные веб-приложения. ColdFusion\CFML был первым языком, разработанным специально для создания веб-приложений. Еще в 1995 году сеть была в основном статическим HTML, и ваш типичный "веб-разработчик" не слишком много программировал. Сам язык был разработан настолько простым, насколько это возможно, поэтому он по-прежнему является одним из самых быстрых/простых языков для изучения.

Это может привести к некоторой путанице, особенно когда код ColdFusion взаимодействует напрямую с Java или .NET. Однако он просто стал одним из этих "причуд". Решение было повторно рассмотрено еще в 2000/2001 году, когда CF был перестроен как приложение Java EE, но обратная совместимость предотвратила изменение.

Ответ 2

Существуют два соглашения, один из которых относится к большинству языков программирования, и один общий для большинства непрограммистов. Вероятно, они были нацелены на людей, которые не начинают рассчитывать с 0.

Ответ 3

Если бы я должен был догадаться, это потому, что ColdFusion был нацелен на обращение к новичкам, а массивы на основе 1 могли бы иметь больше смысла - первый элемент - номер 1, второй - номер 2 и т.д.

Это компьютерные ученые, которые странны!

Ответ 4

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

Если вы посмотрите на исходный язык, он был разработан для разработки типа RAD для людей, которые хотели создавать динамические приложения без большой сложности. Я до сих пор помню радость, когда они наконец выпустили пользовательские функции, поэтому мне не приходилось использовать теги везде.

Исходя из этого, тогда было бы разумно, что с языками, с которыми приходится сталкиваться людям - например, с массивами - они станут более "дружелюбными". Мне кажется, что массив [0] имеет смысл. Но для людей, не знакомых с парадигмой, которые этого не узнали, это не имело никакого смысла. Зачем мне обращаться к объекту в позиции "0"?

Самое смешное, что теперь, когда CF является Java в бэкэнд, вам действительно приходится иметь дело с случаями, когда ваш индекс начинается с 1, а случаи, когда он начинается с нуля. Поэтому, пытаясь быть полезным, они фактически добавили в сложность по мере роста языка.

Ответ 5

Подсчитайте количество пальцев, которые у вас есть, с одной стороны. Вы начали отсчет с 0 или с 1?

Абстрактные идеи, которые тесно параллельны реальной жизни, всегда легче понять и применить (например: думать о физическом "стеке", а затем о абстрактной структуре данных).

Ответ 6

Как другой спин на нем, спросите, почему на некоторых языках индекс массива начинается с нуля? Для подсчета дискретных объектов (например, элементов массива) это имеет мало смысла и не является естественным с точки зрения человека.

Первоначально это происходило из таких языков, как C (хотя я не предполагаю, что это сначала возникло в C: я не знаю, и это не имеет значения для целей этого), в котором язык и его программирование довольно тесно связан с управлением памятью (malloc и т.д.). Некоторые C-языки тщеславия довольно близко сопоставляются с тем, что происходит в памяти под капотом. Переменные - пример этого: а также имена переменных, мы всегда занимаемся адресом памяти, в котором переменная находится (или начинается с) с помощью указателей и т.п.

Итак, мы приходим к массивам в C, и они индексируются таким образом, что существует ряд элементов, которые находятся в памяти, начиная с базового расположения памяти переменной массива, и каждый элемент смещается на размер тип данных (например: a char - один байт и т.д.). Поэтому, чтобы найти каждый элемент в массиве в памяти, мы делаем следующее:

arrayBaseAddress + (whichElementItIsInTheArray * sizeOfDataType)

И действительно, действительно, на самом деле это происходит, когда вы делаете что-то на C, потому что оно довольно близко сопоставляет то, что компьютер должен делать под капотом, чтобы найти значение, которое хочет код.

Итак, whichElementItIsInTheArray используется для смещения адреса памяти (в единицах sizeOfDataType).

Очевидно, что если один из них запускает индекс массива в 1, он будет смещен в памяти одним sizeOfDataType, поскольку все намерения и цели теряют объем памяти sizeOfDataType между arrayBaseAddress и где первый элемент фактически находится.

Можно подумать, что это вряд ли имеет значение, но во времена, когда все это выполнялось, память была похожа на золото: она не могла быть потрачена впустую. Поэтому можно подумать: "Хорошо, просто смещайте whichElementItIsInTheArray на -1 под капотом и делайте с ним. Однако, как память, тактовые циклы были золотыми, поэтому вместо того, чтобы тратить на обработку, идея заключалась в том, что программисту просто нужно было привыкнуть к неестественному способу подсчета.

Таким образом, в этих ситуациях была законная причина запуска массивов с нулевым индексом.

Мне кажется (и теперь это становится редакционным уклоном), когда появились последующие языки "фигурных скобок" (например, Java), они просто последовали примеру, действительно ли это было актуально или нет, потому что "так, как это делается". Вместо этого "это имеет смысл".

С другой стороны, более современные языки и еще более удаленные от внутренней работы компьютера, кто-то остановился, чтобы подумать "зачем мы это делаем?" и "в контексте этого языка и его предполагаемого использования, Имеет ли это смысл?". Я согласен с этим, чем ответ - твердо - "нет". Потери ресурса, чтобы компенсировать индекс массива на -1, или просто просто игнорировать память нулевого элемента, больше не являются важным соображением во многих обстоятельствах. Итак, почему язык и программист должны компенсировать то, как они, естественно, подсчитывают вещи одним, по чисто наследственной причине? Для этого нет законных оснований.

В C существует элемент массива a[0]. Это первый элемент массива (а не "нулевой" элемент), и если это полная длина массива, длина равна единице. Таким образом, индивидуальное поведение здесь происходит со стороны языка программирования, а не с точки зрения того, как вещи считаются/перечислены "в реальной жизни" (в которых большинство из нас проживает). Так зачем же упорствовать в этом?

Некоторые люди здесь возражают против этого аргумента "где начинать индекс" с "хорошо, когда мы рождаемся, мы не ОДИН, а мы - нуль". Это правда, но это измерение непрерывной вещи, и это не то же самое. Так что это не имеет отношения к разговору. Массив представляет собой набор дискретных элементов, и при измерении количества отдельных элементов (т.е. Подсчета их) мы начинаем с одного.

Как это добавляет к разговору? Ну, это не так много, но это другой способ взглянуть на одно и то же. И я полагаю, что это немного рационализация/реакция на это понятие, которое у некоторых людей есть, что начальные индексы массива в 1 как-то "ошибочны". Это не так, с человеческой точки зрения, это более правильно, чем начинать их с нуля. Так пусть человек напишет код, как человек, и заставит машину понять это, как нужно. В основном это только для устаревших технологических ограничений, которые мы когда-либо начинали считать их с нуля в первую очередь, и нет необходимости увековечивать эту практику, если нам больше не нужно.

Все "ИМО", конечно.

Ответ 7

Понятие начальных массивов в 0 было популяризировано на языке C. Более старые языки, такие как FORTRAN и COBOL, начали подсчитывать массивы в 1 (фактически называемые таблицами в COBOL).

Ответ 8

В исходной точке массива нет соглашения. Большинство основ начинаются с 1 также, например. Некоторые языки позволяют вам запускать массив везде, где вам нравится, или индексировать индексы для перечисления и т.д. (Например, Ada). C использовал понятие жало в 0, и многие языки следовали, но не все это делают. Одна из причин, почему они этого не делают, - это то, что массивы, начинающиеся с 1, гораздо более интуитивно понятны.

Ответ 9

Даже в мире программирования Java API есть интересное исключение: подсчет на основе 0: API JDBC. Он начинает отсчет с 1, к большому удивлению, каждый программист делает свой первый доступ к базе данных.

Ответ 10

Возможно, это было не просто неспециалистом... Я думаю, что большинство людей, приближающихся к любому веб-языку, по крайней мере играли с javascript (и то же самое было 10,15 лет назад). 0-индексы не были столь уж чуждыми.

То, что мне нравится в языках, начинающих индексы/позиции (для строк) в 1, - это то, что вы можете делать такие вещи, как

<cfif find("c","cat")>

который вычисляет true, если c найден, и он будет.

тогда как язык на основе 0, такой как javascript

if ("cat".indexOf("c")) { 

оценивается как false, поэтому вам нужно сказать что-то вроде if ("cat".indexOf("c") >= 0) {

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

Я думаю, если бы Allaire знал, где в конечном итоге будет веб-сайт, и как клиент и сервер могут работать вместе, у нас будут индексы на основе 0.