The Mozilla docs say to return undefined (instead of "none"):

http://jsfiddle.net/userdude/rZ5Px/

function replacer(key,value)
{
    if (key=="privateProperty1") return undefined;
    else if (key=="privateProperty2") return undefined;
    else return value;
}

var x = {
    x:0,
    y:0,
    divID:"xyz",
    privateProperty1: 'foo',
    privateProperty2: 'bar'
};

alert(JSON.stringify(x, replacer));

Here is a duplication method, in case you decide to go that route (as per your comment).

http://jsfiddle.net/userdude/644sJ/

function omitKeys(obj, keys)
{
    var dup = {};
    for (var key in obj) {
        if (keys.indexOf(key) == -1) {
            dup[key] = obj[key];
        }
    }
    return dup;
}

var x = {
    x:0,
    y:0,
    divID:"xyz",
    privateProperty1: 'foo',
    privateProperty2: 'bar'
};

alert(JSON.stringify(omitKeys(x, ['privateProperty1','privateProperty2'])));

EDIT - I changed the function key in the bottom function to keep it from being confusing.

Well, the problem is that you're creating AN ARRAY then continue working with it as with an object.

Use

user.regions[a] = {};

instead.

What happens is that JSON.stringify sees there is an array, tries to iterate over its numeric indexes which it does not have so it results in an empty array.

Example on JSFiddle: http://jsfiddle.net/Le80jdsj/

You can use the replacer. The second parameter provided by JSON.stringify.Replacer could be a function or array.

In your case we can create a function which replaces all the special characters with a blank space.The below example replaces the whitespaces and underscores.

function replacer(key, value) {
  return value.replace(/[^\w\s]/gi, '');
}

var foo = {"a":"1","b":2};
var jsonString = JSON.stringify(foo, replacer);

If you simply want to replace the one special character, use:

JSON.stringify({ a: 1, b: 2 }, null, '\t');

For more information on replacer, check the MDN page JSON.stringify().

You can pass a "replacer" function that returns the exact value you want.

var data = {"id":1,"name":"Light Switch","lightStatus":true,"inputPort":{"id":2,"value":0},"outputPort":{"id":2,"value":false},"resistance":100};

var result = JSON.stringify(data, function(k, v) {
    switch (k) {
    case "": case "name": case "resistance":
    	return v
    case "inputPort": case "outputPort":
    	return v.id
    default:
    	return undefined;
  }
}, 2)

document.querySelector("pre").textContent = result

<pre></pre>

The "" represents the top level object. For that, "name", and "resistance", it simply returns the original value.

For "inputPort" and "outputPort" it returns the id property.

Anything else gets undefined, which means it gets omitted from the result.

In your data screenshots, you literally see "\n".

This probably means that the actual string doesn't contain a newline character (\n), but a escaped newline character (\\n).

A newline character would have been rendered as a linebreak. You wouldn't see the \n.

To remove those, use .replace(/\\n/g, '') instead of .replace(/\n/g, '')

This simple regular expression solution works to unquote JSON property names in most cases:

const object = { name: 'John Smith' };
const json = JSON.stringify(object);  // {"name":"John Smith"}
console.log(json);
const unquoted = json.replace(/"([^"]+)":/g, '$1:');
console.log(unquoted);  // {name:"John Smith"}

Extreme case:

var json = '{ "name": "J\\":ohn Smith" }'
json.replace(/\\"/g,"\uFFFF");  // U+ FFFF
json = json.replace(/"([^"]+)":/g, '$1:').replace(/\uFFFF/g, '\\\"');
// '{ name: "J\":ohn Smith" }'

Special thanks to Rob W for fixing it.

Limitations

In normal cases the aforementioned regexp will work, but mathematically it is impossible to describe the JSON format with a regular expression such that it will work in every single cases (counting the same number of curly brackets is impossible with regexp.) Therefore, I have create a new function to remove quotes by formally parsing the JSON string via native function and reserialize it:

function stringify(obj_from_json) {
    if (typeof obj_from_json !== "object" || Array.isArray(obj_from_json)){
        // not an object, stringify using native function
        return JSON.stringify(obj_from_json);
    }
    // Implements recursive object serialization according to JSON spec
    // but without quotes around the keys.
    let props = Object
        .keys(obj_from_json)
        .map(key => `${key}:${stringify(obj_from_json[key])}`)
        .join(",");
    return `{${props}}`;
}

Example: https://jsfiddle.net/DerekL/mssybp3k/

Okay, so apparently you want to take out the quotes and indent it nicely? Then I would do that beforehand:

function indent(str) {
    return str.replace(/\n/g, '\n\t');
}

function toPrettyObject(obj) {
    var ajsoln = []; // Actual JavaScript Object Literal Notation

    if(Object.prototype.toString.call(obj) === '[object Array]') {
        for(var i = 0; i < obj.length; i++) {
            ajsoln.push(indent(toPrettyObject(obj[i])));
        }

        return '[\n' + ajsoln.join(',\n') + '\n]';
    } else if(typeof obj !== 'object') {
        return JSON.stringify(obj);
    } else {
        for(var x in obj) {
            ajsoln.push('\t' + (/^[a-zA-Z_\$][\w\$]+$/.test(x) ? x : JSON.stringify(x)) + ': ' + indent(toPrettyObject(obj[x])));
        }

        return '{\n' + ajsoln.join(',\n') + '\n}';
    }
}