Convertidor de texto a Mayúsculas Iniciales

Convertidor de Cadenas a Mayúsculas Iniciales

Esta herramienta en línea y gratuita te permite convertir una cadena de texto a formato de mayúsculas iniciales. No depende de ningún sistema o software, lo que la hace accesible y conveniente de usar. Con funciones como borrar la entrada, copiar la salida y tener un texto de ejemplo, esta herramienta proporciona una interfaz fácil de usar para convertir cadenas de texto a mayúsculas iniciales.

Propósito y Escenario

El propósito de esta herramienta es convertir cadenas de texto a formato de mayúsculas iniciales. Este formato es comúnmente utilizado al escribir títulos, como el título de un libro, una canción o una película. Al utilizar esta herramienta, puedes fácilmente convertir cualquier cadena de texto a mayúsculas iniciales sin necesidad de conocimientos de programación o instalaciones de software.

Esta herramienta es beneficiosa en varios escenarios, incluyendo:

• Creación de contenido: Al escribir artículos, entradas de blog o cualquier otro tipo de contenido, puedes utilizar esta herramienta para convertir encabezados o títulos a formato de mayúsculas iniciales, dándole a tu contenido un aspecto profesional y pulido.
• Procesamiento de datos: Si tienes un conjunto de datos o una lista de cadenas de texto que necesitan ser convertidas a mayúsculas iniciales, esta herramienta puede manejar eficientemente la tarea sin dependencias del sistema.
• Aprendizaje: Si eres nuevo en la programación y quieres entender cómo funciona la conversión a mayúsculas iniciales, esta herramienta proporciona ejemplos de código en diferentes lenguajes de programación.

Cómo usar la herramienta

El uso de la herramienta es sencillo. Siga los pasos a continuación para convertir sus cadenas de texto a formato de título:

1. Ingrese la cadena de texto: En el cuadro de texto provisto, ingrese o pegue la cadena de texto que desea convertir a formato de título. Por ejemplo, si ingresa la cadena "string to title case", la herramienta la convertirá a "String to Title case".
2. Haga clic en el botón Convertir: Una vez que haya ingresado la cadena de texto deseada, haga clic en el botón Convertir. La herramienta convertirá instantáneamente la cadena de texto al formato de título.
3. Copie la salida: Después de la conversión, simplemente puede hacer clic en el botón Copiar para copiar la cadena de texto convertida en su portapapeles. Esto le permite pegar fácilmente la cadena de texto convertida donde la necesite.

Ejemplos de código en diferentes lenguajes de programación

Si está interesado en comprender cómo se implementa la conversión a título de caso en diferentes lenguajes de programación, esta sección proporciona ejemplos de código y explicaciones para cada lenguaje.

Python

def convert_to_title_case(string):
    title_case_words = []
    non_title_case_words = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'on', 'at', 'to', 'from', 'by', 'over']

    for word in string.split():
        if word.lower() in non_title_case_words:
            title_case_words.append(word.lower())
        else:
            title_case_words.append(word.capitalize())

    return ' '.join(title_case_words)

## Example usage
input_string = 'string to title case'
output_string = convert_to_title_case(input_string)
print(output_string)

En Python, podemos dividir la cadena de entrada en palabras individuales utilizando la función split(). Luego, verificamos si cada palabra está en la lista de palabras que no se capitalizan (artículos, conjunciones y preposiciones). Si es así, convertimos la palabra a minúsculas. De lo contrario, capitalizamos la palabra. Finalmente, unimos las palabras de nuevo usando el método join().

Java

public class TitleCaseConverter {
    public static String convertToTitleCase(String string) {
        StringBuilder titleCaseString = new StringBuilder();
        String[] words = string.split(" ");
        String[] nonTitleCaseWords = {"a", "an", "the", "and", "but", "or", "for", "nor", "on", "at", "to", "from", "by", "over"};

        for (String word : words) {
            if (containsIgnoreCase(nonTitleCaseWords, word)) {
                titleCaseString.append(word.toLowerCase());
            } else {
                titleCaseString.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1).toLowerCase());
            }
            titleCaseString.append(" ");
        }

        return titleCaseString.toString().trim();
    }

    private static boolean containsIgnoreCase(String[] arr, String word) {
        for (String element : arr) {
            if (element.equalsIgnoreCase(word)) {
                return true;
            }
        }
        return false;
    }

    // Example usage
    public static void main(String[] args) {
        String inputString = "string to title case";
        String outputString = convertToTitleCase(inputString);
        System.out.println(outputString);
    }
}

En Java, dividimos la cadena de entrada en palabras individuales usando el método split(). Luego, verificamos si cada palabra está en el arreglo de palabras que no llevan mayúscula. Si es así, convertimos la palabra a minúscula. De lo contrario, capitalizamos el primer carácter y convertimos el resto de los caracteres a minúscula. Finalmente, unimos las palabras y eliminamos cualquier espacio en blanco al principio o al final.

JavaScript

function convertToTitleCase(string) {
  var titleCaseString = "";
  var words = string.toLowerCase().split(" ");
  var nonTitleCaseWords = [
    "a",
    "an",
    "the",
    "and",
    "but",
    "or",
    "for",
    "nor",
    "on",
    "at",
    "to",
    "from",
    "by",
    "over",
  ];

  for (var i = 0; i < words.length; i++) {
    var word = words[i];
    if (nonTitleCaseWords.includes(word)) {
      titleCaseString += word;
    } else {
      titleCaseString += word.charAt(0).toUpperCase() + word.slice(1);
    }
    titleCaseString += " ";
  }

  return titleCaseString.trim();
}

// Example usage
var inputString = "string to title case";
var outputString = convertToTitleCase(inputString);
console.log(outputString);

En JavaScript, dividimos la cadena de entrada en palabras individuales usando el método split(). Luego, verificamos si cada palabra está en el arreglo de palabras que no llevan mayúscula. Si es así, mantenemos la palabra tal cual. De lo contrario, capitalizamos el primer carácter y agregamos el resto de la palabra. Finalmente, unimos las palabras y eliminamos cualquier espacio en blanco al principio o al final.

Golang

package main

import (
    "fmt"
    "strings"
)

func convertToTitleCase(s string) string {
    titleCaseString := ""
    words := strings.Fields(strings.ToLower(s))
    nonTitleCaseWords := []string{"a", "an", "the", "and", "but", "or", "for", "nor", "on", "at", "to", "from", "by", "over"}

    for _, word := range words {
        if contains(nonTitleCaseWords, word) {
            titleCaseString += word
        } else {
            titleCaseString += strings.Title(word)
        }
        titleCaseString += " "
    }

    return strings.TrimSpace(titleCaseString)
}

func contains(arr []string, word string) bool {
    for _, element := range arr {
        if strings.EqualFold(element, word) {
            return true
        }
    }
    return false
}

// Example usage
func main() {
    inputString := "string to title case"
    outputString := convertToTitleCase(inputString)
    fmt.Println(outputString)
}

En Golang, dividimos la cadena de entrada en palabras individuales utilizando la función Fields() del paquete strings. Luego, verificamos si cada palabra está en la lista de palabras no en mayúsculas. Si lo está, mantenemos la palabra tal cual. De lo contrario, convertimos la palabra a mayúscula utilizando Title(). Finalmente, unimos las palabras y eliminamos cualquier espacio en blanco al principio o al final.

Ruby

def convert_to_title_case(string)
    title_case_string = ''
    words = string.downcase.split(' ')
    non_title_case_words = ['a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'on', 'at', 'to', 'from', 'by', 'over']

    words.each do |word|
        if non_title_case_words.include?(word)
            title_case_string += word
        else
            title_case_string += word.capitalize
        end
        title_case_string += ' '
    end

    title_case_string.strip
end

## Example usage
input_string = 'string to title case'
output_string = convert_to_title_case(input_string)
puts output_string

En Ruby, dividimos la cadena de entrada en palabras individuales utilizando split(). Luego, verificamos si cada palabra está en la lista de palabras no en mayúsculas. Si lo está, mantenemos la palabra tal cual. De lo contrario, convertimos la palabra a mayúscula utilizando capitalize(). Finalmente, unimos las palabras y eliminamos cualquier espacio en blanco al principio o al final.