ජාවාස්ක්‍රිප්ට් අරාවෙහි වටිනාකමක් තිබේද යන්න සොයා ගැනීමට වඩාත්ම සංක්ෂිප්ත හා කාර්යක්ෂම ක්‍රමය කුමක්ද?

එය කිරීමට මා දන්නා එකම ක්‍රමය මෙයයි:

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (a[i] === obj) {
            return true;
        }
    }
    return false;
}

මෙය ඉටු කිරීම සඳහා වඩා හොඳ හා සංක්ෂිප්ත ක්‍රමයක් තිබේද?

මෙය Stack Overflow ප්‍රශ්නයට ඉතා සමීපව සම්බන්ධ වේ ජාවාස්ක්‍රිප්ට් අරා හි අයිතමයක් සොයා ගැනීමට හොඳම ක්‍රමය? භාවිතා කරමින් අරාවෙහි වස්තු සොයා ගැනීම ආමන්ත්‍රණය කරයි indexOf.

නවීන බ්‍රව්සර් සතුව ඇත Array#includes, එය හරියටම එය කරන අතර IE හැර අන් සියල්ලන්ගේම පුළුල් සහයෝගය ලැබේ:

console.log(['joe', 'jane', 'mary'].includes('jane')); //true

ඔබට භාවිතා කළ හැකිය Array#indexOf, එය අඩු සෘජු ය, නමුත් යල් පැන ගිය බ්‍රව්සර් සඳහා බහු පිරවුම් අවශ්‍ය නොවේ.

බොහෝ රාමු සමාන ක්‍රම ඉදිරිපත් කරයි:

• jQuery: $.inArray(value, array, [fromIndex])
• Underscore.js: _.contains(array, value)( _.includeසහ අන්වර්ථ කර ඇත _.includes)
• ඩොජෝ මෙවලම් කට්ටලය: dojo.indexOf(array, value, [fromIndex, findLast])
• මූලාකෘතිය: array.indexOf(value)
• MooTools: array.indexOf(value)
• මොචිකිට්: findValue(array, value)
• එම්.එස්. අජැක්ස්: array.indexOf(value)
• දිග: Ext.Array.contains(array, value)
• ලොඩාෂ්: _.includes(array, value, [from])( _.containsපෙර 4.0.0 වේ)
• රාම්ඩා: R.includes(value, array)

සමහර රාමු මඟින් මෙය ශ්‍රිතයක් ලෙස ක්‍රියාත්මක කරන බව සලකන්න, අනෙක් ඒවා ශ්‍රිතය අරාව මූලාකෘතියට එක් කරයි.

2019 සිට යාවත්කාලීන කිරීම: මෙම පිළිතුර 2008 සිට (අවුරුදු 11 යි!) නවීන JS භාවිතය සඳහා අදාළ නොවේ. පොරොන්දු වූ කාර්ය සාධනය වැඩිදියුණු කිරීම පදනම් වූයේ එකල බ්‍රව්සර්වල කළ මිණුම් ලකුණක් මත ය. එය නූතන JS ක්‍රියාත්මක කිරීමේ සන්දර්භයන්ට අදාළ නොවිය හැකිය. ඔබට පහසු විසඳුමක් අවශ්‍ය නම්, වෙනත් පිළිතුරු සොයා බලන්න. ඔබට හොඳම කාර්ය සාධනය අවශ්‍ය නම්, අදාළ ක්‍රියාත්මක කිරීමේ පරිසරයන් තුළ ඔබම මිණුම් ලකුණක්.

අනෙක් අය පවසා ඇති පරිදි, අරාව හරහා පුනරාවර්තනය කිරීම හොඳම ක්‍රමය විය හැකි නමුත් ජාවාස්ක්‍රිප්ට් හි පුනරාවර්තනය සඳහා වේගවත්ම ක්‍රමය අඩු වන ලූපයක් බව ඔප්පු වී ඇතwhile . එබැවින් ඔබේ කේතය පහත පරිදි නැවත ලිවීමට ඔබට අවශ්‍ය විය හැකිය:

function contains(a, obj) {
    var i = a.length;
    while (i--) {
       if (a[i] === obj) {
           return true;
       }
    }
    return false;
}

ඇත්ත වශයෙන්ම, ඔබට අරේ මූලාකෘතිය ද දිගු කළ හැකිය:

Array.prototype.contains = function(obj) {
    var i = this.length;
    while (i--) {
        if (this[i] === obj) {
            return true;
        }
    }
    return false;
}

දැන් ඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය:

alert([1, 2, 3].contains(2)); // => true
alert([1, 2, 3].contains('2')); // => false

