มีวิธีที่ดีกว่าในการเขียน v = (v == 0 หรือไม่ 1: 0); [ปิด]

ฉันต้องการสลับตัวแปรระหว่าง 0 ถึง 1 ถ้าเป็น 0 ฉันต้องการตั้งค่าเป็น 1 มิฉะนั้นถ้าเป็น 1 ฉันต้องการตั้งค่าเป็น 0

นี่เป็นการดำเนินการขั้นพื้นฐานที่ฉันเขียนบ่อยครั้งที่ฉันต้องการตรวจสอบวิธีที่สั้นและชัดเจนที่สุดเท่าที่จะทำได้ นี่คือสิ่งที่ดีที่สุดของฉัน:

v = (v == 0 ? 1 : 0);

คุณสามารถปรับปรุงสิ่งนี้ได้ไหม

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

คุณสามารถใช้:

v = 1 - v;

แน่นอนว่าสมมติว่าตัวแปรนั้นเริ่มต้นอย่างถูกต้องนั่นคือมันมีค่า 0 หรือ 1 เท่านั้น

วิธีอื่นที่สั้นกว่า แต่ใช้ตัวดำเนินการทั่วไปที่น้อยกว่า:

v ^= 1;

แก้ไข:

ต้องมีความชัดเจน; ฉันไม่เคยเข้าหาคำถามนี้ในฐานะนักกอล์ฟเพียงเพื่อหาวิธีสั้น ๆ ในการทำงานโดยไม่ต้องใช้เทคนิคที่คลุมเครือเช่นผลข้างเคียงของผู้ปฏิบัติงาน

เนื่องจาก0เป็นfalseค่าและ1เป็นtrueค่า

v = (v ? 0 : 1);

หากคุณมีความสุขที่จะใช้trueและfalseแทนตัวเลข

v = !v;

หรือถ้าพวกเขาจะต้องเป็นตัวเลข:

v = +!v; /* Boolean invert v then cast back to a Number */

v = (v + 1) % 2และถ้าคุณต้องการเพื่อวงจรผ่านค่าอื่น ๆ อีกมากมายเพียงแค่เปลี่ยนสำหรับ2 (n + 1)สมมติว่าคุณต้องรอบ 0,1,2 v = (v + 1) % 3เพียงแค่ทำ

คุณสามารถเขียนฟังก์ชั่นและใช้งานได้เช่น:

v = inv(v)

หากคุณไม่สนใจความเป็นไปได้อื่น ๆ นอกจาก 1:

v = v ? 0 : 1;

ในกรณีข้างต้น v จะกลายเป็น 1 ถ้า v เป็น 0, false, undefined หรือ null ระวังการใช้วิธีการนี้ - v จะเป็น 0 แม้ว่า v คือ "สวัสดีโลก"

เส้นชอบv = 1 - vหรือv ^= 1หรือv= +!vทั้งหมดจะได้งานทำ แต่พวกเขาเป็นสิ่งที่ผมจะเรียกว่าแฮ็ก สิ่งเหล่านี้ไม่ใช่เส้นรหัสที่สวยงาม แต่เป็นเทคนิคราคาถูกที่มีผลกระทบตามที่ตั้งใจไว้ 1 - vไม่สื่อสาร "สลับค่าระหว่าง 0 และ 1" สิ่งนี้ทำให้รหัสของคุณแสดงออกน้อยลงและแนะนำสถานที่ (แม้ว่าจะเป็นจุดเล็ก ๆ ) ซึ่งนักพัฒนารายอื่นจะต้องแยกวิเคราะห์รหัสของคุณ

แทนที่จะมีฟังก์ชั่นเช่นv = toggle(v)การสื่อสารความตั้งใจได้อย่างรวดเร็ว

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

คำตอบเดิมของฉัน:

ถ้อยคำของข้อกำหนดส่วนนี้:

ถ้าเป็น 0 ฉันต้องการตั้งค่าเป็น 1 มิฉะนั้นตั้งเป็น 0

หมายความว่าทางออกที่ถูกต้องที่สุดคือ:

v = dirac_delta(0,v)

