String.prototype.indexOf(searchString, fromIndex)

indexOf 方法返回调用它的第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，则返回 -1。

'hello world'.indexOf('h');  // 0
'hello world'.indexOf('ll');  // 2

Polyfill：

if (!String.prototype.indexOf) {
String.prototype.indexOf = function(searchString, fromIndex) {
    let i;
    if (typeof searchString == 'undefined') {
        searchString = 'undefined';
    }
    searchString = '' + searchString;
    let flen = this.length;
    let zlen = searchString.length;
    fromIndex = +fromIndex;
    if (isNaN(fromIndex) || fromIndex < 0) {
        i = 0;
    } else if( fromIndex >= flen) {
        return -1;
    } else {
        i = fromIndex;
    }
    if (zlen > flen) {
        return -1;
    } else if (zlen == flen) {
        if (this == searchString) {
            return 0;
        } else {
            return -1;
        }
    } else {
        let str = '';
        while(i < flen) {
            str = this.substr(i, zlen);
            if (str == searchString) {
                return i;
            }
            i++;
        }
        if (i == flen) {
            return -1;
        }
    }
}
}

String.prototype.includes(searchString, position)

includes 方法用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。

var str = 'To be, or not to be, that is the question.';

console.log(str.includes('To be'));       // true
console.log(str.includes('question'));    // true
console.log(str.includes('nonexistent')); // false
console.log(str.includes('To be', 1));    // false
console.log(str.includes('TO BE'));       // false

 Polyfill：

if (!String.prototype.includes) {
    String.prototype.includes = function(searchString, fromIndex) {
        'use strict';
        if (typeof fromIndex !== 'number') {
          fromIndex = 0;
        }
        
        if (fromIndex + search.length > this.length) {
            return false;
        } else {
            return this.indexOf(searchString, fromIndex) !== -1;
        }
    }
}

String.prototype.lastIndexOf(searchString, fromIndex)

lastIndexOf 方法返回调用它的最后一次出现的指定值的索引，从 fromIndex 处从后向前进行搜索。如果未找到该值，则返回 -1。

String.prototype.lastIndexOf = String.prototype.lastIndexOf || function(searchValue, fromIndex) {
    let n = 0;
    if (typeof searchValue == 'undefined') {
        searchValue = 'undefined';
    }
    let flen = this.length;
    let zlen = searchValue.length;
    if (typeof fromIndex !== 'number') {
        fromIndex = flen - 1;
    }
    n = fromIndex;
    if (zlen > flen) {
        return -1;
    } else if (zlen == flen) {
        if (this == searchValue) {
            return 0;
        } else {
            return -1;
        }
    } else {
        var str = '';
        while(n >= 0) {
            str = this.substr(n, zlen)
            if (str == searchValue) {
                return n;
            }
            n--;
        }
        if (n <= 0) {
            return -1;
        }
    }
}