อนุสัญญา JavaScript สำหรับไม่มีการดำเนินการคืออะไร? เช่นเดียวกับpassคำสั่งPython

• ทางเลือกหนึ่งเป็นเพียงฟังก์ชันเปล่า: function() {}
• jQuery เสนอ$.noop()ซึ่งเรียกใช้ฟังก์ชันว่างด้านบน
• เป็นที่ยอมรับได้falseหรือ0ไม่เพียงแค่ป้อนค่าหรือ?

ในบริบท ... ทั้งหมดนี้ทำงานได้โดยไม่มีข้อผิดพลาดใน Chrome:

var a = 2;
(a === 1) ? alert(1) : function() {};
(a === 1) ? alert(1) : $.noop();
(a === 1) ? alert(1) : false;
(a === 1) ? alert(1) : 0;

แก้ไข: ผู้คนจำนวนมากตอบว่า "อย่าทำแบบนี้! เปลี่ยนโครงสร้างโค้ด!" นี่ทำให้ฉันนึกถึงโพสต์ที่มีคนถามว่าจะดมเบราว์เซอร์ได้อย่างไร เขาได้รับการเขื่อนกั้นน้ำของการโพสต์บอกว่า "ไม่ทำอย่างนั้นมันชั่วร้าย" แต่ไม่มีใครบอกเขาถึงวิธีการสูดอากาศเบราว์เซอร์ นี่ไม่ใช่การตรวจสอบโค้ด ลองนึกภาพว่าคุณกำลังจัดการกับรหัสเดิมที่ไม่สามารถเปลี่ยนแปลงได้และหากไม่มีฟังก์ชันบางอย่างที่ส่งผ่านเข้ามาก็จะทำให้เกิดข้อผิดพลาด หรือเพียงแค่ว่าเป็นวิธีการที่ลูกค้าต้องการมันและพวกเขาจะจ่ายเงินให้ฉัน ดังนั้นโปรดตอบคำถาม : วิธีใดที่ดีที่สุดในการระบุฟังก์ชัน "no operation" ใน JavaScript

EDIT2: แล้วหนึ่งในนั้นล่ะ?

true;
false;
0;
1;
null;

เพื่อที่จะตอบคำถามเดิม, การดำเนินงานที่หรูหราที่สุดและเรียบร้อยของฟังก์ชัน noop ใน Javascript บริสุทธิ์ (ในขณะที่ยังมีการกล่าวถึงที่นี่ ) เป็นFunction.prototype นี้เป็นเพราะ:

1. Function.prototype คือฟังก์ชัน:

typeof Function.prototype === "function" // returns true

2. สามารถเรียกใช้เป็นฟังก์ชันได้และโดยพื้นฐานแล้วจะไม่ทำอะไรเลยดังที่แสดงไว้ที่นี่:

setTimeout(function() {
      console.log('Start: ', Date.now());
      Function.prototype();
      console.log('End  : ', Date.now());
    }, 1000);

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

อย่างไรก็ตามดังที่กล่าวมาคุณสามารถกำหนดฟังก์ชัน noop ของคุณเองได้อย่างง่ายดายและ infact ไลบรารีและเฟรมเวิร์กจำนวนมากยังมีฟังก์ชัน noop ด้านล่างนี้เป็นตัวอย่างบางส่วน:

var noop = function () {};           // Define your own noop in ES3 or ES5
const noop = () => {};               // Define in ES6 as Lambda (arrow function)
setTimeout(noop, 10000);             // Using the predefined noop

setTimeout(function () {} , 10000);  // Using directly in ES3 or ES5
setTimeout(() => {} , 10000);        // Using directly in ES6 as Lambda (arrow function)

setTimeout(angular.noop, 10000);     // Using with AngularJS 1.x
setTimeout(jQuery.noop, 10000);      // Using with jQuery

นี่คือรายการตามตัวอักษรของการใช้งานฟังก์ชัน noop ต่างๆ (หรือการอภิปรายที่เกี่ยวข้องหรือการค้นหาโดย Google):

AngularJS 1.x , Angular 2+ (ดูเหมือนจะไม่มีการใช้งานแบบเนทีฟ - ใช้ของคุณเองตามที่แสดงด้านบน), Ember , jQuery , Lodash , NodeJS , Ramda , React (ดูเหมือนจะไม่มีการใช้งานแบบเนทีฟ - ใช้ของคุณเอง ตามที่แสดงด้านบน), RxJS , ขีดล่าง

บรรทัดด้านล่าง : แม้ว่า Function.prototype จะเป็นวิธีที่สวยงามในการแสดง noop ใน Javascript แต่อาจมีปัญหาด้านประสิทธิภาพที่เกี่ยวข้องกับการใช้งาน ดังนั้นคุณสามารถกำหนดและใช้ของคุณเอง (ตามที่แสดงด้านบน) หรือใช้อันที่กำหนดโดยไลบรารี / เฟรมเวิร์กที่คุณอาจใช้ในโค้ดของคุณ

