Javascript 仅当使用箭头函数时，Internet Explorer中的脚本错误

我有一个包含箭头函数的函数。它在Edge、Chrome、FireFox中运行良好，但当我尝试在InternetExplorer10&&11中运行它时，会出现语法错误

是否有任何方法可以支持Internet Explorer或其他解决方案

function range(start, end) {
    return Array.from(Array(end - start + 1), (_, i) => i + start);
}

---

语法错误出现在“=>”

处，因为其他社区成员已经通知您，数组。IE浏览器中不支持From和=>箭头函数

对于阵列。从中有一个可用的。您可以尝试将其用于IE浏览器

代码：

//ECMA-262第6版22.1.2.1的生产步骤
如果（！Array.from）{
Array.from=（函数（）{
变量符号迭代器；
试一试{
symbolIterator=Symbol.iterator
？Symbol.iterator
：'Symbol（Symbol.iterator）'；
}抓住{
symbolIterator='Symbol（Symbol.iterator）'；
}
var toStr=Object.prototype.toString；
var isCallable=函数（fn）{
返回(
fn的类型==='函数'||
toStr.call（fn）='[对象函数]'
);
};
var toInteger=函数（值）{
var编号=编号（值）；
if（isNaN（number））返回0；
if（number==0 | |！isFinite（number））返回数；
返回（编号>0？1:-1）*数学楼层（数学abs（编号））；
};
var maxsafeinger=Math.pow（2,53）-1；
var toLength=函数（值）{
var len=toInteger（值）；
返回Math.min（Math.max（len，0），maxSafeInteger）；
};
var setGetItemHandler=函数setGetItemHandler（isIterator，items）{
var iterator=isIterator&&items[symbolIterator]（）；
返回函数getItem（k）{
返回isIterator？iterator.next（）：items[k]；
};
};
var getArray=函数getArray(
T
A.
伦恩，
getItem，
异想天开，
mapFn
) {
//16.设k为0。
var k=0；
//17.在k1？参数[1]：未定义为void；
变量T；
如果（映射类型Fn！==“未定义”）{
//5.其他
//5.a如果IsCallable（mapfn）为false，则抛出TypeError异常。
如果（！isCallable（mapFn））{
抛出新类型错误(
'Array.from:提供时，第二个参数必须是函数'
);
}
//5.b.如果提供了thisArg，则T为thisArg；否则T为未定义。
如果（arguments.length>2）{
T=参数[2]；
}
}
//10.获取lenValue（项目“长度”）。
//11.让len为ToLength（lenValue）。
var len=总长度（项目长度）；
//13.如果IsConstructor（C）为真，则
//13.a.让a作为调用[[Construct]]内部方法的结果
//使用包含单个项len的参数列表的C。
//14.a.否则，让a成为ArrayCreate（len）。
var A=isCallable（C）？对象（新的C（len））：新的数组（len）；
返回getArray(
T
A.
伦恩，
setGetItemHandler（isIterator，items），
异想天开，
mapFn
);
};
})();
}

---

for=>我建议尝试使用将ES6代码传输到Es5代码。之后，它将与IE浏览器一起工作。

尝试将范围函数更改为数组函数，作为

const range=（start，end）=>{…}

。这里没有LINQ-这完全是误导。LINQ是一个.NET构造，不存在于JavaScript中（除非使用库）。我已经更正了术语，让您专注于真正的问题。问题是IE不支持箭头功能。见和。请注意，即使箭头函数已修复，这也是您将遇到的下一个错误。@micronyks这有什么帮助吗？s

// Production steps of ECMA-262, Edition 6, 22.1.2.1
if (!Array.from) {
    Array.from = (function () {
        var symbolIterator;
        try {
            symbolIterator = Symbol.iterator
                ? Symbol.iterator
                : 'Symbol(Symbol.iterator)';
        } catch {
            symbolIterator = 'Symbol(Symbol.iterator)';
        }

        var toStr = Object.prototype.toString;
        var isCallable = function (fn) {
            return (
                typeof fn === 'function' ||
                toStr.call(fn) === '[object Function]'
            );
        };
        var toInteger = function (value) {
            var number = Number(value);
            if (isNaN(number)) return 0;
            if (number === 0 || !isFinite(number)) return number;
            return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
        };
        var maxSafeInteger = Math.pow(2, 53) - 1;
        var toLength = function (value) {
            var len = toInteger(value);
            return Math.min(Math.max(len, 0), maxSafeInteger);
        };

        var setGetItemHandler = function setGetItemHandler(isIterator, items) {
            var iterator = isIterator && items[symbolIterator]();
            return function getItem(k) {
                return isIterator ? iterator.next() : items[k];
            };
        };

        var getArray = function getArray(
            T,
            A,
            len,
            getItem,
            isIterator,
            mapFn
        ) {
            // 16. Let k be 0.
            var k = 0;

            // 17. Repeat, while k < len… or while iterator is done (also steps a - h)
            while (k < len || isIterator) {
                var item = getItem(k);
                var kValue = isIterator ? item.value : item;

                if (isIterator && item.done) {
                    return A;
                } else {
                    if (mapFn) {
                        A[k] =
                            typeof T === 'undefined'
                                ? mapFn(kValue, k)
                                : mapFn.call(T, kValue, k);
                    } else {
                        A[k] = kValue;
                    }
                }
                k += 1;
            }

            if (isIterator) {
                throw new TypeError(
                    'Array.from: provided arrayLike or iterator has length more then 2 ** 52 - 1'
                );
            } else {
                A.length = len;
            }

            return A;
        };

        // The length property of the from method is 1.
        return function from(arrayLikeOrIterator /*, mapFn, thisArg */) {
            // 1. Let C be the this value.
            var C = this;

            // 2. Let items be ToObject(arrayLikeOrIterator).
            var items = Object(arrayLikeOrIterator);
            var isIterator = isCallable(items[symbolIterator]);

            // 3. ReturnIfAbrupt(items).
            if (arrayLikeOrIterator == null && !isIterator) {
                throw new TypeError(
                    'Array.from requires an array-like object or iterator - not null or undefined'
                );
            }

            // 4. If mapfn is undefined, then let mapping be false.
            var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
            var T;
            if (typeof mapFn !== 'undefined') {
                // 5. else
                // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
                if (!isCallable(mapFn)) {
                    throw new TypeError(
                        'Array.from: when provided, the second argument must be a function'
                    );
                }

                // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
                if (arguments.length > 2) {
                    T = arguments[2];
                }
            }

            // 10. Let lenValue be Get(items, "length").
            // 11. Let len be ToLength(lenValue).
            var len = toLength(items.length);

            // 13. If IsConstructor(C) is true, then
            // 13. a. Let A be the result of calling the [[Construct]] internal method
            // of C with an argument list containing the single item len.
            // 14. a. Else, Let A be ArrayCreate(len).
            var A = isCallable(C) ? Object(new C(len)) : new Array(len);

            return getArray(
                T,
                A,
                len,
                setGetItemHandler(isIterator, items),
                isIterator,
                mapFn
            );
        };
    })();
}