ฉันจะบอกได้อย่างไรว่าวัตถุคือสัญญา?

ไม่ว่าจะเป็นสัญญา ES6 หรือสัญญา Bluebird สัญญา Q ฯลฯ

ฉันจะทดสอบเพื่อดูว่าวัตถุที่ระบุเป็นสัญญาได้อย่างไร

วิธีการตัดสินใจของห้องสมุดสัญญา

ถ้ามันมี.thenฟังก์ชั่น - นั่นเป็นเพียงห้องสมุดสัญญามาตรฐานเท่านั้นที่ใช้

ข้อมูลจำเพาะสัญญา / A + มีความคิดที่เรียกว่าthenซึ่งโดยพื้นฐานแล้วคือ "วัตถุที่มีthenวิธีการ" สัญญาจะและควรดูดซึมสิ่งใดด้วยวิธีการนั้น การดำเนินการตามสัญญาทั้งหมดที่คุณกล่าวถึงทำเช่นนี้

ถ้าเราดูข้อมูลจำเพาะ :

2.3.3.3 ถ้าthenเป็นฟังก์ชั่นให้เรียกมันด้วย x ว่านี่คืออาร์กิวเมนต์แรก

นอกจากนี้ยังอธิบายถึงเหตุผลสำหรับการตัดสินใจออกแบบนี้:

การรักษานี้thenAbles ช่วยให้การใช้งานที่สัญญาว่าจะทำงานร่วมกันได้ตราบใดที่พวกเขาเปิดเผยสัญญา / A + เข้ากันthenวิธีการ นอกจากนี้ยังอนุญาตให้การใช้งานสัญญา / A + สามารถใช้งาน“ ดูดซับ” การดำเนินการที่ไม่เป็นไปตามข้อกำหนดด้วยวิธีการที่สมเหตุสมผลแล้ว

คุณควรตัดสินใจอย่างไร

คุณไม่ควร - แทนโทรPromise.resolve(x)( Q(x)ใน Q) ที่จะเสมอแปลงค่าใด ๆ หรือภายนอกthenสามารถเข้าไปในสัญญาที่เชื่อถือได้ ปลอดภัยกว่าและง่ายกว่าการตรวจสอบด้วยตนเอง

จริงๆต้องให้แน่ใจ?

คุณสามารถเรียกใช้ผ่านชุดทดสอบ : D

ตรวจสอบว่าสิ่งที่สัญญาว่าจะซับซ้อนรหัสโดยไม่จำเป็นเพียงแค่ใช้ Promise.resolve

Promise.resolve(valueOrPromiseItDoesntMatter).then(function(value) {

})

นี่คือคำตอบดั้งเดิมของฉันซึ่งได้รับการยอมรับในสเป็คเป็นวิธีการทดสอบสำหรับสัญญา:

Promise.resolve(obj) == obj

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

ฉันมีคำตอบอื่นที่นี่ซึ่งเคยพูดแบบนี้ แต่ฉันเปลี่ยนเป็นอย่างอื่นเมื่อมันไม่ได้ทำงานกับ Safari ในเวลานั้น นั่นเป็นปีที่แล้วและตอนนี้ทำงานได้อย่างน่าเชื่อถือแม้ใน Safari

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

อัปเดต:นี่ไม่ใช่คำตอบที่ดีที่สุดอีกต่อไป โปรดโหวตคำตอบอื่น ๆ ของฉันแทน

obj instanceof Promise

ควรทำมัน โปรดทราบว่าสิ่งนี้อาจทำงานได้อย่างน่าเชื่อถือกับสัญญา es6 แบบดั้งเดิมเท่านั้น

หากคุณใช้ shim, ห้องสมุดสัญญาหรือสิ่งอื่นใดที่อ้างว่าเป็นเหมือนสัญญาคุณควรทดสอบคำว่า "แล้ว" (อะไรก็ได้ที่มี.thenวิธีการ) ดังที่แสดงไว้ในคำตอบอื่น ๆ ที่นี่

if (typeof thing.then === 'function') {
    // probably a promise
} else {
    // definitely not a promise
}

เพื่อดูว่าวัตถุที่ให้ไว้เป็นสัญญา ES6เราสามารถใช้ภาคแสดงนี้ได้หรือไม่:

function isPromise(p) {
  return p && Object.prototype.toString.call(p) === "[object Promise]";
}

Callไอเอ็นจีtoStringโดยตรงจากObject.prototypeผลตอบแทนที่เป็นตัวแทนสตริงพื้นเมืองของประเภทวัตถุที่กำหนดซึ่งเป็น"[object Promise]"ในกรณีของเรา สิ่งนี้ทำให้มั่นใจได้ว่าวัตถุที่กำหนด

• ข้ามบวกเท็จเช่น .. :
  • ประเภทวัตถุที่กำหนดเองที่มีชื่อตัวสร้างเดียวกัน ("สัญญา")
  • toStringวิธีการเขียนด้วยตนเองของวัตถุที่กำหนด
• สามารถทำงานได้ทั้งบริบทสภาพแวดล้อมหลาย ๆ (เช่น iframes) ในทางตรงกันข้ามกับinstanceofisPrototypeOfหรือ

