สไตล์ JavaScript สำหรับการโทรกลับที่เป็นทางเลือก

ฉันมีฟังก์ชั่นบางอย่างซึ่งบางครั้ง (ไม่เสมอไป) จะได้รับการติดต่อกลับและเรียกใช้ กำลังตรวจสอบว่าการเรียกกลับถูกกำหนด / ฟังก์ชั่นสไตล์ที่ดีหรือมีวิธีที่ดีกว่านี้หรือไม่?

ตัวอย่าง:

function save (callback){
   .....do stuff......
   if(typeof callback !== 'undefined'){
     callback();
   };
};

ฉันชอบเป็นการส่วนตัว

typeof callback === 'function' && callback();

อย่างไรก็ตามtypeofคำสั่งนั้นหลบและควรใช้สำหรับ"undefined"และเท่านั้น"function"

ปัญหาที่เกิดขึ้นtypeof !== undefinedคือผู้ใช้อาจส่งผ่านค่าที่กำหนดไม่ใช่ฟังก์ชัน

คุณยังสามารถทำ:

var noop = function(){}; // do nothing.

function save (callback){
   callback = callback || noop;
   .....do stuff......
};

เป็นประโยชน์อย่างยิ่งหากคุณใช้callbackสถานที่ไม่กี่แห่ง

นอกจากนี้หากคุณใช้jQueryงานอยู่คุณมีฟังก์ชันเช่นนั้นอยู่แล้วเรียกว่า$ .noop

เพียงแค่ทำ

if (callback) callback();

ฉันชอบที่จะโทรกลับหากให้มาไม่ว่าจะเป็นประเภทใดก็ตาม อย่าปล่อยให้มันล้มเหลวโดยเงียบดังนั้นผู้ปฏิบัติจะรู้ว่าเขาส่งผ่านข้อโต้แย้งที่ไม่ถูกต้องและสามารถแก้ไขได้

ECMAScript 6

// @param callback Default value is a noop fn.
function save(callback = ()=>{}) {
   // do stuff...
   callback();
}

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

const identity = x =>
  x

const save (..., callback = identity) {
  // ...
  return callback (...)
}

เมื่อใช้

save (...)              // callback has no effect
save (..., console.log) // console.log is used as callback

สไตล์ดังกล่าวเรียกว่าสไตล์การส่งต่อ นี่คือตัวอย่างจริงcombinationsที่สร้างชุดค่าผสมที่เป็นไปได้ทั้งหมดของอินพุต Array

const identity = x =>
  x

const None =
  Symbol ()

const combinations = ([ x = None, ...rest ], callback = identity) =>
  x === None
    ? callback ([[]])
    : combinations
        ( rest
        , combs =>
            callback (combs .concat (combs .map (c => [ x, ...c ])))
        )

console.log (combinations (['A', 'B', 'C']))
// [ []
// , [ 'C' ]
// , [ 'B' ]
// , [ 'B', 'C' ]
// , [ 'A' ]
// , [ 'A', 'C' ]
// , [ 'A', 'B' ]
// , [ 'A', 'B', 'C' ]
// ]

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

combinations (['A', 'B', 'C'], console.log)
// [ []
// , [ 'C' ]
// , [ 'B' ]
// , [ 'B', 'C' ]
// , [ 'A' ]
// , [ 'A', 'C' ]
// , [ 'A', 'B' ]
// , [ 'A', 'B', 'C' ]
// ]

นอกจากนี้เรายังสามารถส่งต่อแบบกำหนดเองที่ทำอย่างอื่นกับผลลัพธ์

console.log (combinations (['A', 'B', 'C'], combs => combs.length))
// 8
// (8 total combinations)

รูปแบบการส่งต่อสามารถใช้ได้กับผลลัพธ์ที่สวยงามอย่างน่าประหลาดใจ

const first = (x, y) =>
  x

const fibonacci = (n, callback = first) =>
  n === 0
    ? callback (0, 1)
    : fibonacci
        ( n - 1
        , (a, b) => callback (b, a + b)
        )
        
console.log (fibonacci (10)) // 55
// 55 is the 10th fibonacci number
// (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...)

ฉันเบื่อมากที่เห็นตัวอย่างข้อมูลเดิมซ้ำแล้วซ้ำอีกที่ฉันเขียนสิ่งนี้:

  var cb = function(g) {
    if (g) {
      var args = Array.prototype.slice.call(arguments); 
      args.shift(); 
      g.apply(null, args); 
    }
  };

ฉันมีฟังก์ชั่นนับร้อยที่ทำสิ่งต่างๆเช่น

  cb(callback, { error : null }, [0, 3, 5], true);

หรืออะไรก็ได้ ...

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

ฟังก์ชันที่ถูกต้องขึ้นอยู่กับต้นแบบของฟังก์ชันใช้:

if (callback instanceof Function)

เพื่อให้แน่ใจว่าการโทรกลับเป็นฟังก์ชัน

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

ฉันได้ย้ายไปที่ coffee-script แล้วและพบว่าอาร์กิวเมนต์เริ่มต้นเป็นวิธีที่ดีในการแก้ปัญหานี้

doSomething = (arg1, arg2, callback = ()->)->
    callback()

สามารถทำได้อย่างง่ายดายด้วยArgueJS :

function save (){
  arguments = __({callback: [Function]})
.....do stuff......
  if(arguments.callback){
    callback();
  };
};