indexOf සමහර විට, නමුත් එය "ECMA-262 ප්‍රමිතියට ජාවාස්ක්‍රිප්ට් දිගුවකි; එබැවින් එය ප්‍රමිතියේ වෙනත් ක්‍රියාත්මක කිරීම්වල නොතිබිය හැකිය."

උදාහරණයක්:

[1, 2, 3].indexOf(1) => 0
["foo", "bar", "baz"].indexOf("bar") => 1
[1, 2, 3].indexOf(4) => -1

AFAICS මයික්රොසොෆ්ට් කරන්නේ නෑ යම් ආකාරයක විකල්පයක් ඉදිරිපත් මේ, එහෙත් ඔබ Internet Explorer (සහ සපයන්නේ නැත වෙනත් බ්රව්සරයන් තුළ පෙලගැස්මක් සමාන ක්රියාකාරිත්වය එක් කළ හැකිය indexOfලෙස ඔබට අවශ්ය නම්), ඉක්මන් ගූගල් සෙවුම් හෙළි , උදාහරණයක් ( මේ එක ).

ECMAScript 7 හඳුන්වා දෙයි Array.prototype.includes.

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

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

එය විකල්ප දෙවන තර්කයක් ද පිළිගනී fromIndex:

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

මෙන් නොව indexOfයොදා ගන්නා, දැඩි සමානතා සංසන්දනය , includesභාවිතා සංසන්දනය SameValueZero සමානාත්මතාවය ඇල්ගොරිතමය. එයින් අදහස් කරන්නේ අරාවකට ඇතුළත් වන්නේ නම් ඔබට හඳුනාගත හැකි බවයි NaN:

[1, 2, NaN].includes(NaN); // true

එසේම indexOf, includesනැතිවූ දර්ශක මඟහරින්නේ නැත:

new Array(5).includes(undefined); // true

දැනට එය තවමත් කෙටුම්පතක් වන නමුත් එය සියලු බ්‍රව්සර්වල වැඩ කිරීමට බහුඅවයවික කළ හැකිය .

ඉහළම පිළිතුරු ප්‍රාථමික වර්ග උපකල්පනය කරයි, නමුත් අරාවෙහි කිසියම් ගති ලක්ෂණයක් ඇති වස්තුවක් තිබේදැයි සොයා ගැනීමට ඔබට අවශ්‍ය නම් , Array.prototype.some () ඉතා අලංකාර විසඳුමකි:

const items = [ {a: '1'}, {a: '2'}, {a: '3'} ]

items.some(item => item.a === '3')  // returns true
items.some(item => item.a === '4')  // returns false

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

එසේම, එය ifබූලියන් ආපසු ලබා දෙන බැවින් එය ප්‍රකාශයකට හොඳින් ගැලපේ :

if (items.some(item => item.a === '3')) {
  // do something
}

* අදහස් දැක්වීමේදී ජේමස් පෙන්වා දුන් පරිදි, මෙම පිළිතුර වන අවස්ථාවේදී, 2018 සැප්තැම්බර්, Array.prototype.some()පූර්ණ සහය දක්වයි: caniuse.com ආධාරක වගුව

අපි කියමු ඔබ එවැනි පෙළක් අර්ථ දක්වා ඇති බව:

const array = [1, 2, 3, 4]

පහත දැක්වෙන්නේ එහි තිබේද යන්න පරීක්ෂා කිරීමේ ක්‍රම තුනක් 3. ඔවුන් සියලු එක්කෝ නැවත trueහෝ false.

ස්වදේශීය අරාව ක්‍රමය (ES2016 සිට) ( අනුකූලතා වගුව )

array.includes(3) // true

අභිරුචි අරා ක්‍රමය ලෙස (පෙර ES2016)

// Prefixing the method with '_' to avoid name clashes
Object.defineProperty(Array.prototype, '_includes', { value: function (v) { return this.indexOf(v) !== -1 }})
array._includes(3) // true

සරල කාර්යය

const includes = (a, v) => a.indexOf(v) !== -1
includes(array, 3) // true

මෙන්න ජාවාස්ක්‍රිප්ට් 1.6 අනුකූලව ක්‍රියාත්මක කිරීම Array.indexOf:

if (!Array.indexOf) {
    Array.indexOf = [].indexOf ?
        function(arr, obj, from) {
            return arr.indexOf(obj, from);
        } :
        function(arr, obj, from) { // (for IE6)
            var l = arr.length,
                i = from ? parseInt((1 * from) + (from < 0 ? l : 0), 10) : 0;
            i = i < 0 ? 0 : i;
            for (; i < l; i++) {
                if (i in arr && arr[i] === obj) {
                    return i;
                }
            }
            return -1;
        };
}

භාවිත:

function isInArray(array, search)
{
    return array.indexOf(search) >= 0;
}

// Usage
if(isInArray(my_array, "my_value"))
{
    //...
}

