උපස්ථරය සහ උපස්ථරය අතර වෙනස කුමක්ද?

අතර ඇති වෙනස කුමක්ද?

alert("abc".substr(0,2));

සහ

alert("abc".substring(0,2));

ඔවුන් දෙදෙනාම “ab” ප්‍රතිදානය කරන බව පෙනේ.

වෙනස දෙවන තර්කයේ ඇත. දෙවන තර්කය substringවන්නේ නැවැත්විය යුතු දර්ශකයයි (නමුත් ඇතුළත් නොවේ), නමුත් දෙවන තර්කය substrවන්නේ ආපසු පැමිණිය හැකි උපරිම දිගයි.

සබැඳි?

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/substr

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/substring

substring( MDN ) පරාමිතීන් ලෙස සලකයි (from, to).
substr( MDN ) පරාමිතීන් ලෙස සලකයි (from, length).

යාවත්කාලීන කිරීම : එම්ඩීඑන් substrඋරුමය සලකා බලයි .

alert("abc".substr(1,2)); // returns "bc"
alert("abc".substring(1,2)); // returns "b"

substringතවත් සංගීත නිස්සාරණ ක්‍රමයක් වන පෙත්තක් මෙන් දර්ශක ද ගන්නා බව ඔබට මතක ඇති .

0 සිට ආරම්භ කරන විට ඔබට එක් ක්‍රමයක් භාවිතා කළ හැකිය.

යතිමා 2975 හි පිළිතුරේ ඉඟි කර ඇති පරිදි, අමතර වෙනසක් ඇත:

substr()string ණ ආරම්භක ස්ථානයක් නූලේ කෙළවරේ සිට ඕෆ්සෙට් එකක් ලෙස පිළිගනී. substring()නැහැ.

MDN වෙතින් :

ආරම්භය negative ණ නම්, උපස්ථරය () එය නූල් අවසානයේ සිට අක්ෂර දර්ශකයක් ලෙස භාවිතා කරයි.

එබැවින් ක්‍රියාකාරී වෙනස්කම් සාරාංශ කිරීමට:

substring(begin-offset, end-offset-exclusive)ආරම්භක ඕෆ්සෙට් 0හෝ ඊට වැඩි නම්

substr(begin-offset, length) ආරම්භක ඕෆ්සෙට් ද .ණ විය හැකිය

මෑතකදී මට හමු වූ තවත් කරුණක් නම් IE 8 හි "abcd".substr(-1)වැරදි ලෙස ආපසු පැමිණෙන "abcd"අතර ෆයර්ෆොක්ස් 3.6 නැවත "d"පැමිණිය යුතුය. sliceදෙකම මත නිවැරදිව ක්රියා කරයි.

මෙම මාතෘකාව පිළිබඳ වැඩි විස්තර මෙහි සොයාගත හැකිය .

ප්රධාන වෙනස එයයි

නැවත පැමිණිය හැකි උපරිම දිග නියම කිරීමට substr () ඔබට ඉඩ දෙයි

substring () මඟින් දර්ශක නියම කිරීමට ඔබට ඉඩ ලබා දෙන අතර දෙවන තර්කය ඇතුළත් නොවේ

සමාන තර්ක හා negative ණාත්මක තර්ක හැසිරවීම වැනි උපස්ථර () සහ උපස්ථර () අතර අමතර සියුම් කරුණු තිබේ. තවද උපස්ථර () සහ පෙත්ත () සමාන නමුත් සෑම විටම සමාන නොවේ.

  //*** length vs indices:
    "string".substring(2,4);  // "ri"   (start, end) indices / second value is NOT inclusive
    "string".substr(2,4);     // "ring" (start, length) length is the maximum length to return
    "string".slice(2,4);      // "ri"   (start, end) indices / second value is NOT inclusive

  //*** watch out for substring swap:
    "string".substring(3,2);  // "r"    (swaps the larger and the smaller number)
    "string".substr(3,2);     // "in"
    "string".slice(3,2);      // ""     (just returns "")

  //*** negative second argument:
    "string".substring(2,-4); // "st"   (converts negative numbers to 0, then swaps first and second position)
    "string".substr(2,-4);    // ""
    "string".slice(2,-4);     // ""

  //*** negative first argument:
    "string".substring(-3);   // "string"        
    "string".substr(-3);      // "ing"  (read from end of string)
    "string".slice(-3);       // "ing"        