อย่างไรก็ตามวัตถุโฮสต์ใด ๆที่มีการแก้ไขแท็กผ่านSymbol.toStringTagสามารถส่งคืน"[object Promise]"ได้ นี่อาจเป็นผลลัพธ์ที่ตั้งใจหรือไม่ขึ้นอยู่กับโครงการ (เช่นหากมีการใช้งานสัญญาแบบกำหนดเอง)

เพื่อดูว่าวัตถุนั้นมาจากสัญญา ES6 แบบดั้งเดิมเราสามารถใช้:

function isNativePromise(p) {
  return p && typeof p.constructor === "function"
    && Function.prototype.toString.call(p.constructor).replace(/\(.*\)/, "()")
    === Function.prototype.toString.call(/*native object*/Function)
      .replace("Function", "Promise") // replacing Identifier
      .replace(/\(.*\)/, "()"); // removing possible FormalParameterList 
}

ตามนี้และส่วนนี้ของสเปคที่เป็นตัวแทนสตริงของฟังก์ชั่นที่ควรจะเป็น:

"ฟังก์ชั่นตัวระบุ (การ_{เลือก} FormalParameterList ) { FunctionBody }"

ซึ่งจัดการตามข้างต้น FunctionBodyเป็น[native code]เบราว์เซอร์ที่สำคัญทั้งหมด

MDN: Function.prototype.toString

สิ่งนี้สามารถทำงานได้ในสภาพแวดล้อมที่หลากหลายเช่นกัน

ไม่ใช่คำตอบสำหรับคำถามเต็ม แต่ฉันคิดว่ามันมีค่าที่จะกล่าวถึงใน Node.js 10 ฟังก์ชั่น util ใหม่ที่เรียกว่าisPromiseถูกเพิ่มเข้ามาซึ่งจะตรวจสอบว่าวัตถุนั้นเป็น Native Promise หรือไม่:

const utilTypes = require('util').types
const b_Promise = require('bluebird')

utilTypes.isPromise(Promise.resolve(5)) // true
utilTypes.isPromise(b_Promise.resolve(5)) // false

นี่คือวิธีที่แพ็คเกจ Graphql-jsตรวจพบสัญญา:

function isPromise(value) {
  return Boolean(value && typeof value.then === 'function');
}

valueคือค่าที่ส่งคืนของฟังก์ชันของคุณ ฉันใช้รหัสนี้ในโครงการของฉันและไม่มีปัญหาจนถึงตอนนี้

นี่คือรูปแบบรหัสhttps://github.com/ssnau/xkit/blob/master/util/is-promise.js

!!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';

ถ้าวัตถุมีวิธีการก็ควรจะรักษาเป็นthenPromise

ในกรณีที่คุณใช้typescriptฉันต้องการเพิ่มว่าคุณสามารถใช้คุณสมบัติ "พิมพ์ภาค" เพียง แต่ควรรวมการตรวจสอบตรรกะในฟังก์ชันที่ส่งคืนx is Promise<any>และคุณไม่จำเป็นต้องพิมพ์ตัวอักษร ด้านล่างในตัวอย่างของฉันcเป็นสัญญาหรือหนึ่งในประเภทของฉันที่ฉันต้องการแปลงเป็นสัญญาโดยเรียกc.fetch()วิธีการ

export function toPromise(c: Container<any> | Promise<any>): Promise<any> {
    if (c == null) return Promise.resolve();
    return isContainer(c) ? c.fetch() : c;
}

export function isContainer(val: Container<any> | Promise<any>): val is Container<any> {
    return val && (<Container<any>>val).fetch !== undefined;
}

export function isPromise(val: Container<any> | Promise<any>): val is Promise<any> {
    return val && (<Promise<any>>val).then !== undefined;
}

ข้อมูลเพิ่มเติม: https://www.typescriptlang.org/docs/handbook/advanced-types.html

หากคุณอยู่ในวิธีการซิงค์คุณสามารถทำได้และหลีกเลี่ยงความคลุมเครือใด ๆ

async myMethod(promiseOrNot){
  const theValue = await promiseOrNot()
}

หากฟังก์ชันส่งคืนสัญญาจะรอและส่งคืนพร้อมค่าที่แก้ไข หากฟังก์ชั่นส่งกลับค่ามันจะได้รับการปฏิบัติตามที่ได้รับการแก้ไข

หากฟังก์ชันไม่ส่งคืนสัญญาวันนี้ แต่พรุ่งนี้ส่งคืนหนึ่งสัญญาหรือมีการประกาศเป็นอะซิงก์คุณจะได้รับการพิสูจน์ในอนาคต

it('should return a promise', function() {
    var result = testedFunctionThatReturnsPromise();
    expect(result).toBeDefined();
    // 3 slightly different ways of verifying a promise
    expect(typeof result.then).toBe('function');
    expect(result instanceof Promise).toBe(true);
    expect(result).toBe(Promise.resolve(result));
});

ฉันใช้ฟังก์ชั่นนี้เป็นวิธีแก้ปัญหาสากล:

function isPromise(value) {
  return value && value.then && typeof value.then === 'function';
}

หลังจากค้นหาวิธีที่เชื่อถือได้ในการตรวจสอบฟังก์ชั่นAsyncหรือแม้กระทั่งสัญญาฉันก็ลงเอยด้วยการทดสอบต่อไปนี้:

() => fn.constructor.name === 'Promise' || fn.constructor.name === 'AsyncFunction'

ES6:

const promise = new Promise(resolve => resolve('olá'));

console.log(promise.toString().includes('Promise')); //true