ToolDeck

ตัวแปลง Case

แปลงข้อความระหว่าง uppercase, lowercase, title case, camelCase, snake_case และรูปแบบอื่นๆ

ลองตัวอย่าง

อินพุต

เอาต์พุต

ประมวลผลในเครื่อง · ปลอดภัยในการวางข้อมูลลับ
ข้อความที่แปลงแล้วจะปรากฏที่นี่…

การแปลง Case ของข้อความคืออะไร?

การแปลง case ของข้อความคือกระบวนการเปลี่ยนรูปแบบตัวพิมพ์หรือรูปแบบการแยกคำของสตริง ตัวแปลง case รับอินพุตเช่น "hello world" และแปลงเป็น UPPERCASE, lowercase, Title Case, camelCase, snake_case, kebab-case หรือรูปแบบอื่นๆ การแปลงทำได้ตรงไปตรงมาสำหรับข้อความ ASCII ทั่วไป แต่จะมีกรณีพิเศษเมื่อพบตัวย่อ ("XMLParser") กฎเฉพาะของภาษา (ตัว I ในภาษาตุรกี) และสตริงที่ผสมสคริปต์หลายชุด

ภาษาโปรแกรม ระบบไฟล์ และ style guide ต่างกำหนดรูปแบบการตั้งชื่อของตัวเอง ตัวแปรใน JavaScript มักใช้ camelCase ฟังก์ชันและตัวแปรใน Python ใช้ snake_case ตาม PEP 8 ชื่อ class ใน CSS ใช้ kebab-case คอลัมน์ฐานข้อมูลขึ้นอยู่กับแต่ละทีม แต่ snake_case ครอบครองใน PostgreSQL และ MySQL การสลับระหว่างรูปแบบเหล่านี้ด้วยมือนั้นช้าและเสี่ยงต่อความผิดพลาด โดยเฉพาะเมื่อต้องเปลี่ยนชื่อในไฟล์จำนวนมาก

รูปแบบ case ยังมีความสำคัญนอกเหนือจากโค้ดด้วย Title Case ใช้กฎที่กำหนดโดย style guide เช่น Chicago Manual of Style และ APA ซึ่งบทความและคำบุพบทสั้นจะเป็นตัวพิมพ์เล็กเว้นแต่จะอยู่ต้นประโยค Sentence case ใช้ตัวพิมพ์ใหญ่เฉพาะคำแรกและคำนามเฉพาะ สิ่งพิมพ์ภาษาอังกฤษแบบอเมริกันใช้ Title Case เป็นค่าเริ่มต้นสำหรับหัวข้อข่าว ส่วนเอกสารประกอบในยุโรปและเทคโนโลยีส่วนใหญ่ใช้ Sentence case แทน

ทำไมต้องใช้ตัวแปลง Case นี้?

วางข้อความใดก็ได้และแปลงระหว่างเก้ารูปแบบ case ได้ทันที โดยไม่ต้องติดตั้ง extension ใน VS Code หรือเขียน script ใช้ครั้งเดียว

แปลงได้ทันที
เลือกรูปแบบ case และดูผลลัพธ์ได้ทันที ไม่ต้องส่งข้อมูลไปยังเซิร์ฟเวอร์ ไม่ต้องรอ สลับระหว่างรูปแบบเพื่อเปรียบเทียบผลลัพธ์แบบเคียงกัน
🔒
ประมวลผลโดยให้ความเป็นส่วนตัวเป็นหลัก
การแปลงทั้งหมดทำงานในเบราว์เซอร์ด้วย JavaScript ข้อความของคุณอยู่ในอุปกรณ์ของคุณ ไม่มีการส่งข้อมูลไปยังเซิร์ฟเวอร์หรือจัดเก็บไว้ที่ใด
🔄
เก้ารูปแบบในเครื่องมือเดียว
UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case และ CONSTANT_CASE อินพุตเดียวครอบคลุมทุกรูปแบบที่ใช้กันทั่วไป
🌍
ไม่ต้องสมัครบัญชี
เปิดหน้าเว็บแล้วเริ่มแปลงได้เลย ไม่ต้องสมัคร ไม่ต้องติดตั้ง extension หรือแอปพลิเคชันบนเครื่อง รองรับทุกอุปกรณ์ที่มีเบราว์เซอร์สมัยใหม่

