เหตุใดจึงต้องหลีกเลี่ยงตัวดำเนินการเพิ่ม (“ ++”) และตัวลด (“ -”) ใน JavaScript

หนึ่งในเคล็ดลับสำหรับเครื่องมือ jslintคือ:

++ และ -
ผู้ประกอบการ ++ (เพิ่มขึ้น) และ - (ลดลง) ได้รับการรู้จักในการมีส่วนร่วมกับรหัสที่ไม่ดีโดยการส่งเสริมความยุ่งยากมากเกินไป พวกเขาเป็นที่สองเท่านั้นที่สถาปัตยกรรมผิดพลาดในการเปิดใช้งานไวรัสและภัยคุกคามความปลอดภัยอื่น ๆ มีตัวเลือก plusplus ที่ห้ามการใช้งานของผู้ประกอบการเหล่านี้

ฉันรู้ว่า PHP สร้างเหมือน$foo[$bar++]มีได้อย่างง่ายดายอาจส่งผลกับการปิดโดยหนึ่งข้อผิดพลาด แต่ฉันไม่สามารถคิดออกวิธีที่ดีกว่าที่จะควบคุมห่วงกว่าที่หรือwhile( a < 10 ) do { /* foo */ a++; }for (var i=0; i<10; i++) { /* foo */ }

jslint เน้นที่ภาษานั้นเพราะมีบางภาษาที่คล้ายกันที่ไม่มีไวยากรณ์ " ++" และ " --" หรือจัดการแตกต่างกันหรือมีเหตุผลอื่น ๆ ที่จะหลีกเลี่ยง " ++" และ " --" ที่ฉันอาจหายไป?

มุมมองของฉันคือการใช้ ++ และ - ด้วยตัวเองในบรรทัดเดียวเสมอใน:

i++;
array[i] = foo;

แทน

array[++i] = foo;

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

ฉันสับสนตรงไปตรงมาโดยคำแนะนำนั้น ส่วนหนึ่งของฉันสงสัยว่ามันเกี่ยวข้องกับการขาดประสบการณ์ (การรับรู้หรือจริง) กับ javascript coders

ฉันเห็นได้ว่ามีใครบางคนแค่ "แฮ็ค" ในบางตัวอย่างโค้ดอาจทำผิดพลาดอย่างไร้เดียงสาด้วย ++ และ - แต่ฉันไม่เห็นว่าทำไมผู้เชี่ยวชาญที่มีประสบการณ์จะหลีกเลี่ยง

มีประวัติในการทำสิ่ง C เช่น:

while (*a++ = *b++);

เพื่อคัดลอกสตริงบางทีนี่อาจเป็นที่มาของกลอุบายที่มากเกินไปที่เขาอ้างถึง

และมีคำถามอะไรอยู่เสมอ

++i = i++;

หรือ

i = i++ + ++i;

ทำจริง มันถูกกำหนดในบางภาษาและในอีกภาษาหนึ่งไม่มีการรับประกันว่าจะเกิดอะไรขึ้น

ตัวอย่างเหล่านั้นกันฉันไม่คิดว่าจะมีอะไรที่แปลกไปกว่าลูปสำหรับ++การเพิ่มขึ้น ในบางกรณีคุณสามารถออกไปข้างหน้าด้วยการวนลูป foreach หรือในขณะที่การวนลูปที่ตรวจสอบ condtion ที่แตกต่างกัน แต่การบิดโค้ดของคุณเพื่อพยายามหลีกเลี่ยงการใช้การเพิ่มขึ้นนั้นน่าหัวเราะ

หากคุณอ่าน JavaScript The Good Parts คุณจะเห็นว่าการแทนที่ Crockford สำหรับ i ++ ใน a for loop คือ i + = 1 (ไม่ใช่ i = i + 1) นั่นสะอาดและอ่านง่ายและมีโอกาสน้อยที่จะแปรเปลี่ยนเป็นบางสิ่งที่ "ยุ่งยาก"

Crockford ไม่อนุญาตการเก็บข้อมูลอัตโนมัติและการเลือกสร้างอัตโนมัติใน jsLint คุณเลือกว่าจะทำตามคำแนะนำหรือไม่

กฎส่วนบุคคลของฉันคือการไม่ทำอะไรรวมกับการสร้างอัตโนมัติหรือการสร้างอัตโนมัติ

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

ดังนั้นสำหรับกฎของฉันเองการใช้ i ++ เป็นการเพิ่มใน a for loop นั้นใช้ได้

