String.StartsWith Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Sobrecargas

StartsWith(String, Boolean, CultureInfo)	Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la referencia cultural especificada.
StartsWith(String, StringComparison)	Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la opción de comparación especificada.
StartsWith(Char)	Determina si esta instancia de cadena comienza con el carácter especificado.
StartsWith(String)	Determina si el principio de esta instancia de cadena coincide con la cadena especificada.

StartsWith(String, Boolean, CultureInfo)

Source:

String.Comparison.cs

Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la referencia cultural especificada.

C#

public bool StartsWith (string value, bool ignoreCase, System.Globalization.CultureInfo? culture);

Parámetros

value

String

Cadena que se va a comparar.

ignoreCase

Boolean

true para no distinguir entre mayúsculas y minúsculas durante la comparación; de lo contrario, false.

culture

CultureInfo

Información de referencia cultural que determina cómo se comparan esta cadena y value. Si culture es null, se usa la referencia cultural actual.

Devoluciones

Boolean

true si el parámetro value coincide con el principio de esta cadena; en caso contrario, false.

Excepciones

ArgumentNullException

value es null.

Ejemplos

En el ejemplo siguiente se determina si una cadena se produce al principio de otra cadena. Se StartsWith llama al método varias veces con distinción entre mayúsculas y minúsculas, insensibilidad entre mayúsculas y minúsculas y referencias culturales diferentes que influyen en los resultados de la búsqueda.

C#

// This code example demonstrates the 
// System.String.StartsWith(String, ..., CultureInfo) method.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string msg1 = "Search for the target string \"{0}\" in the string \"{1}\".\n";
    string msg2 = "Using the {0} - \"{1}\" culture:";
    string msg3 = "  The string to search ends with the target string: {0}";
    bool result = false;
    CultureInfo ci;

// Define a target string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string capitalARing = "\u00c5";

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string aRingXYZ = "\u0061\u030a" + "xyz";

// Clear the screen and display an introduction.
    Console.Clear();

// Display the string to search for and the string to search.
    Console.WriteLine(msg1, capitalARing, aRingXYZ);

// Search using English-United States culture.
    ci = new CultureInfo("en-US");
    Console.WriteLine(msg2, ci.DisplayName, ci.Name);

    Console.WriteLine("Case sensitive:");
    result = aRingXYZ.StartsWith(capitalARing, false, ci);
    Console.WriteLine(msg3, result);

    Console.WriteLine("Case insensitive:");
    result = aRingXYZ.StartsWith(capitalARing, true, ci);
    Console.WriteLine(msg3, result);
    Console.WriteLine();

// Search using Swedish-Sweden culture.
    ci = new CultureInfo("sv-SE");
    Console.WriteLine(msg2, ci.DisplayName, ci.Name);

    Console.WriteLine("Case sensitive:");
    result = aRingXYZ.StartsWith(capitalARing, false, ci);
    Console.WriteLine(msg3, result);

    Console.WriteLine("Case insensitive:");
    result = aRingXYZ.StartsWith(capitalARing, true, ci);
    Console.WriteLine(msg3, result);
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

Search for the target string "Å" in the string "a°xyz".

Using the English (United States) - "en-US" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: True

Using the Swedish (Sweden) - "sv-SE" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: False

*/

Comentarios

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

Este método realiza una comparación con las mayúsculas y minúsculas especificadas.

StartsWith(String, StringComparison)

Source:

String.Comparison.cs

Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la opción de comparación especificada.

C#

public bool StartsWith (string value, StringComparison comparisonType);

Parámetros

value

String

Cadena que se va a comparar.

comparisonType

StringComparison

Uno de los valores de enumeración que determina cómo se comparan esta cadena y value.

Devoluciones

Boolean

true si esta instancia comienza con value; de lo contrario, false.

Excepciones

ArgumentNullException

value es null.

ArgumentException

comparisonType no es un valor StringComparison.

Ejemplos

