เครื่องมือแปลงเลขฐานสองเป็นเลขฐานสิบ | เครื่องมือออนไลน์ฟรี

เครื่องมือแปลงเลขฐานสอง (Binary) เป็นเลขฐานสิบ (Decimal): แปลงระหว่างระบบตัวเลขได้ทันที

เคยมองดูชุดของเลข 1 และ 0 แล้วสงสัยว่าพวกมันแทนตัวเลขอะไรหรือเปล่า? หากคุณทำงานเกี่ยวกับคอมพิวเตอร์ไม่ว่าระดับใด—ไม่ว่าจะเป็นการแก้ปัญหาเครือข่าย, เขียนโปรแกรมไมโครคอนโทรลเลอร์, หรือเพียงแค่อยากรู้ว่าคอมพิวเตอร์คิดอย่างไร—คุณจะต้องแปลงระหว่างเลขฐานสองและเลขฐานสิบในที่สุด

เครื่องมือนี้จัดการการแปลงได้ทันทีในทั้งสองทิศทาง เพียงพิมพ์ตัวเลขในช่องใดช่องหนึ่งและดูการแปลงเกิดขึ้น สิ่งสำคัญยิ่งกว่านั้นคือ คุณจะเห็น วิธี การแปลงที่เกิดขึ้น ซึ่งสำคัญเมื่อคุณพยายามทำความเข้าใจสิ่งที่เกิดขึ้นภายใต้โค้ดของคุณ

นี่คือสิ่งที่ทำให้การแปลงเลขฐานสอง-เลขฐานสิบยุ่งยาก: สมองของเราถูกออกแบบมาสำหรับฐานสิบ (เรามีนิ้วมือสิบนิ้ว), แต่คอมพิวเตอร์ทำงานเฉพาะในฐานสอง ข้อมูลทุกชิ้น—ข้อความ, รูปภาพ, วิดีโอ, ประวัติการเรียกดูของคุณ—สุดท้ายแล้วแตกออกเป็นลำดับของ 0 และ 1 การเข้าใจความสัมพันธ์นี้ไม่ใช่เรื่องวิชาการเท่านั้น; แต่เป็นความรู้เชิงปฏิบัติที่เกิดขึ้นเมื่อทำงานกับที่อยู่ IP, สิทธิ์ไฟล์, การดำเนินการบิต และที่อยู่หน่วยความจำ

ข่าวดีคือ? เมื่อคุณเข้าใจรูปแบบแล้ว การแปลงจะกลายเป็นเรื่องง่าย คณิตศาสตร์เรียบง่าย—เป็นเพียงการคูณและการบวก (หรือการหารสำหรับการแปลงกลับ) สิ่งที่ทำให้คนสับสนคือการติดตามค่าตำแหน่ง โดยเฉพาะกับตัวเลขที่låยาว นี่คือสิ่งที่เครื่องมือแปลงนี้แก้ปัญหาได้

วิธีแปลงเลขฐานสองเป็นเลขฐานสิบและเลขฐานสิบเป็นเลขฐานสอง

ทำความเข้าใจระบบเลขฐานสิบ (ฐาน 10)

คุณคุ้นเคยกับเลขฐานสิบอยู่แล้ว—เป็นสิ่งที่คุณเรียนรู้ตอนประถม เราใช้เลข 10 หลัก (0-9) และแต่ละตำแหน่งแทนกำลังของ 10:

$\text{เลขฐานสิบ} = d_n \times 10^n + d_{n-1} \times 10^{n-1} + ... + d_1 \times 10^1 + d_0 \times 10^0$

ลองดูเลข 427 โดยแยกตามตำแหน่ง:

4 × 10² = 400 (ตำแหน่งหลัก)
2 × 10¹ = 20 (ตำแหน่งสิบ)
7 × 10⁰ = 7 (ตำแหน่งหน่วย)

บวกค่าเหล่านี้: 400 + 20 + 7 = 427

เรามักจะคิดว่าระบบตำแหน่งนี้เป็นเรื่องปกติ แต่มันเป็นการประดิษฐ์ที่ปฏิวัติ ก่อนหน้าระบบตำแหน่ง การคำนวณเลขคณิตยุ่งยากมาก (ลองคูณเลขโรมันดูสิ)

ทำความเข้าใจระบบฐานสอง (ฐาน 2)

