fast json stringify

รวดเร็ว-json-stringify

fast-json-stringify นั้นเร็วกว่า JSON.stringify() อย่างมากสำหรับเพย์โหลดขนาดเล็ก ความได้เปรียบด้านประสิทธิภาพจะลดลงเมื่อเพย์โหลดของคุณเพิ่มขึ้น มันเข้ากันได้ดีกับ flatstr ซึ่งทริกเกอร์การปรับให้เหมาะสม V8 ซึ่งปรับปรุงประสิทธิภาพเมื่อแปลงสตริงเป็น Buffer ในที่สุด

มันทำงานอย่างไร

fast-json-stringify ต้องใช้อินพุต JSON Schema Draft 7 เพื่อสร้างฟังก์ชัน stringify ที่รวดเร็ว

เกณฑ์มาตรฐาน

• เครื่อง: EX41S-SSD, Intel Core i7, 4Ghz, 64GB RAM, 4C/8T, SSD
• โหนด js เวอร์ชัน v18.12.1

 FJS creation x 4,129 ops/sec ±0.82% (92 runs sampled)
CJS creation x 184,196 ops/sec ±0.12% (97 runs sampled)
AJV Serialize creation x 61,130,591 ops/sec ±0.40% (92 runs sampled)
JSON.stringify array x 5,057 ops/sec ±0.10% (100 runs sampled)
fast-json-stringify array default x 6,243 ops/sec ±0.14% (98 runs sampled)
fast-json-stringify array json-stringify x 6,261 ops/sec ±0.30% (99 runs sampled)
compile-json-stringify array x 6,842 ops/sec ±0.18% (96 runs sampled)
AJV Serialize array x 6,964 ops/sec ±0.11% (95 runs sampled)
JSON.stringify large array x 248 ops/sec ±0.07% (90 runs sampled)
fast-json-stringify large array default x 99.96 ops/sec ±0.22% (74 runs sampled)
fast-json-stringify large array json-stringify x 248 ops/sec ±0.07% (90 runs sampled)
compile-json-stringify large array x 317 ops/sec ±0.09% (89 runs sampled)
AJV Serialize large array x 111 ops/sec ±0.07% (33 runs sampled)
JSON.stringify long string x 16,002 ops/sec ±0.09% (98 runs sampled)
fast-json-stringify long string x 15,979 ops/sec ±0.09% (96 runs sampled)
compile-json-stringify long string x 15,952 ops/sec ±0.31% (97 runs sampled)
AJV Serialize long string x 21,416 ops/sec ±0.08% (98 runs sampled)
JSON.stringify short string x 12,944,272 ops/sec ±0.09% (96 runs sampled)
fast-json-stringify short string x 30,585,790 ops/sec ±0.27% (97 runs sampled)
compile-json-stringify short string x 30,656,406 ops/sec ±0.12% (96 runs sampled)
AJV Serialize short string x 30,406,785 ops/sec ±0.37% (96 runs sampled)
JSON.stringify obj x 3,153,043 ops/sec ±0.33% (99 runs sampled)
fast-json-stringify obj x 6,866,434 ops/sec ±0.11% (100 runs sampled)
compile-json-stringify obj x 15,886,723 ops/sec ±0.15% (98 runs sampled)
AJV Serialize obj x 8,969,043 ops/sec ±0.36% (97 runs sampled)
JSON stringify date x 1,126,547 ops/sec ±0.09% (97 runs sampled)
fast-json-stringify date format x 1,836,188 ops/sec ±0.12% (99 runs sampled)
compile-json-stringify date format x 1,125,735 ops/sec ±0.19% (98 runs sampled)

สารบัญ:

• Example
• Options
• API
• fastJsonStringify
• Specific use cases
• Required
• Missing fields
• Pattern Properties
• Additional Properties
• AnyOf และ OneOf
• Reuse - $ref
• Long integers
• Integers
• Nullable
• Large Arrays
• Security Notice
• Debug Mode
• Standalone Mode
• Acknowledgements
• License

ลองใช้ RunKit: https://runkit.com/npm/fast-json-stringify

ตัวอย่าง

 const fastJson = require ( 'fast-json-stringify' )
const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    firstName : {
      type : 'string'
    } ,
    lastName : {
      type : 'string'
    } ,
    age : {
      description : 'Age in years' ,
      type : 'integer'
    } ,
    reg : {
      type : 'string'
    }
  }
} )