වෙනස දෙවන පරාමිතියයි. ඔවුන්ගේ දෙවන පරාමිතීන් සංඛ්‍යා දෙකම වෙනස් කරුණු දෙකක් අපේක්ෂා කරයි:

උපස්ථරය භාවිතා කරන විට දෙවන පරාමිතිය ඇතුළත් නොකළ යුතු පළමු දර්ශකය වේ:

var s = "string";
s.substring(1, 3); // would return 'tr'

var s = "another example";
s.substring(3, 7); // would return 'ther'

උපස්ථරය භාවිතා කරන විට දෙවන පරාමිතිය උපස්ථරයට ඇතුළත් කළ යුතු අක්ෂර ගණන වේ:

var s = "string";
s.substr(1, 3); // would return 'tri'

var s = "another example";
s.substr(3, 7); // would return 'ther ex'

විශාල වෙනසක් වේ substr()ය යනු අතහැර ක්රමය තවමත් භාවිතා කළ හැකි බව, නමුත් ඔවුන් සම්පූර්ණයෙන්ම ටික අනාගතයේ දී ඉවත් කිරීමට අපේක්ෂා කරන නිසා පරෙස්සමින් භාවිත කළ යුතු ය. ඔබේ කේතයෙන් ඒවායේ භාවිතය ඉවත් කිරීමට ඔබ වැඩ කළ යුතුය. මෙම substring()ක්‍රමය සාර්ථක වූ අතර කලින් සඳහන් කළ ක්‍රමය නියම කළේය.

substring (): එයට "ආරම්භය" සහ "අවසානය" යන පරාමිති 2 ක් ඇත.

• ආරම්භක පරාමිතිය අවශ්‍ය වන අතර නිස්සාරණය ආරම්භ කළ යුතු ස්ථානය නියම කරයි.
• අවසන් පරාමිතිය අත්‍යවශ්‍ය නොවන අතර නිස්සාරණය අවසන් විය යුතු ස්ථානය නියම කරයි.

අවසාන පරාමිතිය නිශ්චිතව දක්වා නොමැති නම්, ආරම්භක ස්ථානයේ සිට නූල් අවසානය දක්වා සියලුම අක්ෂර උපුටා ගනු ලැබේ.

var str = "Substring Example";
var result = str.substring(0, 10);
alert(result);

Output : Substring

ආරම්භක පරාමිතියේ අගය අවසාන පරාමිතියේ වටිනාකමට වඩා වැඩි නම්, මෙම ක්‍රමය මඟින් තර්ක දෙක මාරු කරනු ඇත. මෙයින් අදහස් කරන්නේ ආරම්භය අවසානය ලෙසත් අවසානය ආරම්භය ලෙසත් භාවිතා වන බවයි.

var str = "Substring Example";
var result = str.substring(10, 0);
alert(result);

Output : Substring

substr () : එයට "ආරම්භය" සහ "ගණන් කිරීම" යන පරාමිති 2 ක් ඇත.

• ආරම්භක පරාමිතිය අවශ්‍ය වන අතර නිස්සාරණය ආරම්භ කළ යුතු ස්ථානය නියම කරයි.

• ගණන් පරාමිතිය අත්‍යවශ්‍ය නොවන අතර උපුටා ගැනීම සඳහා අක්ෂර ගණන නියම කරයි.

var str = "Substr Example";
var result = str.substr(0, 10);
alert(result);


Output : Substr Exa

ගණන් පරාමිතිය නිශ්චිතව දක්වා නොමැති නම්, ආරම්භක ස්ථානයේ සිට නූල් අවසානය දක්වා සියලුම අක්ෂර උපුටා ගනු ලැබේ. ගණන් කිරීම 0 හෝ negative ණ නම්, හිස් නූලක් ආපසු දෙනු ලැබේ.

var str = "Substr Example";
var result = str.substr(11);
alert(result);

Output : ple

පෙත්ත එදිරිව Substr එදිරිව Substring vs [] ක්‍රම

මෙම එක් එක් ජාවාස්ක්‍රිප්ට් ක්‍රමයට කාර්ය සාධන ප්‍රතිලාභ ඇත. කරුණාකර ඒ අනුව මෙම කාර්යයන් භාවිතා කරන්න.

උපස්ථරය (startIndex, endIndex (ඇතුළත් කර නැත))

substr (startIndex, අක්ෂර කීයක්)

const string = 'JavaScript';

console.log('substring(1,2)', string.substring(1,2)); // a
console.log('substr(1,2)', string.substr(1,2)); // av