ජාවාස්ක්‍රිප්ට් Arrayවස්තුව දිගු කිරීම ඇත්තෙන්ම නරක අදහසකි, මන්ද ඔබ නව ගුණාංග (ඔබේ අභිරුචි ක්‍රම) for-inලූපවලට හඳුන්වා දෙන බැවින් පවතින ස්ක්‍රිප්ට් බිඳ දැමිය හැකිය. මීට වසර කිහිපයකට පෙර මූලාකෘතියේ කතුවරුන් පුස්තකාලයේ මේ ආකාරයේ දේ ඉවත් කිරීම සඳහා ඔවුන්ගේ පුස්තකාල ක්‍රියාත්මක කිරීම නැවත සැලසුම් කිරීමට සිදු විය.

ඔබේ පිටුවෙහි ක්‍රියාත්මක වන වෙනත් ජාවාස්ක්‍රිප්ට් සමඟ අනුකූල වීම ගැන කරදර වීමට ඔබට අවශ්‍ය නැතිනම්, ඒ සඳහා යන්න, එසේ නොමැති නම්, මම වඩාත් අමුතු, නමුත් ආරක්ෂිත නිදහස් ස්ථාවර ක්‍රියාකාරී විසඳුමක් නිර්දේශ කරමි.

එක් ලයිනර්:

function contains(arr, x) {
    return arr.filter(function(elem) { return elem == x }).length > 0;
}

තත්පරයකට කොටුවෙන් පිටත සිතීම, ඔබ මෙම ඇමතුම බොහෝ වාර ගණනක් කරන්නේ නම්, හැෂ් ශ්‍රිතයක් භාවිතා කර බැලීම් සිදු කිරීම සඳහා සහායක අරා සිතියමක් භාවිතා කිරීම වඩා කාර්යක්ෂම වේ.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

මම පහත සඳහන් දෑ භාවිතා කරමි:

Array.prototype.contains = function (v) {
    return this.indexOf(v) > -1;
}

var a = [ 'foo', 'bar' ];

a.contains('foo'); // true
a.contains('fox'); // false

function contains(a, obj) {
    return a.some(function(element){return element == obj;})
}

Array.prototype.some () 5 වන සංස්කරණයේ ECMA-262 ප්‍රමිතියට එකතු කරන ලදී

බලාපොරොත්තු සහගත වේගවත් ද්විපාර්ශ්වික indexOf/ lastIndexOfවිකල්පයක්

2015

නව ක්‍රමයට ඇතුළත් කිරීම ඉතා කදිම වුවත්, දැන් මූලික වශයෙන් සහාය ශුන්‍ය වේ.

මන්දගාමී දර්ශකය ඕෆ් / අන්තිම ඉන්ඩෙක්ස් ඕෆ් ශ්‍රිත ප්‍රතිස්ථාපනය කිරීමේ ක්‍රමයක් ගැන මා කල්පනා කරමින් සිටියේ බොහෝ කාලයක් ය.

ඉහළ පිළිතුරු දෙස බලන විට දැනටමත් ක්‍රියාකාරී ක්‍රමයක් සොයාගෙන ඇත. contains@ ඩමීර් සෙකික් විසින් පළ කරන ලද ශ්‍රිතය මම තෝරාගත් අයගෙන් වේගවත්ම එකක් විය යුතුය. එහෙත් මිණුම් සලකුණු 2008 සිට පැවත එන ඒවා යල් පැන ගිය ඒවා බව ද එහි සඳහන් වේ.

මම ද කැමති whileපුරා for, නමුත් මම පුඩුවක් සඳහා සමග මෙම උත්සවයට ලියන අවසන් විශේෂිත හේතුවක් නැත සඳහා. එය a සමඟ ද කළ හැකිය while --.

අරාව සිදු කරන අතරතුර දෙපැත්තෙන්ම පරීක්ෂා කර බැලුවහොත් නැවත කිරීම මන්දගාමී වේ දැයි මට කුතුහලයක් ඇති විය. පෙනෙන විදිහට නැත, එබැවින් මෙම ශ්‍රිතය ඉහළම ඡන්ද දායකයින්ට වඩා දෙගුණයක් වේගවත් වේ. නිසැකවම එය ස්වදේශිකයාට වඩා වේගවත් ය. මෙය සැබෑ ලෝක පරිසරයක, ඔබ සොයන වටිනාකම ආරම්භයේ හෝ අවසානයේ අරාවෙහි තිබේදැයි ඔබ කිසි විටෙක නොදැන සිටිති.

