JavaScript developers are always adding new features to the JavaScript language to improve performance and add better functionality. Sometimes, older browser versions don't support new features.
For example, the exponentiation operator was introduced in ES7, and trailing commas in objects are also valid in ES7. Now, while developing the application, we added the exponentiation operator in the application. It will work on newer versions of browsers, but if someone is using a very old version of the browser, they may get errors such as the browser engine not supporting the exponentiation operator.
So, we can use polyfill to avoid this error. Let us break the word polyfill into two parts to understand its meaning. Poly means a lot and fill means filling in the gaps. This means that if a browser does not support the default functionality of JavaScript, a variety of techniques are needed to fill the gaps in browser functionality.
There are two ways to solve the problem that the browser does not support the function. One is a polyfill and the other is a transpiler. A translator converts the code to a lower version so that the browser can support it. For example, we can write code in an ES7 version of JavaScript and then use a transpiler to convert it to ES6 or ES5 so that it is supported by older browsers.
Here we will learn different examples of using polyfill concepts.
Users can manually implement JavaScript methods using the polyfill concept according to the following syntax.
String.prototype.method_name = function (params) {
// implement the code for the method
// use this keyword to access the reference object
}
We have added methods to the string prototype in the above syntax. method_name represents the method name. We assign a function with multiple parameters to the method.
In the following example, we use the built-in contains() method of the String object. We have defined the string and used the includes() method to check if the string contains a specific word or substring.
<html>
<body>
<h2>Using the <i>includes() method without polyfill </i> in JavaScript</h2>
<div id = "content"> </div>
<script>
let content = document.getElementById('content');
let str = "You are welcome on TutorialsPoint's website. Hello users! How are you?";
let isWelcome = str.includes('welcome');
content.innerHTML += "The original string: " + str + "<br>";
content.innerHTML += "The string includes welcome word? " + isWelcome + "<br>";
let isJavaScript = str.includes('javaScript');
content.innerHTML += "The string includes JavaScript word? " + isJavaScript + "<br>";
</script>
</body>
</html>
In the above example, we used the built-in includes() method. In this example, we will define a polyfill for the includes() method. If any browser does not support the includes() method, it will execute the user-defined includes() method.
Here, we add the includes() method to the prototype of the string object. In the function, if the search string is of type regular expression, we will throw an error. Also, the "pos" parameter is an option, so if the user doesn't pass it, it's treated as nil. Finally, use the indexof() method to check if the string contains the word and return a Boolean value based on the result.
<html>
<body>
<h2>Using the <i>includes() method with polyfill </i> in JavaScript</h2>
<div id = "content"> </div>
<script>
let content = document.getElementById('content');
String.prototype.includes = function (str, pos) {
// first, check whether the first argument is a regular expression
if (str instanceof RegExp) {
throw Error("Search string can't be an instance of regular expression");
}
// second parameter is optional. So, if it isn't passed as an argument, consider it zero
if (pos === undefined) {
pos = 0;
}
content.innerHTML += "The user-defined includes method is invoked! <br>"
// check if the index of the string is greater than -1. If yes, string includes the search string.
return this.indexOf(str, pos) !== -1;
};
let str = "This is a testing string. Use this string to test includes method.";
content.innerHTML += `The original string is "` + str +`" <br>`;
let isTesting = str.includes('testing');
content.innerHTML += "The string includes testing word? " + isTesting + "<br>";
let isYour = str.includes('your');
content.innerHTML += "The string includes your word? " + isYour + "<br>";
</script>
</body>
</html>
We implemented a polyfill for the filter() method in the example below. We first make sure that the reference array is not empty and that the callback is a function. After that, we iterate over the array and execute the callback function for each array value. If the callback function returns true, we push it to the output array. Finally, we return the output array containing the filtered values
<html>
<body>
<h2>Using the <i> filter() method with polyfill </i> in JavaScript</h2>
<div id = "content"> </div>
<script>
let content = document.getElementById('content');
Array.prototype.filter = function (callback) {
// check if the reference array is not null
if (this === null) throw new Error;
// check that callback is a type of function
if (typeof callback !== "function") throw new Error;
var output = [];
// iterate through array
for (var k = 0; k < this.length; k++) {
// get value from index k
var val = this[k];
// call the callback function and, based on a returned boolean value, push the array value in the output array
if (callback.call(this, val, k)) {
output.push(val);
}
}
return output;
};
function getDivisibleBy10(val, k) {
// return true if val is divisible by 10.
if (val % 10 == 0) {
return true;
}
return false;
}
let array = [10, 20, 40, 65, 76, 87, 90, 80, 76, 54, 32, 23, 65, 60];
let filtered = array.filter(getDivisibleBy10);
content.innerHTML += "The original array is " + JSON.stringify(array) + "<br>";
content.innerHTML += "The filtered array is " + JSON.stringify(filtered) + "<br>";
</script>
</body>
</html>
This tutorial teaches us how to implement polyfill for the includes() and filter() methods. However, users can use if-else statements to check if the browser supports a specific method. If not, the user-defined method is executed, otherwise the built-in method is executed.
The above is the detailed content of How to use polyfill in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