ระบบฐานสองทำงานเหมือนกับฐานสิบ เพียงแต่ใช้กำลังของ 2 แทนกำลังของ 10 คุณมีเลขเพียง 2 หลัก—0 และ 1:

$\text{เลขฐานสอง} = b_n \times 2^n + b_{n-1} \times 2^{n-1} + ... + b_1 \times 2^1 + b_0 \times 2^0$

ลองดูเลขฐานสอง 1010 แต่ละตำแหน่งจากขวาไปซ้ายแทน 1, 2, 4, 8, 16 ฯลฯ:

1 × 2³ = 8
0 × 2² = 0
1 × 2¹ = 2
0 × 2⁰ = 0

บวกค่าเหล่านี้: 8 + 0 + 2 + 0 = 10 ในฐานสิบ

รูปแบบเหมือนกับฐานสิบ เพียงแต่ใช้ฐานที่ต่างกัน เมื่อคุณเข้าใจแล้ว เลขฐานสองจะกลายเป็นเรื่องธรรมดาเหมือนการอ่านเลขปกติ

การแปลงเลขฐานสองเป็นเลขฐานสิบ: สูตรและวิธีการ

เลขฐานสองเป็นเลขฐานสิบ: คณิตศาสตร์เบื้องหลัง

การแปลงเลขฐานสองเป็นเลขฐานสิบทำตามรูปแบบที่ตรงไปตรงมา: คูณแต่ละหลักด้วยกำลังของ 2 ตามตำแหน่ง แล้วบวกรวมกัน สูตรจะเป็นดังนี้:

$\text{เลขฐานสิบ} = \sum_{i=0}^{n} b_i \times 2^i$

โดยที่:

$b_i$ คือแต่ละหลักเลขฐานสอง (เป็น 0 หรือ 1)
$i$ คือตำแหน่งนับจากขวาไปซ้าย (เริ่มที่ 0)
$n$ คือจำนวนหลักทั้งหมดลบ 1

ดูเหมือนซับซ้อน? แต่จริงๆ แล้วง่ายมากในทางปฏิบัติ แต่ละตำแหน่งจากขวาไปซ้ายแทนค่า 1, 2, 4, 8, 16, 32 และอื่นๆ - เพิ่มขึ้นสองเท่าทุกครั้ง

ตัวอย่าง: แปลงเลขฐานสอง 1101 เป็นเลขฐานสิบ

1 × 2³ = 8
1 × 2² = 4
0 × 2¹ = 0
1 × 2⁰ = 1
ผลรวม: 8 + 4 + 0 + 1 = 13 ฐานสิบ

สังเกตว่าเราเพียงบวกตำแหน่งที่มี 1 เท่านั้น 0 ไม่มีส่วนร่วม ดังนั้นคุณสามารถข้ามไปในใจได้ นี่คือ 1101 แยกออกเป็นตำแหน่ง 0, 2 และ 3 (ซึ่งเท่ากับ 1 + 4 + 8 = 13)

เลขฐานสิบเป็นเลขฐานสอง: วิธีการหาร

การไปในทิศทางตรงกันข้าม - จากเลขฐานสิบเป็นเลขฐานสอง - ใช้วิธีการที่แตกต่าง:

หารตัวเลขฐานสิบด้วย 2
จดเศษ (เสมอเป็น 0 หรือ 1)
นำผลหารไปหารด้วย 2 อีก
ทำต่อไปจนกว่าผลหารจะเป็น 0
อ่านเศษทั้งหมดย้อนกลับ (จากล่างขึ้นบน)

ตัวอย่าง: แปลงเลขฐานสิบ 25 เป็นเลขฐานสอง

25 ÷ 2 = 12 เศษ 1
12 ÷ 2 = 6 เศษ 0
6 ÷ 2 = 3 เศษ 0
3 ÷ 2 = 1 เศษ 1
1 ÷ 2 = 0 เศษ 1
อ่านจากล่างขึ้นบน: 11001 ฐานสอง

เคล็ดลับสำคัญคือจำไว้ว่าต้องกลับลำดับ เศษแรกที่คำนวณจะกลายเป็นหลักสุดท้าย (ทางขวาสุด) ในผลลัพธ์ฐานสอง สิ่งนี้มักทำให้คนสับสนตอนแรก แต่มันสมเหตุสมผลเมื่อคุณตระหนักว่าคุณกำลังแกะหลักที่มีความสำคัญน้อยที่สุดก่อน

วิธีใช้เครื่องมือแปลง

เครื่องมือนี้ทำงานสองทิศทาง—พิมพ์ในช่องใดก็ได้และดูอีกช่องอัปเดตทันที ไม่ต้องคลิกปุ่ม ไม่ต้องกรอกฟอร์ม

แปลงเลขฐานสองเป็นเลขฐานสิบ

พิมพ์เลขฐานสอง (เฉพาะ 0 และ 1) ลงในช่อง Binary ค่าเลขฐานสิบจะปรากฏทันที หากคุณใส่เลข 2 หรือตัวเลขที่ไม่ถูกต้องโดยบังเอิญ คุณจะได้รับข้อความแสดงข้อผิดพลาด

เคล็ดลับพิเศษ: คุณสามารถวางค่าเลขฐานสองจากโค้ด แผ่นข้อมูล หรือเครื่องวิเคราะห์เครือข่ายได้โดยตรง เครื่องมือจะลบช่องว่างและคำนำหน้าทั่วไปเช่น 0b โดยอัตโนมัติ

แปลงเลขฐานสิบเป็นเลขฐานสอง

ป้อนจำนวนเต็มที่ไม่เป็นลบในช่อง Decimal และค่าเลขฐานสองจะปรากฏทันที ใช้งานได้กับทุกค่าตั้งแต่ 0 ถึงมากกว่า 9 ควอดริลเลียน

กรณีการใช้งานทั่วไป: เมื่อคุณกำลังตั้งค่าบิตแฟล็กในโค้ดและต้องการตรวจสอบว่าบิตใดถูกตั้งค่า พิมพ์ 255 และคุณจะเห็น 11111111—บิตทั้ง 8 บิตในไบต์ถูกเปิดใช้งาน

ทำความเข้าใจรายละเอียด

ด้านล่างช่องป้อนข้อมูล คุณจะเห็นขั้นตอนทางคณิตศาสตร์ของการแปลงแต่ละครั้ง ซึ่งมีประโยชน์อย่างยิ่งเมื่อเรียนรู้หรือเมื่อคุณต้องอธิบายการแปลงให้กับผู้อื่น สำหรับการแปลงจากเลขฐานสองเป็นเลขฐานสิบ จะแสดงค่าของแต่ละตำแหน่งและวิธีการบวกรวม สำหรับการแปลงจากเลขฐานสิบเป็นเลขฐานสอง จะแสดงกระบวนการหารด้วย 2

การแปลงเลขฐานสองเป็นเลขฐานสิบ

เลขฐานสอง: 1 0 1 0

ค่าตำแหน่ง:

1 0 1 0

2³ = 8 2² = 4 2¹ = 2 2⁰ = 1

การคำนวณ: 1 × 8 + 0 × 4 + 1 × 2 + 0 × 1 = 8 + 0 + 2 + 0 = 10

เลขฐานสิบ: 10

แอปพลิเคชันแปลงเลขฐานสอง: กรณีการใช้งานในโลกแห่งความเป็นจริง

ในทางปฏิบัติ การแปลงเลขฐานสอง-ฐานสิบปรากฏขึ้นบ่อยกว่าที่คุณคาดคิด นี่คือสถานการณ์ที่ฉันพบว่าการแปลงเหล่านี้มีประโยชน์อย่างแท้จริง:

วิทยาการคอมพิวเตอร์และการเขียนโปรแกรม

เมื่อดีบั๊กปัญหาหน่วยความจำ คุณมักจะเห็นที่อยู่ในเลขฐานสิบหก (ซึ่งก็คือเลขฐานสองที่จัดกลุ่ม) การแปลงเป็นเลขฐานสิบช่วยให้คุณคำนวณการชดเชยหรือตรวจสอบว่าคุณกำลังเข้าถึงตำแหน่งที่ถูกต้อง ในทำนองเดียวกัน การดำเนินการบิตมีความหมายมากขึ้นเมื่อคุณสามารถมองเห็นการแทนค่าในเลขฐานสอง—ลองทำความเข้าใจ x & (x-1) โดยไม่เห็นบิตในการทำงาน

ข้อควรระวังทั่วไป: ลืมว่าการเลื่อนบิตก็คือการคูณหรือหารด้วยกำลังของ 2 เมื่อ x << 3 ปรากฏในโค้ด การรู้ว่านี่คือ "คูณด้วย 8" (2³) ช่วยให้คุณเข้าใจการเพิ่มประสิทธิภาพ

อิเล็กทรอนิกส์ดิจิทัล

เอกสารข้อมูลไมโครคอนโทรลเลอร์ระบุการกำหนดค่าเรจิสเตอร์ในเลขฐานสิบหกและเลขฐานสอง เมื่อตั้งค่าพินของ GPIO หรือกำหนดค่าตัวจับเวลา คุณต้องพลิกบิตเฉพาะโดยไม่กระทบบิตอื่นๆ ซึ่งต้องเข้าใจอย่างแน่ชัดว่าตำแหน่งบิตใดตรงกับค่าเลขฐานสิบใด ตัวอย่างเช่น การตั้งค่าบิต 5 หมายถึงการเพิ่ม 32 (2⁵) ให้กับค่าเรจิสเตอร์

วิศวกรรมเครือข่าย

ที่อยู่ IPv4 ก็คือเลขฐานสองขนาด 32 บิตที่แบ่งออกเป็นสี่ส่วน เมื่อคุณเห็น 192.168.1.1 และต้องเข้าใจซับเน็ตมาสก์ คุณกำลังทำงานกับเลขฐานสอง ลองคำนวณว่า 192.168.1.50 และ 192.168.1.200 อยู่บนเครือข่าย /25 เดียวกันโดยไม่ใช้การแปลงเลขฐานสอง—เกือบเป็นไปไม่ได้ ตาม RFC 791 ที่อยู่ IP โดยพื้นฐานแล้วทำงานเป็นค่าเลขฐานสอง แม้ว่าเราจะเขียนในเลขฐานสิบเพื่อความสะดวก

สิทธิ์การใช้ไฟล์ (Unix/Linux)

รหัสสิทธิ์สามหลักเหล่านั้นเช่น 755 หรือ 644? แต่ละหลักเป็นเลขฐานแปด (ฐาน-8) ซึ่งแปลงเป็นกลุ่มเลขฐานสองสามบิตได้อย่างง่ายดาย เมื่อคุณตั้งสิทธิ์เป็น 755 คุณกำลังบอกว่า 111 101 101 ในเลขฐานสอง—สิทธิ์เต็มสำหรับเจ้าของ อ่าน+เรียกใช้สำหรับกลุ่ม อ่าน+เรียกใช้สำหรับผู้อื่น การเข้าใจพื้นฐานเลขฐานสองนี้ทำให้การดำเนินการ chmod เป็นเรื่องที่เข้าใจได้ง่ายแทนที่จะต้องท่องจำ

ตัวอย่าง: การแปลงที่อยู่ IP

ที่อยู่ IPv4 เช่น 192.168.1.1 สามารถแสดงในเลขฐานสองได้ดังนี้:

192 = 11000000
168 = 10101000
1 = 00000001
1 = 00000001

รวมกัน: 11000000.10101000.00000001.00000001

ระบบตัวเลขอื่นๆ ที่คุณจะพบ

เลขฐานสองและเลขฐานสิบไม่ใช่เพียงผู้เล่นเดียวในการคำนวณ นี่คือระบบตัวเลขอื่นๆ ที่คุณจะพบ:

เลขฐานสิบหก (ฐาน-16)

เลขฐานสิบหกมีอยู่ทุกที่ในการเขียนโปรแกรม—ที่อยู่หน่วยความจำ รหัสสี ภาษาแอสเซมบลี มันใช้หลัก 0-9 และตัวอักษร A-F ความสวยงามของเลขฐานสิบหกคือแต่ละหลักจะแมปกับบิตเลขฐานสองสี่บิตได้อย่างสมบูรณ์ ทำให้เป็นวิธีอ่านเลขฐานสองที่อ่านง่ายขึ้น

ตัวอย่าง: เลขฐานสอง 1010 1101 = เลขฐานสิบหก AD (เทียบกับเลขฐานสิบ 173)

เมื่อคุณเห็นรหัสสี เช่น #FF5733 นั่นคือเลขฐานสิบหก—แต่ละคู่แทนค่าสีแดง เขียว และน้ำเงิน FF (255 ในเลขฐานสิบ) หมายถึงความเข้มของสีแดงสูงสุด

เลขฐานแปด (ฐาน-8)

เลขฐานแปดใช้หลัก 0-7 โดยแต่ละหลักแทนบิตเลขฐานสองสามบิตอย่างแน่ชัด แม้จะน้อยลงในปัจจุบัน แต่คุณยังพบในสิทธิ์การใช้ไฟล์ Unix (chmod 755) และบางครั้งในระบบเก่า มันเป็นที่นิยมในการคำนวณยุคแรกเพราะคอมพิวเตอร์หลายเครื่องใช้ขนาดคำที่เป็นพหุคูณของ 3