ในการวนซ้ำมันไม่เป็นอันตราย แต่ในคำสั่งการมอบหมายมันสามารถนำไปสู่ผลลัพธ์ที่ไม่คาดคิด:

var x = 5;
var y = x++; // y is now 5 and x is 6
var z = ++x; // z is now 7 and x is 7

ช่องว่างระหว่างตัวแปรและตัวดำเนินการสามารถนำไปสู่ผลลัพธ์ที่ไม่คาดคิดเช่นกัน:

a = b = c = 1; a ++ ; b -- ; c; console.log('a:', a, 'b:', b, 'c:', c)

ผลลัพธ์ที่ไม่คาดคิดอาจเป็นปัญหาเช่นกัน:

var foobar = function(i){var count = count || i; return function(){return count++;}}

baz = foobar(1);
baz(); //1
baz(); //2


var alphabeta = function(i){var count = count || i; return function(){return ++count;}}

omega = alphabeta(1);
omega(); //2
omega(); //3

และก่อให้เกิดการแทรกอัฒภาคอัตโนมัติหลังจากขึ้นบรรทัดใหม่:

var foo = 1, bar = 2, baz = 3, alpha = 4, beta = 5, delta = alpha
++beta; //delta is 4, alpha is 4, beta is 6

ความสับสนของการ preincrement / postincrement สามารถสร้างข้อผิดพลาดแบบหนึ่งต่อหนึ่งซึ่งยากต่อการวินิจฉัย โชคดีที่พวกเขายังไม่จำเป็นโดยสมบูรณ์ มีวิธีที่ดีกว่าในการเพิ่ม 1 ให้กับตัวแปร

อ้างอิง

• ความช่วยเหลือ JSLint: การเพิ่มและลดผู้ประกอบการ

พิจารณารหัสต่อไปนี้

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[i++] = i++;
    a[i++] = i++;
    a[i++] = i++;

เนื่องจาก i ++ ได้รับการประเมินสองครั้งผลลัพธ์คือ (จาก vs2005 ดีบักเกอร์)

    [0] 0   int
    [1] 0   int
    [2] 2   int
    [3] 0   int
    [4] 4   int

พิจารณารหัสต่อไปนี้:

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[++i] = ++i;
    a[++i] = ++i;
    a[++i] = ++i;

ขอให้สังเกตว่าการส่งออกเหมือนกัน ตอนนี้คุณอาจคิดว่า ++ i และ i ++ เหมือนกัน พวกเขาจะไม่

    [0] 0   int
    [1] 0   int
    [2] 2   int
    [3] 0   int
    [4] 4   int

ในที่สุดพิจารณารหัสนี้

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[++i] = i++;
    a[++i] = i++;
    a[++i] = i++;

ผลลัพธ์คือ:

    [0] 0   int
    [1] 1   int
    [2] 0   int
    [3] 3   int
    [4] 0   int
    [5] 5   int

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

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

ในมุมมองของฉัน"ชัดเจนกว่าดีกว่าเสมอ" y+ = x++ + ++yเพราะในบางจุดที่คุณอาจได้สับสนกับคำสั่งที่เพิ่มขึ้นนี้ โปรแกรมเมอร์ที่ดีจะทำให้โค้ดของเขาหรือเธออ่านง่ายขึ้น

เหตุผลที่สำคัญที่สุดสำหรับการหลีกเลี่ยง ++ หรือ - คือตัวดำเนินการคืนค่าและทำให้เกิดผลข้างเคียงในเวลาเดียวกันทำให้ยากที่จะให้เหตุผลเกี่ยวกับรหัส

เพื่อประโยชน์ของประสิทธิภาพฉันชอบ:

• ++ ฉันเมื่อไม่ได้ใช้ค่าส่งคืน (ไม่มีชั่วคราว)
• i ++เมื่อใช้ค่าส่งคืน (ไม่มีแผงลอยไปป์ไลน์)

ฉันเป็นแฟนตัวยงของ Mr. Crockford แต่ในกรณีนี้ฉันต้องไม่เห็นด้วย ++iข้อความที่มีการแยกวิเคราะห์น้อยกว่า 25% i+=1 และชัดเจนยิ่งขึ้น

ฉันเคยดูวิดีโอของ Douglas Crockford เกี่ยวกับเรื่องนี้และคำอธิบายของเขาที่ไม่ได้ใช้การเพิ่มและลดก็คือ

