Google Chrome上的xsl:include和xsl:param，以及jQuery转换插件

我一直试图在Google Chrome上使用XSL，但没有成功。
我读到Chrome在XSLT方面有一些缺陷，其中之一是它不支持xsl:include。可以在此处检查错误：。
经过一些研究，我发现Daer系统提供了一个新版本的转换插件，它使xsl:include可以在Chrome上工作

jQuery转换插件可以从以下位置找到：

现在我的问题是：
我在一些xsl模板中使用默认的include，这个include使用一个传递给顶级模板的参数

因此，我有一个声明[xsl:param name=“param”/>的top.xsl模板，我将此参数与include.xsl一起使用，第一个使用[xsl:include href=“include.xsl]”调用该参数。这在Firefox和Internet Explorer上都有效，但在Chrome上不起作用。我在stackoverflow上看到一个问题，有人从插件中重新编写了webkit修复函数，但它不能以这种方式与xsl:param一起工作

---

有人知道在Google Chrome中这样使用[xsl:param]的方法吗？

您的问题是Google Chrome（=Chrome）不支持

xsl:include

在中提出的Chromium项目中，这一特性的缺失是显而易见的。这个问题似乎是由WebKit（Chrome中使用的渲染引擎）中的一些架构问题引起的。因为这个问题源于WebKit，所以这个bug被标记为WontFix——将来当WebKit中的原始问题得到解决时，将提供修复（希望如此）

我认为有三种可能的解决方案：

等待WebKit/Chrome获得修复此问题的修补程序（可能需要很长时间…）

创建/找到一个可以解决此问题的黑客，例如通过模拟Chrome/Webkit的xsl:include（可能需要大量工作/开发黑客）

尝试以一种不需要此特定XSL功能的方式编写软件（或者在服务器端运行XSL转换）

---

我的建议：避免在客户端使用xsl:include和xsl:param，除非您愿意放弃跨浏览器兼容性

这是一种痛苦，但您也可以使用客户端垫片来解决这一问题，该垫片可以在浏览器中预加载任何xsl:import/xsl:include

下面是TypeScript（基本上是编译成JavaScript的静态类型JavaScript），并且有一些对接口的引用..嗯，我没有费心删除，但它似乎在Chrome中工作（不确定其他浏览器），应该足以让任何人开始使用解决方案

module DD.Render.DOM.XSLT {

export class StandardXSLTDOMTransformerFactory implements IXSLTDOMTransformerFactory {

    constructor(private _domParser:DOMParser, private _document:Document) {
    }

    createTransformerFromPath<T>(xslPath: string, xmlTransformer: IStringTransformer<T>, onSuccess: (transformer: IParameterizedDOMTransformer<T>) => void, onFailure: (e: any) => void): void {
        DD.Util.readXML(
            xslPath,
            (node: Node) => {

                // look up any xsl:import or xsl:includes and pull those in too!
                var onIncludesPreloaded = () => {
                    console.log(node);
                    var transformer = this.createTransformerFromNode(node, xmlTransformer);
                    onSuccess(transformer);
                };
                this.rewriteIncludes(xslPath, node, {}, onIncludesPreloaded, onFailure);
            }, function (e: any) {
                onFailure(e);
            }
        );
    }

    rewriteIncludes(path:string, node: Node, imported: { [_: string]: boolean }, onRewritten:()=>void, onFailure:(e:any)=>void): void {
        var result;
        var element = <Element>node;
        var importNodes = element.querySelectorAll("import,include");
        if (importNodes.length == 0) {
            onRewritten();
            result = false;
        } else {
            var rewrittenNodes = 0;
            // load imports
            for (var i = 0; i < importNodes.length; i++) {
                var importElement = <Element>importNodes.item(i);
                var href = importElement.getAttribute("href");
                // TODO work out relative path
                var relativePath = DD.Util.appendRelativePath(path, href);
                console.log("importing " + href +" + "+path+" -> "+relativePath);
                if (!imported[relativePath]) {
                    var e = importElement;
                    imported[relativePath] = true;
                    DD.Util.readXML(relativePath, (importedStylesheet: Node) => {
                        this.rewriteIncludes(relativePath, importedStylesheet, imported, function () {
                            // replace the import with this node (minus stylesheet container)
                            for (var j = 0; j < importedStylesheet.firstChild.childNodes.length; j++) {
                                var templateNode = importedStylesheet.firstChild.childNodes.item(j);
                                if (templateNode.nodeName.indexOf("template") >= 0) {
                                    e.parentNode.insertBefore(templateNode, e);
                                }
                            }
                            e.parentNode.removeChild(e);
                            rewrittenNodes++;
                            if (rewrittenNodes == importNodes.length) {
                                if (onRewritten) {
                                    onRewritten();
                                }
                            }
                        }, onFailure);
                    }, onFailure);
                } else {
                    importElement.parentNode.removeChild(importElement);
                }
            }
            result = true;
        }
        return result;
    }

    createTransformerFromNode<T>(xsl: Node, xmlTransformer: IStringTransformer<T>): IParameterizedDOMTransformer<T> {
        var nodeTransformer = new DOMParserDOMTransformer(this._domParser, xmlTransformer);
        var xsltProcessor = new XSLTProcessor();
        xsltProcessor.importStylesheet(xsl);
        return new StandardXSLTDOMTransformer<T>(xsltProcessor, nodeTransformer, this._document);
    }

}

} 

module DD.Util {

export function readXML(path: string, onSuccess: (node: Node) => void, onFailure: (e: any) => void) {
    var xhr = new XMLHttpRequest();
    xhr.onload = function () {
        onSuccess(xhr.responseXML);
    };
    xhr.onerror = function (e: ErrorEvent) {
        onFailure(e);
    };
    xhr.open("GET", path, true);
    xhr.send(null);
}

export function appendRelativePath(originalPath: string, relativePath: string, originalPathIsDirectory?: boolean) {
    if (originalPathIsDirectory == null) {
        originalPathIsDirectory = originalPath.charAt(originalPath.length - 1) == '/';
    }
    if (!originalPathIsDirectory) {
        // remove file imediately
        var lastSlash = originalPath.lastIndexOf('/');
        if (lastSlash >= 0) {
            originalPath = originalPath.substring(0, lastSlash + 1);
        } else {
            originalPath = "";
        }
    }
    var slashIndex = relativePath.indexOf('/');
    if (slashIndex >= 0) {
        var relativeDirectory = relativePath.substring(0, slashIndex + 1);
        var relativeRemainder = relativePath.substring(slashIndex + 1);
        if (relativeDirectory == "../") {
            // trim off a directory on the original path
            if (originalPath.charAt(originalPath.length - 1) == '/') {
                originalPath = originalPath.substring(0, originalPath.length - 1);
            }
            var dirIndex = originalPath.lastIndexOf('/');
            if (dirIndex >= 0) {
                originalPath = originalPath.substring(0, dirIndex + 1);
            } else {
                originalPath = "";
            }
        } else {
            // append to the original path
            if (originalPath.charAt(originalPath.length - 1) != '/') {
                originalPath += '/';
            }
            originalPath += relativeDirectory;
        }
        appendRelativePath(originalPath, relativeRemainder, true);
    } else {
        // append and be done
        if (originalPath.charAt(originalPath.length - 1) != '/') {
            originalPath += '/';
        }            
        return originalPath + relativePath;
    }
}

}

模块DD.Render.DOM.XSLT{
导出类标准XSLTDOMTransformerFactory实现IXSLTDOMTransformerFactory{
构造函数（私有的domParser:domParser，私有的文档：document）{
}
createTransformerFromPath（xslPath:string，xmlTransformer:IStringTransformer，onSuccess:（transformer:iPParameterizeDdomTransformer）=>void，onFailure:（e:any）=>void）：void{
DD.Util.readXML(
xslPath，
（节点：节点）=>{
//查找任何xsl:import或xsl:includes并将它们也拉入！
变量onincludespreaded=（）=>{
console.log（节点）；
var transformer=this.createTransformerFromNode（节点，xmlTransformer）；
onSuccess（变压器）；
};
重写包括（xslPath、node、{}、onIncludesPreloaded、onFailure）；
}，功能（e:任何）{
失败（e）；
}
);
}
rewriteIncludes（路径：字符串，节点：节点，导入：{[\:string]：boolean}，onRewrited:（）=>void，onFailure:（e:any）=>void）：void{
var结果；
var元素=节点；
var importNodes=element.querySelectorAll（“导入，包括”）；
if（importNodes.length==0）{
onwrited（）；
结果=假；
}否则{
var重写节点=0；
//加载导入
对于（变量i=0；i”+相对路径）；
如果（！已导入[relativePath]）{
var e=重要性；
导入的[relativePath]=真；
readXML（relativePath，（importedStylesheet:Node）=>{
重写包括（relativePath、importedStylesheet、imported、function（）{
//用此节点替换导入（减去样式表容器）
对于（var j=0；j=0）{
e、 insertBefore（templateNode，e）；
}
}
e、 parentNode.removeChild（e）；
重写节点++；
if（重写节点==importNodes.length）{
如果（重新编写）{
onwrited（）；
}
}
}（失败时）；
}（失败时）；
}否则{
importElement.parentNode.removeChild（importElement）；
}
}
结果=真