ตัวอย่าง: เลขฐานสอง 101 011 = เลขฐานแปด 53

เลขฐานสิบแบบเข้ารหัสเลขฐานสอง (BCD)

BCD แทนแต่ละหลักเลขฐานสิบด้วยรหัสเลขฐานสองสี่บิตของตนเอง แทนที่จะแปลงทั้งตัวเลข คุณแปลงแต่ละหลักแยกกัน นี่จะสิ้นเปลืองพื้นที่ (คุณใช้เพียง 10 จาก 16 การผสมผสานที่เป็นไปได้ของสี่บิต) แต่ทำให้การคำนวณเลขฐานสิบง่ายขึ้นในฮาร์ดแวร์ คุณจะพบ BCD ในเครื่องคิดเลข นาฬิกาดิจิทัล และระบบทางการเงินที่ความแม่นยำทศนิยมมีความสำคัญ

ตัวอย่าง: เลขฐานสิบ 42 ใน BCD = 0100 0010 (เข้ารหัส 4 และ 2 แยกกัน)

ประวัติของระบบตัวเลขฐานสอง และฐานสิบ

ทำไมเราจึงนับเป็นฐานสิบ

ระบบฐานสิบรู้สึกเป็นธรรมชาติเพราะเรามีนิ้วมือสิบนิ้ว—จริงๆ แล้วนี่คือเหตุผล อารยธรรมโบราณพัฒนาระบบฐานสิบอย่างอิสระทั่วโลก ชาวอียิปต์ใช้ตัวเลขฐานสิบแบบภาพจารึกประมาณ 3000 ปีก่อนคริสตกาล ชาวบาบิโลเนียผสมระบบฐานหกสิบและฐานสิบ (ซึ่งเป็นเหตุผลว่าทำไมเรายังมี 60 วินาทีใน 1 นาที) แต่ความก้าวหน้าที่แท้จริงมาจากนักคณิตศาสตร์อินเดียราวปี ค.ศ. 500 เมื่อพวกเขาคิดค้นเลขศูนย์และสัญกรณ์ตำแหน่ง—ระบบที่ตำแหน่งของหลักตัวเลขกำหนดค่า นวัตกรรมนี้แพร่กระจายผ่านคณิตศาสตร์อาหรับสู่ยุโรปราวปี ค.ศ. 800 ทำให้เราได้ "ตัวเลขฮินดู-อาหรับ" ที่ใช้กันในปัจจุบัน

ประวัติอันน่าประหลาดของระบบฐานสอง

ระบบฐานสองมีมาก่อนคอมพิวเตอร์หลายศตวรรษ คัมภีร์ไอชิง ตำราจีนโบราณจากประมาณ 1000 ปีก่อนคริสตกาล ใช้เส้นแบบแตกและไม่แตกในรูปแบบที่คล้ายคลึงกับสัญกรณ์ฐานสอง แต่คณิตศาสตร์ฐานสองอย่างเป็นทางการปรากฏขึ้นในปี ค.ศ. 1679 เมื่อ กอตต์ฟรีด วิลเฮล์ม ไลบ์นิซ ตีพิมพ์ "คำอธิบายคณิตศาสตร์ฐานสอง" ไลบ์นิซหลงใหลในความงดงามของฐานสอง—คุณสามารถแสดงตัวเลขใดๆ ด้วยสัญลักษณ์เพียงสองตัว

เรื่องมหัศจรรย์เกิดขึ้นเมื่อ จอร์จ บูล พัฒนาพีชคณิตบูลีนในปี ค.ศ. 1854 โดยใช้ค่าฐานสองแบบจริง/เท็จเพื่อแสดงการดำเนินการทางตรรกะ จากนั้นเกิดการเชื่อมโยงที่สำคัญ: ในปี ค.ศ. 1937 วิทยานิพนธ์ปริญญาโทของ คล็อด แชนนอน พิสูจน์ว่าคุณสามารถใช้พีชคณิตบูลีนกับวงจรไฟฟ้าได้ ข้อคิดเห็นเดียวนี้วางรากฐานสำหรับคอมพิวเตอร์ดิจิทัลทุกเครื่องที่เคยสร้างมา

การปฏิวัติคอมพิวเตอร์