console . log ( stringify ( {
  firstName : 'Matteo' ,
  lastName : 'Collina' ,
  age : 32 ,
  reg : / "([^"]|\")*" /
} ) ) 

ตัวเลือก

ทางเลือก คุณอาจระบุให้ fast-json-stringify ออบเจ็กต์ตัวเลือกเป็นพารามิเตอร์ตัวที่สอง:

 const fastJson = require ( 'fast-json-stringify' )
const stringify = fastJson ( mySchema , {
  schema : { ... } ,
  ajv : { ... } ,
  rounding : 'ceil'
} )

• schema : การอ้างอิงสคีมาภายนอกโดยคุณสมบัติ $ref รายละเอียดเพิ่มเติม
• ajv : การตั้งค่าอินสแตนซ์ ajv v8 สำหรับคุณสมบัติที่ต้องการ ajv รายละเอียดเพิ่มเติม
• rounding : ตั้งค่าวิธีการปัดเศษประเภท integer เมื่อไม่ใช่จำนวนเต็ม รายละเอียดเพิ่มเติม
• largeArrayMechanism : ตั้งค่ากลไกที่ควรใช้เพื่อจัดการอาร์เรย์ขนาดใหญ่ (โดยค่าเริ่มต้น 20000 รายการขึ้นไป) รายละเอียดเพิ่มเติม

เอพีไอ

fastJsonStringify (สคีมา)

สร้างฟังก์ชัน stringify() ตามข้อกำหนด jsonschema Draft 7

ประเภทที่รองรับ:

• 'string'
• 'integer'
• 'number'
• 'array'
• 'object'
• 'boolean'
• 'null'

และแบบซ้อนกันด้วย

กรณีการใช้งานเฉพาะ

ตัวอย่าง	เรียงลำดับเป็น
Date	string ผ่าน toISOString()
RegExp	string
BigInt	integer ผ่าน toString

รองรับรูปแบบในตัวของ JSON Schema สำหรับวันที่และจะเรียงลำดับเป็น:

รูปแบบ	ตัวอย่างรูปแบบซีเรียลไลซ์
date-time	2020-04-03T09:11:08.615Z
date	2020-04-03
time	09:11:08

หมายเหตุ : ในกรณีของสตริงที่จัดรูปแบบ Date และไม่ใช่ Date Object จะไม่มีการปรับเปลี่ยนใดๆ ควรจัดรูปแบบให้เหมาะสม

ตัวอย่างกับวัตถุวันที่:

 const stringify = fastJson ( {
  title : 'Example Schema with string date-time field' ,
  type : 'string' ,
  format : 'date-time'
} )

const date = new Date ( )
console . log ( stringify ( date ) ) // '"YYYY-MM-DDTHH:mm:ss.sssZ"' 

ที่จำเป็น

คุณสามารถตั้งค่าฟิลด์เฉพาะของออบเจ็กต์ได้ตามต้องการในสคีมาของคุณโดยการเพิ่มชื่อฟิลด์ภายในอาร์เรย์ required ในสคีมาของคุณ ตัวอย่าง:

 const schema = {
  title : 'Example Schema with required field' ,
  type : 'object' ,
  properties : {
    nickname : {
      type : 'string'
    } ,
    mail : {
      type : 'string'
    }
  } ,
  required : [ 'mail' ]
}

หากวัตถุที่จะ stringify ขาดฟิลด์ที่จำเป็น fast-json-stringify จะทำให้เกิดข้อผิดพลาด

ช่องที่ขาดหายไป

หาก มีฟิลด์อยู่ ในสคีมา (และไม่จำเป็น) แต่ ไม่มีอยู่ ในออบเจ็กต์ที่จะสตริง fast-json-stringify จะไม่เขียนลงในสตริงสุดท้าย ตัวอย่าง:

 const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    nickname : {
      type : 'string'
    } ,
    mail : {
      type : 'string'
    }
  }
} )

const obj = {
  mail : '[email protected]'
}

console . log ( stringify ( obj ) ) // '{"mail":"[email protected]"}' 

ค่าเริ่มต้น

fast-json-stringify รองรับคีย์ jsonschema default เพื่อสร้างอนุกรมค่าหาก undefined หรือไม่มีอยู่

ตัวอย่าง:

 const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    nickname : {
      type : 'string' ,
      default : 'the default string'
    }
  }
} )

console . log ( stringify ( { } ) ) // '{"nickname":"the default string"}'
console . log ( stringify ( { nickname : 'my-nickname' } ) ) // '{"nickname":"my-nickname"}' 

