Char.IsSeparator Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Indica si un carácter Unicode se clasifica por categorías como un carácter separador.

Sobrecargas

IsSeparator(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un carácter separador.
IsSeparator(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter separador.

Comentarios

El estándar Unicode reconoce tres subcategorías de separadores:

Separadores de espacio (la UnicodeCategory.SpaceSeparator categoría), que incluye caracteres como \u0020.
Separadores de línea (la UnicodeCategory.LineSeparator categoría), que incluye \u2028.
Separadores de párrafo (la UnicodeCategory.ParagraphSeparator categoría), que incluye \u2029.

Nota:

El estándar Unicode clasifica los caracteres \u000A (LF), \u000C (FF) y \u000D (CR) como caracteres de control (miembros de la UnicodeCategory.Control categoría), no como caracteres separadores.

IsSeparator(Char)

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Indica si el carácter Unicode especificado se clasifica por categorías como un carácter separador.

public:
 static bool IsSeparator(char c);

public static bool IsSeparator (char c);

static member IsSeparator : char -> bool

Public Shared Function IsSeparator (c As Char) As Boolean

Parámetros

c: Char

Carácter Unicode que se va a evaluar.

Devoluciones

Boolean

true si c es un carácter separador; en caso contrario, false.

Ejemplos

En el ejemplo siguiente se enumeran los Char objetos clasificados como caracteres separadores.

using namespace System;

int main()
{
   for (int ctr = Convert::ToInt32(Char::MinValue); ctr <= Convert::ToInt32(Char::MaxValue); ctr++)
   {
      wchar_t ch = ctr;
      if (Char::IsSeparator(ch))
         Console::WriteLine("\u{0:X4} ({1})", (int) ch, Char::GetUnicodeCategory(ch).ToString());
   }
}
// The example displays the following output:
//       0020 (SpaceSeparator)
//       u00A0 (SpaceSeparator)
//       u1680 (SpaceSeparator)
//       u180E (SpaceSeparator)
//       u2000 (SpaceSeparator)
//       u2001 (SpaceSeparator)
//       u2002 (SpaceSeparator)
//       u2003 (SpaceSeparator)
//       u2004 (SpaceSeparator)
//       u2005 (SpaceSeparator)
//       u2006 (SpaceSeparator)
//       u2007 (SpaceSeparator)
//       u2008 (SpaceSeparator)
//       u2009 (SpaceSeparator)
//       u200A (SpaceSeparator)
//       u2028 (LineSeparator)
//       u2029 (ParagraphSeparator)
//       u202F (SpaceSeparator)
//       u205F (SpaceSeparator)
//       u3000 (SpaceSeparator)

using System;

public class Class1
{
   public static void Main()
   {
      for (int ctr = (int)(Char.MinValue); ctr <= (int)(Char.MaxValue); ctr++)
      {
         char ch = (Char)ctr;
         if (Char.IsSeparator(ch))
            Console.WriteLine(@"\u{(int)ch:X4} ({Char.GetUnicodeCategory(ch)})");
      }
   }
}
// The example displays the following output:
//       \u0020 (SpaceSeparator)
//       \u00A0 (SpaceSeparator)
//       \u1680 (SpaceSeparator)
//       \u180E (SpaceSeparator)
//       \u2000 (SpaceSeparator)
//       \u2001 (SpaceSeparator)
//       \u2002 (SpaceSeparator)
//       \u2003 (SpaceSeparator)
//       \u2004 (SpaceSeparator)
//       \u2005 (SpaceSeparator)
//       \u2006 (SpaceSeparator)
//       \u2007 (SpaceSeparator)
//       \u2008 (SpaceSeparator)
//       \u2009 (SpaceSeparator)
//       \u200A (SpaceSeparator)
//       \u2028 (LineSeparator)
//       \u2029 (ParagraphSeparator)
//       \u202F (SpaceSeparator)
//       \u205F (SpaceSeparator)
//       \u3000 (SpaceSeparator)

open System

for char in Char.MinValue..Char.MaxValue do
    if Char.IsSeparator char then    
        printfn $@"\u{int char:X4} ({Char.GetUnicodeCategory char})"

// The example displays the following output:
//       \u0020 (SpaceSeparator)
//       \u00A0 (SpaceSeparator)
//       \u1680 (SpaceSeparator)
//       \u180E (SpaceSeparator)
//       \u2000 (SpaceSeparator)
//       \u2001 (SpaceSeparator)
//       \u2002 (SpaceSeparator)
//       \u2003 (SpaceSeparator)
//       \u2004 (SpaceSeparator)
//       \u2005 (SpaceSeparator)
//       \u2006 (SpaceSeparator)
//       \u2007 (SpaceSeparator)
//       \u2008 (SpaceSeparator)
//       \u2009 (SpaceSeparator)
//       \u200A (SpaceSeparator)
//       \u2028 (LineSeparator)
//       \u2029 (ParagraphSeparator)
//       \u202F (SpaceSeparator)
//       \u205F (SpaceSeparator)
//       \u3000 (SpaceSeparator)

Module Example
   Public Sub Main()
      For ctr As Integer = Convert.ToInt32(Char.MinValue) To Convert.ToInt32(Char.MaxValue)
         Dim ch As Char = ChrW(ctr)
         If Char.IsSeparator(ch) Then
            Console.WriteLine("\u{0:X4} ({1})", AscW(ch), Char.GetUnicodeCategory(ch).ToString())
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       \u0020 (SpaceSeparator)
'       \u00A0 (SpaceSeparator)
'       \u1680 (SpaceSeparator)
'       \u180E (SpaceSeparator)
'       \u2000 (SpaceSeparator)
'       \u2001 (SpaceSeparator)
'       \u2002 (SpaceSeparator)
'       \u2003 (SpaceSeparator)
'       \u2004 (SpaceSeparator)
'       \u2005 (SpaceSeparator)
'       \u2006 (SpaceSeparator)
'       \u2007 (SpaceSeparator)
'       \u2008 (SpaceSeparator)
'       \u2009 (SpaceSeparator)
'       \u200A (SpaceSeparator)
'       \u2028 (LineSeparator)
'       \u2029 (ParagraphSeparator)
'       \u202F (SpaceSeparator)
'       \u205F (SpaceSeparator)
'       \u3000 (SpaceSeparator)

Comentarios

El estándar Unicode reconoce tres subcategorías de separadores:

Separadores de espacio (la UnicodeCategory.SpaceSeparator categoría), que incluye caracteres como \u0020.
Separadores de línea (la UnicodeCategory.LineSeparator categoría), que incluye \u2028.
Separadores de párrafo (la UnicodeCategory.ParagraphSeparator categoría), que incluye \u2029.

Nota:

El estándar Unicode clasifica los caracteres \u000A (LF), \u000C (FF) y \u000D (CR) como caracteres de control (miembros de la UnicodeCategory.Control categoría), no como caracteres separadores.

Consulte también

Se aplica a

IsSeparator(String, Int32)

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter separador.

public:
 static bool IsSeparator(System::String ^ s, int index);

public static bool IsSeparator (string s, int index);

static member IsSeparator : string * int -> bool

Public Shared Function IsSeparator (s As String, index As Integer) As Boolean

Parámetros

s: String

Una cadena.

index: Int32

Posición del carácter que se va a evaluar en s.

Devoluciones

Boolean

true si el carácter que ocupa la posición index en s es un carácter separador; en caso contrario, false.

Excepciones

ArgumentNullException

s es null.

ArgumentOutOfRangeException

index es menor que cero o mayor que la última posición en s.

Ejemplos

En el ejemplo siguiente se muestra IsSeparator.

using namespace System;
int main()
{
   String^ str =  "twain1 twain2";
   Console::WriteLine( Char::IsSeparator( 'a' ) ); // Output: "False"
   Console::WriteLine( Char::IsSeparator( str, 6 ) ); // Output: "True"
}

using System;

public class IsSeparatorSample {
    public static void Main() {
        string str = "twain1 twain2";

        Console.WriteLine(Char.IsSeparator('a'));		// Output: "False"
        Console.WriteLine(Char.IsSeparator(str, 6));	// Output: "True"
    }
}

open System

let str = "twain1 twain2"

printfn $"{Char.IsSeparator 'a'}"       // Output: "False"
printfn $"{Char.IsSeparator(str, 6)}"   // Output: "True"

Module IsSeparatorSample

    Sub Main()

        Dim str As String
        str = "twain1 twain2"

        Console.WriteLine(Char.IsSeparator("a"c))       ' Output: "False"
        Console.WriteLine(Char.IsSeparator(str, 6))     ' Output: "True"

    End Sub

End Module

Comentarios

Las posiciones de caracteres de una cadena se indexan a partir de cero.

El estándar Unicode reconoce tres subcategorías de separadores:

Separadores de espacio (la UnicodeCategory.SpaceSeparator categoría), que incluye caracteres como \u0020.
Separadores de línea (la UnicodeCategory.LineSeparator categoría), que incluye \u2028.
Separadores de párrafo (la UnicodeCategory.ParagraphSeparator categoría), que incluye \u2029.

Nota:

El estándar Unicode clasifica los caracteres \u000A (LF), \u000C (FF) y \u000D (CR) como caracteres de control (miembros de la UnicodeCategory.Control categoría), no como caracteres separadores.

Consulte también

Se aplica a

Compartir a través de

Char.IsSeparator Método

Definición

Sobrecargas

Comentarios

IsSeparator(Char)

Parámetros

Devoluciones

Ejemplos

Comentarios

Consulte también

Se aplica a

IsSeparator(String, Int32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales