01
เชี่ยวชาญพื้นฐานพิมพ์สัมผัส
ตำแหน่งแป้นเหย้า การกำหนดนิ้วที่ถูกต้อง และไม่มองแป้น รากฐานนี้กำหนดเพดานของทุกอย่างที่ตามมา
เจาะโค้ด · ซินแท็กซ์จริง · ความเร็วสายเดฟ
คุณพิมพ์ โค้ดจริง ได้เร็วแค่ไหน?
วัดค่า CWPM ของคุณด้วยซินแท็กซ์การเขียนโปรแกรมจริง — วงเล็บ ตัวดำเนินการ สัญลักษณ์ และรูปแบบการพิมพ์ทุกอย่างที่นักพัฒนาใช้ทุกวัน
ความเร็ว + ความแม่นยำ + ความสม่ำเสมอ ไม่ต้องสมัคร ฟรีตลอด
อ่านผลของคุณ
เข้าใจคะแนนของคุณ
ผลลัพธ์แสดงสี่ค่า แต่ละค่าบอกอะไรบางอย่างเกี่ยวกับความคล่องบนแป้นพิมพ์เวลาเขียนโค้ด
C
CWPM — คำโค้ดต่อนาที
CWPM วัดว่าคุณพิมพ์ซินแท็กซ์การเขียนโปรแกรมจริงได้เร็วแค่ไหน — ทุก 5 อักขระคือ 1 คำ เหมือน WPM มาตรฐาน แต่ข้อความมีวงเล็บ สัญลักษณ์ ตัวดำเนินการ และการสลับตัวพิมพ์ที่ร้อยแก้วไม่มี
CWPM vs WPM: นักพัฒนาส่วนใหญ่ได้คะแนนโค้ดต่ำกว่าข้อความปกติ 15–30 คะแนน คนที่พิมพ์ได้ 90 WPM มักลงมาที่ 55–70 CWPM บนซอร์สโค้ดจริง
!
ความแม่นยำ — ทำไมสำคัญกว่าในโค้ด
ในร้อยแก้ว พิมพ์ผิดก็แค่ดูไม่สวย แต่ในโค้ด ;
ที่หายไปหรือวงเล็บผิดตัว ทำให้เกิด syntax error, build พัง หรือบั๊กที่ใช้เวลาหาหลายนาที
ความแม่นยำไม่ใช่ทางเลือก — มันคือค่าหลัก
เป้าหมาย: ความแม่นยำ 95%+ ก่อนดัน CWPM ให้สูงขึ้น ต่ำกว่า 95% เวลาที่เสียไปกับการแก้จะมากกว่าที่ความเร็วช่วยประหยัด
CWPM
ความเร็วสุทธิเวลาเขียนโค้ด — นับเฉพาะอักขระที่ถูกต้อง แบ่งเป็นคำละ 5 อักขระ ต่อนาที
ความแม่นยำ
เปอร์เซ็นต์การกดที่ถูกปุ่ม ทุกอักขระผิดในโค้ดมีต้นทุน — ตั้งเป้า 95%+
ความสม่ำเสมอ
จังหวะของคุณคงที่แค่ไหน จังหวะที่ไม่แน่นอน — รัวแล้วลังเล — แสดงช่องว่างในความจำกล้ามเนื้อของสัญลักษณ์
อัตราข้อผิดพลาด
ด้านตรงข้ามของความแม่นยำ แม้อักขระผิดตัวเดียวต่อบรรทัด ก็สะสมเป็นการช้าลงอย่างมากในเซสชันจริง
CWPM ของคุณตอนนี้หมายความว่าอย่างไร
| คะแนน | ความหมาย | ควรเน้นต่อไป |
|---|---|---|
| ต่ำกว่า 30 | ยังไม่คุ้นปุ่มสัญลักษณ์ — ลังเลมากกับ {}[]();=> |
เริ่มจากพิมพ์สัมผัสก่อน แล้วค่อยฝึกสัญลักษณ์ |
| 30–50 | คล่องกับตัวอักษรแล้ว แต่สัญลักษณ์ยังทำให้หยุดชะงัก | ฝึกวงเล็บและตัวดำเนินการจนเป็นอัตโนมัติ |
| 50–70 | ช่วงที่ดีสำหรับนักพัฒนาส่วนใหญ่ — สัญลักษณ์เกือบอัตโนมัติ | ฝึกความสม่ำเสมอ กำจัดจังหวะลังเล |
| 70–90 | คล่องมาก — การพิมพ์แทบไม่เป็นคอขวดในการเขียนโค้ด | รักษาความแม่นยำที่ความเร็ว ฝึกโค้ดที่ยากขึ้น |
| 90+ | ระดับเอลิท — นักพัฒนาไม่กี่เปอร์เซ็นต์บนสุด | รักษาไว้ภายใต้ความกดดัน ลองโหมดภาษาที่ยากขึ้น |
ผลิตภาพนักพัฒนา
ทำไมนักพัฒนาทุกคนควรใส่ใจความเร็วในการพิมพ์
โค้ดทุกบรรทัดคือชุดของการตัดสินใจบนแป้นพิมพ์เล็ก ๆ — หลายสิบครั้ง ทำซ้ำหลายพันครั้งต่อสัปดาห์
{ }
( )
[ ]
;
:
.
,
=
==
===
->
=>
$
@
#
การพิมพ์สัญลักษณ์เหล่านี้หลายพันครั้งต่อสัปดาห์สร้างได้ทั้งแรงเสียดทานหรือโฟลว์ ประหยัดแค่ 0.15 วินาที ต่อครั้งก็รวมเป็นชั่วโมงจริงต่อเดือน แป้นพิมพ์ที่เร็วขึ้นไม่ได้ทำให้คุณเป็นนักพัฒนาที่เก่งขึ้น — แค่หลีกทางให้ คุณจึงใช้เวลาคิดเรื่องโค้ดมากขึ้นและตามหาปุ่มน้อยลง
อยู่ในโฟลว์
ทุกครั้งที่หยุดหาปุ่มจะตัดกระแสความคิด การพิมพ์สัญลักษณ์แบบอัตโนมัติ ทำให้ใจจดจ่อกับตรรกะ ไม่ใช่แป้นพิมพ์
ค้นหาปุ่มน้อยลง
การชำเลืองมองหา ; [ ] หรือ -> ดูเล็กน้อย แต่เกิดขึ้นหลายร้อยครั้งต่อวัน
ในเซสชันจริง
ดีบักเร็วขึ้น
การแก้บั๊กคือการพิมพ์ ลบ และพิมพ์บรรทัดเดิมซ้ำ ๆ การพิมพ์สัญลักษณ์ช้า ทำให้การแก้ที่ควรเร็วกลายเป็นช้า
ล้าน้อยลง
การเอื้อมที่งุ่มง่ามและการลังเลสร้างความตึงที่สะสมตลอดเซสชันยาว การพิมพ์ที่ลื่นไหลหมายถึงตึงน้อยลงเมื่อจบวัน
บริบท
ทำไมการพิมพ์โค้ดถึงต่างออกไป
นักพัฒนาที่ทำ 90 WPM ในแบบทดสอบปกติ มักลงมาที่ 50–70 CWPM บนซอร์สโค้ดจริง นี่คือเหตุผล
ใช้สัญลักษณ์เยอะ
อักขระอย่าง {}[]()=>;
ต้องเคลื่อนนิ้วอย่างแม่นยำไปยังปุ่มที่หลายคนแทบไม่เคยฝึกในการเขียนทั่วไป
ตัวพิมพ์ผสมและตัวระบุ
การสลับระหว่าง camelCase, PascalCase และ snake_case ต้องประสาน Shift ตลอดเวลา
ซึ่งร้อยแก้วไม่ต้องการ
รูปแบบที่คาดเดาไม่ได้
ภาษามนุษย์มีจังหวะคุ้นเคยที่สมองเดาล่วงหน้าได้ แต่โค้ดไม่ใช่ — ทุกบรรทัดบังคับให้คิดถึงแต่ละอักขระอย่างรอบคอบก่อนพิมพ์
ตัวเลขโผล่ทุกที่
ดัชนี พอร์ต เวอร์ชัน การคำนวณ — การเขียนโปรแกรมดึงแถวตัวเลขมาใช้ตลอด เผยจุดอ่อนที่ร้อยแก้วไม่เคยเจอ
ความแม่นยำสำคัญมาก
อักขระผิดตัวเดียวทำให้เกิด syntax error, build พัง หรือบั๊ก ในโค้ด ความแม่นยำสำคัญกว่าความเร็วดิบ — คนพิมพ์เร็วที่สุดไม่ใช่นักพัฒนาที่ผลิตงานได้มากที่สุดเสมอ
คอขวดที่นิ้วก้อย
ปุ่มอย่าง ; : " ' [ ]
ควบคุมด้วยนิ้วที่อ่อนที่สุด การลังเลเล็ก ๆ ตรงนี้สะสมเป็นการช้าลงอย่างมากตลอดเซสชัน
เทียบกัน
แต่ละภาษาใช้รูปแบบแป้นพิมพ์ต่างกัน
แต่ละภาษาพึ่งพาชุดสัญลักษณ์ต่างกัน จึงฝึกนิ้วที่ต่างกันเล็กน้อย
ภาษา
ปุ่มที่ใช้หนักสุด
ฝึกอะไร
JavaScript
{ } ( ) => ===
จับคู่วงเล็บและการเอื้อม
=> ที่ต้องใช้ Shift
Python
: ( ) [ ] _
วินัยเรื่องโคลอนและขีดล่างใน
snake_case
PHP
$ -> :: { }
การนำหน้าตัวแปรด้วย
$ และเชนลูกศร
HTML
< > </> =""
จับคู่วงเล็บมุมและแอตทริบิวต์ในเครื่องหมายคำพูด
CSS
{ } : ; #
จังหวะโคลอนและเซมิโคลอนที่รวดเร็วในบล็อก
SQL
SELECT JOIN ( ) =
คีย์เวิร์ดตัวพิมพ์ใหญ่ยาว ๆ ผสมตัวดำเนินการสั้น ๆ
ภาษาต่างกันฝึกนิ้วต่างกัน — ฝึกภาษาที่คุณเขียนจริง
ภาษา
เลือกภาษาของคุณ
แต่ละภาษาฝึกรูปแบบแป้นพิมพ์ต่างกัน ฝึกภาษาที่คุณเขียนจริง
คู่มือ CWPM
ความเร็วพิมพ์โค้ดเท่าไรถึงดี?
ความเร็วพิมพ์โค้ดมักต่ำกว่าการพิมพ์ปกติ ใช้ตารางนี้ตั้งเป้าหมายที่สมจริง
ระดับช่วงความเร็วและความแม่นยำบริบท
เริ่มต้น
20–40 CWPM
90%
ปานกลาง
40–60 CWPM
95%
ระดับสูง
60–80 CWPM
97%
มืออาชีพ
80+ CWPM
99%
จำไว้: ความเร็วในการพิมพ์ไม่ได้กำหนดฝีมือการเขียนโปรแกรม สถาปัตยกรรม การแก้ปัญหา และการดีบักสำคัญกว่ามาก
คู่มือภาพ
แผนที่ความร้อนแป้นพิมพ์ของนักพัฒนา
ภาพคร่าว ๆ ของปุ่มที่รับภาระหนักที่สุดในเซสชันเขียนโค้ดทั่วไป — ตัวอักษรที่ใช้บ่อยบวกกับปุ่มสัญลักษณ์ที่โค้ดพึ่งพามากที่สุด
esc
1
2
3
4
5
6
7
8
9
0
-
=
Q
W
E
R
T
Y
U
I
O
P
[
]
A
S
D
F
G
H
J
K
L
;
'
Z
X
C
V
B
N
M
,
.
/
ใช้บ่อย
ใช้ปานกลาง
ใช้น้อย
ปุ่มสัญลักษณ์ที่ใช้บ่อยที่สุดในโค้ด
{ }
( )
;
.
,
=
$
> <
#
@
พิมพ์สัมผัส
นิ้วไหนควบคุมปุ่มเหล่านี้?
การรู้ว่านิ้วไหนเป็นเจ้าของปุ่มสัญลักษณ์แต่ละปุ่มคือวิธีเลิกลังเลที่เร็วที่สุด และเป็นรากฐานที่บทเรียนฝึกพิมพ์ของเราต่อยอด
นิ้วก้อยซ้าย
Tab
Caps
Shift
Q
A
Z
นิ้วนางซ้าย
W
S
X
2
นิ้วกลางซ้าย
E
D
C
3
นิ้วชี้ซ้าย
R
T
F
G
V
B
นิ้วชี้ขวา
Y
U
H
J
N
M
นิ้วกลางขวา
I
K
,
8
นิ้วนางขวา
O
L
.
9
นิ้วก้อยขวา
;
'
[
]
/
Enter
รูปแบบที่พบบ่อย
นักพัฒนาเสียความเร็วตรงไหน
การช้าลงส่วนใหญ่ไม่ได้ดราม่า — เป็นการลังเลเล็ก ๆ ซ้ำ ๆ ที่ค่อย ๆ สะสมตลอดเซสชัน
หา ;
ชำเลืองมองลงเพื่อยืนยันปุ่มเซมิโคลอนก่อนกด
เวลาเพิ่มโดยทั่วไป
+0.2 วิ
หา }
วงเล็บปีกกาปิดซ้อนกันในโค้ดที่ซ้อนลึก นิ้วที่ล้าจึงสับสนว่าตัวไหนต่อ
เวลาเพิ่มโดยทั่วไป
+0.3 วิ
หา ]
วงเล็บเหลี่ยมอยู่ไกลจากแป้นเหย้า การเอื้อมจึงใช้เวลาลงตำแหน่งนานขึ้น
เวลาเพิ่มโดยทั่วไป
+0.3 วิ
ใช้นิ้วผิดกับ Shift
ใช้ Shift ฝั่งเดียวกันแทนนิ้วก้อยฝั่งตรงข้าม ทำให้จังหวะขาดและกดปุ่มถัดไปช้าลง
เวลาเพิ่มโดยทั่วไป
+0.4 วิ
มองแป้นพิมพ์
ทุกครั้งที่ละสายตาจากจอต้องเสียเวลาโฟกัสใหม่เพิ่มจากการกดปุ่มเอง
เวลาเพิ่มโดยทั่วไป
+0.5 วิ
กด Backspace แก้ข้อผิดพลาด
แก้อักขระผิดคือการลบและพิมพ์ใหม่ — ตัวถ่วง CWPM จริงที่ใหญ่ที่สุด
เวลาเพิ่มโดยทั่วไป
+0.6 วิ
ค่าเฉลี่ยเชิงประกอบจากรูปแบบการลังเลที่พบบ่อย — ตัวเลขของคุณจะต่างกันตามภาษาและความคุ้นเคย
ทักษะสำคัญ
สัญลักษณ์การเขียนโปรแกรมที่นักพัฒนาทุกคนควรเชี่ยวชาญ
ยิ่งคุณคุ้นกับปุ่มเหล่านี้ เซสชันเขียนโค้ดยิ่งรู้สึกลื่นไหล
วงเล็บ
( )[ ]{ }< >
ใช้ในทุกภาษา คู่ที่ไม่ปิดทำให้เกิด syntax error ที่พบบ่อยที่สุด
ตัวดำเนินการ
=====!==>>=
เงื่อนไขและการเปรียบเทียบ ความต่างของ
=== กับ == ทำให้หลายคนสับสน
เครื่องหมายวรรคตอน
;:,....
พบบ่อยใน JS, CSS, SQL การลืมเซมิโคลอน เป็นข้อผิดพลาดคลาสสิกของมือใหม่
อักขระพิเศษ
@#$%_&
เดคอเรเตอร์ ซีเลกเตอร์ ตัวแปร และเทมเพลตลิเทอรัลล้วนพึ่งอักขระเหล่านี้
เส้นทางพัฒนา
วิธีพัฒนาการพิมพ์โค้ด
การพัฒนาเกิดขึ้นทีละขั้น ความแม่นยำก่อน แล้วความเร็วจะตามมาเอง
02
สร้างความแม่นยำกับสัญลักษณ์
ฝึกวงเล็บ ตัวดำเนินการ และเครื่องหมายแยกต่างหากจนเป็นอัตโนมัติ ตั้งเป้าความแม่นยำที่คงที่ก่อนเร่งความเร็ว
03
ฝึกรูปแบบโค้ดที่พบบ่อย
การประกาศฟังก์ชัน การกำหนดค่าตัวแปร เงื่อนไข ลูป — สร้างความจำกล้ามเนื้อกับสิ่งที่คุณพิมพ์วันละหลายสิบครั้ง
04
ฝึกกับตัวอย่างที่สมจริง
ก้าวจากสัญลักษณ์เดี่ยว ๆ ไปสู่โค้ดจริงที่สมบูรณ์ แบบทดสอบใช้ซินแท็กซ์จริงจาก JavaScript, Python, PHP และอื่น ๆ
05
รักษาผลงานในเซสชันยาว
แค่ฝึกเจาะจง 10–15 นาทีทุกวันก็ให้ผลที่วัดได้ ความสม่ำเสมอชนะการฝึกมาราธอนเสมอ
เริ่มเลย
พร้อมเริ่มพัฒนาแล้วหรือยัง?
นำขั้นตอนไปลงมือกับโค้ดจริง ฟรี ไม่ต้องสมัคร
คำถามที่พบบ่อย
คำถามที่พบบ่อย
ทุกอย่างเกี่ยวกับการพิมพ์โค้ด CWPM และวิธีพัฒนา
การพิมพ์โค้ดคืออะไร?
การพิมพ์โค้ดคือการพิมพ์ซินแท็กซ์ของภาษาโปรแกรม สัญลักษณ์ ตัวเลข และซอร์สโค้ด แทนข้อความทั่วไป เป็นการวัดความคล่องบนแป้นพิมพ์กับอักขระทุกแบบที่นักพัฒนาต้องใช้ทุกวัน
พิมพ์โค้ดต่างจากพิมพ์ข้อความทั่วไปอย่างไร?
ต่างมาก การเขียนโปรแกรมใช้สัญลักษณ์ ตัวเลข เครื่องหมาย และการสลับตัวพิมพ์เล็ก-ใหญ่มากกว่ามาก หลายคนที่ทำได้ 90+ WPM ในแบบทดสอบปกติ พบว่าความเร็วพิมพ์โค้ดของตัวเองต่ำกว่าอย่างเห็นได้ชัด — มักอยู่ที่ 50–70 CWPM
ความเร็วพิมพ์โค้ดเท่าไรถึงเรียกว่าดี?
นักพัฒนาส่วนใหญ่อยู่ที่ 40–80 CWPM ขึ้นกับประสบการณ์และความคุ้นเคยกับภาษา 60+ CWPM พร้อมความแม่นยำสูงถือเป็นเกณฑ์มืออาชีพที่ดี
ควรเน้นความเร็วหรือความแม่นยำ?
เน้นความแม่นยำก่อนเสมอ อักขระผิดตัวเดียวในโค้ดอาจทำให้ build พังหรือเกิดบั๊กที่หายาก ความเร็วจะดีขึ้นเองเมื่อความจำกล้ามเนื้อและความคุ้นเคยกับแป้นพิมพ์เพิ่มขึ้น
รองรับภาษาโปรแกรมอะไรบ้าง?
แบบทดสอบมีตัวอย่างโค้ดจริงจาก JavaScript, Python, PHP, HTML, CSS, SQL, JSON และ Java ครอบคลุมรูปแบบการพิมพ์ที่พบบ่อยที่สุดทั้งงาน frontend, backend และงานข้อมูล
คนไทยพิมพ์โค้ดต้องสลับเป็นแป้นภาษาอังกฤษไหม?
ใช่ ซอร์สโค้ดเกือบทั้งหมดเป็นภาษาอังกฤษ ดังนั้นการพิมพ์โค้ดจึงใช้เลย์เอาต์ QWERTY อังกฤษ การฝึกพิมพ์สัมผัสบนแป้นอังกฤษให้คล่อง — โดยเฉพาะปุ่มสัญลักษณ์ — จึงสำคัญมากสำหรับโปรแกรมเมอร์ไทย
พิมพ์โค้ดเร็วขึ้นช่วยให้เขียนโปรแกรมเก่งขึ้นไหม?
ไม่โดยตรง — สถาปัตยกรรม การแก้ปัญหา และการดีบักสำคัญกว่ามาก แต่ความคล่องบนแป้นพิมพ์ลดแรงเสียดทานระหว่างเขียนโค้ดนาน ๆ ทำให้คุณอยู่ในโฟลว์ได้โดยไม่ต้องลังเลกับสัญลักษณ์หรือตำแหน่งปุ่ม
โปรแกรมเมอร์ควรฝึกพิมพ์สัมผัสไหม?
ควรอย่างยิ่ง การพิมพ์สัมผัส — พิมพ์โดยไม่มองแป้น — เป็นรากฐานที่ทักษะความเร็วอื่น ๆ ต่อยอดขึ้นมา ถ้าขาดมัน ทั้งความแม่นยำกับสัญลักษณ์และ CWPM จะตันเร็ว
CWPM คำนวณอย่างไร?
คำนวณเหมือน WPM มาตรฐาน — ทุก 5 อักขระที่ถูกต้องนับเป็น 1 คำ หารด้วยเวลาที่ใช้เป็นนาที ต่างกันที่ตัวข้อความ: เป็นโค้ดจริงแทนร้อยแก้ว จึงทำให้คะแนน CWPM ออกมาต่ำกว่า
ภาษาโปรแกรมไหนพิมพ์ยากที่สุด?
ไม่มีคำตอบเดียว — ขึ้นกับนิสัยการพิมพ์ของคุณ ภาษาที่มีการซ้อนวงเล็บและซินแท็กซ์ลูกศรเยอะ (เช่น JavaScript และ PHP) มักรู้สึกยากที่สุดสำหรับคนที่ยังไม่ได้ฝึกปุ่มสัญลักษณ์
ประเภทของคีย์บอร์ดมีผลต่อความเร็วพิมพ์โค้ดไหม?
มีผลเล็กน้อย — ระยะกดปุ่ม สัมผัสของสวิตช์ และความคุ้นเคยกับเลย์เอาต์ล้วนส่งผลต่อความสบายในการพิมพ์นาน ๆ แต่เทคนิคและความจำกล้ามเนื้อสำคัญกว่าฮาร์ดแวร์มาก
ฝึกพิมพ์โค้ดที่นี่ฟรีไหม?
ฟรีทั้งหมด ไม่ต้องสมัครหรือดาวน์โหลด พิมพ์โค้ดจริงจาก 8 ภาษา วัดค่า CWPM และทำแบบทดสอบซ้ำได้ไม่จำกัด
ฟรีตลอด
พร้อมทดสอบความเร็วพิมพ์โค้ดของคุณแล้วหรือยัง?
วัด CWPM พัฒนาความแม่นยำกับสัญลักษณ์ และสร้างความจำกล้ามเนื้อการเขียนโปรแกรมที่แข็งแรงขึ้น ด้วยแบบฝึกโค้ดที่สมจริง
พัฒนาการวางนิ้ว
พัฒนาความแม่นยำ
ฝึกโค้ดจริง
ทดสอบซ้ำ
10,432 ครั้งที่ทดสอบวันนี้