ජාවාස්ක්‍රිප්ට් සමඟ

ජාවාස්ක්‍රිප්ට් හි විශේෂිත අක්ෂරයකින් නූලක් අවසන් වේදැයි පරීක්ෂා කරන්නේ කෙසේද?

උදාහරණය: මට නූලක් තිබේ

var str = "mystring#";

මට දැන ගැනීමට අවශ්‍යයි එම නූල අවසන් වන්නේ දැයි #. මම එය පරීක්ෂා කරන්නේ කෙසේද?

1. endsWith()JavaScript හි ක්‍රමයක් තිබේද?

2. මට ඇති එක් විසඳුමක් නම් නූල් වල දිග ගෙන අවසාන අක්‍ෂරය ලබා ගෙන එය පරීක්ෂා කිරීමයි.

මෙය හොඳම ක්‍රමයද නැත්නම් වෙනත් ක්‍රමයක් තිබේද?

යාවත්කාලීන කිරීම (2015 නොවැම්බර් 24):

මෙම පිළිතුර මුලින් පළ කර ඇත්තේ 2010 වර්ෂයේදීය (මීට වසර හයකට පෙර.) එබැවින් කරුණාකර මෙම තීක්ෂ්ණ බුද්ධිමත් අදහස් සැලකිල්ලට ගන්න:

• ෂෝනා - ගූගල්කරුවන් සඳහා යාවත්කාලීන කිරීම - ඊසීඑම්ඒ 6 මෙම ක්‍රියාව එකතු කරන බව පෙනේ. එම්ඩීඑන් ලිපියේ පොලිෆිල් එකක් ද පෙන්වයි. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• ටී. ජේ. ක්‍රෝඩර් - නවීන බ්‍රව්සර්වල උපස්ථර සෑදීම මිල අධික නොවේ; මෙම පිළිතුර පළ කරන විට එය 2010 දී විය හැකිය. මේ දිනවල සරල this.substr(-suffix.length) === suffixප්‍රවේශය ක්‍රෝම් හි වේගවත්ම වේ, අයිඊ 11 දර්ශක ඕෆ් ලෙසම වන අතර ෆයර්ෆොක්ස් හි 4% මන්දගාමී (ෆර්ගෙටබුටිට් භූමි ප්‍රදේශය) පමණි: jsperf.com/endswith-stackoverflow/14 ප්‍රති result ලය අසත්‍ය වන විට පුවරුව හරහා වේගවත්: jsperf.com/endswith-stackoverflow-when-false ඇත්ත වශයෙන්ම, ES6 කෙළවර එකතු කිරීමත් සමඟ, කාරණය වැදගත් වේ. :-)

මුල් පිළිතුර:

මෙය වසරක් පැරණි ප්‍රශ්නයක් බව මම දනිමි ... නමුත් මට මෙයද අවශ්‍ය වන අතර හරස් බ්‍රව්සරය වැඩ කිරීමට මට එය අවශ්‍යය ... එබැවින් සෑම දෙනාගේම පිළිතුරු සහ අදහස් ඒකාබද්ධ කර එය ටිකක් සරල කරන්න:

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

• උපස්ථරයක් සාදන්නේ නැත
• indexOfවේගවත්ම ප්‍රති .ල සඳහා ස්වදේශීය ක්‍රියාකාරිත්වය භාවිතා කරයි
• indexOfඉදිරියට යාම සඳහා දෙවන පරාමිතිය භාවිතා කරමින් අනවශ්‍ය සැසඳීම් මඟ හරින්න
• ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි වැඩ කරයි
• රෙජෙක්ස් සංකූලතා නොමැත

එසේම, දේශීය දත්ත ව්‍යුහයේ මූලාකෘතිවල දේවල් පුරවා ගැනීමට ඔබ අකමැති නම්, මෙන්න ස්වාධීන අනුවාදයක්:

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

සංස්කරණය කරන්න: අදහස් දැක්වීමේදී @ හාමිෂ් විසින් සටහන් කර ඇති පරිදි, ඔබට ආරක්ෂිත පැත්තේ වැරැද්දක් කිරීමට අවශ්‍ය නම් සහ ක්‍රියාත්මක කිරීමක් දැනටමත් ලබා දී typeofඇත්දැයි පරීක්ෂා කර බැලීමට ඔබට අවශ්‍ය නම්, එවැනි චෙක්පතක් එක් කළ හැකිය :

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

/#$/.test(str)

සියලු බ්‍රව්සර් වල ක්‍රියා කරනු ඇත, වඳුරු පැච් කිරීම අවශ්‍ය නොවේ String, සහ නොගැලපෙන lastIndexOfවිට මෙන් සම්පූර්ණ නූල පරිලෝකනය කිරීම අවශ්‍ය නොවේ.

