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

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

ОТВЕТЫ

Ответ 1

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

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

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

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

"x начинается с y, если x.Substring(0, y.Length).Equals(y)"

Ответ 2

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

Пусть говорят, что x, y и z - строки, а + оператор на самом деле является конкатенацией, то:

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

Итак, потому что ( "+" abcd ") ==" abcd "следует, что" abcd "начинается с" "

Ответ 3

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

.NET String.StartsWith

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

Java String.startsWith

Ответ 4

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

Пустое множество - это подмножество каждого множества.

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

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

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

Во-первых, мы должны договориться о нашем определении начала с. Пусть s и t be string Мы говорим, что 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 index такое, что 0 <= 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.Length is equal to zero, there is no Int32 index satisfying 0 <= index < 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;
}

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

Ответ 5

Скажем, "abcd".StartsWith("") возвращает false.

если да, то что означает следующее выражение eval, true или false:

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

получается, что evals соответствует true, поэтому строка начинается с пустой строки;-) или, другими словами, подстрока "abcd", начинающаяся с позиции 0 и имеющая длину 0, равна пустой строке "", Довольно логично.

Ответ 6

В С# это означает, что спецификация реагирует;

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

Ответ 7

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

РЕАЛЬНЫЙ ОТВЕТ:

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

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

    but yet

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

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

Ответ 8

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

Ответ 9

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

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

Ответ 10

Поскольку строка начинается с "ничего".

Ответ 11

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

Ответ 12

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

Если вы посмотрите исходный код, вы найдете определенную логику для обработки пустой строки:

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

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

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