javascript中常量(理想情况下是文字)圆形对象的表示

我认为实现尖锐变量是复杂的，并没有使计算更容易。我会用函数实现这样的行为:

var sharps={};
Object.prototype.sharp=function(str){
 sharps[str]=this;
}
function gs(str){
return function(){return sharps[str];};
}

你可以这样写:

var obj1={a:{b:gs("1");}
obj1.sharp("1");
alert(obj1.a.b());//returns obj1

这里有一个答案:

function isPrimitive(x){
  switch(typeof x){
    case "number":
    case "string":
    case "boolean":
    case "undefined":
      return true;
  }
  return false;
}
function isSerialisable(x){
  switch(typeof x){
    case "function":
    case "symbol":
      return false;
    case "number":
    case "string":
    case "object":
    case "boolean":
    case "undefined":
      return true;
  }
  return false;
}
function isValidIdentifier(string){
  //this is *really* stupid
  //TODO: operate brain
  if(/[] ,;'".+=-()[]!*/.test(string)) return false; 
  //don't want anything too stupid
  try{ 
    //this throws a syntax error if our identifier is invalid!
    //note that whilst e.g. `var in = ...` is invalid, `foo.in` is valid
    void new Function("x", "return x." + string + ";")
  } catch(e) { return false;}
  return true;
}

function serialise(object){
  var seenObjects = new Map();
  var places = [];
  //this function traverses object in depth-first order,
  //simultaneously finding recursive references and
  //building up a tree-shaped near-deep-copy of object that can be
  //JSON.stringified
  function process(object, path){
    if(!isSerialisable(object)) throw "Object is not serialisable";
    if(isPrimitive(object)) return object;
    //object really is an object now
    if(seenObjects.has(object)){
      places.push({path:path.slice(),from:seenObjects.get(object)});
      return null; //so we don't have cycles.
      //we use null so it is included by JSON.stringify so that the
      //order of the keys is preserved.
    } else {
      //iterate over the own properties
      var ret = Array.isArray(object) ? [] : {} //maybe Object.create(null); doesn't really matter
      seenObjects.set(object, path.slice()); //so we can find it again
      for(var prop in object){
        if(Object.prototype.hasOwnProperty.call(object, prop)){
          var p = +prop;
          prop = (p == prop && prop !== "") ? p : prop;
          path.push(prop);
          ret[prop] = process(object[prop], path);
          console.assert(prop == path.pop(), "Path stack not maintained");
        }
      }
      return ret;
    }
  }
  function dotPath(path){
    return path.map(function(x){
      if(isValidIdentifier(x)){
        return "." + x;
      } else {
        return "[" + JSON.stringify(x) + "]";
      }}).join("");
    //we use JSON.stringify to properly escape strings
    //therefore we hope that they do not contain the types of vertical space
    //which JSON ignores.
  }
  var tree = process(object, []);
  if(places.length == 0){
    //object not cyclic
    return JSON.stringify(tree);
  }
  //object is cyclic
  var result = "(function(){x=" + JSON.stringify(tree) + ";"
  return result + places.map(function(obj){
    //obj = {path:..., from:...}
    return "x" + dotPath(obj.path) + "=x" + dotPath(obj.from);
  }).join(";") + ";return x;})()";
}

一些辅助函数特别糟糕，但主要部分基本上是可以的，如果对于大对象来说内存有点重。也许使用conses为路径创建一个链表可以减少一点内存使用。