รัดกุมมากที่สุดและ noop performant เป็นฟังก์ชั่นลูกศรที่ว่างเปล่า()=>{} :

ฟังก์ชัน Arrowทำงานได้ในทุกเบราว์เซอร์ยกเว้น IE (มีการแปลง Babelหากคุณต้องการ):

()=>{} เมื่อเทียบกับ Function.Prototype

• ()=>{}เป็น87% เร็วกว่าFunction.prototypeใน Chrome 67
• ()=>{}เป็น25% เร็วกว่าFunction.prototypeใน Firefox 60
• ()=>{}เป็น85% เร็วกว่าFunction.prototypeในขอบ(2018/06/15)
• ()=>{}เป็น65% โค้ดน้อยFunction.prototypeกว่า

การทดสอบด้านล่างจะร้อนขึ้นโดยใช้ฟังก์ชันลูกศรเพื่อให้ความลำเอียงFunction.prototypeแต่ฟังก์ชันลูกศรเป็นผู้ชนะที่ชัดเจน:

const noop = ()=>{};
const noopProto = Function.prototype;

function test (_noop, iterations) {
    const before = performance.now();
    for(let i = 0; i < iterations; i++) _noop();
    const after = performance.now();
    const elapsed = after - before;
    console.info(`${elapsed.toFixed(4)}MS\t${_noop.toString().replace('\n', '')}\tISNOOP? ${_noop() === undefined}`);
    return elapsed;
}

const iterations = 10000000
console.info(`noop time for ${iterations.toLocaleString()} iterations`)
const timings = {
    noop: test(noop, iterations),
    noopProto: test(noopProto, iterations)
}

const percentFaster = ((timings.noopProto - timings.noop)/timings.noopProto).toLocaleString("en-us", { style: "percent" });
console.info(`()=>{} is ${percentFaster} faster than Function.prototype in the current browser!`)

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

ไม่มีคำแนะนำของคุณให้ทำ:

var a = 2;
if (a === 1)
    alert(1)
// else do nothing!

จากนั้นโค้ดจะเข้าใจง่ายอ่านได้และมีประสิทธิภาพมากที่สุดเท่าที่จะทำได้

ทำไมต้องทำให้ยากขึ้นในเมื่อมันเป็นเรื่องง่าย

แก้ไข:

ถ้าอย่างนั้นคำสั่ง "no-operation" โดยพื้นฐานแล้วบ่งบอกถึงโครงสร้างโค้ดที่ด้อยกว่าหรือไม่?

คุณไม่มีประเด็นของฉัน ทั้งหมดข้างต้นเกี่ยวกับนิพจน์ด้านx ? y : zบน

แต่คำสั่ง no operation ไม่สมเหตุสมผลในภาษาระดับสูงกว่าเช่น Javascript

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

ใน JS ไม่ว่าคุณจะทำอย่างไร0;, null;, function () {};หรือคำว่างมีโอกาสที่ดีที่จะได้รับการปฏิเสธโดย interpretor เมื่อมีการอ่านมัน แต่ก่อนที่จะได้รับการตีความดังนั้นในท้ายที่สุดคุณก็จะทำให้โปรแกรมของคุณจะ โหลดช้าลงโดยใช้เวลาเพียงเล็กน้อย Nota Bene : ฉันสมมติว่าฉันไม่ได้เกี่ยวข้องกับล่าม JS ที่ใช้กันอย่างแพร่หลายและมีโอกาสที่ล่ามแต่ละคนจะมีกลยุทธ์ของตัวเอง

ในกรณีที่คุณใช้สิ่งที่ซับซ้อนกว่านี้เล็กน้อยเช่น$.noop()หรือvar foo = function () {}; foo()ล่ามอาจเรียกใช้ฟังก์ชันที่ไม่เป็นประโยชน์ซึ่งจะทำให้สแต็กฟังก์ชันของคุณเสียหายไม่กี่ไบต์และไม่กี่รอบ

เหตุผลเดียวที่ฉันเห็นว่ามีฟังก์ชันเช่น$.noop()จะมีอยู่คือยังคงสามารถให้ฟังก์ชันการโทรกลับให้กับฟังก์ชันเหตุการณ์บางอย่างที่จะทำให้เกิดข้อยกเว้นหากไม่สามารถเรียกใช้การเรียกกลับนั้นได้ แต่ถ้าอย่างนั้นมันจำเป็นต้องเป็นฟังก์ชันที่คุณต้องให้และการnoopตั้งชื่อนั้นเป็นความคิดที่ดีดังนั้นคุณจึงบอกผู้อ่านของคุณ (และนั่นอาจเป็นคุณใน 6 เดือน) ว่าคุณตั้งใจให้ฟังก์ชันว่างเปล่า

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

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

