Почему "abcd" .StartsWith ("") возвращает true?

Question

Название - это весь вопрос. Может ли кто-нибудь объяснить мне, почему это происходит?

Answer 1

Да - потому, что она начинается с пустой строкой. Действительно, пустая строка логически встречается между каждой парой символов.

Положите это так: какое определение «начинается с» вы могли бы дать, что бы исключить это? Вот простое определение «начинается с», которое не имеет значения:

«x начинается с y, если первые y.Length символов х совпадают с символами y».

Альтернативный (эквивалент) Определение:

«х начинается с у, если x.Substring(0, y.Length).Equals(y)»

Answer 2

Этот метод сравнивает параметр значения с подстрокой в ​​начале этой строки, которая равна той же длине, что и значение, и возвращает значение, указывающее, являются ли они равными. Чтобы быть равным, значение должно быть пустой строкой (пустой), ссылкой на этот же экземпляр или соответствовать началу этого экземпляра.

.NET String.StartsWith

верно, если последовательность символов, представленного аргументом является префиксом символьной последовательности, представленной этой строки; false в противном случае. Обратите внимание, что true будет возвращен, если аргумент пустой строки или равен этому объекту String, как определено методом equals (Object).

Java String.startsWith

Answer 3

Первые N символов двух строк идентичны. N - длина второй строки, то есть нуль.

Answer 4

В C# это так, как specification сообщает, что он реагирует;

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

Answer 5

Потому что строка начинается хорошо с «ничего».

Answer 6

Если вы думаете об этом в выражениях с регулярными выражениями, это имеет смысл. Каждая строка (а не только «abcd», также «» и «sdf \ nff»), возвращает true при вычислении регулярного выражения «начинается с пустой строки».

Answer 7

Я попытаюсь подробно рассказать о том, что сказал Джон Скит.

Допустим, х, у и г являются строками и + оператор фактически конкатенации, то:

Если мы можем разделить г записать г = х + у, что означает, что г начинается с х. Поскольку каждая строка z может быть разбита на z = "" + z, то каждая строка начинается с "".

Таким образом, потому что ("" + "ABCD") == "ABCD" следует, что "ABCD" начинается с ""

Answer 8

Давайте просто скажем, "abcd".StartsWith("") возвращает ложь.

если да, то, что делает следующее выражение Eval к, истинным или ложным:

("abcd".Substring(0,0) == "") 

получается, что Evals к истинным, так что строка действительно начинается с пустой строкой ;-), или положить в другими словами, подстрока «abcd», начинающаяся с позиции 0 и имеющая длину 0, равна пустой строке «». Довольно логично.

Answer 9

Начну с связанного с этим факта, который легче понять.

Пустой набор является подмножеством каждого множества.

Почему? В definition из подмножество указано, что A является подмножеством B, если каждый элемент A является элементом B. И наоборот, A не является подмножеством B, если существует элемент A, который не является элементом B.

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

Любая строка начинается с пустой строки.

Прежде всего, мы должны согласиться с тем, что наше определение начинается с. Пусть s и t быть string s Мы говорим, что sначинается сt если s.Length >= t.Length и первые t.Length персонажи t совпадают s. То есть s.Length >= t.Length и на каждые Int32 index такие, что 0 <= index < t.Length, s[index] == t[index] истинно. С другой стороны, мы хотели бы сказать, что s не начинается с t если оператор

s.Length < t.Length или s.Length >= t.Length и есть Int32 index0 <= index < t.Length таким образом, что и s[index] != t[index]

верно. На простом английском языке s короче t, или, если нет, есть символ в t, не соответствующий символу в той же позиции в s.

Теперь исправьте строку s. Я установил, что s начинается с пустой строки. Я сделаю это, показывая, что это не тот случай, когда s не начинается с пустой строки. Если s не начинается с пустой строки, то s.Length < String.Empty.Length или s.Length >= String.Empty.Length и есть Int32 index такой, что 0 <= index < String.Empty.Length. Но s.Length >= 0 и String.Empty.Length равно нулю, поэтому для s.Length < String.Empty.Length невозможно. Аналогично, поскольку `` String.Empty.Длина is equal to zero, there is no Индекс Int32 = индекс < String.Empty.Length`. Поэтому

s.Length < String.Empty.Length или s.Length >= String.Empty.Length и есть Int32 index таким образом, что 0 <= index < String.Empty.Length

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

Ниже приведена реализация , начинающаяся с, кодированная как расширение до string.

public static bool DoStartsWith(this string s, string t) { 
    if (s.Length >= t.Length) { 
     for (int index = 0; index < t.Length; index++) { 
      if (s[index] != t[index]) { 
       return false; 
      } 
     } 
     return true; 
    } 
    return false; 
} 

Вышеуказанные две полужирный факты являются примерами vacuously true statements. Они верны в силу того факта, что операторы, определяющие их (подмножество и начинаются с), являются universal quantifications по пустым вселенным. В пустом наборе нет элементов, поэтому не может быть никаких элементов пустого набора, не в каком-либо другом фиксированном множестве. В пустой строке нет символов, поэтому не может быть символ как некоторая позиция в пустой строке, не соответствующая символу в той же позиции в некоторой другой фиксированной строке.

Answer 10

Просто для записи, String.StartsWith() внутренне вызывает метод System.Globalization.CultureInfo.IsPrefix(), который делает следующий чек явно:

if (prefix.Length == 0) 
{ 
    return true; 
} 

Answer 11

Почему «ABCD» .StartsWith («») возвращает истину?

РЕАЛЬНАЯ ОТВЕТ:

Это должно быть так иначе вы бы случай, когда

"".startsWith("") == false 
    "".equals("") == true 

    but yet 

    "a".startsWith("a") == true 
    "a".equals("a") == true 

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

Answer 12

В C# причина, по которой он возвращает true, заключается в том, что разработчики специально закодированы для него.

Если вы проверить source code, вы найдете специфическую логику для обработки пустой строки:

public Boolean StartsWith(String value) 
{ 
    return StartsWith(value, StringComparison.CurrentCulture); 
} 

public Boolean StartsWith(String value, StringComparison comparisonType) 
{ 
    ... 

    if (value.Length == 0) 
    { 
     return true; 
    }