กรณีการใช้งานของตัวแปลง Case

การพัฒนา Frontend
แปลงชื่อ prop ของ component จาก snake_case ที่ได้รับจาก API เป็น camelCase สำหรับ object ใน JavaScript เปลี่ยนชื่อ class ใน CSS จาก camelCase เป็น kebab-case เมื่อย้ายไปใช้ระบบการตั้งชื่อแบบ BEM หรือ utility-first
การออกแบบ Backend API
แปลงชื่อฟิลด์ระหว่างรูปแบบเมื่อแมปคอลัมน์ฐานข้อมูล (snake_case) ไปยัง key ใน JSON response (camelCase) ตรวจสอบว่า layer การซีเรียลไลเซชันให้ผลลัพธ์ในรูปแบบที่คาดหวัง
DevOps และโครงสร้างพื้นฐาน
สร้างชื่อตัวแปรสภาพแวดล้อมในรูปแบบ CONSTANT_CASE จากวลีที่อธิบาย แปลงชื่อ resource ใน Terraform ระหว่าง snake_case และ kebab-case เมื่อปรับให้ตรงกับ style guide ของทีม
QA และการทดสอบอัตโนมัติ
เตรียมข้อมูล fixture สำหรับการทดสอบที่มีชื่อฟิลด์ถูกรูปแบบ ตรวจจับความไม่ตรงกันของ case ระหว่าง API contract และความคาดหวังของ client ก่อนที่จะถึงระบบผลิต
วิศวกรรมข้อมูล
ทำให้หัวคอลัมน์เป็นมาตรฐานเมื่อนำเข้าไฟล์ CSV หรือ Excel เข้าสู่ฐานข้อมูล แปลงหัวคอลัมน์แบบผสมเช่น "First Name" เป็นคอลัมน์ snake_case เช่น "first_name" เพื่อการออกแบบ schema ที่สอดคล้องกัน
การเขียนเชิงเทคนิคและเอกสารประกอบ
จัดรูปแบบการอ้างอิงโค้ดในเอกสารด้วย case ที่ถูกต้อง แปลงคำอธิบายภาษาธรรมดาเป็นชื่อ class ในรูปแบบ PascalCase หรือ URL slug แบบ kebab-case เพื่อความสอดคล้องในข้อกำหนดทางเทคนิค

ตารางอ้างอิงรูปแบบ Case

รูปแบบการตั้งชื่อแต่ละแบบมีกฎเฉพาะสำหรับการใช้ตัวพิมพ์ใหญ่และการแยกคำ ตารางด้านล่างแสดงทั้งเก้ารูปแบบที่เครื่องมือนี้รองรับ โดยใช้วลี "the quick brown fox" เป็นตัวอย่างอ้างอิง

Caseกฎตัวอย่าง
UPPERCASEEvery letter capitalizedTHE QUICK BROWN FOX
lowercaseEvery letter lowercasedthe quick brown fox
Title CaseFirst letter of each word capitalizedThe Quick Brown Fox
Sentence caseFirst letter of each sentence capitalizedThe quick brown fox
camelCaseNo separators, first word lowercasetheQuickBrownFox
PascalCaseNo separators, every word capitalizedTheQuickBrownFox
snake_caseWords joined by underscores, all lowercasethe_quick_brown_fox
kebab-caseWords joined by hyphens, all lowercasethe-quick-brown-fox
CONSTANT_CASEWords joined by underscores, all uppercaseTHE_QUICK_BROWN_FOX

camelCase vs snake_case vs kebab-case