ก่อนอื่นสารภาพ: ฉันทำให้ฟังก์ชั่นเดลต้าสับสน Kronecker delta น่าจะเหมาะสมกว่าเล็กน้อย แต่ไม่มากเท่าที่ฉันต้องการบางสิ่งบางอย่างที่ไม่ขึ้นกับโดเมน แต่ฉันไม่ควรใช้ฟังก์ชันเดลต้าเลยจริง ๆ ฉันควรพูดว่า:

v = characteristic_function({0},v)

ให้ฉันอธิบาย จำได้ว่าฟังก์ชั่นเป็นสาม(X, Y, ฉ)ที่XและYเป็นชุด (เรียกว่าโดเมนและโคโดเมนตามลำดับ) และFคือกฎที่กำหนดองค์ประกอบของYกับองค์ประกอบของแต่ละX เรามักจะเขียนสาม(X, Y, ฉ)เป็นf: X → Y รับเซตย่อยของXพูดAมีฟังก์ชั่นพิเศษซึ่งเป็นฟังก์ชั่นχ _A : X → {0,1}(มันอาจจะคิดว่าเป็นฟังก์ชั่นกับโคโดเมนขนาดใหญ่เช่นℕหรือℝ) ฟังก์ชั่นนี้ถูกกำหนดโดยกฎ:

χ (x) = 1ถ้าx ∈และχ (x) = 0ถ้าx ∉

หากคุณชอบตารางความจริงมันเป็นตารางความจริงสำหรับคำถาม "องค์ประกอบxของXเป็นองค์ประกอบของชุดย่อยAหรือไม่"

ดังนั้นจากคำนิยามนี้ก็เป็นที่ชัดเจนว่าลักษณะการทำงานเป็นสิ่งที่จำเป็นที่นี่กับXชุดใหญ่บางมี 0 และA = {0} นั่นคือสิ่งที่ฉันควรจะเขียน

และเพื่อฟังก์ชั่นเดลต้า สำหรับสิ่งนี้เราจำเป็นต้องรู้เกี่ยวกับการรวม ไม่ว่าคุณจะรู้หรือไม่ก็ตาม หากคุณไม่ทำสิ่งที่ฉันสามารถพูดได้ที่นี่จะบอกคุณเกี่ยวกับความซับซ้อนของทฤษฎี แต่ฉันสามารถให้สรุปหนึ่งประโยค การวัดในเซตXนั้นมีความสำคัญว่า "สิ่งที่จำเป็นในการทำให้ค่าเฉลี่ยทำงาน" กล่าวได้ว่าถ้าเรามีเซตXและหน่วยวัดμบนเซตนั้นก็มีคลาสของฟังก์ชันX →ℝเรียกว่าฟังก์ชันที่วัดได้ซึ่งนิพจน์∫ _X f dμนั้นสมเหตุสมผลและในบางแง่มุมที่คลุมเครือ ว่า "ค่าเฉลี่ย" ของฉมากกว่าX

เมื่อทำการวัดในชุดหนึ่งสามารถกำหนด "การวัด" สำหรับชุดย่อยของชุดนั้นได้ สิ่งนี้ทำได้โดยการกำหนดให้ส่วนย่อยของฟังก์ชั่นคุณสมบัติของมัน (สมมติว่านี่เป็นฟังก์ชั่นที่วัดได้) สิ่งนี้อาจเป็นอนันต์หรือไม่ได้นิยาม

มีมาตรการมากมาย แต่มีสองสิ่งที่สำคัญที่นี่ หนึ่งคือการวัดมาตรฐานในสายจริงℝ สำหรับมาตรการนี้แล้ว∫ _ℝฉdμสวยมากสิ่งที่คุณจะได้รับการสอนในโรงเรียน (เป็นแคลคูลัสยังสอนในโรงเรียน?): สรุปสี่เหลี่ยมเล็ก ๆ น้อย ๆ และใช้ความกว้างขนาดเล็กและขนาดเล็ก ในการวัดนี้การวัดช่วงเวลาคือความกว้าง การวัดจุดคือ 0

อีกวัดที่สำคัญซึ่งทำงานบนใด ๆชุดที่เรียกว่าวัดจุด มันถูกกำหนดไว้เพื่อให้อินทิกรัลของฟังก์ชันคือผลรวมของค่า:

∫ _X f dμ = ∑ _{x ∈X} f (x)

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