ฉันคิดว่า jQuery noop()ส่วนใหญ่มีไว้เพื่อป้องกันไม่ให้โค้ดหยุดทำงานโดยให้ฟังก์ชันเริ่มต้นเมื่อไม่มีการร้องขอ ตัวอย่างเช่นเมื่อพิจารณาจากตัวอย่างโค้ดต่อไปนี้$.noopจะถูกเลือกหากfakeFunctionไม่ได้กำหนดไว้เพื่อป้องกันไม่ให้การเรียกครั้งถัดไปfnหยุดทำงาน:

var fn = fakeFunction || $.noop;
fn() // no crash

จากนั้นnoop()อนุญาตให้บันทึกหน่วยความจำโดยหลีกเลี่ยงการเขียนฟังก์ชันว่างเดียวกันหลาย ๆ ครั้งทุกที่ในโค้ดของคุณ อย่างไรก็ตาม$.noopนั้นสั้นกว่าเล็กน้อยfunction(){}(6 ไบต์ที่บันทึกต่อโทเค็น) ดังนั้นจึงไม่มีความสัมพันธ์ระหว่างรหัสของคุณกับรูปแบบฟังก์ชันว่าง การใช้งานnull, falseหรือ0หากคุณต้องการในกรณีของคุณจะมีผลข้างเคียงใด ๆ นอกจากนี้เป็นที่น่าสังเกตว่ารหัสนี้ ...

true/false ? alert('boo') : function(){};

... ไม่มีประโยชน์เลยเพราะคุณจะไม่เรียกใช้ฟังก์ชันนี้และอันนี้ ...

true/false ? alert('boo') : $.noop();

... ก็ยิ่งไร้ประโยชน์เมื่อคุณเรียกใช้ฟังก์ชันว่างซึ่งเหมือนกับ ...

true/false ? alert('boo') : undefined;

ลองแทนที่นิพจน์ด้านท้ายด้วยifคำสั่งเพื่อดูว่ามันไร้ประโยชน์มากแค่ไหน:

if (true/false) {
    alert('boo');
} else {
    $.noop(); // returns undefined which goes nowhere
}

คุณสามารถเขียน:

if (true/false) alert('boo');

หรือสั้นกว่านั้น:

true/false && alert('boo');

เพื่อตอบคำถามของคุณในที่สุดฉันเดาว่า "การไม่ดำเนินการแบบเดิม" คือสิ่งที่ไม่เคยเขียน

ฉันใช้:

 (0); // nop

ในการทดสอบเวลาดำเนินการของการรันนี้เป็น:

console.time("mark");
(0); // nop
console.timeEnd("mark");

ผลลัพธ์: เครื่องหมาย: 0.000ms

ใช้Boolean( 10 > 9)สามารถลดลงไปเพียงซึ่งผลตอบแทน( 10 > 9) trueมาพร้อมกับแนวคิดที่จะใช้ตัวถูกดำเนินการตัวเดียวที่ฉันคาดหวังไว้อย่างเต็มที่ว่า(0);จะกลับมาfalseแต่จะส่งคืนอาร์กิวเมนต์กลับตามที่ตรวจสอบได้โดยทำการทดสอบนี้ที่คอนโซล

> var a = (0);
< undefined
> a
< 0

มีอย่างไม่มีปัญหาหรือประสิทธิภาพของการใช้โทษมากกว่าFunction.prototype() => {}

ประโยชน์หลักของFunction.prototypeการมีฟังก์ชันซิงเกิลตันแทนที่จะกำหนดฟังก์ชันใหม่ที่ไม่ระบุตัวตนในแต่ละครั้ง สิ่งสำคัญอย่างยิ่งที่จะต้องใช้ no-op เช่นFunction.prototypeเมื่อกำหนดค่าเริ่มต้นและบันทึกช่วยจำเนื่องจากจะให้ตัวชี้วัตถุที่สอดคล้องกันซึ่งไม่มีวันเปลี่ยนแปลง

เหตุผลที่ฉันแนะนำFunction.prototypeมากกว่าFunctionเป็นเพราะมันไม่เหมือนกัน:

Function() === Function()
// false

Function.prototype() === Function.prototype()
// true

นอกจากนี้มาตรฐานจากคำตอบอื่น ๆ จะทำให้เข้าใจผิด ในความเป็นจริงFunction.prototypeทำงานได้เร็วกว่า() => {}ขึ้นอยู่กับว่าคุณเขียนและเรียกใช้เกณฑ์มาตรฐานอย่างไร:

คุณไม่สามารถเชื่อถือ JS Benchmarks << โดยเฉพาะการเรียกใช้ Benchmarks สำหรับคำถามนี้

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