สามรูปแบบนี้ครอบครองในการพัฒนาซอฟต์แวร์ แต่ละแบบอยู่ในระบบนิเวศที่แตกต่างกัน การเลือกผิดจะทำให้ linter ล้มเหลว ละเมิด API contract หรือทำให้ codebase ไม่สอดคล้องกัน

camelCase
มาตรฐานสำหรับตัวแปร ชื่อฟังก์ชัน และ key ของ object ใน JavaScript และ TypeScript Java และ C# ใช้สำหรับตัวแปรท้องถิ่นและพารามิเตอร์ของเมธอด JSON API ที่สร้างสำหรับ JavaScript client มักใช้ key แบบ camelCase คำแรกเป็นตัวพิมพ์เล็ก คำถัดไปแต่ละคำขึ้นต้นด้วยตัวพิมพ์ใหญ่
snake_case
ค่าเริ่มต้นสำหรับ Python (PEP 8), Ruby, Rust และฐานข้อมูล SQL ส่วนใหญ่ ฟังก์ชันใน C standard library ก็ใช้รูปแบบนี้เช่นกัน คำต่างๆ คั่นด้วยเครื่องหมายขีดล่าง ทั้งหมดเป็นตัวพิมพ์เล็ก CONSTANT_CASE (ตัวพิมพ์ใหญ่ทั้งหมดพร้อมขีดล่าง) คือตัวแปรที่ใช้สำหรับค่าคงที่และตัวแปรสภาพแวดล้อม
kebab-case
มาตรฐานสำหรับชื่อ class ใน CSS แอตทริบิวต์ HTML URL slug และชื่อ flag ใน CLI (--output-dir) นิยมใช้ใน Lisp และ Clojure คำต่างๆ คั่นด้วยขีดกลาง ทั้งหมดเป็นตัวพิมพ์เล็ก ภาษาโปรแกรมส่วนใหญ่ไม่สามารถใช้ขีดกลางในตัวระบุ ดังนั้น kebab-case จึงจำกัดอยู่ในสตริง ชื่อไฟล์ และ markup

ตัวอย่างโค้ด

วิธีแปลงระหว่างรูปแบบ case ด้วยโปรแกรม ตัวอย่างแต่ละอันครอบคลุมการแปลงที่พบบ่อยที่สุด ได้แก่ camelCase เป็น snake_case, snake_case เป็น camelCase และการแปลงพื้นฐานระหว่าง upper, lower และ title

JavaScript
// 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"
Python
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"
Go
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
}
CLI (bash / sed)
# 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

คำถามที่พบบ่อย