และตอนนี้ฟังก์ชั่นเดลต้า ลองนิยามที่กว้างมาก ๆ เรามีพื้นที่ที่วัด(x, μ) (เพื่อให้เป็นชุดที่มีมาตรการเกี่ยวกับมัน) และองค์ประกอบ∈ X เรา "กำหนดว่า" ฟังก์ชั่นเดลต้า (ขึ้นอยู่กับ) จะเป็น "ฟังก์ชั่น" δ : X →ℝกับทรัพย์สินที่δ (x) = 0ถ้าx ≠และ∫ _X δ dμ = 1

ความจริงที่สำคัญที่สุดเกี่ยวกับเรื่องนี้ที่จะได้รับการระงับการคือ: ฟังก์ชั่นเดลต้าไม่จำเป็นต้องเป็นฟังก์ชั่น มันไม่ได้ถูกกำหนดอย่างถูกต้อง: ฉันไม่ได้พูดว่าδ _a (a)คืออะไร

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

ตกลงดังนั้นฟังก์ชันเดลต้าอาจไม่ถูกกำหนด ดู Let 's ที่คุณสมบัติสมมุติและดูว่าเราสามารถหาบ้านที่เหมาะสมสำหรับมันที่มันถูกกำหนดไว้ เราสามารถทำเช่นนั้นและเราจบลงด้วยการกระจาย ฟังก์ชั่นเหล่านี้ไม่ได้ (จำเป็น) ฟังก์ชั่น แต่เป็นสิ่งที่ทำหน้าที่เหมือนฟังก์ชั่นเล็กน้อยและบ่อยครั้งที่เราสามารถทำงานกับพวกเขาราวกับว่าพวกเขาฟังก์ชั่น; แต่มีบางสิ่งที่พวกเขาไม่มี (เช่น "ค่า") ดังนั้นเราจึงต้องระมัดระวัง

หากคุณไม่ใช่นักคณิตศาสตร์คุณพูดสิ่งต่อไปนี้:

ตกลงดังนั้นฟังก์ชันเดลต้าอาจไม่ได้รับการกำหนดอย่างถูกต้อง ใครบอกอย่างนั้น นักคณิตศาสตร์กลุ่มหนึ่ง ไม่สนใจพวกเขา! พวกเขารู้อะไร

ตอนนี้ฉันต้องโกรธผู้ชมของฉันต่อไป

เดลต้า Diracมักจะถูกนำไปเป็นฟังก์ชั่นเดลต้าของจุด (มัก 0) ในบรรทัดจริงกับตัวชี้วัดมาตรฐาน ดังนั้นผู้ที่บ่นในความคิดเห็นเกี่ยวกับฉันที่ไม่รู้ว่า delta ของฉันกำลังทำเช่นนั้นเพราะพวกเขาใช้คำจำกัดความนี้ สำหรับพวกเขาฉันขอโทษ: แม้ว่าฉันจะดิ้นออกจากที่โดยใช้การป้องกันของนักคณิตศาสตร์ (เป็นที่นิยมโดยHumpty Dumpty : เพียงแค่กำหนดทุกอย่างเพื่อให้ถูกต้อง) มันเป็นรูปแบบที่ไม่ดีที่จะใช้คำมาตรฐานที่หมายถึงสิ่งที่แตกต่าง

แต่มีเป็นฟังก์ชั่นเดลต้าซึ่งจะทำสิ่งที่ฉันต้องการจะทำและมันคือสิ่งที่ฉันต้องการที่นี่ ถ้าฉันวัดค่าจุดบนเซตXดังนั้นจะมีฟังก์ชั่นของแท้δ _a : X →ℝซึ่งเป็นไปตามเกณฑ์ของฟังก์ชั่นเดลต้า นี่เป็นเพราะเรากำลังมองหาฟังก์ชั่นX →ℝซึ่งเป็นศูนย์ยกเว้นที่aและผลรวมของค่าทั้งหมดของมันคือ 1 ฟังก์ชั่นนั้นง่าย: ชิ้นข้อมูลที่ขาดหายไปเพียงอย่างเดียวคือค่าที่aและ เพื่อให้ได้ผลรวมที่จะเป็น 1 เราเพียงแค่กำหนดค่าที่ 1 นี้เป็นใครอื่นนอกจากฟังก์ชั่นในลักษณะ{a} แล้ว:

∫ _X δ _a dμ = ∑ _{x ∈ X} δ _a (x) = δ _a (a) = 1

ดังนั้นในกรณีนี้สำหรับชุดซิงเกิลฟังก์ชันคุณสมบัติและฟังก์ชันเดลต้าจึงเห็นด้วย

โดยสรุปมี "ฟังก์ชั่น" สามตระกูลที่นี่:

1. ฟังก์ชั่นลักษณะของชุดซิงเกิล
2. ฟังก์ชันเดลต้า
3. ฟังก์ชัน Kronecker delta

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

ดังนั้นในที่สุดเมื่อฉันเดิมเขียนคำตอบที่ฉันไม่ได้คิดอย่างถูกต้อง (ฉันจะไม่ไปให้ไกลที่สุดเท่าที่จะบอกว่าผมกำลังสับสนเป็นฉันหวังว่าฉันได้แสดงให้เห็นเพียงแค่ผมไม่ทราบว่าสิ่งที่ผมพูดเกี่ยวกับเมื่อ ฉันคิดอย่างแรกจริงๆฉันไม่ได้คิดอะไรมาก) ความหมายทั่วไปของเดลต้า dirac ไม่ใช่สิ่งที่ต้องการในที่นี้ แต่หนึ่งในคำตอบของฉันคือว่าโดเมนอินพุทไม่ได้ถูกกำหนดไว้ดังนั้น Kronecker delta ก็จะไม่ถูกต้องเช่นกัน ดังนั้นที่ดีที่สุดทางคณิตศาสตร์คำตอบ (ซึ่งผมกำลังเล็งหา) จะได้รับลักษณะฟังก์ชั่น

ฉันหวังว่าทุกอย่างชัดเจน และฉันก็หวังว่าฉันจะไม่ต้องเขียนชิ้นส่วนทางคณิตศาสตร์อีกครั้งโดยใช้เอนทิตี HTML แทนที่จะเป็นมาโคร TeX!

คุณสามารถทำได้

v = Math.abs(--v);

การลดลงตั้งค่าเป็น 0 หรือ -1 แล้วMath.absแปลง -1 เป็น +1

โดยทั่วไปเมื่อใดก็ตามที่คุณต้องการสลับระหว่างสองค่าคุณสามารถลบค่าปัจจุบันจากผลรวมของค่าสลับสองค่า:

    0,1 -> v = 1 - v
    1,2 -> v = 3 - v
    4,5 -> v = 9 - v 

ถ้ามันต้องเป็นจำนวนเต็ม 1 หรือ 0 แสดงว่าคุณทำได้ดี แต่ไม่จำเป็นต้องใช้วงเล็บ หาก a เหล่านี้จะถูกใช้เป็นบูลีนคุณสามารถทำได้ดังนี้:

v = !v;

v = v == 0 ? 1 : 0;

ก็พอแล้ว!

รายการโซลูชั่น

มีสามวิธีที่ฉันต้องการเสนอ ทั้งหมดของพวกเขาแปลงค่าใด ๆ ไป0(ถ้า1, trueฯลฯ ) หรือ1(ถ้า0, false, nullฯลฯ ):

• v = 1*!v
• v = +!v
• v = ~~!v

และอีกหนึ่งที่กล่าวถึงแล้ว แต่ฉลาดและรวดเร็ว (แม้ว่าใช้ได้กับ0s และ1s เท่านั้น):

• v = 1-v

โซลูชันที่ 1

คุณสามารถใช้วิธีแก้ไขปัญหาต่อไปนี้:

v = 1*!v

นี่เป็นครั้งแรกจะแปลงจำนวนเต็มเพื่อบูลตรงข้าม ( 0การTrueและค่าอื่น ๆ ให้False) 1แล้วจะรักษามันเป็นจำนวนเต็มเมื่อคูณด้วย ผลที่ตามมา0จะถูกแปลงเป็น1และความคุ้มค่าอื่น ๆ 0ให้

เป็นหลักฐานดู jsfiddle นี้และให้ค่าใด ๆ ที่คุณต้องการทดสอบ: jsfiddle.net/rH3g5/

ผลลัพธ์มีดังนี้:

• -123จะแปลงเป็นจำนวนเต็ม0,
• -10จะแปลงเป็นจำนวนเต็ม0,
• -1จะแปลงเป็นจำนวนเต็ม0,
• 0จะแปลงเป็นจำนวนเต็ม1,
• 1จะแปลงเป็นจำนวนเต็ม0,
• 2จะแปลงเป็นจำนวนเต็ม0,
• 60จะแปลงเป็นจำนวนเต็ม0,

โซลูชันที่ 2

ตามที่ mblase75 ตั้งข้อสังเกตไว้ jAndy มีวิธีแก้ปัญหาอื่น ๆ ที่ทำงานเหมือนกับของฉัน:

v = +!v

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

โซลูชันที่ 3

อีกวิธีคือการใช้~~โอเปอเรเตอร์:

v = ~~!v

มันค่อนข้างแปลกและแปลงเป็นจำนวนเต็มจากบูลีนเสมอ

เพื่อสรุปคำตอบอื่นความคิดเห็นและความคิดเห็นของฉันฉันขอแนะนำให้รวมสองสิ่ง:

1. ใช้ฟังก์ชั่นสำหรับสลับ
2. ภายในฟังก์ชั่นนี้ใช้การใช้งานที่อ่านง่ายขึ้น

นี่คือฟังก์ชั่นที่คุณสามารถวางไว้ในห้องสมุดหรือห่อในปลั๊กอินสำหรับ Javascript Framework อื่น

function inv(i) {
  if (i == 0) {
    return 1
  } else {
    return 0;
  }
}

และการใช้งานเป็นเพียง:

v = inv(v);

ข้อดีคือ:

1. ไม่มีการทำสำเนารหัส
2. หากคุณหรือใครอ่านอีกในอนาคตคุณจะเข้าใจรหัสของคุณในเวลาไม่นาน

ฉันไม่รู้ว่าทำไมคุณต้องการสร้างบูลีนของคุณเอง? ฉันชอบไวยากรณ์ที่ขี้ขลาด แต่ทำไมไม่เขียนโค้ดที่เข้าใจได้?

นี่ไม่ใช่สั้นที่สุด / เร็วที่สุด แต่ชัดเจนที่สุด (และอ่านได้สำหรับทุกคน) กำลังใช้สถานะ / อื่น ๆ ที่รู้จักกันดี:

if (v === 0)
{
  v = 1;
}
else
{
  v = 0;
}

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

v = !v;

อีกรูปแบบของโซลูชันดั้งเดิมของคุณ:

v = Number(v == 0);

แก้ไข: ขอบคุณ TehShrike และ Guffa ที่ชี้ให้เห็นข้อผิดพลาดในโซลูชันดั้งเดิมของฉัน

ฉันจะทำให้ชัดเจนยิ่งขึ้น

อะไรvหมายถึง?

เช่นเมื่อ v เป็นบางสถานะ สร้างสถานะของวัตถุ ใน DDD วัตถุค่า

ใช้ตรรกะในวัตถุค่านี้ จากนั้นคุณสามารถเขียนโค้ดของคุณในลักษณะที่ใช้งานได้มากกว่าซึ่งอ่านได้ง่ายกว่า การเปลี่ยนสถานะสามารถทำได้โดยการสร้างสถานะใหม่ตามสถานะปัจจุบัน คำสั่ง if / logic ของคุณจะถูกห่อหุ้มในวัตถุของคุณซึ่งคุณสามารถ unittest ได้ valueObject นั้นไม่เปลี่ยนรูปเสมอดังนั้นจึงไม่มีตัวตน ดังนั้นสำหรับการเปลี่ยนแปลงมันเป็นคุณค่าที่คุณต้องสร้างขึ้นมาใหม่

ตัวอย่าง:

public class Status
{
    private readonly int _actualValue;
    public Status(int value)
    {
        _actualValue = value;
    }
    public Status(Status status)
    {
        _actualValue = status._actualValue == 0 ? 1 : 0; 
    }

    //some equals method to compare two Status objects
}

var status = new Status(0);

Status = new Status(status);

อีกวิธีในการทำ:

v = ~(v|-v) >>> 31;

สิ่งนี้หายไป:

v = [1, 0][v];

มันทำงานเหมือนโรบินกลมเช่นกัน:

v = [2, 0, 1][v]; // 0 2 1 0 ...
v = [1, 2, 0][v]; // 0 1 2 0 ...
v = [1, 2, 3, 4, 5, 0][v]; // 0 1 2 3 4 5 ...
v = [5, 0, 1, 2, 3, 4][v]; // 0 5 4 3 2 1 0 ...

หรือ

v = {0: 1, 1: 0}[v];

เสน่ห์ของการแก้ปัญหาที่ผ่านมามันทำงานได้กับค่าอื่น ๆ ทั้งหมดเช่นกัน

v = {777: 'seven', 'seven': 777}[v];

สำหรับกรณีพิเศษอย่างเช่นต้องการรับค่า (เปลี่ยน) และundefinedรูปแบบนี้อาจมีประโยชน์:

v = { undefined: someValue }[v]; // undefined someValue undefined someValue undefined ...

เนื่องจากนี่คือ JavaScript เราสามารถใช้ unary +เพื่อแปลงเป็น int:

v = +!v;

สิ่งนี้จะNOTทำให้คุณค่าของv(ให้trueถ้าv == 0หรือfalseถ้าv == 1) จากนั้นเราแปลงค่าบูลีนที่ส่งคืนเป็นค่าจำนวนเต็มที่สอดคล้องกัน

สำหรับการเตะเท่านั้น: v = Math.pow(v-1,v)สลับระหว่าง 1 และ 0

อีกหนึ่ง: v=++v%2

(ใน C มันจะง่าย++v%=2)

PS ใช่ฉันรู้ว่ามันเป็นการมอบหมายสองครั้ง แต่นี่เป็นเพียงการเขียนดิบของวิธีการของ C (ซึ่งไม่ได้ผลเหมือนที่เป็นสาเหตุ

หากคุณรับประกันว่าอินพุตของคุณเป็น 1 หรือ 0 คุณสามารถใช้:

v = 2+~v;

กำหนดอาร์เรย์ {1,0} ตั้งค่า v เป็น v [v] ดังนั้น v ที่มีค่าเป็น 0 จะกลายเป็น 1 และ vica ในทางกลับกัน

อีกวิธีที่สร้างสรรค์ในการทำเช่นนี้โดยมีvค่าเท่ากับค่าใด ๆ จะส่งคืน0หรือเสมอ1

v = !!v^1;

หากค่าที่เป็นไปได้สำหรับ v เป็นเพียง 0 และ 1 ดังนั้นสำหรับจำนวนเต็ม x ใด ๆ นิพจน์: v = Math.pow ((Math.pow (x, v) - x), v); จะสลับค่า

ฉันรู้ว่านี่เป็นวิธีแก้ปัญหาที่น่าเกลียดและ OP ไม่ได้มองหาสิ่งนี้ ... แต่ฉันกำลังคิดหาวิธีแก้ปัญหาอื่นเมื่อฉันอยู่ในลู: P

ยังไม่ได้ทดสอบ แต่ถ้าคุณอยู่หลังบูลีนฉันคิดว่าvar v = !vจะใช้ได้

ข้อมูลอ้างอิง: http://www.jackfranklin.co.uk/blog/2011/05/a-better-way-to-reverse-variables

v=!v;

จะใช้ได้กับ v = 0 และ v = 1; และสลับสถานะ

หากมีเพียงสองค่าดังเช่นในกรณีนี้ (0, 1) ฉันเชื่อว่าการใช้ int นั้นสิ้นเปลือง ค่อนข้างไปบูลีนและทำงานในบิต ฉันรู้ว่าฉันสมมติว่า แต่ในกรณีที่สลับระหว่างสองสถานะบูลีนดูเหมือนว่าจะเป็นตัวเลือกในอุดมคติ

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

นั่นv = v == 0ก็เพียงพอแล้วสำหรับสิ่งนั้น

ด้านล่างเป็นรหัสสำหรับสิ่งนั้น:

var v = 0;
alert("if v  is 0 output: " + (v == 0));

setTimeout(function() {
  v = 1;
  alert("if v  is 1 Output: " + (v == 0));
}, 1000);

JSFiddle: https://jsfiddle.net/vikash2402/83zf2zz0/

หวังว่าสิ่งนี้จะช่วยคุณได้ :)

v = หมายเลข (! v)

มันจะพิมพ์ส่งค่า Inverted Boolean เป็น Number ซึ่งเป็นเอาต์พุตที่ต้องการ