නිත්‍ය ප්‍රකාශන විශේෂ අක්ෂර අඩංගු විය හැකි නියත නූලක් ඔබට ගැලපීමට අවශ්‍ය නම්, ඔබට '$'පහත සඳහන් දෑ භාවිතා කළ හැකිය:

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

එවිට ඔබට එය මේ ආකාරයෙන් භාවිතා කළ හැකිය

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

1. අවාසනාවට නැත.
2. if( "mystring#".substr(-1) === "#" ) {}

එන්න, මෙය නිවැරදි endsWithක්‍රියාත්මක කිරීමකි:

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

lastIndexOfගැලපීමක් නොමැති නම් හුදෙක් භාවිතා කිරීම අනවශ්‍ය CPU ලූප නිර්මාණය කරයි.

මෙම අනුවාදය උපස්ථරයක් සෑදීමෙන් වළක්වන අතර නිත්‍ය ප්‍රකාශන භාවිතා නොකරයි (මෙහි සමහර රීජෙක්ස් පිළිතුරු ක්‍රියාත්මක වනු ඇත; අනෙක් ඒවා කැඩී ඇත):

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

කාර්ය සාධනය ඔබට වැදගත් නම්, lastIndexOfඋපස්ථරයක් සෑදීමට වඩා ඇත්ත වශයෙන්ම වේගවත් ද නැද්ද යන්න පරීක්ෂා කිරීම වටී . . අපි ඇත්තටම ගණන් ගන්නේ නැහැ :(

තනි අක්ෂරයක් පරික්ෂා කිරීම සඳහා, දිග සොයා ගැනීම සහ පසුව භාවිතා charAtකිරීම හොඳම ක්‍රමය වේ.

sliceක්‍රමවේදය සමඟ අපෝරාච් දැක නැත . ඒ නිසා මම එය මෙහි තබමි:

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

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

මුල් නූල් දිග සෙවුම් නූල් දිගට වඩා අඩු වන අතර සෙවුම් නූල සොයාගත නොහැකි වූ විට එය ක්‍රියා නොකරයි:

lastIndexOf -1 නැවත ලබා දෙයි, පසුව ඔබ සෙවුම් නූල් දිග එකතු කරන අතර ඔබට මුල් නූලෙහි දිග ඉතිරි වේ.

හැකි විසඳුමක්

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

Developper.mozilla.org වෙතින් String.prototype.endsWith ()

සාරාංශය

එම endsWith() ක්රමය සුදුසු පරිදි සත්ය හෝ අසත්ය නැවත තවත් නූල් චරිත සමග වැලක් අවසන් යන්න තීරණය කරයි.

සින්ටැක්ස්

str.endsWith(searchString [, position]);

පරාමිතීන්

• searchString : මෙම නූල අවසානයේ සෙවිය යුතු අක්ෂර.

• පිහිටීම : මෙම නූල දිගු කාලයක් මෙන් මෙම නූල තුළ සොයන්න; මෙම නූලෙහි සත්‍ය දිගට පෙරනිමිය, මෙම නූලෙහි දිග මගින් ස්ථාපිත පරාසය තුළ ගැට ගැසී ඇත.

විස්තර

මෙම ක්‍රමය මඟින් නූලක් වෙනත් නූලකින් අවසන් වේද නැද්ද යන්න තීරණය කිරීමට ඔබට ඉඩ සලසයි.

උදාහරණ

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

alert( str.endsWith("question.") );  // true
alert( str.endsWith("to be") );      // false
alert( str.endsWith("to be", 19) );  // true

පිරිවිතර

ECMAScript භාෂා පිරිවිතර 6 වන සංස්කරණය (ECMA-262)

බ්‍රව්සර් අනුකූලතාව

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

-- හෝ --

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

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? කැමන් ...

රීජෙක්ස් භාවිතා කරමින් මට ආකර්ශනීය ලෙස ක්‍රියා කළ තවත් ඉක්මන් විකල්පයක්:

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

ඔබ ලොඩාෂ් භාවිතා කරන්නේ නම් :

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

ලොඩාෂ් භාවිතා නොකරන්නේ නම්, ඔබට එහි ප්‍රභවයෙන් ණයට ගත හැකිය .

මම මේ සංගීත පුස්තකාලය ගැන ඉගෙන ගත්තා:

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;
}

එවැනි කුඩා ගැටළුවක් සඳහා බොහෝ දේ, මෙම නිත්‍ය ප්‍රකාශනය භාවිතා කරන්න

var str = "mystring#";
var regex = /^.*#$/

if (regex.test(str)){
  //if it has a trailing '#'
}

මෙම ප්රශ්නය සඳහා වසර ගණනාවක් ගත වී ඇත. වඩාත්ම ඡන්දය දුන් චක්‍රිට් පිළිතුර භාවිතා කිරීමට කැමති පරිශීලකයින් සඳහා වැදගත් යාවත්කාලීන කිරීමක් එක් කිරීමට මට ඉඩ දෙන්න.