ඔබ වටිනාකමක් සහිත අරාවක් තල්ලු කළ බව ඔබ දන්නා විට, lastIndexOf භාවිතා කිරීම හොඳම විසඳුම ලෙස පවතී, නමුත් ඔබට විශාල අරා හරහා ගමන් කළ යුතු අතර ප්‍රති result ලය සෑම තැනකම තිබිය හැකි නම්, මෙය දේවල් වේගවත් කිරීමට ස්ථිර විසඳුමක් විය හැකිය.

ද්විපාර්ශ්වික දර්ශකයOf / lastIndexOf

function bidirectionalIndexOf(a, b, c, d, e){
  for(c=a.length,d=c*1; c--; ){
    if(a[c]==b) return c; //or this[c]===b
    if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b
  }
  return -1
}

//Usage
bidirectionalIndexOf(array,'value');

කාර්ය සාධනය ටෙස්ට්

http://jsperf.com/bidirectionalindexof

පරීක්ෂණය ලෙස මම 100k ඇතුළත් කිරීම් සහිත අරාවක් නිර්මාණය කළෙමි.

විමසුම් තුනක්: ආරම්භයේ දී, මැද හා අරාව අවසානයේ.

ඔබත් මෙය සිත්ගන්නාසුළු යැයි සොයාගෙන කාර්ය සාධනය පරීක්ෂා කරනු ඇතැයි මම බලාපොරොත්තු වෙමි.

සටහන: ඔබ දැක ගැනීමට හැකි වන පරිදි මම තරමක් වෙනස් contains(එසේ මූලික වශයෙන් indexOf සහ lastIndexOf ප්රතිදානය පිළිබිඹු කටයුතු කිරීමට trueසමග indexහා falseසමග -1). එය හානියක් නොවිය යුතුය.

අරාව මූලාකෘති ප්‍රභේදය

Object.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){
  for(c=this.length,d=c*1; c--; ){
    if(this[c]==b) return c; //or this[c]===b
    if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b
  }
  return -1
},writable:false, enumerable:false});

// Usage
array.bidirectionalIndexOf('value');

සත්‍ය හෝ අසත්‍ය හෝ වස්තුව, නූල හෝ එය කුමක් වුවත් ආපසු ලබා දීම සඳහා ශ්‍රිතය පහසුවෙන් වෙනස් කළ හැකිය.

මෙන්න whileප්‍රභේදය:

function bidirectionalIndexOf(a, b, c, d){
  c=a.length; d=c-1;
  while(c--){
    if(b===a[c]) return c;
    if(b===a[d-c]) return d-c;
  }
  return c
}

// Usage
bidirectionalIndexOf(array,'value');

මෙය කළ හැක්කේ කෙසේද?

අරාව තුළ පරාවර්තනය වූ දර්ශකය ලබා ගැනීම සඳහා සරල ගණනය කිරීම ඉතා සරල යැයි මම සිතමි.

පුනරාවර්තනයකට චෙක්පත් තුනක් කරන සංකීර්ණ උදාහරණයක් මෙන්න, නමුත් මෙය කළ හැක්කේ කේතය මන්දගාමී වීමට හේතු වන දිගු ගණනය කිරීමකින් පමණි.

http://jsperf.com/bidirectionalindexof/2

කාර්ය සාධනය

අද 2020.01.07 තෝරාගත් විසඳුම් 15 ක් සඳහා ක්‍රෝම් v78.0.0, සෆාරි v13.0.4 සහ ෆයර්ෆොක්ස් v71.0.0 මත මැක් ඕස් හයිසෙයිරා 10.13.6 හි පරීක්ෂණ සිදු කරමි. නිගමන

• මත පදනම් වූ විසඳුම් JSON, Setපුදුමfind (K, N, O) සියලු බ්රව්සර් මත මන්දගාමී වේ වේ
• es6 includes (F) වේගවත් වන්නේ ක්‍රෝම් මත පමණි
• මත පදනම් වූ විසඳුම් for(C, D) සහindexOf (G, H) කුඩා හා විශාල අරා වල ඇති සියලුම බ්‍රව්සර්වල ඉතා වේගවත් බැවින් ඒවා කාර්යක්ෂම විසඳුමක් සඳහා හොඳම තේරීම විය හැකිය
• ලූපය තුළ දර්ශකය අඩු වන විසඳුම්, (බී) මන්දගාමී වන්නේ බොහෝ විට CPU හැඹිලි ක්‍රමය ක්‍රියාත්මක වන බැවිනි.
• සෙවූ මූලද්‍රව්‍යය අරාවෙහි දිගින් 66% ක් වන විට මම විශාල අරාව සඳහා පරීක්‍ෂණයක් forපවත්වමි. සී සහ ඩී වලට වඩා 20% මන්දගාමී වේ)

ප්රතිපල

විස්තර