คุณสมบัติรูปแบบ

fast-json-stringify รองรับคุณสมบัติรูปแบบตามที่กำหนดโดยสคีมา JSON patternProperties ต้องเป็นอ็อบเจ็กต์ โดยที่คีย์คือ regex ที่ถูกต้อง และค่าคืออ็อบเจ็กต์ ซึ่งประกาศในลักษณะนี้: { type: 'type' } patternProperties จะทำงานเฉพาะกับคุณสมบัติที่ไม่ได้ระบุไว้อย่างชัดเจนในอ็อบเจ็กต์คุณสมบัติ ตัวอย่าง:

 const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    nickname : {
      type : 'string'
    }
  } ,
  patternProperties : {
    'num' : {
      type : 'number'
    } ,
    '.*foo$' : {
      type : 'string'
    }
  }
} )

const obj = {
  nickname : 'nick' ,
  matchfoo : 42 ,
  otherfoo : 'str' ,
  matchnum : 3
}

console . log ( stringify ( obj ) ) // '{"matchfoo":"42","otherfoo":"str","matchnum":3,"nickname":"nick"}' 

คุณสมบัติเพิ่มเติม

fast-json-stringify รองรับคุณสมบัติเพิ่มเติมตามที่กำหนดโดยสคีมา JSON คุณสมบัติเพิ่มเติม ต้องเป็นอ็อบเจ็กต์หรือบูลีน ซึ่งประกาศในลักษณะนี้: { type: 'type' } moreProperties จะทำงานเฉพาะกับคุณสมบัติที่ไม่ได้ระบุไว้อย่างชัดเจนใน คุณสมบัติ และอ็อบเจ็กต์ patternProperties

หากไม่มี คุณสมบัติเพิ่มเติม หรือตั้งค่าเป็น false คุณสมบัติทั้งหมดที่ไม่ได้ระบุไว้อย่างชัดเจนใน คุณสมบัติ และอ็อบเจ็กต์ patternProperties จะถูกละเว้น ตามที่อธิบายไว้ในฟิลด์ที่ขาดหายไป ช่องที่ขาดหายไปจะถูกละเว้นเพื่อหลีกเลี่ยงไม่ให้ต้องเขียนอ็อบเจ็กต์ใหม่ก่อนที่จะทำให้เป็นอนุกรม อย่างไรก็ตาม กฎสคีมาอื่นๆ อาจเกิดขึ้นในสถานการณ์ที่คล้ายคลึงกัน หากตั้ง ค่า addedProperties เป็น true JSON.stringify จะใช้เพื่อทำให้คุณสมบัติเพิ่มเติมเป็นสตริง หากคุณต้องการได้รับประสิทธิภาพสูงสุด เราขอแนะนำให้คุณใช้สคีมาคงที่หากเป็นไปได้ คุณสมบัติเพิ่มเติมจะถูกทำให้เป็นอนุกรมที่ส่วนท้ายของวัตถุเสมอ ตัวอย่าง:

 const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    nickname : {
      type : 'string'
    }
  } ,
  patternProperties : {
    'num' : {
      type : 'number'
    } ,
    '.*foo$' : {
      type : 'string'
    }
  } ,
  additionalProperties : {
    type : 'string'
  }
} )

const obj = {
  nickname : 'nick' ,
  matchfoo : 42 ,
  otherfoo : 'str' ,
  matchnum : 3 ,
  nomatchstr : 'valar morghulis' ,
  nomatchint : 313
}

console . log ( stringify ( obj ) ) // '{"nickname":"nick","matchfoo":"42","otherfoo":"str","matchnum":3,"nomatchstr":"valar morghulis",nomatchint:"313"}' 

AnyOf และ OneOf

fast-json-stringify รองรับคีย์เวิร์ด anyOf และ oneOf ตามที่กำหนดโดยสคีมา JSON ทั้งสองรายการต้องเป็นอาร์เรย์ของสคีมา JSON ที่ถูกต้อง สคีมาที่แตกต่างกันจะถูกทดสอบตามลำดับที่ระบุ ยิ่งต้องลองสคี stringify มากขึ้นก่อนที่จะค้นหาคู่ที่ตรงกัน ก็จะยิ่งช้าลงเท่านั้น