1. มันถูกนำมาใช้ในอดีตในภาษาอื่น ๆ เพื่อทำลายขอบเขตของอาร์เรย์และก่อให้เกิดมารยาทที่เลวร้ายและ
2. มันเป็นเรื่องที่สับสนและไม่มีประสบการณ์มากนักพัฒนา JS ไม่รู้ว่ามันทำอะไร

ประการแรกอาร์เรย์ใน JavaScript มีขนาดแบบไดนามิกและโปรดยกโทษให้ฉันถ้าฉันผิดฉันไม่สามารถทำลายขอบเขตของอาร์เรย์และข้อมูลการเข้าถึงที่ไม่ควรเข้าถึงได้โดยใช้วิธีนี้ใน JavaScript

ประการที่สองเราควรหลีกเลี่ยงสิ่งที่ซับซ้อนแน่นอนปัญหาไม่ใช่ว่าเรามีสิ่งอำนวยความสะดวกนี้ แต่ปัญหาคือมีนักพัฒนาออกมีที่อ้างว่าทำ JavaScript แต่ไม่รู้ว่าผู้ประกอบการเหล่านี้ทำงานอย่างไร? มันง่ายพอ value ++ ให้ค่าปัจจุบันกับฉันและหลังจากนิพจน์บวกหนึ่งค่าไปยังค่า ++ ให้เพิ่มค่าก่อนที่จะมอบให้ฉัน

นิพจน์เช่น a ++ + ++ b นั้นง่ายต่อการออกกำลังกายถ้าคุณจำข้างต้น

var a = 1, b = 1, c;
c = a ++ + ++ b;
// c = 1 + 2 = 3; 
// a = 2 (equals two after the expression is finished);
// b = 2;

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

Btw ฉันคิดว่า Douglas Crockford เป็นตำนานอยู่แล้ว แต่ฉันคิดว่าเขาสร้างความหวาดกลัวให้กับโอเปอเรเตอร์ที่ไม่สมควรได้รับมันมากมาย

ฉันมีชีวิตอยู่เพื่อพิสูจน์ว่าผิด ...

อีกตัวอย่างหนึ่งง่ายกว่าบางคนด้วยการคืนค่าที่เพิ่มขึ้นอย่างง่าย ๆ :

function testIncrement1(x) {
    return x++;
}

function testIncrement2(x) {
    return ++x;
}

function testIncrement3(x) {
    return x += 1;
}

console.log(testIncrement1(0)); // 0
console.log(testIncrement2(0)); // 1
console.log(testIncrement3(0)); // 1

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

function closureIncrementTest() {
    var x = 0;

    function postIncrementX() {
        return x++;
    }

    var y = postIncrementX();

    console.log(x); // 1
}

ฉันคิดว่าโปรแกรมเมอร์ควรมีความสามารถในภาษาที่ใช้ ใช้อย่างชัดเจน และใช้งานได้ดี ฉันไม่คิดว่าพวกเขาควรทำลายภาษาที่พวกเขาใช้ ฉันพูดจากประสบการณ์ ครั้งหนึ่งฉันเคยทำงานใกล้ ๆ กับร้าน Cobol ที่พวกเขาไม่ได้ใช้ ELSE เพราะมันซับซ้อนเกินไป Reductio ad absurdam

ดังที่กล่าวไว้ในบางคำตอบที่มีอยู่ (ซึ่งน่ารำคาญฉันไม่สามารถแสดงความคิดเห็นใน), ปัญหาคือ x ++ ++ x ประเมินค่าที่แตกต่างกัน (ก่อน vs หลังจากเพิ่มขึ้น) ซึ่งไม่ชัดเจนและอาจสับสนมาก - ถ้าใช้ค่านั้น cdmckay แนะนำให้ใช้ตัวดำเนินการเพิ่มอย่างชาญฉลาด แต่ในทางที่ไม่ได้ใช้ค่าที่ส่งคืนเช่นในบรรทัดของตัวเอง ฉันจะรวมถึงการใช้มาตรฐานภายในวงสำหรับ (แต่เฉพาะในคำสั่งที่สามซึ่งไม่ได้ใช้ค่าส่งคืน) ฉันไม่สามารถคิดถึงตัวอย่างอื่นได้ เมื่อถูก "เผา" ตัวเองฉันจะแนะนำแนวทางเดียวกันสำหรับภาษาอื่นเช่นกัน