En el ejemplo siguiente se busca la cadena "the" al principio de una cadena más larga que comienza con la palabra "The". Como se muestra en la salida del ejemplo, una llamada al StartsWith(String, StringComparison) método que realiza una comparación sin distinción entre referencias culturales pero que distingue mayúsculas de minúsculas no coincide con la cadena, mientras que una llamada que realiza una comparación sin distinción entre mayúsculas y minúsculas coincide con la cadena.

C#

using System;

public class Example
{
   public static void Main()
   {
      String title = "The House of the Seven Gables";
      String searchString = "the";
      StringComparison comparison = StringComparison.InvariantCulture;
      Console.WriteLine("'{0}':", title);
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));

      comparison = StringComparison.InvariantCultureIgnoreCase;
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));
   }
}
// The example displays the following output:
//       'The House of the Seven Gables':
//          Starts with 'the' (InvariantCulture comparison): False
//          Starts with 'the' (InvariantCultureIgnoreCase comparison): True

En el ejemplo siguiente se determina si una cadena comienza con una subcadena determinada. Inicializa una matriz de cadenas bidimensionales. El primer elemento de la segunda dimensión contiene una cadena y el segundo elemento contiene la cadena que se va a buscar al principio de la primera cadena. Los resultados se ven afectados por la elección de la referencia cultural, si se omiten mayúsculas y minúsculas y si se realiza una comparación ordinal. Tenga en cuenta que cuando la instancia de cadena contiene una ligadura, las comparaciones sensibles a la referencia cultural con sus caracteres consecutivos coinciden correctamente.

C#

using System;

public class Example
{
   public static void Main()
   {
      string[,] strings = { {"ABCdef", "abc" },                    
                            {"ABCdef", "abc" },  
                            {"œil","oe" },
                            { "læring}", "lae" } };
      for (int ctr1 = strings.GetLowerBound(0); ctr1 <= strings.GetUpperBound(0); ctr1++)
      {
            foreach (string cmpName in Enum.GetNames(typeof(StringComparison)))
            { 
               StringComparison strCmp = (StringComparison) Enum.Parse(typeof(StringComparison), 
                                                      cmpName);
               string instance = strings[ctr1, 0];
               string value = strings[ctr1, 1];
               Console.WriteLine("{0} starts with {1}: {2} ({3} comparison)", 
                                 instance, value, 
                                 instance.StartsWith(value, strCmp), 
                                 strCmp); 
            }
            Console.WriteLine();   
      }   
   }
}
// The example displays the following output:
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       œil starts with oe: True (CurrentCulture comparison)
//       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
//       œil starts with oe: True (InvariantCulture comparison)
//       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
//       œil starts with oe: False (Ordinal comparison)
//       œil starts with oe: False (OrdinalIgnoreCase comparison)
//       
//       læring} starts with lae: True (CurrentCulture comparison)
//       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
//       læring} starts with lae: True (InvariantCulture comparison)
//       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
//       læring} starts with lae: False (Ordinal comparison)
//       læring} starts with lae: False (OrdinalIgnoreCase comparison)

Comentarios

El StartsWith método compara el value parámetro con la subcadena al principio de esta cadena y devuelve un valor que indica si son iguales. Para ser igual, value debe ser una referencia a esta misma cadena, debe ser la cadena vacía ("") o debe coincidir con el principio de esta cadena. El tipo de comparación realizado por el StartsWith método depende del valor del comparisonType parámetro . La comparación puede usar las convenciones de la referencia cultural actual (StringComparison.CurrentCulture y StringComparison.CurrentCultureIgnoreCase) o la referencia cultural invariable (StringComparison.InvariantCulture y StringComparison.InvariantCultureIgnoreCase), o puede constar de una comparación de caracteres por carácter de puntos de código (StringComparison.Ordinal o StringComparison.OrdinalIgnoreCase). La comparación también puede distinguir mayúsculas de minúsculas (StringComparison.CurrentCulture, StringComparison.InvariantCultureo StringComparison.Ordinal), o puede omitir mayúsculas de minúsculas (StringComparison.CurrentCultureIgnoreCase, StringComparison.InvariantCultureIgnoreCase, StringComparison.OrdinalIgnoreCase).

