Почему разработчики ColdFusion решили индексировать массивы от 1, а не от 0? - PullRequest
11 голосов
/ 07 января 2009

Мне просто интересно об этом, кто-нибудь знает, почему они нарушили соглашение об этом?

Спасибо, Киран

Ответы [ 10 ]

24 голосов
/ 07 января 2009

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

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

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

10 голосов
/ 07 января 2009

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

9 голосов
/ 07 января 2009

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

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

6 голосов
/ 07 января 2009

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

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

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

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

5 голосов
/ 27 июня 2012

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

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

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

arrayBaseAddress + (whichElementItIsInTheArray * sizeOfDataType)

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

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

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

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

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

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

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

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

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

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

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

5 голосов
/ 07 января 2009

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

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

3 голосов
/ 14 января 2009

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

2 голосов
/ 07 января 2009

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

0 голосов
/ 26 января 2015

Может быть, дело не только в непрофессионале ... Я думаю, что большинство людей, обращающихся к любому веб-языку, по крайней мере возились с 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.

0 голосов
/ 07 января 2009

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

...