Подтвердить что ты не робот

Точки с запятой в С#

Почему точки с запятой необходимы в конце каждой строки в С#? Почему он не может знать, где заканчивается каждая строка?

4b9b3361

ОТВЕТЫ

Ответ 1

Символ терминатора линии позволит вам разбить оператор на несколько строк.

С другой стороны, такие языки, как VB, имеют символ продолжения строки. Я лично считаю, что намного проще прекращать операции с точкой с запятой, а не продолжать использовать символы подчеркивания.

Ответ 2

Сколько это утверждений?

for (int i = 0; i < 100; i++) // <--- should there be a semi-colon here?
Console.WriteLine("foo")

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

Ответ 3

Нет, компилятор не знает, что прерывание строки для завершения заявления, и не должно. Это позволяет вам переносить выражение в многострочные, если хотите.

См:

string sql = @"SELECT foo
               FROM bar
               WHERE baz=42";

Или как о перегрузках больших методов:

CallMyMethod(thisIsSomethingForArgument1,
             thisIsSomethingForArgument2,
             thisIsSomethingForArgument2,
             thisIsSomethingForArgument3,
             thisIsSomethingForArgument4,
             thisIsSomethingForArgument5,
             thisIsSomethingForArgument6);

И наоборот, полуколония также допускает многострочные строки:

string s = ""; int i = 0;

Ответ 4

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

Ответ 5

Строго говоря, это верно: если человек может понять, где заканчивается утверждение, то и компилятор. На самом деле это еще не дошло, и немногие языки реализуют что-либо подобное. Следующая версия VB, вероятно, станет первым языком для правильной обработки операторов, которые не требуют ни явного завершения, ни продолжения строки [source]. Это позволит сделать код следующим образом:

Dim a = OneVeryLongExpression +
        AnotherLongExpression
Dim b = 2 * a

Пусть наши пальцы скрещены.

С другой стороны, это делает синтаксический анализ намного сложнее и может привести к плохим сообщениям об ошибках (см. Haskell).

Тем не менее, причина того, что С# использовать синтаксис типа C, вероятно, объясняется маркетинговыми соображениями больше всего: люди уже знакомы с такими языками, как C, С++ и Java. Не нужно вводить еще один синтаксис. Это имеет смысл по целому ряду причин, но, очевидно, наследует множество слабых сторон от этих языков.

Ответ 6

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

И вопреки распространенному мнению, 100% времени для компилятора невозможно выяснить, где заканчивается один конец, а другой начинается без помощи! Есть краевые случаи, когда это неоднозначно, является ли это одним утверждением или несколькими операторами, охватывающими несколько строк.

Прочитайте эту статью от Paul Vick, технический руководитель Visual Basic, чтобы понять, почему это не так просто, как кажется.

Ответ 7

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

a = b + c = d

может быть устранен между

a = b + c; = d

с ошибкой во втором выражении или

a = b + ; c = d

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

Это также помогает другим способом - если вы хотите написать

a = b; c = d;

но опечатал и оставил "c", а затем без semis выглядел бы как

a = b = d

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

Ответ 8

Я немного обдумывал этот вопрос, и если я могу угадать мотивы дизайнеров языка:

С#, очевидно, имеет точки с запятой из-за своего наследия от C. В последнее время я перечитываю книгу K & R, и довольно очевидно, что Деннис Ричи действительно не хотел заставить программистов кодировать то, как он считал лучшим. В книге много комментариев: "Хотя мы не догматичны по этому поводу, кажется, что инструкции goto следует использовать редко, если вообще", а в разделе о функциях они упоминают, что они выбрали один из многих стилей формата, неважно, какой из них вы выбираете, просто будьте последовательны.

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

Ответ 9

Это можно сделать. То, что вы называете, называется "вставка точки с запятой". JavaScript делает это с большим успехом, причина, почему он не применяется в С#, зависит от его дизайнеров. Возможно, они не знали об этом или боялись, что это может вызвать путаницу среди программистов.