මම පරීක්ෂණ අවස්ථා 2 ක් සිදු කරමි: මූලද්‍රව්‍ය 10 ක් සහිත අරාව සඳහා සහ මිලියන් මූලද්‍රව්‍ය 1 ක් සහිත අරාව සඳහා. අවස්ථා දෙකේදීම අපි සෙවූ මූලද්‍රව්‍යය අරාව මැදට දැමුවෙමු.

let log = (name,f) => console.log(`${name}: 3-${f(arr,'s10')}  's7'-${f(arr,'s7')}  6-${f(arr,6)} 's3'-${f(arr,'s3')}`)

let arr = [1,2,3,4,5,'s6','s7','s8','s9','s10'];
//arr = new Array(1000000).fill(123); arr[500000]=7;

function A(a, val) {
    var i = -1;
    var n = a.length;
    while (i++<n) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function B(a, val) {
    var i = a.length;
    while (i--) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function C(a, val) {
    for (var i = 0; i < a.length; i++) {
        if (a[i] === val) return true;
    }
    return false;
}

function D(a,val)
{
    var len = a.length;
    for(var i = 0 ; i < len;i++)
    {
        if(a[i] === val) return true;
    }
    return false;
} 

function E(a, val){  
  var n = a.length-1;
  var t = n/2;
  for (var i = 0; i <= t; i++) {
        if (a[i] === val || a[n-i] === val) return true;
  }
  return false;
}

function F(a,val) {
	return a.includes(val);
}

function G(a,val) {
	return a.indexOf(val)>=0;
}

function H(a,val) {
	return !!~a.indexOf(val);
}

function I(a, val) {
  return a.findIndex(x=> x==val)>=0;
}

function J(a,val) {
	return a.some(x=> x===val);
}

function K(a, val) {
  const s = JSON.stringify(val);
  return a.some(x => JSON.stringify(x) === s);
}

function L(a,val) {
	return !a.every(x=> x!==val);
}

function M(a, val) {
  return !!a.find(x=> x==val);
}

function N(a,val) {
	return a.filter(x=>x===val).length > 0;
}

function O(a, val) {
  return new Set(a).has(val);
}

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);

This shippet only presents functions used in performance tests - it not perform tests itself!

කුඩා අරා - මූලද්රව්ය 10 ක්

ඔබේ යන්ත්‍රය තුළ පරීක්ෂණ සිදු කළ හැකිය මෙතැන

විශාල අරා - 1.000.000 මූලද්රව්ය

ඔබේ යන්ත්‍රය තුළ පරීක්ෂණ සිදු කළ හැකිය මෙතැන

ඔබ ජාවාස්ක්‍රිප්ට් 1.6 හෝ ඊට පසු භාවිතා කරන්නේ නම් (ෆයර්ෆොක්ස් 1.5 හෝ ඊට පසු) ඔබට Array.indexOf භාවිතා කළ හැකිය . එසේ නොමැතිනම්, මම සිතන්නේ ඔබ ඔබේ මුල් කේතයට සමාන දෙයක් සමඟ අවසන් වනු ඇත.

function inArray(elem,array)
{
    var len = array.length;
    for(var i = 0 ; i < len;i++)
    {
        if(array[i] == elem){return i;}
    }
    return -1;
} 

අරාව දර්ශකය හමු වුවහොත් හෝ -1 සොයාගත නොහැකි නම් ලබා දෙයි

අපි මෙම ස්නිපටය භාවිතා කරමු (වස්තු, අරා, නූල් සමඟ ක්‍රියා කරයි):

/*
 * @function
 * @name Object.prototype.inArray
 * @description Extend Object prototype within inArray function
 *
 * @param {mix}    needle       - Search-able needle
 * @param {bool}   searchInKey  - Search needle in keys?
 *
 */
Object.defineProperty(Object.prototype, 'inArray',{
    value: function(needle, searchInKey){

        var object = this;

        if( Object.prototype.toString.call(needle) === '[object Object]' || 
            Object.prototype.toString.call(needle) === '[object Array]'){
            needle = JSON.stringify(needle);
        }

        return Object.keys(object).some(function(key){

            var value = object[key];

            if( Object.prototype.toString.call(value) === '[object Object]' || 
                Object.prototype.toString.call(value) === '[object Array]'){
                value = JSON.stringify(value);
            }

            if(searchInKey){
                if(value === needle || key === needle){
                return true;
                }
            }else{
                if(value === needle){
                    return true;
                }
            }
        });
    },
    writable: true,
    configurable: true,
    enumerable: false
});

භාවිතය:

var a = {one: "first", two: "second", foo: {three: "third"}};
a.inArray("first");          //true
a.inArray("foo");            //false
a.inArray("foo", true);      //true - search by keys
a.inArray({three: "third"}); //true

var b = ["one", "two", "three", "four", {foo: 'val'}];
b.inArray("one");         //true
b.inArray('foo');         //false
b.inArray({foo: 'val'})   //true
b.inArray("{foo: 'val'}") //false

var c = "String";
c.inArray("S");        //true
c.inArray("s");        //false
c.inArray("2", true);  //true
c.inArray("20", true); //false

අරාවෙහි වස්තුවක පැවැත්ම සඳහා ඔබ නැවත නැවතත් පරීක්ෂා කරන්නේ නම්, ඔබ සොයා බැලිය යුතුය

1. ඔබගේ අරාව තුළට ඇතුළු කිරීමේ වර්ග කිරීම මඟින් සෑම විටම අරාව වර්ග කර තබා ගැනීම (නව වස්තු නිවැරදි ස්ථානයට දමන්න)
2. ඉවත් කරන්න + වර්ග කළ ඇතුළු කිරීමේ ක්‍රියාවලිය ලෙස වස්තු යාවත්කාලීන කරන්න
3. ඔබගේ ද්විමය සෙවුම් සෙවීමක් භාවිතා කරන්න contains(a, obj).

සියලුම නවීන බ්‍රව්සර්වල ක්‍රියාත්මක වන විසඳුම:

function contains(arr, obj) {
  const stringifiedObj = JSON.stringify(obj); // Cache our object to not call `JSON.stringify` on every iteration
  return arr.some(item => JSON.stringify(item) === stringifiedObj);
}

භාවිතය:

contains([{a: 1}, {a: 2}], {a: 1}); // true

IE6 + විසඳුම:

function contains(arr, obj) {
  var stringifiedObj = JSON.stringify(obj)
  return arr.some(function (item) {
    return JSON.stringify(item) === stringifiedObj;
  });
}

// .some polyfill, not needed for IE9+
if (!('some' in Array.prototype)) {
  Array.prototype.some = function (tester, that /*opt*/) {
    for (var i = 0, n = this.length; i < n; i++) {
      if (i in this && tester.call(that, this[i], i, this)) return true;
    } return false;
  };
}

භාවිතය:

contains([{a: 1}, {a: 2}], {a: 1}); // true

භාවිතා කළ යුත්තේ ඇයි JSON.stringify?

Array.indexOfසහ Array.includes(මෙන්ම මෙහි ඇති බොහෝ පිළිතුරු) සංසන්දනය කරන්නේ යොමු කිරීමෙන් මිස වටිනාකමෙන් නොවේ.

[{a: 1}, {a: 2}].includes({a: 1});
// false, because {a: 1} is a new object

පාරිතෝෂිකය

ප්‍රශස්තිකරණය නොකළ ES6 එක්-ලයිනර්:

[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));
// true