ฉันไม่เห็นด้วยกับข้อเรียกร้องที่เกินความเข้มงวดนี้เนื่องจากโปรแกรมเมอร์ JS จำนวนมากไม่มีประสบการณ์ นี่คือการเขียนตามแบบฉบับของโปรแกรมเมอร์ "ฉลาดเกินเหตุ" และฉันแน่ใจว่ามันเป็นเรื่องธรรมดามากในภาษาดั้งเดิมมากขึ้นและกับนักพัฒนา JS ที่มีพื้นหลังในภาษาดังกล่าว

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

while ( a < 10 ){
    array[a++] = val
}

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

นอกจากนี้ Crockford ดูเหมือนว่าจะใช้ i- = 1 ซึ่งฉันคิดว่าอ่านยากกว่า --i หรือ i -

2cents ของฉันคือพวกเขาควรหลีกเลี่ยงในสองกรณี:

1) เมื่อคุณมีตัวแปรที่ใช้ในหลาย ๆ แถวและคุณเพิ่ม / ลดลงในคำสั่งแรกที่ใช้มัน (หรือสุดท้ายหรือแย่กว่านั้นคือตรงกลาง):

// It's Java, but applies to Js too
vi = list.get ( ++i );
vi1 = list.get ( i + 1 )
out.println ( "Processing values: " + vi + ", " + vi1 )
if ( i < list.size () - 1 ) ...

ในตัวอย่างเช่นนี้คุณสามารถพลาดได้ง่าย ๆ ว่าตัวแปรนั้นเพิ่มขึ้น / ลดลงโดยอัตโนมัติหรือแม้แต่ลบคำสั่งแรก กล่าวอีกนัยหนึ่งให้ใช้เฉพาะในบล็อกที่สั้นมากหรือตำแหน่งที่ตัวแปรปรากฏในบล็อกบนข้อความสั่งปิดสองสามข้อเท่านั้น

2) ในกรณีที่มีหลาย ++ และ - เกี่ยวกับตัวแปรเดียวกันในคำสั่งเดียวกัน มันยากมากที่จะจำสิ่งที่เกิดขึ้นในกรณีเช่นนี้:

result = ( ++x - --x ) * x++;

การสอบและการทดสอบระดับมืออาชีพถามเกี่ยวกับตัวอย่างเช่นด้านบนและแน่นอนฉันได้พบกับคำถามนี้ในขณะที่มองหาเอกสารเกี่ยวกับหนึ่งในนั้น แต่ในชีวิตจริงหนึ่งไม่ควรถูกบังคับให้คิดมากเกี่ยวกับรหัสบรรทัดเดียว

Fortran เป็นภาษา C หรือไม่ มันไม่มีทั้ง ++ และ - นี่คือวิธีที่คุณเขียนลูป :

     integer i, n, sum

      sum = 0
      do 10 i = 1, n
         sum = sum + i
         write(*,*) 'i =', i
         write(*,*) 'sum =', sum
  10  continue

องค์ประกอบดัชนีiถูกเพิ่มค่าโดยกฎภาษาในแต่ละครั้งที่วนซ้ำ หากคุณต้องการเพิ่มด้วยค่าอื่นที่ไม่ใช่ 1 ให้นับถอยหลังเป็นสองตัวอย่างเช่นไวยากรณ์คือ ...

      integer i

      do 20 i = 10, 1, -2
         write(*,*) 'i =', i
  20  continue

Python C เป็นแบบไหน? มันใช้ช่วงและรายการความเข้าใจและไวยากรณ์อื่น ๆ เพื่อหลีกเลี่ยงความจำเป็นในการเพิ่มดัชนี:

print range(10,1,-2) # prints [10,8.6.4.2]
[x*x for x in range(1,10)] # returns [1,4,9,16 ... ]

ดังนั้นจากการสำรวจขั้นพื้นฐานของทางเลือกสองทางนี้นักออกแบบภาษาอาจหลีกเลี่ยง ++ และ - โดยการคาดการณ์กรณีการใช้งานและการจัดเตรียมไวยากรณ์ทางเลือก

Fortran และ Python มีข้อผิดพลาดน้อยกว่าภาษาเชิงโพรซีเดอร์ที่มี ++ และ - หรือไม่? ฉันไม่มีหลักฐาน

ฉันอ้างว่า Fortran และ Python เหมือน C เพราะฉันไม่เคยพบใครบางคนใน C ที่ไม่สามารถแม่นยำ 90% เดาได้อย่างถูกต้องว่าเจตนาของ Fortran หรือ Python ที่ไม่ทำให้สับสน