จอห์น อแทนาซอฟ และ คลิฟฟอร์ด เบอร์รี ออกแบบคอมพิวเตอร์ดิจิทัลอิเล็กทรอนิกส์เครื่องแรกโดยใช้ระบบฐานสองในปี ค.ศ. 1939 จอห์น ฟอน นิวแมนน์ กำหนดสถาปัตยกรรมโปรแกรมที่จัดเก็บในปี ค.ศ. 1945 โดยให้ทั้งข้อมูลและคำสั่งอยู่ในรหัสฐานสองในหน่วยความจำ—โมเดลที่เรายังคงใช้อยู่ในปัจจุบัน ภายในปี ค.ศ. 1953 IBM เริ่มขายคอมพิวเตอร์ฐานสองเชิงพาณิชย์ มาตรฐาน ASCII ในปี ค.ศ. 1963 ให้วิธีที่เป็นเอกภาพในการแสดงอักขระข้อความในฐานสอง

สิ่งที่น่าทึ่งคือความก้าวหน้าทุกอย่างในการคำนวณ—จากบัตรเจาะไปจนถึงสมาร์ทโฟน—ยังคงทำงานด้วยระบบฐานสองมาโดยตลอด เราเพียงแค่ซ่อนความซับซ้อนนั้นไว้ด้วยชั้นของการนิรภัย

ตัวอย่างโค้ดแปลงเลขฐานสองเป็นเลขฐานสิบสำหรับนักพัฒนา

ต้องการนำการแปลงนี้ไปใช้ในโค้ดของคุณเองหรือไม่? นี่คือการใช้งานที่สะอาดและพร้อมใช้งานในภาษาต่างๆ แต่ละตัวอย่างรวมการตรวจสอบข้อมูลนำเข้าเนื่องจากผู้ใช้จะแน่นอนว่าจะวางข้อมูลที่ไม่ถูกต้อง

ภาษาสมัยใหม่ส่วนใหญ่มีฟังก์ชันในตัวสำหรับการแปลงนี้—parseInt(str, 2) ใน JavaScript, int(str, 2) ใน Python, Integer.parseInt(str, 2) ใน Java ตัวอย่างเหล่านี้แสดงทั้งวิธีการใช้ฟังก์ชันในตัวและวิธีการทำงานของตรรกะการแปลงจริงๆ:

JavaScript

1// การแปลงเลขฐานสองเป็นเลขฐานสิบ
2function binaryToDecimal(binary) {
3  if (!/^[01]+$/.test(binary)) {
4    return "เลขฐานสองไม่ถูกต้อง";
5  }
6  return parseInt(binary, 2);
7}
8
9// การแปลงเลขฐานสิบเป็นเลขฐานสอง
10function decimalToBinary(decimal) {
11  if (!/^\d+$/.test(decimal) || decimal < 0) {
12    return "เลขฐานสิบไม่ถูกต้อง";
13  }
14  return Number(decimal).toString(2);
15}
16
17// การใช้งานตัวอย่าง
18console.log(binaryToDecimal("1010")); // แสดงผล: 10
19console.log(decimalToBinary("42"));   // แสดงผล: 101010
20

Python

1# การแปลงเลขฐานสองเป็นเลขฐานสิบ
2def binary_to_decimal(binary):
3    try:
4        # ตรวจสอบว่าอินพุตมีเฉพาะ 0 และ 1
5        if not all(bit in '01' for bit in binary):
6            return "เลขฐานสองไม่ถูกต้อง"
7        return int(binary, 2)
8    except ValueError:
9        return "เลขฐานสองไม่ถูกต้อง"
10
11# การแปลงเลขฐานสิบเป็นเลขฐานสอง
12def decimal_to_binary(decimal):
13    try:
14        # ตรวจสอบว่าอินพุตเป็นจำนวนเต็มที่ไม่เป็นลบ
15        decimal = int(decimal)
16        if decimal < 0:
17            return "เลขฐานสิบไม่ถูกต้อง"
18        return bin(decimal)[2:]  # ลบคำนำหน้า '0b'
19    except ValueError:
20        return "เลขฐานสิบไม่ถูกต้อง"
21
22# การใช้งานตัวอย่าง
23print(binary_to_decimal("1010"))  # แสดงผล: 10
24print(decimal_to_binary("42"))    # แสดงผล: 101010
25

Java