සටහන: යතුරු එකම අනුපිළිවෙලකට තිබේ නම් වස්තු සංසන්දනය කිරීම වඩා හොඳ වනු ඇත, එබැවින් ආරක්ෂිත වීමට නම් ඔබට පළමුව යතුරු මෙවැනි පැකේජයක් සමඟ වර්ග කළ හැකිය: https://www.npmjs.com/package/sort-keys

containsපරිපූර්ණ ප්‍රශස්තිකරණයකින් ශ්‍රිතය යාවත්කාලීන කරන ලදි . ස්තුති itinance එය පෙන්වා දෙමින් ය.

ලොඩාෂ්ගේ යම් කාර්යයක් භාවිතා කරන්න .

එය සංක්ෂිප්ත, නිරවද්‍ය සහ හරස් වේදිකා සහාය ඇත.

පිළිගත් පිළිතුර අවශ්‍යතා පවා සපුරාලන්නේ නැත.

අවශ්‍යතා: ජාවාස්ක්‍රිප්ට් අරාවෙහි වස්තුවක් තිබේදැයි සොයා බැලීමට වඩාත් සංක්ෂිප්ත හා කාර්යක්ෂම ක්‍රමයක් නිර්දේශ කරන්න.

පිළිගත් පිළිතුර:

$.inArray({'b': 2}, [{'a': 1}, {'b': 2}])
> -1

මගේ නිර්දේශය:

_.some([{'a': 1}, {'b': 2}], {'b': 2})
> true

සටහන්:

$ .inArray තිබේද යන්න තීරණය කිරීම සඳහා දඩ වැඩ අදිශ රාශියක් අගය scalars රැසක් තුළ පවත්නා ...

$.inArray(2, [1,2])
> 1

... නමුත් ප්‍රශ්නය පැහැදිලිවම අසන්නේ වස්තුවක් අරාවෙහි අඩංගු දැයි තීරණය කිරීමට කාර්යක්ෂම ක්‍රමයක් ය .

පරිමාණයන් සහ වස්තු යන දෙකම හැසිරවීම සඳහා, ඔබට මෙය කළ හැකිය:

(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)

ECMAScript 6 සොයා ගැනීම සඳහා අලංකාර යෝජනාවක් ඇත.

සෙවුම් ක්‍රමය මඟින් අරාවෙහි ඇති සෑම මූලද්‍රව්‍යයක් සඳහාම එක් වරක් නැවත ඇමතුම් ලබා ගැනීමේ ක්‍රියාවලිය ක්‍රියාත්මක කරයි. එවැනි මූලද්‍රව්‍යයක් සොයාගත හොත්, එම මූලද්‍රව්‍යයේ වටිනාකම වහාම සොයා ගන්න. එසේ නොමැති නම්, නිර්වචනය නොකළ ප්‍රතිලාභ සොයා ගන්න. ඇමතුම් ලබා ගැනීම ඉල්ලා සිටින්නේ අගයන් පවරා ඇති අරාවේ දර්ශක සඳහා පමණි; මකාදැමූ හෝ කිසි විටෙකත් අගයන් පවරා නොමැති දර්ශක සඳහා එය ආයාචනා නොකෙරේ.

මෙන්න ඒ පිළිබඳ එම්ඩීඑන් ලියකියවිලි .

සොයා ගැනීමේ ක්‍රියාකාරිත්වය මේ ආකාරයට ක්‍රියා කරයි.

function isPrime(element, index, array) {
    var start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) return false;
    }
    return (element > 1);
}

console.log( [4, 6, 8, 12].find(isPrime) ); // Undefined, not found
console.log( [4, 5, 8, 12].find(isPrime) ); // 5

ශ්‍රිතය නිර්වචනය කිරීමෙන් ඔබට මෙය ECMAScript 5 සහ ඊට පහළින් භාවිතා කළ හැකිය .

if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(predicate) {
      if (this == null) {
        throw new TypeError('Array.prototype.find called on null or undefined');
      }
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }
      var list = Object(this);
      var length = list.length >>> 0;
      var thisArg = arguments[1];
      var value;

      for (var i = 0; i < length; i++) {
        if (i in list) {
          value = list[i];
          if (predicate.call(thisArg, value, i, list)) {
            return value;
          }
        }
      }
      return undefined;
    }
  });
}

අතර array.indexOf(x)!=-1මෙය කිරීමට වඩාත් සංක්ෂිප්ත මාර්ගය (සහ ... දශකයකට වැඩි කාලයක් නොවන Internet Explorer වෙබ් බ්රව්සර සහයෝගය කර ඇත), එය එසේ නොවේ සාමාන්ය (1), දරුණු වන වන අතර, ඒ වෙනුවට, සාමාන්ය (N). ඔබේ මාලාවක් වෙනස් කළ නොහැකි වනු ඇත නම්, ඔබ, එය hashtable ඔබේ මාලාවක් බවට පරිවර්තනය පසුව කළ හැකි table[x]!==undefinedහෝ ===undefined:

Array.prototype.toTable = function() {
    var t = {};
    this.forEach(function(x){t[x]=true});
    return t;
}

නිරූපණය:

var toRemove = [2,4].toTable();
[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})

. උදාහරණයක් ලෙස පයිතන් මෙන් නොව මෙම තත්වය පවත්වා ගැනීමට ඔබට ඉඩ දෙන්න.)

කෙනෙකුට "ඇති ()" ක්‍රමය ඇති සෙට් භාවිතා කළ හැකිය :

function contains(arr, obj) {
      var proxy = new Set(arr);
      if (proxy.has(obj))
        return true;
      else
        return false;
    }

    var arr = ['Happy', 'New', 'Year'];
    console.log(contains(arr, 'Happy'));

භාවිත:

var myArray = ['yellow', 'orange', 'red'] ;

alert(!!~myArray.indexOf('red')); //true

නිරූපණය

tilde ~මෙම අවස්ථාවේදී කරන්නේ කුමක්දැයි හරියටම දැන ගැනීමට, මෙම ප්‍රශ්නය වෙත යොමු වන්න ප්‍රකාශනයකට පෙර ටිල්ඩයක් කරන්නේ කුමක්ද? .

හරි, ප්‍රති result ලය ලබා ගැනීම සඳහා ඔබේ කේතය ප්‍රශස්තිකරණය කළ හැකිය !

මෙය කිරීමට වඩා පිරිසිදු හා වඩා හොඳ ක්‍රම බොහොමයක් ඇත, නමුත් මට අවශ්‍ය වූයේ ඔබේ රටාව ලබාගෙන එම භාවිතයට අදාළ කර ගැනීමටය JSON.stringify, ඔබේ නඩුවේදී මෙවැනි දෙයක් කරන්න:

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (JSON.stringify(a[i]) === JSON.stringify(obj)) {
            return true;
        }
    }
    return false;
}

