Polyfill Explained (Simplified Version)
Tags: javascript, vanillajs, polyfill
Published: 2020-05-28 02:07:43

Hello Guys, 
I recently migrated <a target="_blank" href="https://github.com/BMSVieira/BVSelect-VanillaJS/blob/master/README.md">my project</a> from Jquery to VanillaJS.

One of the problems that i had was Browser Compatibility, so i started searching ways to solve that problem and i found people talking about Polyfill.

<b>What is Polyfill?</b>
Think in Polyfill as pieces of code, that converts code you wrote in such way that will be supported in older browsers (Like IE)

For example, Internet Explorer 11 does not support:
```javascript
Array.From();
```
So you have to include before, the Polyfilled version of <i>Array.From</i> in order for IE be able to run it: 
```javascript
/**
 * Array.from() polyfill
 */
// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from
// Production steps of ECMA-262, Edition 6, 22.1.2.1
if (!Array.from) {
	Array.from = (function () {
		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);
		};

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

			// 2. Let items be ToObject(arrayLike).
			var items = Object(arrayLike);

			// 3. ReturnIfAbrupt(items).
			if (arrayLike == null) {
				throw new TypeError('Array.from requires an array-like object - 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);

			// 16. Let k be 0.
			var k = 0;
			// 17. Repeat, while k < len… (also steps a - h)
			var kValue;
			while (k < len) {
				kValue = items[k];
				if (mapFn) {
					A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
				} else {
					A[k] = kValue;
				}
				k += 1;
			}
			// 18. Let putStatus be Put(A, "length", len, true).
			A.length = len;
			// 20. Return A.
			return A;
		};
	}());
}

```
<b>How do i know what is not being supported in my code?</b>
The best way to do it is check in the <i>Console Log</i> what is currently not being supported by the browser you are in, and use <a target="_blank" href="https://polyfill.io/v3/url-builder/">Polyfill Bundle</a> to select the Polyfilled versions of it.

After that, include the source in your project.
There are other ways, but this is the easiest to get started.

I hope this helps someone, it is just an introduction to Polyfill, there are many things involved but i don't want you to lose focus.

Thank you!