anyOf และ oneOf ใช้ ajv เป็นตัวตรวจสอบสคีมา JSON เพื่อค้นหาสคีมาที่ตรงกับข้อมูล สิ่งนี้มีผลกระทบต่อประสิทธิภาพ—ใช้เป็นทางเลือกสุดท้ายเท่านั้น

ตัวอย่าง:

 const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    'undecidedType' : {
      'anyOf' : [ {
	type : 'string'
      } , {
	type : 'boolean'
      } ]
    }
  }
} )

เมื่อระบุสคีมา JSON ของออบเจ็กต์สำหรับ anyOf ให้เพิ่มคีย์เวิร์ดการตรวจสอบ ที่จำเป็น เพื่อจับคู่เฉพาะออบเจ็กต์ที่มีคุณสมบัติที่คุณต้องการ

ตัวอย่าง:

 const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'array' ,
  items : {
    anyOf : [
      {
        type : 'object' ,
        properties : {
          savedId : { type : 'string' }
        } ,
        // without "required" validation any object will match
        required : [ 'savedId' ]
      } ,
      {
        type : 'object' ,
        properties : {
          error : { type : 'string' }
        } ,
        required : [ 'error' ]
      }
    ]
  }
} ) 

ถ้า/แล้ว/อย่างอื่น

fast-json-stringify รองรับคุณสมบัติ if/then/else jsonschema ดูเอกสาร ajv

ตัวอย่าง:

 const stringify = fastJson ( {
  'type' : 'object' ,
  'properties' : {
  } ,
  'if' : {
    'properties' : {
      'kind' : { 'type' : 'string' , 'enum' : [ 'foobar' ] }
    }
  } ,
  'then' : {
    'properties' : {
      'kind' : { 'type' : 'string' , 'enum' : [ 'foobar' ] } ,
      'foo' : { 'type' : 'string' } ,
      'bar' : { 'type' : 'number' }
    }
  } ,
  'else' : {
    'properties' : {
      'kind' : { 'type' : 'string' , 'enum' : [ 'greeting' ] } ,
      'hi' : { 'type' : 'string' } ,
      'hello' : { 'type' : 'number' }
    }
  }
} )

console . log ( stringify ( {
  kind : 'greeting' ,
  foo : 'FOO' ,
  bar : 42 ,
  hi : 'HI' ,
  hello : 45
} ) ) // {"kind":"greeting","hi":"HI","hello":45}
console . log ( stringify ( {
  kind : 'foobar' ,
  foo : 'FOO' ,
  bar : 42 ,
  hi : 'HI' ,
  hello : 45
} ) ) // {"kind":"foobar","foo":"FOO","bar":42}

หมายเหตุ อย่าประกาศคุณสมบัติสองครั้ง ไม่เช่นนั้นคุณจะพิมพ์สองครั้ง!

ใช้ซ้ำ - $ref

หากคุณต้องการนำคำจำกัดความของค่ากลับมาใช้ใหม่ คุณสามารถใช้คุณสมบัติ $ref ได้ ค่าของ $ref ต้องเป็นสตริงในรูปแบบ JSON Pointer ตัวอย่าง:

 const schema = {
  title : 'Example Schema' ,
  definitions : {
    num : {
      type : 'object' ,
      properties : {
        int : {
          type : 'integer'
        }
      }
    } ,
    str : {
      type : 'string'
    }
  } ,
  type : 'object' ,
  properties : {
    nickname : {
      $ref : '#/definitions/str'
    }
  } ,
  patternProperties : {
    'num' : {
      $ref : '#/definitions/num'
    }
  } ,
  additionalProperties : {
    $ref : '#/definitions/def'
  }
}

const stringify = fastJson ( schema )

หากคุณจำเป็นต้องใช้คำจำกัดความภายนอก คุณสามารถส่งผ่านมันเป็นตัวเลือกในการ fast-json-stringify ตัวอย่าง:

 const schema = {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    nickname : {
      $ref : 'strings#/definitions/str'
    }
  } ,
  patternProperties : {
    'num' : {
      $ref : 'numbers#/definitions/num'
    }
  } ,
  additionalProperties : {
    $ref : 'strings#/definitions/def'
  }
}

const externalSchema = {
  numbers : {
    definitions : {
      num : {
        type : 'object' ,
        properties : {
          int : {
            type : 'integer'
          }
        }
      }
    }
  } ,
  strings : require ( './string-def.json' )
}

const stringify = fastJson ( schema , { schema : externalSchema } )