කොහෙත්ම හොඳම දේ නොවේ, නමුත් මම නිර්මාණශීලී වෙමින් තාලයට එකතු කරමින් සිටියෙමි.

මෙය භාවිතා නොකරන්න

Object.defineProperty(Array.prototype, 'exists', {
  value: function(element, index) {

    var index = index || 0

    return index === this.length ? -1 : this[index] === element ? index : this.exists(element, ++index)
  }
})


// Outputs 1
console.log(['one', 'two'].exists('two'));

// Outputs -1
console.log(['one', 'two'].exists('three'));

console.log(['one', 'two', 'three', 'four'].exists('four'));

මගේ ශත 2 එකතු කරමින් මෙම ප්‍රශ්නයට තවමත් නවතම සින්ටැක්ස් එකතු නොවීම ගැන පුදුමයට පත්වේ.

අපි කියමු අපට අර්‍ග වස්තු පෙළක් ඇති අතර අපට එහි වස්තු සෙවීමට අවශ්‍යයි.

Array.prototype. indexOf -> (ප්‍රතිලාභ දර්ශකය හෝ -1 ) සාමාන්‍යයෙන් අරාවෙහි මූලද්‍රව්‍ය දර්ශකය සොයා ගැනීම සඳහා භාවිතා කරයි. මෙය වස්තුව සෙවීම සඳහා ද භාවිතා කළ හැකි නමුත් එය ක්‍රියාත්මක වන්නේ ඔබ එකම වස්තුවක් වෙත යොමු කරන්නේ නම් පමණි.

let obj = { name: 'Sumer', age: 36 };
let arrObj = [obj, { name: 'Kishor', age: 46 }, { name: 'Rupen', age: 26 }];


console.log(arrObj.indexOf(obj));// 0
console.log(arrObj.indexOf({ name: 'Sumer', age: 36 })); //-1

console.log([1, 3, 5, 2].indexOf(2)); //3

Array.prototype. ඇතුළත් - - ( සත්‍ය හෝ අසත්‍ය ප්‍රතිලාභ )

console.log(arrObj.includes(obj));  //true
console.log(arrObj.includes({ name: 'Sumer', age: 36 })); //false

console.log([1, 3, 5, 2].includes(2)); //true

Array.prototype. find -> (ඇමතුම ලබා ගනී, පළමු අගය / වස්තුව CB හි සත්‍ය බවට පත් කරයි).

console.log(arrObj.find(e => e.age > 40));  //{ name: 'Kishor', age: 46 }
console.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }

console.log([1, 3, 5, 2].find(e => e > 2)); //3

Array.prototype. findIndex -> ( ඇමතුම ලබා ගනී, පළමු අගය / වස්තුවෙහි දර්ශකය CB හි සත්‍ය බවට පත්වේ ).

console.log(arrObj.findIndex(e => e.age > 40));  //1
console.log(arrObj.findIndex(e => e.age > 40)); //1

console.log([1, 3, 5, 2].findIndex(e => e > 2)); //1

Find and findIndex නැවත ඇමතුමක් ගන්නා බැවින්, සත්‍ය තත්වය නිර්මාණාත්මකව සැකසීමෙන් අපට ඕනෑම වස්තුවක් (අපට යොමු කිරීමක් නොමැති වුවද) අරාවෙන් ලබා ගත හැකිය.

මෙම අවශ්‍යතාවය සඳහා සරල විසඳුමක් භාවිතා කිරීමයි find()

ඔබට පහත වැනි වස්තු සමූහයක් තිබේ නම්,

var users = [{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "admin"},
{id: "105", name: "user"}];

එවිට ඔබේ අගය සහිත වස්තුව දැනටමත් තිබේද නැද්ද යන්න පරීක්ෂා කළ හැකිය

let data = users.find(object => object['id'] === '104');

දත්ත ශුන්‍ය නම් පරිපාලක නැත, එසේ නොමැති නම් එය පහත දැක්වෙන ආකාරයට පවතින වස්තුව නැවත ලබා දෙනු ඇත.

{id: "104", name: "admin"}

එවිට ඔබට අරාවෙහි ඇති වස්තුවෙහි දර්ශකය සොයා ගත හැකි අතර පහත කේතය භාවිතා කර වස්තුව ප්‍රතිස්ථාපනය කරන්න.

let indexToUpdate = users.indexOf(data);
let newObject = {id: "104", name: "customer"};
users[indexToUpdate] = newObject;//your new object
console.log(users);

ඔබට පහත වැනි අගය ලැබෙනු ඇත

[{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "customer"},
{id: "105", name: "user"}];

මෙය ඕනෑම කෙනෙකුට උපකාරී වේ යැයි සිතමි.