ECMAScript 6 (පර්යේෂණාත්මක තාක්ෂණය) හි කොටසක් ලෙස 'endWith' කාර්යයන් දැනටමත් ජාවාස්ක්‍රිප්ට් වෙත එකතු කර ඇත.

එය මෙහි යොමු කරන්න: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

එබැවින් පිළිතුරෙහි සඳහන් කර ඇති පරිදි ස්වදේශීය ක්‍රියාත්මක කිරීමේ පැවැත්ම සඳහා චෙක්පත් එක් කිරීම රෙකමදාරු කරනු ලැබේ.

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

අනාගත සාධනය සඳහා සහ / හෝ පවත්නා මූලාකෘති නැවත ලිවීම වැළැක්වීමේ ක්‍රමයක් වන්නේ එය දැනටමත් සංගීත මූලාකෘතියට එකතු කර ඇත්දැයි පරීක්ෂා කිරීමයි. මෙන්න මම රීජෙක්ස් නොවන ඉහළ ශ්‍රේණිගත කළ අනුවාදය ලබා ගනිමි.

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

@ චක්‍රිත්ගේ පිළිගත් පිළිතුර එය ඔබම කිරීමට ස්ථිර ක්‍රමයකි. කෙසේ වෙතත්, ඔබ ඇසුරුම් කළ විසඳුමක් සොයන්නේ නම්, lmlunoe පෙන්වා දුන් පරිදි, underscore.string දෙස බැලීමට මම නිර්දේශ කරමි . Undererscore.string භාවිතා කරමින්, කේතය වනුයේ:

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

දීර් long පිළිතුරු වලට පසුව, මෙම කේත කොටස සරල හා තේරුම් ගැනීමට පහසු බව මට පෙනී ගියේය!

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

ඔබට 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.prototype.endWith = function (a) {
    var isExp = a.constructor.name === "RegExp",
    val = this;
    if (isExp === false) {
        a = escape(a);
        val = escape(val);
    } else
        a = a.toString().replace(/(^\/)|(\/$)/g, "");
    return eval("/" + a + "$/.test(val)");
}

// example
var str = "Hello";
alert(str.endWith("lo"));
alert(str.endWith(/l(o|a)/));

අවසානය ක්‍රියාත්මක කිරීම මෙයයි: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

මෙය ක්‍රියාත්මක කිරීම endsWith:

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

මෙය @ චාර්කිට්ගේ පිළිගත් පිළිතුර මත පදනම් වේ, එය නූල් පෙළක් හෝ තර්කයක් ලෙස සම්මත කිරීමට ඉඩ දෙයි.

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);
        }
    };
}

මේ සඳහා යටි ඉරි ලකුණු අවශ්‍ය වේ - නමුත් බොහෝ විට යටි ඉරි මත යැපීම ඉවත් කිරීම සඳහා සකස් කළ හැකිය.

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
        ;
    };
}

ප්‍රතිලාභ:

• මෙම අනුවාදය දර්ශක නැවත භාවිතා කිරීම පමණක් නොවේ.
• දිගු නූල් මත විශිෂ්ටතම කාර්ය සාධනය. මෙන්න වේගවත් පරීක්ෂණයක් http://jsperf.com/starts-ends-with/4
• Ecmascript පිරිවිතර සමඟ සම්පුර්ණයෙන්ම අනුකූල වේ. එය පරීක්ෂණ සමත් වේ

සාමාන්‍ය ප්‍රකාශන භාවිතා නොකරන්න. වේගවත් භාෂාවලින් පවා ඒවා මන්දගාමී වේ. නූලක අවසානය පරික්ෂා කරන ශ්‍රිතයක් ලියන්න. : මෙම පුස්තකාලය ලස්සන උදාහරණ ඇති groundjs / util.js . String.prototype වෙත ශ්‍රිතයක් එක් කිරීමට ප්‍රවේශම් වන්න. මෙම කේතයට එය කරන්නේ කෙසේද යන්න පිළිබඳ හොඳ උදාහරණ ඇත: groundjs / prototype.js පොදුවේ ගත් කල, මෙය කදිම භාෂා මට්ටමේ පුස්තකාලයකි: groundjs ඔබට ලොඩාෂ් දෙසද බැලිය හැකිය

ඒවා සියල්ලම ඉතා ප්‍රයෝජනවත් උදාහරණ වේ. එකතු කිරීමString.prototype.endsWith = function(str) මඟින් අපගේ නූල අවසන් වන්නේ ද නැද්ද යන්න පරීක්ෂා කිරීම සඳහා ක්‍රමවේදය ඇමතීමට අපට උපකාරී වනු ඇත, හොඳින් regexp ද එය කරනු ඇත.

මට වඩා හොඳ විසඳුමක් මම සොයාගත්තා. සියලු දෙනාටම ස්තුතියි.

කෝපි පිටපත සඳහා

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