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

Question

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

Answer 1

Sí - ya que comienzan con la cadena vacía. De hecho, la cadena vacía se produce lógicamente entre cada par de caracteres.

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

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

Una alternativa (equivalente) Definición:

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

Answer 2

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 iguales, el valor debe ser una cadena vacía (Vacío), una referencia a esta misma instancia, o debe coincidir con el comienzo de esta instancia.

.NET String.StartsWith

cierto si la secuencia de caracteres representado 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 true se devolverá 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 3

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

Answer 4

En C# así es como el specification le dice que reaccione;

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

Answer 5

Porque una cuerda comienza bien con "nada".

Answer 6

Si lo 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 cadena vacía'.

Answer 7

Trataré de explicar lo que dijo Jon Skeet.

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

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

Por lo tanto, debido a que ("" + "ABCD") == "ABCD" se deduce que "ABCD" comienza con ""

Answer 8

Digamos "abcd".StartsWith("") vuelve falsa.

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

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

resulta que a evals cierto, por lo que la cadena se pone en marcha con la cadena vacía ;-), o poner en en otras palabras, la subcadena de "abcd" que comienza en la posición 0 y tiene 0 de longitud es igual a la cadena vacía "". Muy lógico imo.

Answer 9

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é? El definition de subconjunto indica 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 que el conjunto vacío no sea un subconjunto de B. Si el conjunto vacío no fuera un subconjunto de B, entonces 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 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 estar de acuerdo con nuestra definición de que comienza con. Vamos s y t ser string s Decimos que scomienza cont si s.Length >= t.Length y los primeros caracteres del t.Lengtht coinciden con los de s. Es decir, s.Length >= t.Length y para cada Int32 index tal que 0 <= index < t.Length, s[index] == t[index] es verdadero. Por el contrario, diremos que s no se inicia con t si la declaración

s.Length < t.Length o s.Length >= t.Length y hay una 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 como 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 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 <= index < String.Empty.Length. Pero s.Length >= 0 y String.Empty.Length es igual a cero, por lo que es imposible que s.Length < String.Empty.Length sea verdadero. Del mismo modo, desde `` String.Empty.Longitud is equal to zero, there is no Int32 índice = índice < String.Empty.Length`. Por lo tanto

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

es falso. Por lo tanto, no es el caso 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 vacuously true statements. Son verdaderos en virtud del hecho de que las declaraciones que los definen (subconjunto y comienza con) son universal quantifications en universos vacíos. No hay elementos en el conjunto vacío, por lo que no puede haber ningún elemento del conjunto vacío en ningún otro conjunto fijo. No hay caracteres en la cadena vacía, por lo que no puede haber un carácter como posición en la cadena vacía que no coincida con el carácter en la misma posición en alguna otra cadena fija.

Answer 10

Sólo para que conste, String.StartsWith() llama internamente al método System.Globalization.CultureInfo.IsPrefix() que hace que la siguiente lista de comprobaciones de forma explícita:

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

Answer 11

¿Por qué “ABCD” .StartsWith (“”) devuelven true?

la respuesta real:

Tiene que ser así de lo contrario usted tendría el caso en que

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

    but yet 

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

y entonces tendríamos Y2K todo de nuevo porque todo el banco el software que depende de cadenas iguales comenzando por ellos mismos hará que nuestras cuentas se mezclen y, de repente, Bill Gates tendrá mi riqueza y yo la suya, ¡y maldita sea! El destino simplemente no es tan bueno para mí.

Answer 12

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

Si compruebas el source code, 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; 
    }