Подробнее о вставке с запятой в JavaScript см. ECMA- script стандарт 262, где указан JavaScript.

Я цитирую со страницы 22 (в формате PDF, стр. 34):

  • Когда, когда программа анализируется слева справа, конец ввода поток токенов встречается и синтаксический анализатор не может проанализировать поток входных токенов как единый полный ECMA Script Программа, то точка с запятой вводится автоматически конец входного потока.

  • Когда, как программа анализируется слева направо, появляется токен, который допускается некоторым производством грамматики, но производство является ограниченным производством, и токеном будет первый токен для терминала или нетерминал сразу после аннотация "[no LineTerminator здесь]" с ограниченным производством (и, следовательно, такой токен называемый ограниченным токеном), и ограниченный токен отделен от него предыдущий токен, по крайней мере, один LineTerminator, затем точка с запятой автоматически вставлена ​​перед ограниченным токеном.

Однако существует дополнительная условие превышения предыдущего правила: точка с запятой никогда автоматически вставлен, если точка с запятой затем анализируется как пустой оператор или если эта точка с запятой станет одной из двух точек с запятой в заголовке оператора for (раздел 12.6.3).

[...]

В документе спецификации содержатся даже примеры!

Ответ 10

Я бы сказал, что самая большая причина, по которой точки с запятой необходимы после того, как каждое утверждение является знакомством для программистов, уже знакомых с C, С++ и/или Java. С# наследует многие синтаксические варианты с этих языков и не просто называется аналогично им. Операторы с концевыми запятыми - это лишь один из многих вариантов синтаксиса, заимствованных из этих языков.

Ответ 11

Вы можете точно утверждать, что требование о запятой для прекращения утверждения является излишним. Технически можно удалить точку с запятой с языка С# и по-прежнему работать. Проблема в том, что он оставляет место для неправильной интерпретации людьми. Я хотел бы утверждать, что необходимость точки с запятой - это неоднозначность ради людей, а не компилятора. Без какой-либо разграничения формулировок людям гораздо труднее интерпретировать консистентные элементы, такие как:

int i = someFlag ? 12 : 5 int j = i + 3

Компилятор должен иметь возможность обрабатывать это просто отлично, но для человека ниже выглядит намного лучше

int i = someFlag ? 12 : 5; int j = i + 3;

Ответ 12

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

int i; for( i = 0; i < 10; i++ ) printf("hello world.\n"); printf("%d instance.\n", i);

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

int i;
for( i = 0; i < 10; i++ )
{
    printf("hello world.\n);
    printf("%d instance.\n", i);
}

Очень многословие! Для современных языков компиляторы могут быть легко разработаны, чтобы сделать вывод о выводах. С# может быть изменен на другой язык, который не использует ненужных разделителей, кроме вкладки пробела и отступов, т.е.

int i
for i=0 i<10 i++
   printf "hello world.\n"
   printf "%d instance.\n" i

Это наверняка сохранило бы некоторую типизацию и выглядело бы аккуратно. Если используются отступы, а не пробелы, код становится намного читабельнее. Мы можем сделать это лучше, если разрешить типы вывода и сделать особый случай для чтения, (для [value] = [начальное значение] до [конечное значение:

for i=1 to 10  // i is inferred to be an integer
    printf "hello world.\n"
    printf "%d instance.\n" i

Теперь его начало выглядеть как f # и f #, в некотором роде, почти похоже на С# без ненужной пунктуации. Однако f # не хватает так много дополнительных функций (таких как специальные .NET-языковые конструкции, завершение кода и хороший intellisense). Таким образом, в конце f # может быть больше работы, чем С# или VB.NET для реализации, к сожалению.

Лично моя работа требовала VB.NET, и я был счастливее не иметь дело с полуколонами. С# - датированный язык. Linq позволил мне сократить количество строк кода, которые мне нужно написать. Тем не менее, если бы у меня было время, я бы написал версию С#, в которой было много функций f #.