1public class BinaryDecimalConverter {
2    // การแปลงเลขฐานสองเป็นเลขฐานสิบ
3    public static int binaryToDecimal(String binary) {
4        if (!binary.matches("[01]+")) {
5            throw new IllegalArgumentException("เลขฐานสองไม่ถูกต้อง");
6        }
7        return Integer.parseInt(binary, 2);
8    }
9    
10    // การแปลงเลขฐานสิบเป็นเลขฐานสอง
11    public static String decimalToBinary(int decimal) {
12        if (decimal < 0) {
13            throw new IllegalArgumentException("ไม่รองรับตัวเลขติดลบ");
14        }
15        return Integer.toBinaryString(decimal);
16    }
17    
18    public static void main(String[] args) {
19        System.out.println(binaryToDecimal("1010"));  // แสดงผล: 10
20        System.out.println(decimalToBinary(42));      // แสดงผล: 101010
21    }
22}
23

C++

1#include <iostream>
2#include <string>
3#include <cmath>
4#include <regex>
5
6// การแปลงเลขฐานสองเป็นเลขฐานสิบ
7int binaryToDecimal(const std::string& binary) {
8    // ตรวจสอบว่าอินพุตมีเฉพาะ 0 และ 1
9    if (!std::regex_match(binary, std::regex("[01]+"))) {
10        throw std::invalid_argument("เลขฐานสองไม่ถูกต้อง");
11    }
12    
13    int decimal = 0;
14    for (int i = 0; i < binary.length(); i++) {
15        if (binary[binary.length() - 1 - i] == '1') {
16            decimal += std::pow(2, i);
17        }
18    }
19    return decimal;
20}
21
22// การแปลงเลขฐานสิบเป็นเลขฐานสอง
23std::string decimalToBinary(int decimal) {
24    if (decimal < 0) {
25        throw std::invalid_argument("ไม่รองรับตัวเลขติดลบ");
26    }
27    
28    if (decimal == 0) {
29        return "0";
30    }
31    
32    std::string binary = "";
33    while (decimal > 0) {
34        binary = (decimal % 2 == 0 ? "0" : "1") + binary;
35        decimal /= 2;
36    }
37    return binary;
38}
39
40int main() {
41    std::cout << binaryToDecimal("1010") << std::endl;  // แสดงผล: 10
42    std::cout << decimalToBinary(42) << std::endl;      // แสดงผล: 101010
43    return 0;
44}
45

Excel

1' การแปลงเลขฐานสองเป็นเลขฐานสิบ
2Function BinaryToDecimal(binary As String) As Variant
3    ' ตรวจสอบว่าอินพุตมีเฉพาะ 0 และ 1
4    Dim i As Integer
5    For i = 1 To Len(binary)
6        If Mid(binary, i, 1) <> "0" And Mid(binary, i, 1) <> "1" Then
7            BinaryToDecimal = CVErr(xlErrValue)
8            Exit Function
9        End If
10    Next i
11    
12    BinaryToDecimal = Application.WorksheetFunction.Bin2Dec(binary)
13End Function
14
15' การแปลงเลขฐานสิบเป็นเลขฐานสอง
16Function DecimalToBinary(decimal As Long) As String
17    If decimal < 0 Then
18        DecimalToBinary = CVErr(xlErrValue)
19        Exit Function
20    End If
21    
22    DecimalToBinary = Application.WorksheetFunction.Dec2Bin(decimal)
23End Function
24
25' การใช้งานตัวอย่างในเซลล์:
26' =BinaryToDecimal("1010")  ' ส่งคืน: 10
27' =DecimalToBinary(42)      ' ส่งคืน: 101010
28

คำถามที่พบบ่อยเกี่ยวกับการแปลงเลขฐานสองเป็นเลขฐานสิบ

เลขฐานสองคืออะไร?

เลขฐานสองใช้เพียงสองหลัก—0 และ 1—เพื่อแสดงค่า แต่ละหลักเรียกว่าบิต (หลักฐานสอง) คิดเหมือนสวิตช์ไฟ: มันปิด (0) หรือเปิด (1) แม้ว่าจะดูเหมือนจำกัด แต่คุณสามารถแสดงตัวเลขใดๆ ได้โดยการเรียงบิตเข้าด้วยกัน เหมือนกับที่คุณสามารถเขียนคำใดๆ โดยใช้เพียง 26 ตัวอักษร

ทำไมคอมพิวเตอร์จึงใช้เลขฐานสองแทนเลขฐานสิบ?

