Konwerter Wielkości Liter

Czym jest konwersja wielkości liter?

Konwersja wielkości liter to proces zmiany zapisu liter lub wzorca separacji słów w ciągu znaków. Konwerter przyjmuje dane wejściowe, np. \"hello world\", i przekształca je w UPPERCASE, lowercase, Title Case, camelCase, snake_case, kebab-case lub inne konwencje. Transformacja jest prosta dla zwykłego tekstu ASCII, ale pojawiają się przypadki brzegowe przy akronimach (\"XMLParser\"), zasadach zależnych od ustawień regionalnych (tureckie kropkowane I) oraz ciągach zawierających różne alfabety.

Języki programowania, systemy plików i przewodniki stylu narzucają własne konwencje nazewnictwa. Zmienne JavaScript zazwyczaj używają camelCase. Funkcje i zmienne w Pythonie stosują snake_case zgodnie z PEP 8. Nazwy klas CSS używają kebab-case. Kolumny baz danych różnią się między zespołami, ale snake_case dominuje w PostgreSQL i MySQL. Ręczne przełączanie między tymi konwencjami jest powolne i podatne na błędy, zwłaszcza przy zmianie nazw w dziesiątkach plików.

Konwencje zapisu liter mają znaczenie również poza kodem. Title Case stosuje zasady zdefiniowane przez przewodniki stylu, takie jak Chicago Manual of Style i APA, gdzie spójniki i krótkie przyimki pozostają małymi literami, chyba że zaczynają zdanie. Sentence case zapisuje wielką literą tylko pierwsze słowo i nazwy własne. Angielskie publikacje amerykańskie domyślnie stosują Title Case dla nagłówków; większość europejskich i technicznych dokumentacji używa zamiast tego Sentence case.

Dlaczego warto użyć tego konwertera?

Wklej dowolny tekst i natychmiast przekonwertuj go na jeden z dziewięciu formatów zapisu — bez instalowania rozszerzenia do VS Code ani pisania jednorazowego skryptu.

Przypadki użycia konwertera wielkości liter

Przewodnik po konwencjach zapisu

Każda konwencja nazewnictwa ma szczegółowe zasady dotyczące wielkości liter i separacji słów. Poniższa tabela przedstawia wszystkie dziewięć formatów obsługiwanych przez to narzędzie, z użyciem frazy "the quick brown fox" jako przykładu odniesienia.

camelCase vs snake_case vs kebab-case

Te trzy konwencje dominują w tworzeniu oprogramowania, ale każda z nich należy do innego ekosystemu. Wybór niewłaściwej łamie lintery, narusza kontrakty API lub prowadzi do niespójnych baz kodu.

Przykłady kodu

Jak programowo konwertować między konwencjami zapisu. Każdy przykład obejmuje najczęstsze przekształcenia: camelCase na snake_case, snake_case na camelCase oraz podstawowe konwersje upper/lower/title.

// camelCase → snake_case
function toSnakeCase(str) {
  return str
    .replace(/([a-z])([A-Z])/g, '$1_$2')
    .replace(/[\s-]+/g, '_')
    .toLowerCase()
}
toSnakeCase('myVariableName')  // → "my_variable_name"
toSnakeCase('kebab-case-str')  // → "kebab_case_str"

// snake_case → camelCase
function toCamelCase(str) {
  return str
    .toLowerCase()
    .replace(/[_-](\w)/g, (_, c) => c.toUpperCase())
}
toCamelCase('my_variable_name')  // → "myVariableName"

// Title Case
function toTitleCase(str) {
  return str.replace(/\w\S*/g, w =>
    w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()
  )
}
toTitleCase('the quick brown fox')  // → "The Quick Brown Fox"

import re

text = "the quick brown fox"

# UPPERCASE / lowercase
text.upper()  # → "THE QUICK BROWN FOX"
text.lower()  # → "the quick brown fox"

# Title Case
text.title()  # → "The Quick Brown Fox"

# camelCase
def to_camel(s):
    words = re.split(r'[\s_-]+', s)
    return words[0].lower() + ''.join(w.capitalize() for w in words[1:])

to_camel("my_variable_name")  # → "myVariableName"

# snake_case from camelCase
def to_snake(s):
    return re.sub(r'([a-z])([A-Z])', r'\1_\2', s).lower()

to_snake("myVariableName")  # → "my_variable_name"

# kebab-case
def to_kebab(s):
    return re.sub(r'([a-z])([A-Z])', r'\1-\2', s).replace('_', '-').lower()

to_kebab("myVariableName")  # → "my-variable-name"

package main

import (
	"fmt"
	"regexp"
	"strings"
)

// camelCase → snake_case
func toSnake(s string) string {
	re := regexp.MustCompile("([a-z])([A-Z])")
	snake := re.ReplaceAllString(s, "${1}_${2}")
	return strings.ToLower(snake)
}

// snake_case → camelCase
func toCamel(s string) string {
	parts := strings.Split(strings.ToLower(s), "_")
	for i := 1; i < len(parts); i++ {
		parts[i] = strings.Title(parts[i])
	}
	return strings.Join(parts, "")
}

func main() {
	fmt.Println(toSnake("myVariableName"))  // → my_variable_name
	fmt.Println(toCamel("my_variable_name")) // → myVariableName
	fmt.Println(strings.ToUpper("hello"))    // → HELLO
	fmt.Println(strings.ToUpper("hello world")) // → HELLO WORLD
}

# UPPERCASE
echo "hello world" | tr '[:lower:]' '[:upper:]'
# → HELLO WORLD

# lowercase
echo "HELLO WORLD" | tr '[:upper:]' '[:lower:]'
# → hello world

# camelCase → snake_case (using sed)
echo "myVariableName" | sed 's/\([a-z]\)\([A-Z]\)/\1_\2/g' | tr '[:upper:]' '[:lower:]'
# → my_variable_name

# snake_case → kebab-case
echo "my_variable_name" | tr '_' '-'
# → my-variable-name

Często zadawane pytania