javascript中的endsWith

1. 可惜不是。
2. if( "mystring#".substr(-1) === "#" ) {}

if( ("mystring#").substr(-1,1) == '#' )

--或者--

if( ("mystring#").match(/#$/) )

所有这些都是非常有用的例子。添加String.prototype.endsWith = function(str)将帮助我们简单地调用方法来检查我们的字符串是否以它结尾，正则表达式也会这样做。

我找到了一个比我的更好的解决方案。谢谢大家。

这个版本避免创建子字符串，并且不使用正则表达式（这里的一些regex答案可以工作；其他的坏了）：

String.prototype.endsWith = function(str){var lastIndex = this.lastIndexOf(str);return (lastIndex !== -1) && (lastIndex + str.length === this.length);}

如果性能对你来说很重要，那么测试lastIndexOf是否真的比创建子字符串更快是值得的。（这很可能取决于你使用的JS引擎…）在匹配的情况下，它可能会更快，当字符串很小时-但是当字符串很大时，它需要回顾整个事情，即使我们并不真正关心：（

对于检查单个字符，找到长度然后使用charAt可能是最好的方法。

return this.lastIndexOf(str) + str.length == this.length;

在原始字符串长度比搜索字符串长度小一且找不到搜索字符串的情况下不起作用：

lastIndexOf返回-1，然后添加搜索字符串长度，并留下原始字符串的长度。

一个可能的解决办法是

return this.length >= str.length && this.lastIndexOf(str) + str.length == this.length

/#$/.test(str)

将适用于所有浏览器，不需要猴子修补String，也不需要像lastIndexOf那样扫描整个字符串，当没有匹配时。

如果要匹配可能包含正则表达式特殊字符（例如'$'）的常量字符串，则可以使用以下命令：

function makeSuffixRegExp(suffix, caseInsensitive) {return new RegExp(String(suffix).replace(/[$%()*+.?\[\\\]{|}]/g, "\\$&") + "$",caseInsensitive ? "i" : "");}

然后你可以像这样使用它

makeSuffixRegExp("a[complicated]*suffix*").test(str)

这是正确的endsWith实现：

String.prototype.endsWith = function (s) {return this.length >= s.length && this.substr(this.length - s.length) == s;}

如果没有匹配，使用lastIndexOf只会创建不必要的CPU循环。

更新（2015年11月24日）：

这个答案最初发布于2010年（六年前），所以请注意这些有见地的评论：

• Shauna-

Google员工更新-看起来ECMA6添加了此功能。MDN文章还显示了一个PolyFill。https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• T. J.克劳德-

在现代浏览器上创建子字符串并不昂贵；当这个答案发布时，它很可能是在2010年。如今，简单的this.substr(-suffix.length) === suffix方法在Chrome上最快，在IE11上与indexOf相同，在Firefox上仅慢4%（fergetaboutit领域）：https://jsben.ch/OJzlM当结果为false时更快：jsperf.com/endswith-stackoverflow-when-false当然，随着ES6添加endsWith，这一点是没有意义的。：-）

原始答案：

我知道这是一个一年前的问题……但我也需要这个，我需要它跨浏览器工作，所以……结合大家的回答和评论并简化它一点：

String.prototype.endsWith = function(suffix) {return this.indexOf(suffix, this.length - suffix.length) !== -1;};

• 不创建子字符串
• 使用原生indexOf函数以获得最快的结果
• 使用indexOf的第二个参数跳过不必要的比较
• 在Internet Explorer中工作
• 无Regex并发症

此外，如果你不喜欢在原生数据结构的原型中填充东西，这里有一个独立版：

function endsWith(str, suffix) {return str.indexOf(suffix, str.length - suffix.length) !== -1;}

编辑：正如@hamish在评论中指出的那样，如果你想安全起见并检查是否已经提供了实现，你可以像这样添加typeof检查：

if (typeof String.prototype.endsWith !== 'function') {String.prototype.endsWith = function(suffix) {return this.indexOf(suffix, this.length - suffix.length) !== -1;};}

function check(str){var lastIndex = str.lastIndexOf('/');return (lastIndex != -1) && (lastIndex  == (str.length - 1));}

如果您不想使用lasIndexOf或substr，那么为什么不只是查看字符串的自然状态（即数组）

String.prototype.endsWith = function(suffix) {if (this[this.length - 1] == suffix) return true;return false;}

或作为独立功能

function strEndsWith(str,suffix) {if (str[str.length - 1] == suffix) return true;return false;}

将来证明和/或防止覆盖现有原型的一种方法是测试检查它是否已经添加到String原型中。这是我对非正则表达式高评级版本的看法。

if (typeof String.endsWith !== 'function') {String.prototype.endsWith = function (suffix) {return this.indexOf(suffix, this.length - suffix.length) !== -1;};}

String.prototype.endWith = function (a) {var isExp = a.constructor.name === "RegExp",val = this;if (isExp === false) {a = escape(a);val = escape(val);} elsea = a.toString().replace(/(^\/)|(\/$)/g, "");return eval("/" + a + "$/.test(val)");}
// examplevar str = "Hello";alert(str.endWith("lo"));alert(str.endWith(/l(o|a)/));

String.prototype.endsWith = function(str){return (this.match(str+"$")==str)}
String.prototype.startsWith = function(str){return (this.match("^"+str)==str)}

我希望这能有所帮助

var myStr = “  Earth is a beautiful planet  ”;var myStr2 = myStr.trim();//==“Earth is a beautiful planet”;
if (myStr2.startsWith(“Earth”)) // returns TRUE
if (myStr2.endsWith(“planet”)) // returns TRUE
if (myStr.startsWith(“Earth”))// returns FALSE due to the leading spaces…
if (myStr.endsWith(“planet”))// returns FALSE due to trailing spaces…

的传统方式

function strStartsWith(str, prefix) {return str.indexOf(prefix) === 0;}
function strEndsWith(str, suffix) {return str.match(suffix+"$")==suffix;}

我不知道你，但是：

var s = "mystring#";s.length >= 1 && s[s.length - 1] == '#'; // will do the thing!

为什么是正则表达式？为什么要弄乱原型？substr？来吧…

这建立在@charkit接受的答案之上，允许字符串数组或字符串作为参数传入。

if (typeof String.prototype.endsWith === 'undefined') {String.prototype.endsWith = function(suffix) {if (typeof suffix === 'String') {return this.indexOf(suffix, this.length - suffix.length) !== -1;}else if(suffix instanceof Array){return _.find(suffix, function(value){console.log(value, (this.indexOf(value, this.length - value.length) !== -1));return this.indexOf(value, this.length - value.length) !== -1;}, this);}};}

这需要underScorejs-但可能可以调整以删除下划线依赖项。

if(typeof String.prototype.endsWith !== "function") {/*** String.prototype.endsWith* Check if given string locate at the end of current string* @param {string} substring substring to locate in the current string.* @param {number=} position end the endsWith check at that position* @return {boolean}** @edition ECMA-262 6th Edition, 15.5.4.23*/String.prototype.endsWith = function(substring, position) {substring = String(substring);
var subLen = substring.length | 0;
if( !subLen )return true;//Empty string
var strLen = this.length;
if( position === void 0 )position = strLen;else position = position | 0;
if( position < 1 )return false;
var fromIndex = (strLen < position ? strLen : position) - subLen;
return (fromIndex >= 0 || subLen === -fromIndex)&& (position === 0// if position not at the and of the string, we can optimise search substring//  by checking first symbol of substring exists in search position in current string|| this.charCodeAt(fromIndex) === substring.charCodeAt(0)//fast false)&& this.indexOf(substring, fromIndex) === fromIndex;};}

好处：

• 这个版本不仅仅是重用indexOf。
• 在长弦上表现最好。这是一个速度测试http://jsperf.com/starts-ends-with/4
• 完全兼容ecmascript规范。它通过了测试

不要使用正则表达式。即使在快速语言中，它们也很慢。只需编写一个检查字符串末尾的函数即可。这个库有很好的示例：util.js。小心将函数添加到String.prototype.这段代码有很好的示例说明如何做到这一点：prototype.js一般来说，这是一个不错的语言级别库：ground js你也可以去看看黄瓜

developer.mozilla.orgString.prototype.ends（）

总结

endsWith()方法确定一个字符串是否以另一个字符串的字符结尾，并根据需要返回true或false。

语法

str.endsWith(searchString [, position]);

参数范围

• 搜索用例：要在此字符串末尾搜索的字符。

• 职位：在此字符串中搜索，就好像此字符串只有这么长一样；默认为此字符串的实际长度，固定在此字符串长度确定的范围内。

特性介绍

此方法可让您确定一个字符串是否以另一个字符串结尾。

示例

var str = "To be, or not to be, that is the question.";
alert( str.endsWith("question.") );  // truealert( str.endsWith("to be") );      // falsealert( str.endsWith("to be", 19) );  // true

产品规格

ECMAScript语言规范第6版（ECMA-262）

浏览器兼容性

我刚刚了解了这个字符串库：

http://stringjs.com/

包含js文件，然后像这样使用S变量：

S('hi there').endsWith('hi there')

它也可以通过安装在NodeJS中使用：

npm install string

然后要求它作为S变量：

var S = require('string');

该网页还具有指向备用字符串库的链接，如果这个不喜欢的话。

function strEndsWith(str,suffix) {var reguex= new RegExp(suffix+'$');
if (str.match(reguex)!=null)return true;
return false;}

为了咖啡

String::endsWith = (suffix) ->-1 != @indexOf suffix, @length - suffix.length

这么多事情，这么小的问题，就用这个正则表达式

var str = "mystring#";var regex = /^.*#$/
if (regex.test(str)){//if it has a trailing '#'}

@chakrit接受的答案是自己动手的可靠方法。但是，如果您正在寻找打包的解决方案，我建议查看underscore.string，正如@mlunoe指出的那样。使用underscore.string，代码将是：

function endsWithHash(str) {return _.str.endsWith(str, '#');}

如果您使用豆沙：

_.endsWith('abc', 'c'); // true

如果不使用黄瓜，你可以借用它的来源。

这个问题已经有很多年了。让我为想要使用投票最多的chakrit答案的用户添加一个重要的更新。

'endsWith'函数已经作为ECMAScript 6（实验技术）的一部分添加到JavaScript中

点击这里：https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

因此，强烈建议添加检查是否存在答案中提到的本机实现。

只是另一个快速替代方案，对我来说就像一个魅力，使用regex：

// Would be equivalent to:// "Hello World!".endsWith("World!")"Hello World!".match("World!$") != null

没有看到slice方法的apporach。所以我把它留在这里：

function endsWith(str, suffix) {return str.slice(-suffix.length) === suffix}

7岁的帖子，但我无法理解前几篇帖子，因为它们很复杂。所以，我写了自己的解决方案：

function strEndsWith(str, endwith){var lastIndex = url.lastIndexOf(endsWith);var result = false;if (lastIndex > 0 && (lastIndex + "registerc".length) == url.length){result = true;}return result;}

在所有这些长时间的答案之后，我发现这段代码简单易懂！

function end(str, target) {return str.substr(-target.length) == target;}

这是endsWith的实现：

String.prototype.endsWith = function (str) {return (this.length >= str.length) && (this.substr(this.length - str.length) === str);}