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

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

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

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

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

.NET String.StartsWith

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

Java String.startsWith

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

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

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

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

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

Во-первых, мы должны согласиться с нашим определением начинается с . Позвольте sи tбыть strings Мы говорим, что s начинается с t if 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 noInt32 index satisfying0 <= index

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;
}

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

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

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

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

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

В C # это то, как спецификация говорит ему реагировать;

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

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

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

НАСТОЯЩИЙ ОТВЕТ:

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

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

    but yet

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

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

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

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

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

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