Consulte también

• StringComparison

StartsWith(Char)

Source:

String.Comparison.cs

Determina si esta instancia de cadena comienza con el carácter especificado.

C#

public bool StartsWith (char value);

Parámetros

value

Char

El carácter que se va a comparar.

Devoluciones

Boolean

true si value coincide con el principio de esta cadena; en caso contrario, false.

Comentarios

Este método realiza una comparación ordinal (sin distinción entre mayúsculas y minúsculas y sin distinción entre referencias culturales).

StartsWith(String)

Source:

String.Comparison.cs

Determina si el principio de esta instancia de cadena coincide con la cadena especificada.

C#

public bool StartsWith (string value);

Parámetros

value

String

Cadena que se va a comparar.

Devoluciones

Boolean

true si value coincide con el principio de esta cadena; en caso contrario, false.

Excepciones

ArgumentNullException

value es null.

Ejemplos

En el ejemplo siguiente se define un StripStartTags método que usa el StartsWith(String) método para quitar etiquetas de inicio HTML desde el principio de una cadena. Tenga en cuenta que el StripStartTags método se llama de forma recursiva para asegurarse de que se quitan varias etiquetas de inicio HTML al principio de la línea. En el ejemplo no se quitan las etiquetas HTML incrustadas en una cadena.

C#

using System;

public class Example
{
   public static void Main() {
      string [] strSource = { "<b>This is bold text</b>", "<H1>This is large Text</H1>",
                "<b><i><font color=green>This has multiple tags</font></i></b>",
                "<b>This has <i>embedded</i> tags.</b>",
                "<This line simply begins with a lesser than symbol, it should not be modified" };

      // Display the initial string array.
      Console.WriteLine("The original strings:");
      Console.WriteLine("---------------------");
      foreach (var s in strSource)
         Console.WriteLine(s);
      Console.WriteLine();

      Console.WriteLine("Strings after starting tags have been stripped:");
      Console.WriteLine("-----------------------------------------------");

      // Display the strings with starting tags removed.
     foreach (var s in strSource)
        Console.WriteLine(StripStartTags(s));
   }

   private static string StripStartTags(string item)
   {
      // Determine whether a tag begins the string.
      if (item.Trim().StartsWith("<")) {
         // Find the closing tag.
         int lastLocation = item.IndexOf( ">" );
         // Remove the tag.
         if (lastLocation >= 0) {
            item =  item.Substring( lastLocation + 1 );

            // Remove any additional starting tags.
            item = StripStartTags(item);
         }
      }

      return item;
   }
}
// The example displays the following output:
//    The original strings:
//    ---------------------
//    <b>This is bold text</b>
//    <H1>This is large Text</H1>
//    <b><i><font color = green>This has multiple tags</font></i></b>
//    <b>This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified
//
//    Strings after starting tags have been stripped:
//    -----------------------------------------------
//    This is bold text</b>
//    This is large Text</H1>
//    This has multiple tags</font></i></b>
//    This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified

Comentarios

Este método se value compara con la subcadena al principio de esta instancia que tiene la misma longitud valueque y devuelve una indicación de si son iguales. Para ser igual, value debe ser una cadena vacía (String.Empty), debe ser una referencia a esta misma instancia o debe coincidir con el principio de esta instancia.

Este método realiza una comparación de palabras (con distinción entre mayúsculas y minúsculas y con distinción de referencia cultural) mediante la referencia cultural actual.

Notas a los autores de las llamadas

Como se explica en Procedimientos recomendados para usar cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituya los valores predeterminados y, en su lugar, llame a métodos que requieren que se especifiquen explícitamente parámetros. Para determinar si una cadena comienza con una subcadena determinada mediante las reglas de comparación de cadenas de la referencia cultural actual, indique su intención explícitamente llamando a la sobrecarga del StartsWith(String, StringComparison) método con un valor de CurrentCulture para su comparisonType parámetro. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

• EndsWith(String)