JavaScript เป็นภาษาโปรแกรมที่ทนต่อข้อผิดพลาดได้มากและสำนวนหลายอย่างที่ไม่ถูกกฎหมายในภาษาโปรแกรมอื่น ๆ จะทำงานได้ดีใน JavaScript
ส่งผลให้เกิดโค้ดแปลกๆ มากมาย คุณต้องการที่จะท้าทายมัน?
ในการท้าทายนี้ คุณจะได้พบกับสำนวนแปลกๆ 20 แบบและขอให้เดาผลลัพธ์ของพวกเขา
1.
จริง + เท็จ
2.
**1.**
3.
[1, 2, 3] + [4, 5, 6]
4.
0.2 + 0.1 === 0.3
5.
10,2
6.
!!""
7.
+!![]
8.
จริง == "จริง"
9.
010 - 03
10.
"" - - ""
11.
null + 0
12.
0/0
13.
1/0 === 10 ** 1,000
14.
จริง++
15.
"" - 1
16.
(null - 1) - "1"
17.
38 * 4343 * 2342+ ("จริง" — 0) 18.
5 + !5 + !!5
19.
[] + [1] + 2
20.
1 + 2 + "3"
จริง + เท็จ
เมื่อพยายามใช้ตัวดำเนินการบวก (+) ระหว่างค่าบูลีนสองค่า ค่าเหล่านั้นจะถูกแปลงเป็นตัวเลข
และเราทุกคนรู้ดี true ควรแปลงเป็น 1 และ false ควรแปลงเป็น 0 ดังนั้นคืนค่า true+false 1
[,,,].length
[,,,] เอาท์พุตอาร์เรย์ที่มีช่องว่างสามช่อง เครื่องหมายจุลภาคสุดท้ายคือเครื่องหมายจุลภาคต่อท้าย
คุณสามารถคิดแบบนี้ได้
[,] ==> [ว่าง] [,,] ==> [ว่าง, ว่าง,] [,,,] ==> [empty, Empty, Empty,]
ดังนั้น [,,,].length จะส่งกลับ 3
[1, 2, 3] + [4, 5, 6]
เมื่อคุณพยายามใช้ตัวดำเนินการบวก (+) ระหว่างอาร์เรย์ ตัวดำเนินการเหล่านั้นจะถูกแปลงเป็นสตริง
เมื่อแปลงอาร์เรย์เป็นสตริง จะเรียกเมธอด toString() ของอาร์เรย์ JavaScript ใช้เมธอด toString() ภายใน เมื่ออาร์เรย์จำเป็นต้องแสดงเป็นข้อความ มันจะเชื่อมต่อองค์ประกอบต่างๆ ด้วยเครื่องหมายจุลภาค
[1, 2, 3].toString() ==> '1, 2, 3' [4, 5, 6].toString() ==> '4, 5, 6'
ดังนั้น
[1, 2, 3] + [4, 5, 6] ==> '1, 2, 3' + '4 , 5, 6' ==> "1,2,34,5,6"
0.2 + 0.1 === 0.3
เนื่องจากตัวเลขทศนิยมเป็นเรื่องยากที่จะแทนค่าได้อย่างแม่นยำในคอมพิวเตอร์ ดังนั้น 0.1 และ 0.2 ทางคณิตศาสตร์จึงสามารถประมาณได้เฉพาะในคอมพิวเตอร์ดิจิทัลเท่านั้น การเป็นตัวแทน
ผลลัพธ์ของ 0.1+0.2 นั้นไม่แน่นอน 0.3 ไม่ใช่แค่ JavaScript ภาษาโปรแกรมอื่น ๆ ก็มีปัญหาเดียวกัน
10, 2
เครื่องหมายจุลภาค ( , ) เป็นตัวดำเนินการทางกฎหมายใน JavaScript โดยจะประเมินแต่ละตัวถูกดำเนินการ (จากซ้ายไปขวา) และส่งกลับค่าของตัวถูกดำเนินการสุดท้าย
ดังนั้น 10,2 ส่งคืน 2
!!""
"" จึงเป็นสตริงว่างซึ่งเป็นค่าจำลอง
หมายเหตุ: 0, สตริงว่าง "", null และไม่ได้กำหนดเป็นค่าเสมือนทั้งหมด
! เป็นตัวดำเนินการเชิงตรรกะ "ไม่" เปลี่ยนเป็นจริงเป็นเท็จและในทางกลับกัน
หากเราใช้ ! สองครั้ง นั่นคือ !! มันจะแปลงค่าปกติให้เป็นค่าบูลีน ดังนั้น !"" ส่งคืน false
+!![]
อาร์เรย์เป็นค่าจริงทั้งหมด แม้แต่อาร์เรย์ว่างก็ตาม ดังนั้น !![] จะกลับมา true
!![]; // -> true
และเครื่องหมาย + แปลงค่าจริงเป็นการแสดงตัวเลข: 1 ดังนั้น +!![] จึงส่งคืน 1
true == "true"
ตัวดำเนินการความเท่าเทียมกัน (==) ตรวจสอบว่าตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ และส่งกลับผลลัพธ์บูลีน
ตามกฎการเปรียบเทียบความเท่าเทียมกันเชิงนามธรรม ค่าทั้งสองจะถูกแปลงเป็นตัวเลขเมื่อเปรียบเทียบ
true == "true" ==> Number(true) == Number("true") ==> 1 == NaN ดังนั้น ture =="true" ส่งคืนค่า false
010 - 03
ต่อไปนี้เป็นเคล็ดลับเล็กๆ น้อยๆ: หากตัวเลขขึ้นต้นด้วย 0 จะถือเป็นเลขฐานแปดใน JavaScript ดังนั้น:
010 - 03 ==> 8 - 3 ==> 5
นอกจากนี้:
""--""
ดูเหมือนจะใช้ไวยากรณ์ไม่ดี แต่ก็ใช้ได้ดี
สตริงว่างสามารถแปลงเป็นค่าบูลีน false หรือค่าตัวเลข 0 ดังนั้น -"" จึงเป็น 0
null + 0
ดังที่เราได้กล่าวไปแล้ว null คือค่าเสมือน มันจะถูกแปลงเป็นค่าบูลีน false หรือค่าตัวเลข 0 ดังนั้นผลลัพธ์จึงคืนค่า 0
0/0
นี่เป็นนิพจน์ทางคณิตศาสตร์ที่ผิดกฎหมาย สมการ 0/0 ไม่มีคำตอบที่เป็นตัวเลขที่มีความหมาย ผลลัพธ์ที่ได้คือ NaN เท่านั้น
1/0 === 10 1,000**
แม้ว่า 1/0 จะเป็นนิพจน์ทางคณิตศาสตร์ที่ผิดกฎเหมือนแต่ก่อน แต่เมื่อตัวหารไม่ใช่ 0 JavaScript จะคิดว่าผลลัพธ์ของนิพจน์นี้คือ Infinity
และ 10**1000 เป็นตัวเลขจำนวนมาก และ JS ไม่สามารถแสดงตัวเลขนี้ได้อย่างถูกต้อง (ค่าจำนวนเต็มสูงสุดใน JavaScript คือ 2^53-1 ) ดังนั้น 10 * 1000 ก็ถือเป็นอนันต์เช่นกัน
อนันต์จะเท่ากับอนันต์อื่นเสมอ ดังนั้น 1/0 === 10 ** 1000 ส่งคืนค่าจริง
true++
ไม่มีอะไรพิเศษเกี่ยวกับเรื่องนี้ มันเป็นเพียงข้อผิดพลาดทางไวยากรณ์
""- 1
แม้ว่าตัวดำเนินการบวก (+) ใช้ได้กับทั้งตัวเลขและสตริง ตัวดำเนินการลบ (-) จะไม่มีประโยชน์กับสตริง ดังนั้น JavaScript จึงตีความว่าเป็นการดำเนินการระหว่างตัวเลข สตริงว่างจะถูกบังคับให้พิมพ์เป็น 0
"" - 1 ==> Number("") - 1 ==> 0 - 1 ==> -1 ดังนั้น "" — 1 ส่งคืน -1
(null - 1) - "1"
ตามที่กล่าวข้างต้น
โมฆะ ==> 0 (ว่าง - 1) ==> -1 "1" ==> 1
ดังนั้น (null — 1) — “1” คืนค่า -2
38 4343 2342+ ("true" - 0)
คุณอาจสงสัยว่า JS บ้ามากจนแปลงสตริง "จริง" เป็นตัวเลข การแสดงค่าบูลีนที่เป็นจริง อย่างไรก็ตาม มันไม่ได้บ้าขนาดนั้น สิ่งที่เกิดขึ้นจริงคือมันพยายามแปลงสตริงให้เป็นตัวเลข แต่มันล้มเหลว
Number("true"); // -> NaN ในการดำเนินการเชิงตัวเลขของ JavaScript ตราบใดที่ค่าหนึ่งคือ NaN ผลลัพธ์สุดท้ายของการดำเนินการจะต้องเป็น NaN 38 * 4343 * 2342 เป็นแค่ม่านควัน
5 + !5 + !!5
ตามที่กล่าวข้างต้น
ดังนั้น:
!5 ==> 0 !!5 ==> 1
[] + [1] + 2
เมื่อพยายามใช้ตัวดำเนินการบวก (+) ระหว่างอาร์เรย์ ค่าเหล่านั้นจะถูกแปลงเป็นสตริง
- [1] ==> '1' [] + [1] ==> '1' '1' + 2 ==> '12'
ดังนั้นผลลัพธ์คือ '12'
1 + 2 + "3"
JavaScript ดำเนินการเหล่านี้จากซ้ายไปขวา เมื่อเพิ่มหมายเลข 3 ลงในสตริง 3 การต่อสตริงจะมีความสำคัญกว่า
1 + 2; // -> 3 3 + "3"; // -> "33"
พูดตรงๆ ความท้าทายเหล่านี้ไม่ได้ให้คุณค่ากับทักษะการเขียนโค้ดของเรา ดังนั้นโค้ดประเภทนี้จึงไม่ควรเขียนในโครงการจริง
อย่างไรก็ตาม ให้ถือว่าทักษะเหล่านี้เป็นเพื่อนกัน การแกล้งทำเป็นอายุ 13 กับเพื่อนร่วมงานเป็นเรื่องที่น่าสนใจใช่ไหม?
ผู้แต่ง: Marina Mosti
ที่มา: medium
ข้อความต้นฉบับ: https://medium.com/frontend-canteen/20-useless-but-ตลก-challange-for-javascript-develor-9eea39bb8efb
[คำแนะนำวิดีโอสอนที่เกี่ยวข้อง: ส่วนหน้าของเว็บ]
ข้างต้นคือนิพจน์ JS แปลก ๆ 20 รายการ , เดาผลลัพธ์ที่ได้! สำหรับรายละเอียดเพิ่มเติม โปรดอ่านบทความอื่นๆ ที่เกี่ยวข้องบนเว็บไซต์ php Chinese!