String
Un tipo integrado para strings.
Descripción
This is the built-in string Variant type (and the one used by GDScript). Strings may contain any number of Unicode characters, and expose methods useful for manipulating and generating strings. Strings are reference-counted and use a copy-on-write approach (every modification to a string returns a new String), so passing them around is cheap in resources.
Some string methods have corresponding variations. Variations suffixed with n (countn(), findn(), replacen(), etc.) are case-insensitive (they make no distinction between uppercase and lowercase letters). Method variations prefixed with r (rfind(), rsplit(), etc.) are reversed, and start from the end of the string, instead of the beginning.
To convert any Variant to or from a string, see @GlobalScope.str(), @GlobalScope.str_to_var(), and @GlobalScope.var_to_str().
Note: In a boolean context, a string will evaluate to false if it is empty (""). Otherwise, a string will always evaluate to true.
Nota
Hay diferencias notables cuando usa esta API con C#. Véase Diferencias de la API de C# con GDScript para más información.
Tutoriales
Constructores
String() |
|
String(from: StringName) |
Métodos
Operadores
operator !=(right: String) |
|
operator !=(right: StringName) |
|
operator %(right: Variant) |
|
operator +(right: String) |
|
operator +(right: StringName) |
|
operator <(right: String) |
|
operator <=(right: String) |
|
operator ==(right: String) |
|
operator ==(right: StringName) |
|
operator >(right: String) |
|
operator >=(right: String) |
|
operator [](index: int) |
Descripciones de Constructores
Construye una String vacía ("").
Construye una String como copia de la String dada.
Construye una nueva String desde el NodePath dado.
String String(from: StringName)
Construye una nueva String desde el StringName dado.
Descripciones de Métodos
bool begins_with(text: String) const 🔗
Devuelve true si la string comienza con el text dado. Véase también ends_with().
PackedStringArray bigrams() const 🔗
Devuelve un array que contiene los bigramas (pares de caracteres consecutivos) de esta string.
print("Levántate!".bigrams()) # Imprime ["Le", "ev", "vá", "nt", "ta", "at", "te", "e!"]
Converts the string representing a binary number into an int. The string may optionally be prefixed with "0b", and an additional - prefix for negative numbers.
print("101".bin_to_int()) # Prints 5
print("0b101".bin_to_int()) # Prints 5
print("-0b10".bin_to_int()) # Prints -2
GD.Print("101".BinToInt()); // Prints 5
GD.Print("0b101".BinToInt()); // Prints 5
GD.Print("-0b10".BinToInt()); // Prints -2
Devuelve una copia de la string con caracteres especiales escapados usando el estándar del lenguaje C.
Returns a copy of the string with escaped characters replaced by their meanings. Supported escape sequences are \', \", \\, \a, \b, \f, \n, \r, \t, \v.
Note: Unlike the GDScript parser, this method doesn't support the \uXXXX escape sequence.
Changes the appearance of the string: replaces underscores (_) with spaces, adds spaces before uppercase letters in the middle of a word, converts all letters to lowercase, then converts the first one and each one following a space to uppercase.
"move_local_x".capitalize() # Returns "Move Local X"
"sceneFile_path".capitalize() # Returns "Scene File Path"
"2D, FPS, PNG".capitalize() # Returns "2d, Fps, Png"
"move_local_x".Capitalize(); // Returns "Move Local X"
"sceneFile_path".Capitalize(); // Returns "Scene File Path"
"2D, FPS, PNG".Capitalize(); // Returns "2d, Fps, Png"
int casecmp_to(to: String) const 🔗
Performs a case-sensitive comparison to another string. Returns -1 if less than, 1 if greater than, or 0 if equal. "Less than" and "greater than" are determined by the Unicode code points of each string, which roughly matches the alphabetical order.
If the character comparison reaches the end of one string, but the other string contains more characters, then it will use length as the deciding factor: 1 will be returned if this string is longer than the to string, or -1 if shorter. Note that the length of empty strings is always 0.
To get a bool result from a string comparison, use the == operator instead. See also nocasecmp_to(), filecasecmp_to(), and naturalcasecmp_to().
String chr(code: int) static 🔗
Returns a single Unicode character from the integer code. You may use unicodelookup.com or unicode.org as points of reference.
print(String.chr(65)) # Prints "A"
print(String.chr(129302)) # Prints "🤖" (robot face emoji)
See also unicode_at(), @GDScript.char(), and @GDScript.ord().
bool contains(what: String) const 🔗
Returns true if the string contains what. In GDScript, this corresponds to the in operator.
print("Node".contains("de")) # Prints true
print("team".contains("I")) # Prints false
print("I" in "team") # Prints false
GD.Print("Node".Contains("de")); // Prints True
GD.Print("team".Contains("I")); // Prints False
If you need to know where what is within the string, use find(). See also containsn().
bool containsn(what: String) const 🔗
Devuelve true si la string contiene what, ignorando mayúsculas y minúsculas.
Si necesitas saber dónde está what dentro de la string, usa findn(). Véase también contains().
int count(what: String, from: int = 0, to: int = 0) const 🔗
Devuelve el número de ocurrencias de la substring what entre las posiciones from y to. Si to es 0, la búsqueda continúa hasta el final de la string.
int countn(what: String, from: int = 0, to: int = 0) const 🔗
Devuelve el número de ocurrencias de la substring what entre las posiciones from y to, ignorando mayúsculas y minúsculas. Si to es 0, la búsqueda continúa hasta el final de la string.
Returns a copy of the string with indentation (leading tabs and spaces) removed. See also indent() to add indentation.
bool ends_with(text: String) const 🔗
Returns true if the string ends with the given text. See also begins_with().
String erase(position: int, chars: int = 1) const 🔗
Devuelve una string con chars caracteres borrados, comenzando desde position. Si chars excede la longitud de la string dada la position especificada, se borrarán menos caracteres de la string devuelta. Devuelve una string vacía si position o chars son negativos. Devuelve la string original sin modificar si chars es 0.
int filecasecmp_to(to: String) const 🔗
Como naturalcasecmp_to() pero prioriza las strings que comienzan con puntos (.) y guiones bajos (_) antes que cualquier otro carácter. Útil al ordenar carpetas o nombres de archivos.
Para obtener un resultado bool de una comparación de strings, usa el operador == en su lugar. Véase también filenocasecmp_to(), naturalcasecmp_to() y casecmp_to().
int filenocasecmp_to(to: String) const 🔗
Como naturalnocasecmp_to() pero prioriza las strings que comienzan con puntos (.) y guiones bajos (_) antes que cualquier otro carácter. Útil al ordenar carpetas o nombres de archivos.
Para obtener un resultado bool de una comparación de strings, usa el operador == en su lugar. Véase también filecasecmp_to(), naturalnocasecmp_to() y nocasecmp_to().
int find(what: String, from: int = 0) const 🔗
Returns the index of the first occurrence of what in this string, or -1 if there are none. The search's start can be specified with from, continuing to the end of the string.
print("Team".find("I")) # Prints -1
print("Potato".find("t")) # Prints 2
print("Potato".find("t", 3)) # Prints 4
print("Potato".find("t", 5)) # Prints -1
GD.Print("Team".Find("I")); // Prints -1
GD.Print("Potato".Find("t")); // Prints 2
GD.Print("Potato".Find("t", 3)); // Prints 4
GD.Print("Potato".Find("t", 5)); // Prints -1
Note: If you just want to know whether the string contains what, use contains(). In GDScript, you may also use the in operator.
Note: A negative value of from is converted to a starting index by counting back from the last possible index with enough space to find what.
int findn(what: String, from: int = 0) const 🔗
Devuelve el índice de la primera ocurrencia insensible a mayúsculas y minúsculas de what en esta string, o -1 si no hay ninguna. El índice de búsqueda inicial se puede especificar con from, continuando hasta el final de la string.
String format(values: Variant, placeholder: String = "{_}") const 🔗
Formats the string by replacing all occurrences of placeholder with the elements of values.
values can be a Dictionary, an Array, or an Object. Any underscores in placeholder will be replaced with the corresponding keys in advance. Array elements use their index as keys.
# Prints "Waiting for Godot is a play by Samuel Beckett, and Godot Engine is named after it."
var use_array_values = "Waiting for {0} is a play by {1}, and {0} Engine is named after it."
print(use_array_values.format(["Godot", "Samuel Beckett"]))
# Prints "User 42 is Godot."
print("User {id} is {name}.".format({"id": 42, "name": "Godot"}))
Some additional handling is performed when values is an Array. If placeholder does not contain an underscore, the elements of the values array will be used to replace one occurrence of the placeholder in order; If an element of values is another 2-element array, it'll be interpreted as a key-value pair.
# Prints "User 42 is Godot."
print("User {} is {}.".format([42, "Godot"], "{}"))
print("User {id} is {name}.".format([["id", 42], ["name", "Godot"]]))
When passing an Object, the property names from Object.get_property_list() are used as keys.
# Prints "Visible true, position (0, 0)"
var node = Node2D.new()
print("Visible {visible}, position {position}".format(node))
See also the GDScript format string tutorial.
Note: Each replacement is done sequentially for each element of values, not all at once. This means that if any element is inserted and it contains another placeholder, it may be changed by the next replacement. While this can be very useful, it often causes unexpected results. If not necessary, make sure values's elements do not contain placeholders.
print("{0} {1}".format(["{1}", "x"])) # Prints "x x"
print("{0} {1}".format(["x", "{0}"])) # Prints "x {0}"
print("{a} {b}".format({"a": "{b}", "b": "c"})) # Prints "c c"
print("{a} {b}".format({"b": "c", "a": "{b}"})) # Prints "{b} c"
Note: In C#, it's recommended to interpolate strings with "$", instead.
Si la string es una ruta de archivo válida, devuelve el nombre del directorio base.
var dir_path = "/ruta/al/archivo.txt".get_base_dir() # dir_path es "/ruta/al"
Si la string es una ruta de archivo válida, devuelve la ruta de acceso de archivo completa, sin la extensión.
var base = "/ruta/a/archivo.txt".get_basename() # la base es "/ruta/a/archivo"
String get_extension() const 🔗
If the string is a valid file name or path, returns the file extension without the leading period (.). Otherwise, returns an empty string.
var a = "/path/to/file.txt".get_extension() # a is "txt"
var b = "cool.txt".get_extension() # b is "txt"
var c = "cool.font.tres".get_extension() # c is "tres"
var d = ".pack1".get_extension() # d is "pack1"
var e = "file.txt.".get_extension() # e is ""
var f = "file.txt..".get_extension() # f is ""
var g = "txt".get_extension() # g is ""
var h = "".get_extension() # h is ""
If the string is a valid file path, returns the file name, including the extension.
var file = "/path/to/icon.png".get_file() # file is "icon.png"
String get_slice(delimiter: String, slice: int) const 🔗
Splits the string using a delimiter and returns the substring at index slice. Returns the original string if delimiter does not occur in the string. Returns an empty string if the slice does not exist.
This is faster than split(), if you only need one or two substrings.
print("i/am/example/hi".get_slice("/", 2)) # Prints "example"
int get_slice_count(delimiter: String) const 🔗
Returns the total number of slices when the string is split with the given delimiter (see split()).
Use get_slice() to extract a specific slice.
print("i/am/example/string".get_slice_count("/")) # Prints '4'.
print("i am example string".get_slice_count("/")) # Prints '1'.
String get_slicec(delimiter: int, slice: int) const 🔗
Splits the string using a Unicode character with code delimiter and returns the substring at index slice. Returns an empty string if the slice does not exist.
This is faster than split(), if you only need one or two substrings.
This is a Unicode version of get_slice().
Devuelve el valor hash de 32 bits que representa el contenido de la string.
Nota: No se garantiza que las strings con valores hash iguales sean las mismas, como resultado de colisiones hash. Por el contrario, se garantiza que las strings con diferentes valores hash sean diferentes.
PackedByteArray hex_decode() const 🔗
Decodes a hexadecimal string as a PackedByteArray.
var text = "hello world"
var encoded = text.to_utf8_buffer().hex_encode() # outputs "68656c6c6f20776f726c64"
print(encoded.hex_decode().get_string_from_utf8())
var text = "hello world";
var encoded = text.ToUtf8Buffer().HexEncode(); // outputs "68656c6c6f20776f726c64"
GD.Print(encoded.HexDecode().GetStringFromUtf8());
Converts the string representing a hexadecimal number into an int. The string may be optionally prefixed with "0x", and an additional - prefix for negative numbers.
print("0xff".hex_to_int()) # Prints 255
print("ab".hex_to_int()) # Prints 171
GD.Print("0xff".HexToInt()); // Prints 255
GD.Print("ab".HexToInt()); // Prints 171
String humanize_size(size: int) static 🔗
Converts size which represents a number of bytes into a human-readable form.
The result is in IEC prefix format, which may end in either "B", "KiB", "MiB", "GiB", "TiB", "PiB", or "EiB".
String indent(prefix: String) const 🔗
Indenta cada línea de la string con el prefix dado. Las líneas vacías no se indentan. Véase también dedent() para eliminar la indentación.
Por ejemplo, la string se puede indentar con dos tabulaciones usando "\t\t", o cuatro espacios usando " ".
String insert(position: int, what: String) const 🔗
Inserta what en la position dada en la string.
bool is_absolute_path() const 🔗
Devuelve true si la string es una ruta a un archivo o directorio, y su punto de inicio está definido explícitamente. Este método es lo opuesto a is_relative_path().
Esto incluye todas las rutas que comienzan con "res://", "user://", "C:\", "/", etc.
Returns true if the string's length is 0 (""). See also length().
bool is_relative_path() const 🔗
Devuelve true si la string es una ruta, y su punto de inicio depende del contexto. La ruta podría comenzar desde el directorio actual, o el Node actual (si la string deriva de un NodePath), y a veces puede tener el prefijo "./". Este método es lo opuesto a is_absolute_path().
bool is_subsequence_of(text: String) const 🔗
Returns true if all characters of this string can be found in text in their original order. This is not the same as contains().
var text = "Wow, incredible!"
print("inedible".is_subsequence_of(text)) # Prints true
print("Word!".is_subsequence_of(text)) # Prints true
print("Window".is_subsequence_of(text)) # Prints false
print("".is_subsequence_of(text)) # Prints true
bool is_subsequence_ofn(text: String) const 🔗
Returns true if all characters of this string can be found in text in their original order, ignoring case. This is not the same as containsn().
bool is_valid_ascii_identifier() const 🔗
Returns true if this string is a valid ASCII identifier. A valid ASCII identifier may contain only letters, digits, and underscores (_), and the first character may not be a digit.
print("node_2d".is_valid_ascii_identifier()) # Prints true
print("TYPE_FLOAT".is_valid_ascii_identifier()) # Prints true
print("1st_method".is_valid_ascii_identifier()) # Prints false
print("MyMethod#2".is_valid_ascii_identifier()) # Prints false
See also is_valid_unicode_identifier().
bool is_valid_filename() const 🔗
Returns true if this string is a valid file name. A valid file name cannot be empty, begin or end with space characters, or contain characters that are not allowed (: / \ ? * " | % < >).
Returns true if this string represents a valid floating-point number. A valid float may contain only digits, one decimal point (.), and the exponent letter (e). It may also be prefixed with a positive (+) or negative (-) sign. Any valid integer is also a valid float (see is_valid_int()). See also to_float().
print("1.7".is_valid_float()) # Prints true
print("24".is_valid_float()) # Prints true
print("7e3".is_valid_float()) # Prints true
print("Hello".is_valid_float()) # Prints false
bool is_valid_hex_number(with_prefix: bool = false) const 🔗
Returns true if this string is a valid hexadecimal number. A valid hexadecimal number only contains digits or letters A to F (either uppercase or lowercase), and may be prefixed with a positive (+) or negative (-) sign.
If with_prefix is true, the hexadecimal number needs to prefixed by "0x" to be considered valid.
print("A08E".is_valid_hex_number()) # Prints true
print("-AbCdEf".is_valid_hex_number()) # Prints true
print("2.5".is_valid_hex_number()) # Prints false
print("0xDEADC0DE".is_valid_hex_number(true)) # Prints true
bool is_valid_html_color() const 🔗
Returns true if this string is a valid color in hexadecimal HTML notation. The string must be a hexadecimal value (see is_valid_hex_number()) of either 3, 4, 6 or 8 digits, and may be prefixed by a hash sign (#). Other HTML notations for colors, such as names or hsl(), are not considered valid. See also Color.html().
bool is_valid_identifier() const 🔗
Obsoleto: Use is_valid_ascii_identifier() instead.
Devuelve true si esta string es un identificador válido. Un identificador válido solo puede contener letras, dígitos y guiones bajos (_), y el primer carácter no puede ser un dígito.
print("node_2d".is_valid_identifier()) # Imprime true
print("TYPE_FLOAT".is_valid_identifier()) # Imprime true
print("1st_method".is_valid_identifier()) # Imprime false
print("MyMethod#2".is_valid_identifier()) # Imprime false
Devuelve true si esta string representa un entero válido. Un entero válido solo contiene dígitos y puede ir prefijado con un signo positivo (+) o negativo (-). Véase también to_int().
print("7".is_valid_int()) # Imprime true
print("1.65".is_valid_int()) # Imprime false
print("Hi".is_valid_int()) # Imprime false
print("+3".is_valid_int()) # Imprime true
print("-12".is_valid_int()) # Imprime true
bool is_valid_ip_address() const 🔗
Devuelve true si esta string representa una dirección IPv4 o IPv6 bien formateada. Este método considera válidas las direcciones IP reservadas como "0.0.0.0" y "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff".
bool is_valid_unicode_identifier() const 🔗
Devuelve true si esta string es un identificador Unicode válido.
Un identificador Unicode válido debe comenzar con un carácter Unicode de clase XID_Start o "_", y puede contener caracteres Unicode de clase XID_Continue en las otras posiciones.
print("node_2d".is_valid_unicode_identifier()) # Imprime true
print("1st_method".is_valid_unicode_identifier()) # Imprime false
print("MyMethod#2".is_valid_unicode_identifier()) # Imprime false
print("állóképesség".is_valid_unicode_identifier()) # Imprime true
print("выносливость".is_valid_unicode_identifier()) # Imprime true
print("体力".is_valid_unicode_identifier()) # Imprime true
Véase también is_valid_ascii_identifier().
Nota: Este método verifica identificadores de la misma manera que GDScript. Consulta TextServer.is_valid_identifier() para comprobaciones más avanzadas.
String join(parts: PackedStringArray) const 🔗
Devuelve la concatenación de los elementos de parts, con cada elemento separado por la string que llama a este método. Este método es lo opuesto a split().
var fruits = ["Manzana", "Naranja", "Pera", "Kiwi"]
print(", ".join(fruits)) # Imprime "Manzana, Naranja, Pera, Kiwi"
print("---".join(fruits)) # Imprime "Manzana---Naranja---Pera---Kiwi"
string[] fruits = ["Manzana", "Naranja", "Pera", "Kiwi"];
// En C#, este método es estático.
GD.Print(string.Join(", ", fruits)); // Imprime "Manzana, Naranja, Pera, Kiwi"
GD.Print(string.Join("---", fruits)); // Imprime "Manzana---Naranja---Pera---Kiwi"
Devuelve una copia de la string con los caracteres especiales escapados usando el estándar JSON. Debido a que coincide estrechamente con el estándar C, es posible usar c_unescape() para desencapsular la string, si es necesario.
String left(length: int) const 🔗
Devuelve los primeros length caracteres desde el principio de la string. Si length es negativo, elimina los últimos length caracteres del final de la string.
print("¡Hola mundo!".left(3)) # Imprime "¡Ho"
print("¡Hola mundo!".left(-4)) # Imprime "¡Hola mu"
Devuelve el número de caracteres en la string. Las strings vacías ("") siempre devuelven 0. Véase también is_empty().
String lpad(min_length: int, character: String = " ") const 🔗
Formatea la string para que tenga al menos min_length de longitud añadiendo characters a la izquierda de la string, si es necesario. Véase también rpad().
String lstrip(chars: String) const 🔗
Elimina un conjunto de caracteres definidos en chars del comienzo de la string. Véase también rstrip().
Nota: chars no es un prefijo. Usa trim_prefix() para eliminar un solo prefijo, en lugar de un conjunto de caracteres.
bool match(expr: String) const 🔗
Realiza una comparación simple de expresiones (también llamado "glob" o "globbing"), donde * coincide con cero o más caracteres arbitrarios y ? coincide con cualquier carácter individual excepto un punto (.). Una string vacía o una expresión vacía siempre se evalúa como false.
bool matchn(expr: String) const 🔗
Realiza una comparación simple de expresiones insensible a mayúsculas/minúsculas, donde * coincide con cero o más caracteres arbitrarios y ? coincide con cualquier carácter individual excepto un punto (.). Una string vacía o una expresión vacía siempre se evalúa como false.
PackedByteArray md5_buffer() const 🔗
Devuelve el hash MD5 de la string como un PackedByteArray.
Devuelve el hash MD5 de la string como otra String.
int naturalcasecmp_to(to: String) const 🔗
Realiza una comparación de sensible a mayúsculas y minúsculas y orden natural con otra cadena. Devuelve -1 si es menor, 1 si es mayor, o 0 si es igual. "Menor que" o "mayor que" se determinan por los puntos de código Unicode de cada cadena, lo que coincide aproximadamente con el orden alfabético.
Cuando se usa para ordenar, la comparación de orden natural ordena las secuencias de números por el valor combinado de cada dígito como se espera a menudo, en lugar del valor de un solo dígito. Una secuencia ordenada de strings numeradas será ["1", "2", "3", ...], no ["1", "10", "2", "3", ...].
Si la comparación de caracteres llega al final de una cadena, pero la otra cadena contiene más caracteres, entonces usará la longitud como factor decisivo: se devolverá 1 si esta cadena es más larga que la cadena to, o -1 si es más corta. Ten en cuenta que la longitud de las strings vacías es siempre 0.
Para obtener un resultado bool de una comparación de strings, usa el operador == en su lugar. Consulta también naturalnocasecmp_to(), filecasecmp_to() y nocasecmp_to().
int naturalnocasecmp_to(to: String) const 🔗
Realiza una comparación de no sensible a mayúsculas y minúsculas y orden natural con otra string. Devuelve -1 si es menor, 1 si es mayor, o 0 si es igual. "Menor que" o "mayor que" se determinan por los puntos de código Unicode de cada string, lo que coincide aproximadamente con el orden alfabético. Internamente, los caracteres en minúscula se convierten a mayúscula para la comparación.
Cuando se usa para ordenar, la comparación de orden natural ordena las secuencias de números por el valor combinado de cada dígito como se espera a menudo, en lugar del valor de un solo dígito. Una secuencia ordenada de strings numeradas será ["1", "2", "3", ...], no ["1", "10", "2", "3", ...].
Si la comparación de caracteres llega al final de una string, pero la otra string contiene más caracteres, entonces usará la longitud como factor decisivo: se devolverá 1 si esta string es más larga que la string to, o -1 si es más corta. Ten en cuenta que la longitud de las strings vacías es siempre 0.
Para obtener un resultado bool de una comparación de strings, usa el operador == en su lugar. Véase también naturalcasecmp_to(), filenocasecmp_to() y casecmp_to().
int nocasecmp_to(to: String) const 🔗
Realiza una comparación no sensible a mayúsculas y minúsculas con otra string. Devuelve -1 si es menor, 1 si es mayor, o 0 si es igual. "Menor que" o "mayor que" se determinan por los puntos de código Unicode de cada string, lo que coincide aproximadamente con el orden alfabético. Internamente, los caracteres en minúscula se convierten a mayúscula para la comparación.
Si la comparación de caracteres llega al final de una string, pero la otra string contiene más caracteres, entonces usará la longitud como factor decisivo: se devolverá 1 si esta string es más larga que la string to, o -1 si es más corta. Ten en cuenta que la longitud de las strings vacías es siempre 0.
Para obtener un resultado bool de una comparación de strings, usa el operador == en su lugar. Véase también casecmp_to(), filenocasecmp_to() y naturalnocasecmp_to().
String num(number: float, decimals: int = -1) static 🔗
Convierte un float a una representación de string de un número decimal, con el número de decimales especificado en decimals.
Si decimals es -1 como por defecto, la representación de string puede tener solo hasta 14 dígitos significativos, con los dígitos antes del punto decimal teniendo prioridad sobre los dígitos después.
Los ceros finales no se incluyen en la string. El último dígito se redondea, no se trunca.
String.num(3.141593) # Devuelve "3.141593"
String.num(3.141593, 3) # Devuelve "3.142"
String.num(3.14159300) # Devuelve "3.141593"
# Aquí, el último dígito se redondeará hacia arriba,
# lo que reduce el conteo total de dígitos, ya que los ceros finales se eliminan:
String.num(42.129999, 5) # Returns "42.13"
# Si `decimals` no se especifica, el número máximo de dígitos significativos es 14:
String.num(-0.0000012345432123454321) # Devuelve "-0.00000123454321"
String.num(-10000.0000012345432123454321) # Devuelve "-10000.0000012345"
String num_int64(number: int, base: int = 10, capitalize_hex: bool = false) static 🔗
Convierte el number dado a una representación de string, con la base dada.
Por defecto, base se establece en decimal (10). Otras bases comunes en programación incluyen binario (2), octal (8), hexadecimal (16).
Si capitalize_hex es true, los dígitos mayores que 9 se representan en mayúsculas.
String num_scientific(number: float) static 🔗
Convierte el number dado a una representación de string, en notación científica.
var n = -5.2e8
print(n) # Imprime -520000000
print(String.num_scientific(n)) # Imprime -5.2e+08
// Este método no está implementado en C#.
// Usa `string.ToString()` con "e" para obtener resultados similares.
var n = -5.2e8f;
GD.Print(n); // Imprime -520000000
GD.Print(n.ToString("e1")); // Imprime -5.2e+008
Nota: En C#, este método no está implementado. Para obtener resultados similares, véanse las strings de formato numérico estándar de C#.
String num_uint64(number: int, base: int = 10, capitalize_hex: bool = false) static 🔗
Convierte el int sin signo dado a una representación de string, con la base dada.
Por defecto, base se establece en decimal (10). Otras bases comunes en programación incluyen binario (2), octal (8), hexadecimal (16).
Si capitalize_hex es true, los dígitos mayores que 9 se representan en mayúsculas.
String pad_decimals(digits: int) const 🔗
Formatea la string que representa un número para que tenga exactamente digits dígitos después del punto decimal.
String pad_zeros(digits: int) const 🔗
Formatea la string que representa un número para que tenga exactamente digits dígitos antes del punto decimal.
String path_join(path: String) const 🔗
Concatenates path at the end of the string as a subpath, adding / if necessary.
Example: "this/is".path_join("path") == "this/is/path".
String remove_char(what: int) const 🔗
Elimina todas las ocurrencias del carácter Unicode con el código what. Versión más rápida de replace() cuando la clave tiene solo un carácter de longitud y el reemplazo es "".
String remove_chars(chars: String) const 🔗
Elimina cualquier ocurrencia de los caracteres en chars. Véase también remove_char().
String repeat(count: int) const 🔗
Repite esta string un número de veces. count debe ser mayor que 0. De lo contrario, devuelve una string vacía.
String replace(what: String, forwhat: String) const 🔗
Reemplaza todas las instancias de what dentro de la string con el forwhat dado.
String replace_char(key: int, with: int) const 🔗
Reemplaza todas las ocurrencias del carácter Unicode con el código key con el carácter Unicode con el código with. Versión más rápida de replace() cuando la clave tiene solo un carácter de longitud. Para obtener un solo carácter, usa "X".unicode_at(0) (ten en cuenta que algunas strings, como las letras compuestas y los emojis, pueden estar compuestas de múltiples puntos de código Unicode, y no funcionarán con este método; usa length() para asegurarte).
String replace_chars(keys: String, with: int) const 🔗
Reemplaza cualquier ocurrencia de los caracteres en keys con el carácter Unicode con el código with. Véase también replace_char().
String replacen(what: String, forwhat: String) const 🔗
Reemplaza todas las ocurrencias insensibles a mayúsculas y minúsculas de what dentro de la string con el forwhat dado.
Devuelve la copia de esta string en orden inverso. Esta operación funciona en puntos de código Unicode, en lugar de secuencias de puntos de código, y puede romper cosas como letras compuestas o emojis.
int rfind(what: String, from: int = -1) const 🔗
Devuelve el índice de la última ocurrencia de what en esta string, o -1 si no hay ninguna. El inicio de la búsqueda se puede especificar con from, continuando hacia el principio de la string. Este método es el inverso de find().
Nota: Un valor negativo de from se convierte en un índice de inicio contando hacia atrás desde el último índice posible con espacio suficiente para encontrar what.
Nota: Un valor de from mayor que el último índice posible con espacio suficiente para encontrar what se considera fuera de límites y devuelve -1.
int rfindn(what: String, from: int = -1) const 🔗
Devuelve el índice de la última ocurrencia insensible a mayúsculas y minúsculas de what en esta string, o -1 si no hay ninguna. El índice de búsqueda inicial se puede especificar con from, continuando hasta el principio de la string. Este método es el inverso de findn().
String right(length: int) const 🔗
Returns the last length characters from the end of the string. If length is negative, strips the first length characters from the string's beginning.
print("Hello World!".right(3)) # Prints "ld!"
print("Hello World!".right(-4)) # Prints "o World!"
String rpad(min_length: int, character: String = " ") const 🔗
Formatea la string para que tenga al menos min_length de longitud, añadiendo characters a la derecha de la string, si es necesario. Véase también lpad().
PackedStringArray rsplit(delimiter: String = "", allow_empty: bool = true, maxsplit: int = 0) const 🔗
Divide la string usando un delimiter y devuelve un array de las subcadenas, empezando desde el final de la string. Las divisiones en el array devuelto aparecen en el mismo orden que la string original. Si delimiter es una string vacía, cada subcadena será un solo carácter.
Si allow_empty es false, las strings vacías entre delimitadores adyacentes se excluyen del array.
Si maxsplit es mayor que 0, el número de divisiones no puede exceder maxsplit. Por defecto, la string completa se divide, lo que es casi idéntico a split().
var some_string = "Uno,Dos,Tres,Cuatro"
var some_array = some_string.rsplit(",", true, 1)
print(some_array.size()) # Imprime 2
print(some_array[0]) # Imprime "Uno,Dos,Tres"
print(some_array[1]) # Imprime "Cuatro"
// En C#, no existe el método String.RSplit().
String rstrip(chars: String) const 🔗
Elimina un conjunto de caracteres definidos en chars del final de la string. Véase también lstrip().
Nota: chars no es un sufijo. Usa trim_suffix() para eliminar un solo sufijo, en lugar de un conjunto de caracteres.
PackedByteArray sha1_buffer() const 🔗
Devuelve el hash SHA-1 de la string como un PackedByteArray.
Devuelve el hash SHA-1 de la string como otra String.
PackedByteArray sha256_buffer() const 🔗
Devuelve el SHA-256 hash de la string como un PackedByteArray.
Devuelve el hash SHA-256 de la string como otra String.
float similarity(text: String) const 🔗
Returns the similarity index (Sørensen-Dice coefficient) of this string compared to another. A result of 1.0 means totally similar, while 0.0 means totally dissimilar.
print("ABC123".similarity("ABC123")) # Prints 1.0
print("ABC123".similarity("XYZ456")) # Prints 0.0
print("ABC123".similarity("123ABC")) # Prints 0.8
print("ABC123".similarity("abc123")) # Prints 0.4
String simplify_path() const 🔗
Si la string es una ruta de archivo válida, convierte la string en una ruta canónica. Esta es la ruta más corta posible, sin "./", y todo el ".." y "/" innecesarios.
var ruta_simple = "./ruta/a///../archivo".simplify_path()
print(ruta_simple) # Imprime "ruta/archivo"
PackedStringArray split(delimiter: String = "", allow_empty: bool = true, maxsplit: int = 0) const 🔗
Splits the string using a delimiter and returns an array of the substrings. If delimiter is an empty string, each substring will be a single character. This method is the opposite of join().
If allow_empty is false, empty strings between adjacent delimiters are excluded from the array.
If maxsplit is greater than 0, the number of splits may not exceed maxsplit. By default, the entire string is split.
var some_array = "One,Two,Three,Four".split(",", true, 2)
print(some_array.size()) # Prints 3
print(some_array[0]) # Prints "One"
print(some_array[1]) # Prints "Two"
print(some_array[2]) # Prints "Three,Four"
// C#'s `Split()` does not support the `maxsplit` parameter.
var someArray = "One,Two,Three".Split(",");
GD.Print(someArray[0]); // Prints "One"
GD.Print(someArray[1]); // Prints "Two"
GD.Print(someArray[2]); // Prints "Three"
Note: If you only need one substring from the array, consider using get_slice() which is faster. If you need to split strings with more complex rules, use the RegEx class instead.
PackedFloat64Array split_floats(delimiter: String, allow_empty: bool = true) const 🔗
Splits the string into floats by using a delimiter and returns a PackedFloat64Array.
If allow_empty is false, empty or invalid float conversions between adjacent delimiters are excluded.
var a = "1,2,4.5".split_floats(",") # a is [1.0, 2.0, 4.5]
var c = "1| ||4.5".split_floats("|") # c is [1.0, 0.0, 0.0, 4.5]
var b = "1| ||4.5".split_floats("|", false) # b is [1.0, 4.5]
String strip_edges(left: bool = true, right: bool = true) const 🔗
Strips all non-printable characters from the beginning and the end of the string. These include spaces, tabulations (\t), and newlines (\n \r).
If left is false, ignores the string's beginning. Likewise, if right is false, ignores the string's end.
String strip_escapes() const 🔗
Strips all escape characters from the string. These include all non-printable control characters of the first page of the ASCII table (values from 0 to 31), such as tabulation (\t) and newline (\n, \r) characters, but not spaces.
String substr(from: int, len: int = -1) const 🔗
Returns part of the string from the position from with length len. If len is -1 (as by default), returns the rest of the string starting from the given position.
PackedByteArray to_ascii_buffer() const 🔗
Converts the string to an ASCII/Latin-1 encoded PackedByteArray. This method is slightly faster than to_utf8_buffer(), but replaces all unsupported characters with spaces. This is the inverse of PackedByteArray.get_string_from_ascii().
String to_camel_case() const 🔗
Devuelve la string convertida a camelCase.
Converts the string representing a decimal number into a float. This method stops on the first non-number character, except the first decimal point (.) and the exponent letter (e). See also is_valid_float().
var a = "12.35".to_float() # a is 12.35
var b = "1.2.3".to_float() # b is 1.2
var c = "12xy3".to_float() # c is 12.0
var d = "1e3".to_float() # d is 1000.0
var e = "Hello!".to_float() # e is 0.0
Converts the string representing an integer number into an int. This method removes any non-number character and stops at the first decimal point (.). See also is_valid_int().
var a = "123".to_int() # a is 123
var b = "x1y2z3".to_int() # b is 123
var c = "-1.2.3".to_int() # c is -1
var d = "Hello!".to_int() # d is 0
String to_kebab_case() const 🔗
Returns the string converted to kebab-case.
Note: Numbers followed by a single letter are not separated in the conversion to keep some words (such as "2D") together.
"Node2D".to_kebab_case() # Returns "node-2d"
"2nd place".to_kebab_case() # Returns "2-nd-place"
"Texture3DAssetFolder".to_kebab_case() # Returns "texture-3d-asset-folder"
"Node2D".ToKebabCase(); // Returns "node-2d"
"2nd place".ToKebabCase(); // Returns "2-nd-place"
"Texture3DAssetFolder".ToKebabCase(); // Returns "texture-3d-asset-folder"
Devuelve la string convertida a minúsculas.
PackedByteArray to_multibyte_char_buffer(encoding: String = "") const 🔗
Converts the string to system multibyte code page encoded PackedByteArray. If conversion fails, empty array is returned.
The values permitted for encoding are system dependent. If encoding is empty string, system default encoding is used.
For Windows, see Code Page Identifiers .NET names.
For macOS and Linux/BSD, see
libiconvlibrary documentation andiconv --listfor a list of supported encodings.
String to_pascal_case() const 🔗
Devuelve la string convertida a PascalCase.
String to_snake_case() const 🔗
Returns the string converted to snake_case.
Note: Numbers followed by a single letter are not separated in the conversion to keep some words (such as "2D") together.
"Node2D".to_snake_case() # Returns "node_2d"
"2nd place".to_snake_case() # Returns "2_nd_place"
"Texture3DAssetFolder".to_snake_case() # Returns "texture_3d_asset_folder"
"Node2D".ToSnakeCase(); // Returns "node_2d"
"2nd place".ToSnakeCase(); // Returns "2_nd_place"
"Texture3DAssetFolder".ToSnakeCase(); // Returns "texture_3d_asset_folder"
Devuelve la string convertida a MAYÚSCULAS.
PackedByteArray to_utf8_buffer() const 🔗
Convierte la string a un PackedByteArray codificado en UTF-8. Este método es un poco más lento que to_ascii_buffer(), pero soporta todos los caracteres UTF-8. En la mayoría de los casos, es preferible usar este método. Este es el inverso de PackedByteArray.get_string_from_utf8().
PackedByteArray to_utf16_buffer() const 🔗
Convierte la string a un PackedByteArray codificado en UTF-16. Este es el inverso de PackedByteArray.get_string_from_utf16().
PackedByteArray to_utf32_buffer() const 🔗
Convierte la string a un PackedByteArray codificado en UTF-32. Este es el inverso de PackedByteArray.get_string_from_utf32().
PackedByteArray to_wchar_buffer() const 🔗
Convierte la string en un PackedByteArray codificado carácter ancho (wchar_t, UTF-16 en Windows, UTF-32 en otras plataformas). Esto es el inverso de PackedByteArray.get_string_from_wchar().
String trim_prefix(prefix: String) const 🔗
Elimina el prefix dado del inicio de la string, o devuelve la string sin cambios.
String trim_suffix(suffix: String) const 🔗
Elimina el suffix dado del final de la string, o string la string sin cambios.
int unicode_at(at: int) const 🔗
Devuelve el código de carácter en la posición at.
Véase también chr(), @GDScript.char() y @GDScript.ord().
Decodes the string from its URL-encoded format. This method is meant to properly decode the parameters in a URL when receiving an HTTP request. See also uri_encode().
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
print(url.uri_decode()) # Prints "$DOCS_URL/?highlight=Godot Engine:docs"
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
GD.Print(url.URIDecode()) // Prints "$DOCS_URL/?highlight=Godot Engine:docs"
Note: This method decodes + as space.
Encodes the string to URL-friendly format. This method is meant to properly encode the parameters in a URL when sending an HTTP request. See also uri_decode().
var prefix = "$DOCS_URL/?highlight="
var url = prefix + "Godot Engine:docs".uri_encode()
print(url) # Prints "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
var prefix = "$DOCS_URL/?highlight=";
var url = prefix + "Godot Engine:docs".URIEncode();
GD.Print(url); // Prints "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
String uri_file_decode() const 🔗
Decodifica la ruta del archivo desde su formato codificado en URL. A diferencia de uri_decode() este método deja + como está.
String validate_filename() const 🔗
Devuelve una copia de la string con todos los caracteres que no están permitidos en is_valid_filename() reemplazados con guiones bajos.
String validate_node_name() const 🔗
Devuelve una copia de la string con todos los caracteres que no están permitidos en Node.name (. : @ / " %) reemplazados con guiones bajos.
String xml_escape(escape_quotes: bool = false) const 🔗
Devuelve una copia de la string con los caracteres especiales escapados usando el estándar XML. Si escape_quotes es true, la comilla simple (') y la comilla doble (") también se escapan.
Devuelve una copia de la string con los caracteres escapados reemplazados por sus significados según el estándar XML.
Descripciones de Operadores
bool operator !=(right: String) 🔗
Devuelve true si ambas strings no contienen la misma secuencia de caracteres.
bool operator !=(right: StringName) 🔗
Devuelve true si esta String no es equivalente al StringName dado.
String operator %(right: Variant) 🔗
Formats the String, replacing the placeholders with one or more parameters. To pass multiple parameters, right needs to be an Array.
print("I caught %d fishes!" % 2) # Prints "I caught 2 fishes!"
var my_message = "Travelling to %s, at %2.2f km/h."
var location = "Deep Valley"
var speed = 40.3485
print(my_message % [location, speed]) # Prints "Travelling to Deep Valley, at 40.35 km/h."
For more information, see the GDScript format strings tutorial.
Note: In C#, this operator is not available. Instead, see how to interpolate strings with "$".
String operator +(right: String) 🔗
Añade right al final de esta String, también conocido como concatenación de strings.
String operator +(right: StringName) 🔗
Añade right al final de esta String, devolviendo un String. Esto también se conoce como concatenación de strings.
bool operator <(right: String) 🔗
Devuelve true si la String de la izquierda es anterior a right en el orden Unicode, que coincide aproximadamente con el orden alfabético. Útil para ordenar.
bool operator <=(right: String) 🔗
Devuelve true si la String de la izquierda es anterior a right en el orden Unicode, que coincide aproximadamente con el orden alfabético, o si ambos son iguales.
bool operator ==(right: String) 🔗
Devuelve true si ambas strings contienen la misma secuencia de caracteres.
bool operator ==(right: StringName) 🔗
Devuelve true si esta String es equivalente al StringName dado.
bool operator >(right: String) 🔗
Devuelve true si la String de la izquierda es posterior a right en el orden Unicode, que coincide aproximadamente con el orden alfabético. Útil para ordenar.
bool operator >=(right: String) 🔗
Devuelve true si la String de la izquierda es posterior a right en el orden Unicode, que coincide aproximadamente con el orden alfabético, o si ambos son iguales.
String operator [](index: int) 🔗
Devuelve una nueva String que solo contiene el carácter en index. Los índices comienzan desde 0. Si index es mayor o igual que 0, el carácter se obtiene desde el principio de la string. Si index es un valor negativo, se obtiene desde el final. Acceder a una string fuera de los límites provocará un error en tiempo de ejecución, pausando la ejecución del proyecto si se ejecuta desde el editor.