คำจำกัดความภายนอกยังสามารถอ้างอิงถึงกันได้ ตัวอย่าง:

 const schema = {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    foo : {
      $ref : 'strings#/definitions/foo'
    }
  }
}

const externalSchema = {
  strings : {
    definitions : {
      foo : {
        $ref : 'things#/definitions/foo'
      }
    }
  } ,
  things : {
    definitions : {
      foo : {
        type : 'string'
      }
    }
  }
}

const stringify = fastJson ( schema , { schema : externalSchema } ) 

จำนวนเต็มยาว

ตามค่าเริ่มต้น ไลบรารีจะจัดการ BigInt โดยอัตโนมัติ

จำนวนเต็ม

คุณสมบัติ type: integer จะถูกตัดทอนหากมีการระบุจุดลอยตัว คุณสามารถปรับแต่งลักษณะการทำงานนี้ได้ด้วยตัวเลือก rounding ที่จะยอมรับ round ceil floor หรือ trunc ค่าเริ่มต้นคือ trunc :

 const stringify = fastJson ( schema , { rounding : 'ceil' } ) 

เป็นโมฆะ

ตามข้อกำหนดของ Open API 3.0 ค่าที่สามารถเป็นโมฆะได้จะต้องถูกประกาศว่า nullable

วัตถุที่เป็นโมฆะ

 const stringify = fastJson ( {
  'title' : 'Nullable schema' ,
  'type' : 'object' ,
  'nullable' : true ,
  'properties' : {
    'product' : {
      'nullable' : true ,
      'type' : 'object' ,
      'properties' : {
        'name' : {
          'type' : 'string'
        }
      }
    }
  }
} )

console . log ( stringify ( { product : { name : "hello" } } ) ) // "{"product":{"name":"hello"}}"
console . log ( stringify ( { product : null } ) ) // "{"product":null}"
console . log ( stringify ( null ) ) // null

มิฉะนั้น แทนที่จะทำให้เกิดข้อผิดพลาด ค่า Null จะถูกบังคับดังนี้:

• integer -> 0
• number -> 0
• string -> ""
• boolean -> false
• object -> {}
• array -> []

อาร์เรย์ขนาดใหญ่

สำหรับขอบเขตของเอกสารนี้ อาร์เรย์ขนาดใหญ่ถูกกำหนดให้เป็นอาร์เรย์ที่มีองค์ประกอบ 20000 รายการขึ้นไปตามค่าเริ่มต้น ค่านั้นสามารถปรับได้ผ่านพารามิเตอร์ตัวเลือก largeArraySize

ในบางจุด โอเวอร์เฮดที่เกิดจากกลไกเริ่มต้นที่ใช้โดย fast-json-stringify เพื่อจัดการอาร์เรย์จะเริ่มเพิ่มขึ้นแบบทวีคูณ ส่งผลให้การประมวลผลโดยรวมช้าลง

การตั้งค่า

เพื่อปรับปรุงให้ผู้ใช้สามารถตั้งค่าตัวเลือก largeArrayMechanism และ largeArraySize ได้

ค่าเริ่มต้นของ largeArrayMechanism คือค่า default ค่าที่ถูกต้องสำหรับมันคือ:

• default - ตัวเลือกนี้เป็นการประนีประนอมระหว่างประสิทธิภาพและคุณลักษณะที่กำหนดโดยยังคงให้ฟังก์ชันการทำงานที่คาดหวังจาก lib นี้ แต่ให้ประสิทธิภาพที่เพิ่มขึ้นบางส่วนที่เป็นไปได้ ด้วยชุดตัวเลือกนี้ อาร์เรย์ขนาดใหญ่ จะถูกทำให้เป็นสตริงโดยการรวมองค์ประกอบที่เป็นสตริงโดยใช้ Array.join แทนการต่อสตริงเพื่อประสิทธิภาพที่ดีขึ้น
• json-stringify - ตัวเลือกนี้จะลบการสนับสนุนสำหรับการตรวจสอบความถูกต้องของสคีมาภายใน อาร์เรย์ขนาดใหญ่ โดยสิ้นเชิง การทำเช่นนี้ทำให้ค่าใช้จ่ายที่กล่าวถึงก่อนหน้านี้เป็นโมฆะ ซึ่งช่วยปรับปรุงเวลาดำเนินการได้อย่างมาก โปรดทราบว่าไม่มีการเปลี่ยนแปลงพฤติกรรมสำหรับอาร์เรย์ที่ไม่ถือว่า ใหญ่

