有谁知道在cscharp(c#)中是否有像NUnit这样的测试框架？
当然我在javascript上自己编写测试,所以它应该是好的.

但我只想绝对确定它的有效性.

可以更改此代码以生成一般堆栈跟踪吗？或者有更好的方法在IE中获得堆栈跟踪？

(function () {

YOUR_NAMESPACE.getStackTrace = (function () {

var mode;
try {(0)()} catch (e) {
    mode = e.stack ? 'Firefox' : window.opera ? 'Opera' : 'Other';
}

switch (mode) {
    case 'Firefox' : return function () {
        try {(0)()} catch (e) {
            return e.stack.replace(/^.*?\n/,'').
                           replace(/(?:\n@:0)?\s+$/m,'').
                           replace(/^\(/gm,'{anonymous}(').
                           split("\n");
        }
    };

    case 'Opera' : return function () {
        try {(0)()} catch (e) {
            var lines = e.message.split("\n"),ANON = '{anonymous}',lineRE = /Line\s+(\d+).*?in\s+(http\S+)(?:.*?in\s+function\s+(\S+))?/i,i,j,len;

            for (i=4,j=0,len=lines.length; i<len; i+=2) {
                if (lineRE.test(lines[i])) {
                    lines[j++] = (RegExp.$3 ?
                        RegExp.$3 + '()@' + RegExp.$2 + RegExp.$1 :
                        ANON + RegExp.$2 + ':' + RegExp.$1) +
                        ' -- ' + lines[i+1].replace(/^\s+/,'');
                }
            }

            lines.splice(j,lines.length-j);
            return lines;
        }
    };

    default : return function () {
        var curr  = arguments.callee.caller,FUNC  = 'function',ANON = "{anonymous}",fnRE  = /function\s*([\w\-$]+)?\s*\(/i,stack = [],fn,args,i;

        while (curr) {
            fn    = fnRE.test(curr.toString()) ? RegExp.$1 || ANON : ANON;
            args  = stack.slice.call(curr.arguments);
            i     = args.length;

            while (i--) {
                switch (typeof args[i]) {
                    case 'string'  : args[i] = '"'+args[i].replace(/"/g,'\\"')+'"'; break;
                    case 'function': args[i] = FUNC; break;
                }
            }

            stack[j++] = fn + '(' + args.join() + ')';
            curr = curr.caller;
        }

        return stack;
    };
}

})();

function foo() {
    // debug how this is being called
    alert(YOUR_NAMESPACE.getStackTrace());
}

或者为您引发的错误添加更多细节：

function foo() {
    // signal something went wrong
    var error = new Error("error in foo");
    if (!error.stack)
        error.stack = YOUR_NAMESPACE.getStackTrace();
    throw error;
}

你不能这样使用它：

try {
    foo();
} catch (e) {
    alert(YOUR_NAMESPACE.getStackTrace(e));
}

以下是您可以获得的堆栈信息以及发生错误时从哪些浏览器获取的详细信息：Three Painful Ways to Obtain a Stack Trace in Javascript(Archive.org链接替换死链接)

var x = 0
var newobj;

function loop(obj,type1,type2) {
    for (i in obj) {
        if (obj[i].shape == type1 && obj[i].health == type2) {
            $('div').append(obj[i].shape + '-' + obj[i].health + '<br>')
            if (!x) {
                newobj = obj[i];
            } else {
                newobj.children = obj[i]
            }
            x++
        }
        loop(obj[i].children,type2)
    }
}

function filter() {
    loop(obj,'circle','red')
}

filter()

console.log(newobj)

编辑

编辑fiddle,数据清晰,预期结果如下

{
    "shape": "circle","health": "red","children": [
        {
            "shape": "circle","health": "red"
        },{
            "shape": "circle","children": [
                {
                    "shape": "circle","health": "red"
                },{
                    "shape": "circle","health": "red"
                }
            ]
        }
    ]
}

老照片 –

预期结果-

首先,让我们创建一个根元素,这样如果第一个元素与过滤条件不匹配,树就不会分裂：

var tree = {"shape":"root","health":"ultraviolet","children":obj};
// obj is your structure in your question

现在removeNode函数将是

function removeNode(victim,parent) {
  // remove the victim from parent's children
  var target = parent.children.indexOf(victim);
  if(target>-1) parent.children.splice(target,1);
  // add victim's children to parent's children
  if(victim.children) parent.children = parent.children.concat(victim.children);
  // don't do this if you need a clone
  delete(victim);
}

并且过滤功能将是

function filter(root,shape,health) {
  if(root.children) root.children.forEach(function(o) {
    filter(o,health);
    if(!(o.shape==shape && o.health==health) && o.shape!="root") {
      removeNode(o,root);
      // possible optimization: you Could skip nodes which passed already
      filter(root,health);
    }
  });
}

所以你可以做到

filter(tree,"circle","red");

获得理想的结果.