นี่คือเหตุผลที่เป็นรูปธรรม: การสร้างส่วนประกอบอิเล็กทรอนิกส์ที่สามารถแยกแยะระหว่างระดับแรงดันไฟฟ้าสิบระดับ (สำหรับเลขฐานสิบ) มีค่าใช้จ่ายสูงและมีโอกาสผิดพลาด สองสถานะ—แรงดันไฟฟ้าสูงกับต่ำ, แม่เหล็กกับไม่แม่เหล็ก—มีความน่าเชื่อถือและถูกผลิตได้ง่ายกว่ามาก Claude Shannon พิสูจน์ในวิทยานิพนธ์ปริญญาโทปี 1937 ว่าตรรกะบูลีน (ซึ่งใช้ค่าฐานสอง) สามารถแสดงการดำเนินการทางตรรกะใดๆ ได้ วางรากฐานสำหรับวงจรดิจิทัลสมัยใหม่ คุณสามารถอ่านเพิ่มเติมเกี่ยวกับพื้นฐานพีชคณิตบูลีนได้ในรายการของ สารานุกรมปรัชญาของมหาวิทยาลัยสแตนฟอร์ดเกี่ยวกับพีชคณิตบูลีน

[ส่วนที่เหลือของการแปลจะดำเนินต่อไป...]

เอกสารอ้างอิงและการอ่านเพิ่มเติม

Knuth, Donald E. "The Art of Computer Programming, Volume 2: Seminumerical Algorithms." Addison-Wesley, 1997.
Shannon, Claude E. "การวิเคราะห์เชิงสัญลักษณ์ของวงจรรีเลย์และสวิตชิ่ง" วารสารของสถาบันวิศวกรไฟฟ้าอเมริกัน, เล่มที่ 57, ฉบับที่ 12, 1938, หน้า 713-723. สามารถดูได้จาก IEEE Xplore
Leibniz, Gottfried Wilhelm. "คำอธิบายเลขฐานสอง" (Explanation of Binary Arithmetic). บันทึกของราชวิทยาลัยวิทยาศาสตร์, 1703.
Boole, George. "การสอบสวนกฎของความคิด" สำนักพิมพ์ดอเวอร์, 1854 (พิมพ์ซ้ำ 1958).
Ifrah, Georges. "ประวัติศาสตร์สากลของตัวเลข: จากยุคก่อนประวัติศาสตร์ถึงการประดิษฐ์คอมพิวเตอร์" Wiley, 2000.
"POSIX.1-2017: chmod" ข้อกำหนดพื้นฐานของกลุ่มเปิด. https://pubs.opengroup.org/onlinepubs/9699919799/utilities/chmod.html
"RFC 791: โพรโทคอลอินเทอร์เน็ต" คณะทำงานวิศวกรรมอินเทอร์เน็ต (IETF), 1981. https://tools.ietf.org/html/rfc791
"คู่มือนักพัฒนาซอฟต์แวร์สถาปัตยกรรม Intel 64 และ IA-32" บริษัท Intel. https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html

เริ่มแปลงเดี๋ยวนี้

เครื่องมือแปลงที่ด้านบนของหน้านี้จัดการการแปลงได้ทันทีในทั้งสองทิศทาง พิมพ์ตัวเลขของคุณในช่องใดก็ได้และดูผลลัพธ์ทันที พร้อมกับคำอธิบายทางคณิตศาสตร์ที่แสดงวิธีการแปลงอย่างละเอียด

สิ่งที่คุณจะได้รับ:

การแปลงทันทีระหว่างเลขฐานสองและเลขฐานสิบ
คำอธิบายภาพของกระบวนการแปลง
รองรับตัวเลขสูงสุด 53 บิต (มากกว่า 9 ควอดริลเลียน)
การคัดลอกผลลัพธ์ด้วยคลิกเดียว
ไม่ต้องสมัคร ไม่มีค่าใช้จ่าย ใช้งานได้กับทุกอุปกรณ์

ไม่ว่าคุณจะกำลังแก้ไขการกำหนดค่าเครือข่าย ตั้งค่าสิทธิ์ไฟล์ หรือเรียนรู้เกี่ยวกับสถาปัตยกรรมคอมพิวเตอร์ การเข้าใจการแปลงระหว่างเลขฐานสองและเลขฐานสิบเป็นทักษะพื้นฐาน เครื่องมือนี้ทำให้เรื่องนี้เป็นเรื่องง่าย