我会这样说：

function removeCircular(ref) {
    for (let i in ref) {
        if (ref[i] === ref) delete(ref[i]);
        else if (typeof ref[i] == 'Object') removeCircular(ref[i]);
    }
}

或者你想让它递归地工作？- edit，它现在是递归的。然而，这段代码可能会以循环结束。所以@NiettheDarkAbsol的代码更好。
但是，您的示例不是循环的。您将其赋给property，它实际上是窗口对象。如果您希望有一个循环对象，则必须执行以下操作：

certainObject = { abc: 'test' };
certainObject.propery = certainObject;

有了这样一个例子，我的代码就可以工作了。

您需要遍历对象，同时跟踪已经看到的对象。

function removeCircular(obj) {
    const seen = new Map();
    const recurse = obj => {
        seen.add(obj,true);
        for( let [k, v] of Object.entries(obj)) {
            if( typeof v !== "object") continue;
            if(seen.has(v)) delete obj[k];
            else recurse(v);
        }
    }
    recurse(obj);
}

请注意，这将在原处修改对象。如果您希望保留原始对象，则需要先克隆它。

var prams = {
                name: 'abc',
                obj : this,
                val : 'hello ',
               
            }
            

           

            function removecyclic(obj){
               newobj = {};
               for(key in obj){
                    if(typeof obj[key] == 'object'){
                        if(!obj.hasOwnProperty(key)){
                             newobj[key] = obj[key];
                            
                        }
                       
                        
                    }
                    else{
                        newobj[key] = obj[key];
                    }
                    
                }
                return newobj;
            }

           

           console.log(removecyclic(prams));

只是添加了一个对我有用的Niet答案的更新版本。而且还因为我不能评论/回复Markus Knappen Johansson的问题。：-P
不同的是使用seen.set而不是seen.add。我猜.add来自另一种语言？

function removeCircular(obj) {
  const seen = new Map();

  const recurse = obj => {
    seen.set(obj, true);

    Object.entries(obj).forEach(([k, v]) => {
      if (typeof v !== 'object') return;
      if (seen.has(v)) delete obj[k];
      else recurse(v);
    });
  };

  recurse(obj);
}