ความแตกต่างระหว่าง camelCase และ PascalCase คืออะไร?
camelCase ขึ้นต้นด้วยตัวพิมพ์เล็ก (myVariable) ในขณะที่ PascalCase ขึ้นต้นด้วยตัวพิมพ์ใหญ่ (MyVariable) ใน JavaScript, camelCase ใช้สำหรับตัวแปรและฟังก์ชัน ส่วน PascalCase ใช้สำหรับชื่อ class และชื่อ component ใน React C# ใช้ PascalCase สำหรับ method และ property ที่เป็น public ความแตกต่างทางโครงสร้างเพียงอย่างเดียวคืออักขระตัวแรก
จะแปลง camelCase เป็น snake_case ใน JavaScript ได้อย่างไร?
แทรกเครื่องหมายขีดล่างก่อนตัวอักษรพิมพ์ใหญ่แต่ละตัวโดยใช้ regex แล้วแปลงผลลัพธ์เป็นตัวพิมพ์เล็ก: str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase() วิธีนี้ใช้ได้กับ camelCase มาตรฐาน สำหรับสตริงที่มีตัวพิมพ์ใหญ่ต่อเนื่องเช่น "XMLParser" คุณต้องใช้ regex เพิ่มเติมเพื่อแยกชุดตัวพิมพ์ใหญ่ให้ถูกต้อง
ทำไม Python จึงใช้ snake_case แทน camelCase?
PEP 8 ซึ่งเป็น style guide อย่างเป็นทางการของ Python ที่เผยแพร่ในปี 2001 เลือก snake_case สำหรับฟังก์ชันและตัวแปร เนื่องจาก Guido van Rossum และทีมหลักเห็นว่าอ่านง่ายกว่าเมื่อมองแวบแรก งานศึกษาของ Binkley et al. (2009) พบว่าตัวระบุแบบ snake_case ถูกจดจำได้เร็วกว่า camelCase ในงานอ่านบางประเภท รูปแบบนี้ถูกบังคับใช้โดย linter เช่น flake8 และ pylint
Title Case เหมือนกับการพิมพ์ตัวใหญ่ทุกคำหรือไม่?
Title Case แบบเรียบง่ายใช้ตัวพิมพ์ใหญ่กับอักษรตัวแรกของทุกคำ ซึ่งนั่นคือสิ่งที่เครื่องมือนี้ทำ Title Case แบบทางการ (AP, Chicago, APA) มีกฎเพิ่มเติม ได้แก่ articles (a, an, the) conjunctions สั้น (and, but, or) และ preposition สั้น (in, on, at) ต้องเป็นตัวพิมพ์เล็กเว้นแต่จะเป็นคำแรกหรือคำสุดท้าย Title Case แบบทางการต้องใช้การค้นหาพจนานุกรม ไม่ใช่แค่การแปลงระดับอักขระ
เครื่องมือนี้รองรับ Unicode และสคริปต์ที่ไม่ใช่ภาษาละตินได้หรือไม่?
เครื่องมือใช้ method toUpperCase() และ toLowerCase() ที่มีอยู่ใน JavaScript ซึ่งเป็นไปตามกฎ Unicode casing ที่กำหนดใน Unicode Standard (Chapter 3, Section 3.13) วิธีนี้จัดการตัวอักษรที่มีสำเนียง (e เป็น E) เยอรมัน eszett (ss เป็น SS) และอักษรกรีกได้ถูกต้อง อย่างไรก็ตาม กฎเฉพาะของภาษาเช่น Turkish casing (ซึ่งตัว i ตัวพิมพ์เล็กควรแปลงเป็น İ ที่มีจุด ไม่ใช่ I) ขึ้นอยู่กับการตั้งค่า locale ของเบราว์เซอร์ ไม่ใช่เครื่องมือ
CONSTANT_CASE ใช้สำหรับอะไร?
CONSTANT_CASE (เรียกอีกชื่อว่า SCREAMING_SNAKE_CASE) ใช้สำหรับค่าคงที่และตัวแปรสภาพแวดล้อม ใน JavaScript: const MAX_RETRIES = 3 ใน Python: MAX_RETRIES = 3 (ตามแนวปฏิบัติ เนื่องจาก Python ไม่มีค่าคงที่จริงๆ) ใน shell script: export DATABASE_URL=... รูปแบบตัวพิมพ์ใหญ่ทั้งหมดเป็นสัญญาณว่าค่านี้ไม่ควรถูกกำหนดซ้ำหลังการเริ่มต้น
จะเลือกรูปแบบ case ที่เหมาะสมสำหรับโปรเจกต์ได้อย่างไร?
ปฏิบัติตามรูปแบบที่ครอบครองในภาษาและ framework ของคุณ JavaScript/TypeScript: camelCase สำหรับตัวแปร, PascalCase สำหรับ class และ component Python: snake_case สำหรับฟังก์ชันและตัวแปร, PascalCase สำหรับ class CSS: kebab-case SQL: snake_case สำหรับคอลัมน์และตาราง REST API JSON key: ให้ตรงกับภาษา frontend (camelCase สำหรับ JS client, snake_case สำหรับ Python client) หากไม่แน่ใจ ให้ตรวจสอบการตั้งค่า linter หรือ .editorconfig ในโฟลเดอร์ root ของโปรเจกต์