Feat. New option ignoreFunction according to issue#32

README.md

@@ -101,6 +101,11 @@ serialize(obj, {isJSON: true});
 
 This option is to signal `serialize()` that we want to do a straight conversion, without the XSS protection. This options needs to be explicitly set to `true`. HTML characters and JavaScript line terminators will not be escaped. You will have to roll your own.
 
+#### `options.ignoreFunction`
+
+This option is to signal `serialize()` that we do not want serialize JavaScript function. 
+Just treat function like `JSON.stringify` do, but other features will work as expected.
+
 ```js
 serialize(obj, {unsafe: true});
 ```

index.js

@@ -31,6 +31,18 @@ function escapeUnsafeChars(unsafeChar) {
     return ESCAPED_CHARS[unsafeChar];
 }
 
+function deleteFunctions(obj){
+    var functionKeys = []
+    for(var key in obj){
+        if(typeof obj[key] === 'function'){
+            functionKeys.push(key);
+        }
+    }
+    for(var i=0; i<functionKeys.length; i++){
+        delete obj[functionKeys[i]]
+    }
+}
+
 module.exports = function serialize(obj, options) {
     options || (options = {});
 
@@ -50,6 +62,11 @@ module.exports = function serialize(obj, options) {
     // which are later replaced by their string representation.
     function replacer(key, value) {
 
+        // For nested function
+        if(options.ignoreFunction){
+            deleteFunctions(value);
+        }
+
         if (!value && value !== undefined) {
             return value;
         }
@@ -125,6 +142,10 @@ module.exports = function serialize(obj, options) {
       return serializedFn;
     }
 
+    // Check if the parameter is function
+    if( options.ignoreFunction && typeof obj==='function'){
+        obj = undefined;
+    }
     // Protects against `JSON.stringify()` returning `undefined`, by serializing
     // to the literal string: "undefined".
     if (obj === undefined) {

test/unit/serialize.js

@@ -424,6 +424,29 @@ describe('serialize( obj )', function () {
             expect(serialize(["<"], {space: 2})).to.equal('[\n  "\\u003C"\n]');
             expect(serialize(["<"], {unsafe: true, space: 2})).to.equal('[\n  "<"\n]');
         });
+
+        it("should accept a `ignoreFunction` option", function() {
+            function fn() { return true; }
+            const obj = {
+              fn,
+              fn_arrow: () => {
+                return true;
+              }
+            };            
+            const obj2 = {
+                num:123,
+                str:'str',
+                fn
+            }
+            // case 1. Pass function to serialize
+            expect(serialize(fn, { ignoreFunction: true })).to.equal(`undefined`);
+            // case 2. Pass function(arrow) in object to serialze
+            expect(serialize(obj, { ignoreFunction: true })).to.equal("{}");
+            // case 3. Other features should work
+            expect(serialize(obj2, { ignoreFunction: true })).to.equal(
+              `{"num":123,"str":"str"}`
+            );
+        });
     });
 
     describe('backwards-compatability', function () {