¿Por qué "abcd" .StartsWith ("") devuelve verdadero?

Question

El título es toda la pregunta. ¿Alguien puede darme una razón por la que esto sucede?

Answer 1

Sí, porque comienza con la cadena vacía. De hecho, la cadena vacía ocurre lógicamente entre cada par de caracteres.

Ponlo de esta manera: qué definición de " comienza con " ¿podría dar eso impediría esto? Aquí hay una definición simple de "comienza con" eso no:

" x comienza con y si los primeros caracteres y.Length de x coinciden con los de y. "

Una definición alternativa (equivalente):

" x comienza con y if x.Substring (0, y.Length) .Equals (y) "

Answer 2

Trataré de explicar lo que dijo Jon Skeet.

Digamos que x, y y z son cadenas y que el operador + es de hecho una concatenación, entonces:

Si podemos dividir z para escribir z = x + y eso significa que z comienza con x. Porque cada cadena z se puede dividir en z = " " + z se deduce que cada cadena comienza con " " ;.

Entonces, porque (" " + " abcd ") == " abcd " se deduce que "abcd" comienza con " "

Answer 3

Este método compara el parámetro de valor con la subcadena al comienzo de esta cadena que tiene la misma longitud que el valor y devuelve un valor que indica si son iguales. Para ser igual, el valor debe ser una cadena vacía (Vacío), una referencia a esta misma instancia, o coincidir con el comienzo de esta instancia.

.NET String.StartsWith

verdadero si la secuencia de caracteres representada por el argumento es un prefijo de la secuencia de caracteres representada por esta cadena; falso de lo contrario. Tenga en cuenta también que se devolverá verdadero si el argumento es una cadena vacía o es igual a este objeto String según lo determinado por el método equals (Object).

Java String.startsWith

Answer 4

Comenzaré con un hecho relacionado que es más fácil de entender.

El conjunto vacío es un subconjunto de cada conjunto.

¿Por qué? La definición del subconjunto establece que A es un subconjunto de B si cada elemento de A es un elemento de B . Por el contrario, A no es un subconjunto de B si hay un elemento de A que no es un elemento de B .

Ahora arregle un conjunto B . Estableceré que el conjunto vacío es un subconjunto de B . Haré esto mostrando que no es el caso de que el conjunto vacío no sea un subconjunto de B . Si el conjunto vacío no fuera un subconjunto de B , podría encontrar un elemento del conjunto vacío que no esté en B . Pero el conjunto vacío no tiene ningún elemento y, por lo tanto, no puedo encontrar un elemento que no esté en B . Por lo tanto, no es el caso de que el conjunto vacío no sea un subconjunto de B . Por lo tanto, el conjunto vacío debe ser un subconjunto de B .

Cualquier cadena comienza con la cadena vacía.

Primero, debemos acordar que nuestra definición de comienza con . Supongamos que s y t sean string s. Decimos que s comienza con t if s.Length > = t.Length y los primeros caracteres t.Length de t coinciden con los de < code> s . Es decir, s.Length > = t.Length y para cada Int32 index de modo que 0 < = index < t.Length , s [index] == t [index] es verdadero. Por el contrario, diríamos que s no comienza con t si la declaración

s.Longitud < t.Length o s.Length > = t.Length y hay un Int32 index tal que 0 < = index < t.Length y s [index]! = t [index]

es cierto. En inglés simple, s es más corto que t o, si no, hay un carácter en t que no coincide con el carácter en la misma posición en s .

Ahora arregle una cadena s . Estableceré que s comienza con la cadena vacía. Haré esto mostrando que no es el caso de que s no comience con la cadena vacía. Si s no comienza con la cadena vacía, entonces s.Length < String.Empty.Length o s.Length > = String.Empty.Length y hay un Int32 index tal que 0 < = índice < String.Empty.Length . Pero s.Length > = 0 y String.Empty.Length es igual a cero, por lo que es imposible para s.Length < String.Empty.Length para ser verdad. De manera similar, dado que `` String.Empty.Length es igual a cero, no hay Int32 index satisfactorio 0 < = index < String.Empty.Length`. Por lo tanto

s.Longitud < String.Empty.Length o s.Length > = String.Empty.Length y hay un Int32 index tal que 0 < = índice < String.Empty.Length

es falso. Por lo tanto, no es el caso de que s no comience con la cadena vacía. Por lo tanto, s debe comenzar con la cadena vacía.

La siguiente es una implementación de que comienza con codificada como una extensión de 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;
}

Los dos hechos en negrita anteriores son ejemplos de declaraciones vacías verdaderas . Son ciertas en virtud del hecho de que las declaraciones que las definen ( subconjunto y comienzan con ) son cuantificaciones universales sobre universos vacíos. No hay elementos en el conjunto vacío, por lo que no puede haber ningún elemento del conjunto vacío que no esté en otro conjunto fijo. No hay caracteres en la cadena vacía, por lo que no puede haber un carácter ya que alguna posición en la cadena vacía no coincide con el carácter en la misma posición en alguna otra cadena fija.

Answer 5

Digamos " abcd " .StartsWith (" ") devuelve false.

si es así, ¿qué evalúa la siguiente expresión, verdadero o falso?

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

resulta que evals a true, por lo que la cadena comienza con la cadena vacía ;-), o dicho de otro modo, la subcadena de " abcd " comenzando en la posición 0 y teniendo 0 longitud es igual a la cadena vacía " " ;. Imo bastante lógico.

Answer 6

En C #, así es como la especificación le dice que reaccione;

  

Para ser igual, el valor debe ser una cadena vacía (Vacío), una referencia a esta misma instancia o coincidir con el comienzo de esta instancia.

Answer 7

  

¿Por qué & # 8220; abcd & # 8221; .StartsWith (& # 8220; & # 8221;) devuelve verdadero?

LA RESPUESTA REAL:

Tiene que ser así, de lo contrario tendría el caso donde

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

    but yet

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

y luego tendríamos Y2K de nuevo porque todo el software del banco que depende de la misma secuencia, comenzando por ellos mismos, mezclará nuestras cuentas y de repente Bill Gates tendrá mi riqueza y yo tendré la suya, y maldita sea. ! El destino simplemente no es tan amable conmigo.

Answer 8

Los primeros N caracteres de las dos cadenas son idénticos. N es la longitud de la segunda cadena, es decir, cero.

Answer 9

Solo para el registro, String.StartsWith () llama internamente al método System.Globalization.CultureInfo.IsPrefix () que realiza la siguiente comprobación explícitamente:

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

Answer 10

Porque una cadena comienza bien con " nothing " ;.

Answer 11

Si piensas en términos de expresiones regulares, tiene sentido. Cada cadena (no solo " abcd " ;, también " " y " sdf \ nff "), devuelve verdadero al evaluar la expresión regular de 'comienza con una cadena vacía'.

Answer 12

En C #, la razón por la que devuelve true es que los desarrolladores lo codificaron específicamente.

Si revisa el código fuente , usted ' Encontraré lógica específica para manejar una cadena vacía:

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

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

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