ค่าเริ่มต้นของ largeArraySize คือ 20000 ค่าที่ถูกต้องสำหรับมันคือค่าที่มีลักษณะเป็นจำนวนเต็ม เช่น:

• 20000
• 2e4
• '20000'
• '2e4' - โปรดทราบว่าสิ่งนี้จะถูกแปลงเป็น 2 ไม่ใช่ 20000
• 1.5 - โปรดทราบว่าสิ่งนี้จะถูกแปลงเป็น 1

สตริงที่ไม่ปลอดภัย

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

ตัวอย่าง:

 const stringify = fastJson ( {
  title : 'Example Schema' ,
  type : 'object' ,
  properties : {
    'code' : {
	    type : 'string' ,
	    format 'unsafe'
    }
  }
} ) 

เกณฑ์มาตรฐาน

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

• เครื่องจักร: ST1000LM024 HN-M 1TB HDD, Intel Core i7-3610QM @ 2.3GHz, 12GB RAM, 4C/8T .
• โหนด js เวอร์ชัน v16.13.1

 JSON.stringify large array x 157 ops/sec ±0.73% (86 runs sampled)
fast-json-stringify large array default x 48.72 ops/sec ±4.92% (48 runs sampled)
fast-json-stringify large array json-stringify x 157 ops/sec ±0.76% (86 runs sampled)
compile-json-stringify large array x 175 ops/sec ±4.47% (79 runs sampled)
AJV Serialize large array x 58.76 ops/sec ±4.59% (60 runs sampled)

ประกาศด้านความปลอดภัย

ถือว่าข้อกำหนดสคีมาเหมือนกับโค้ดแอปพลิเคชัน การใช้สคีมาที่ผู้ใช้จัดเตรียมไว้ไม่ปลอดภัย

เพื่อให้บรรลุต้นทุนต่ำและประสิทธิภาพสูง การทำซ้ำ fast-json-stringify จะสร้างและคอมไพล์ฟังก์ชัน (โดยใช้ตัวสร้าง Function ) ในการเริ่มต้น แม้ว่า schema จะได้รับการตรวจสอบข้อผิดพลาดของนักพัฒนาในปัจจุบัน แต่ก็ไม่มีการรับประกันว่าการจัดหาสคีมาที่ผู้ใช้สร้างขึ้นจะไม่ทำให้แอปพลิเคชันของคุณถูกโจมตีจากระยะไกล

ผู้ใช้มีหน้าที่รับผิดชอบในการส่งข้อมูลที่เชื่อถือได้ fast-json-stringify รับประกันว่าคุณจะได้รับเอาต์พุตที่ถูกต้องเฉพาะในกรณีที่อินพุตของคุณตรงกับสคีมาหรือสามารถบังคับกับสคีมาได้ หากอินพุตของคุณไม่ตรงกับสคีมา คุณจะได้รับพฤติกรรมที่ไม่ได้กำหนดไว้

โหมดแก้ไขข้อบกพร่อง

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

 const debugCompiled = fastJson ( {
  title : 'default string' ,
  type : 'object' ,
  properties : {
    firstName : {
      type : 'string'
    }
  }
} , { mode : 'debug' } )

console . log ( debugCompiled ) // it is a object contain code, ajv instance
const rawString = debugCompiled . code // it is the generated code
console . log ( rawString )

const stringify = fastJson . restore ( debugCompiled ) // use the generated string to get back the `stringify` function
console . log ( stringify ( { firstName : 'Foo' , surname : 'bar' } ) ) // '{"firstName":"Foo"}'

โหมดสแตนด์อโลน

โหมดสแตนด์อโลนใช้เพื่อคอมไพล์โค้ดที่สามารถรันโดยตรงโดย node เอง คุณต้องติดตั้ง fast-json-stringify เพื่อให้โค้ดแบบสแตนด์อโลนทำงานได้

 const fs = require ( 'fs' )
const code = fastJson ( {
  title : 'default string' ,
  type : 'object' ,
  properties : {
    firstName : {
      type : 'string'
    }
  }
} , { mode : 'standalone' } )

fs . writeFileSync ( 'stringify.js' , code )
const stringify = require ( 'stringify.js' )
console . log ( stringify ( { firstName : 'Foo' , surname : 'bar' } ) ) // '{"firstName":"Foo"}' 

รับทราบ

โครงการนี้ได้รับการสนับสนุนอย่างดีจาก nearForm

ใบอนุญาต

เอ็มไอที