javascript array একটি অ্যারে জাভাস্ক্রিপ্ট একটি বস্তু অন্তর্ভুক্ত যদি আমি কিভাবে পরীক্ষা করবেন?




array in c (24)

একটি জাভাস্ক্রিপ্ট অ্যারে একটি বস্তু রয়েছে যদি খুঁজে বের করতে সবচেয়ে সংক্ষিপ্ত এবং দক্ষ উপায় কি?

আমি এটা করতে একমাত্র উপায় জানি:

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

এই সম্পন্ন একটি ভাল এবং আরো সংক্ষিপ্ত উপায় আছে?

এটি স্ট্যাক ওভারফ্লো প্রশ্নটির সাথে খুব ঘনিষ্ঠভাবে সম্পর্কিত একটি জাভাস্ক্রিপ্ট অ্যারেতে কোনও আইটেম খুঁজে পাওয়ার সেরা উপায়? indexOf ব্যবহার করে একটি অ্যারের মধ্যে বস্তু ফাইন্ডিং যা ঠিকানা।


আমি নিম্নলিখিত ব্যবহার করুন:

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

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

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

একটি Set ব্যবহার করতে পারে যার পদ্ধতি আছে "আছে ()":

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

আমরা এই স্নিপেটটি ব্যবহার করি (বস্তু, অ্যারে, স্ট্রিংগুলির সাথে কাজ করে):

/*
 * @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.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;
      };
}

উপরের উত্তরগুলি প্রাথমিক ধরনের অনুমান করে তবে যদি আপনি কোন অ্যারের কিছু বৈশিষ্ট্য সহ কোনও বস্তু ধারণ করেন তা খুঁজে বের করতে চান, 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 সমর্থন টেবিল


কোনও উপায়ে সেরাটি নয়, তবে আমি কেবল সৃজনশীল হয়ে ওঠার জন্য যোগদান করছিলাম।

এই ব্যবহার করবেন না

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


আপনি এই কৌশল ব্যবহার করতে পারেন:

var arrayContains = function(object) {
  return (serverList.filter(function(currentObject) {
    if (currentObject === object) {
      return currentObject
    }
    else {
      return false;
    }
  }).length > 0) ? true : false
}

ব্যবহার করুন:

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

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

আপনি যদি জাভাস্ক্রিপ্ট 1.6 বা তার পরে ব্যবহার করেন (ফায়ারফক্স 1.5 বা তার পরে) আপনি Array.indexOf ব্যবহার করতে পারেন। অন্যথায়, আমি মনে করি আপনি আপনার মূল কোডের মতো কিছু শেষ করতে যাচ্ছেন।


সমাধান যে সব আধুনিক ব্রাউজারে কাজ করে:

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 ব্যবহার 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

একটি perf অপ্টিমাইজেশান সহ contains ফাংশন আপডেট। এটা ইঙ্গিত জন্য ধন্যবাদ itinance ।


যদিও array.indexOf(x)!=-1 এটি করার সবচেয়ে সংক্ষিপ্ত উপায় (এবং দশক ধরে অ-ইন্টারনেট এক্সপ্লোরার ব্রাউজার দ্বারা সমর্থিত ...), এটি O (1) নয়, বরং O (1) এন), যা ভয়ানক। যদি আপনার অ্যারে পরিবর্তিত হবে না, তবে আপনি আপনার অ্যারে একটি হ্যাশেবলিতে রূপান্তর করতে পারেন, তারপরে 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})

(দুর্ভাগ্যবশত, যখন আপনি একটি অ্যারে.প্রোটোটাইপ.contains তৈরি করতে পারেন তখন একটি অ্যারে "ফ্রিজ" করতে এবং এই। ক্যাশে দুই লাইনে একটি হ্যাশ টেবিল সংরক্ষণ করুন, যদি আপনি পরে আপনার অ্যারে সম্পাদনা করতে পছন্দ করেন তবে এটি ভুল ফলাফল দেবে। জাভাস্ক্রিপ্টে অপর্যাপ্ত হুকগুলি রয়েছে উদাহরণস্বরূপ পাইথনের বিপরীতে আপনি এই অবস্থাটি রাখতে দিন।)


বর্তমান ব্রাউজারগুলির Array#includes যা ঠিক আছে , এটি ব্যাপকভাবে সমর্থিত এবং পুরানো ব্রাউজারগুলির জন্য একটি polyfill রয়েছে।

> ['joe', 'jane', 'mary'].includes('jane');
true 

আপনি Array#indexOf ব্যবহার করতে পারেন যা কম সরাসরি, তবে বহিরাগত ব্রাউজারগুলির জন্য পলিফিলগুলির প্রয়োজন হয় না।

jQuery $.inArray অফার করে যা কার্যকরীভাবে Array#indexOf সমতুল্য।

underscore.js , একটি জাভাস্ক্রিপ্ট ইউটিলিটি লাইব্রেরি, _.contains(list, value) , ওরফে _.include(list, value) , যা উভয় _.include(list, value) ব্যবহার করে যদি কোনও জাভাস্ক্রিপ্ট অ্যারে পাস করে তবে অভ্যন্তরীণভাবে।

কিছু অন্যান্য কাঠামো অনুরূপ পদ্ধতি প্রস্তাব:

লক্ষ্য করুন কিছু কাঠামো এটি একটি ফাংশন হিসাবে বাস্তবায়ন করে, অন্যরা ফাংশনটিকে অ্যারে প্রোটোটাইপে যুক্ত করে।


ঠিক আছে, আপনি ফলাফল পেতে আপনার কোডটি অপ্টিমাইজ করতে পারেন!এটি পরিষ্কার করার জন্য অনেকগুলি উপায় রয়েছে যা আরও পরিষ্কার এবং উন্নত, তবে আমি কেবল আপনার প্যাটার্ন পেতে চাই এবং সেটি প্রয়োগ 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;
}

b মান, এবং a অ্যারে হয়। এটা true বা false ফেরত দেয়:

function(a, b) {
    return a.indexOf(b) != -1
}

জাভাস্ক্রিপ্ট Array অবজেক্টটি সম্প্রসারিত করা সত্যিই একটি খারাপ ধারণা কারণ আপনি নতুন বৈশিষ্ট্যগুলি (আপনার কাস্টম পদ্ধতি) ফায়ার for-in লুপগুলিতে উপস্থাপন করেন যা বিদ্যমান স্ক্রিপ্টগুলি ভাঙ্গতে পারে। কয়েক বছর আগে Prototype লাইব্রেরির লেখককে এই ধরনের জিনিসটি অপসারণের জন্য তাদের লাইব্রেরির বাস্তবায়ন পুনরায়-ইঞ্জিন করতে হয়েছিল।

যদি আপনার পৃষ্ঠাতে চলমান অন্যান্য জাভাস্ক্রিপ্টের সাথে সামঞ্জস্য সম্পর্কে চিন্তা করতে না হয় তবে এটির জন্য যান, অন্যথা, আমি আরো বেদনাদায়ক, কিন্তু নিরাপদ মুক্ত স্থায়ী ফাংশন সমাধানটি সুপারিশ করব।


ECMAScript 6 খুঁজে পাওয়া একটি মার্জিত প্রস্তাব আছে।

সন্ধান পদ্ধতিটি অ্যারে উপস্থিত প্রতিটি উপাদানটির জন্য একবার কলব্যাক ফাংশনটি কার্যকর করে না যতক্ষণ না এটি এমন একটি খুঁজে পায় যেখানে কলব্যাক একটি সত্য মান প্রদান করে। যদি এই ধরনের একটি উপাদান পাওয়া যায়, অবিলম্বে যে উপাদান মান ফেরত পাওয়া। অন্যথায়, অনির্ধারিত আয় খুঁজুন। কলব্যাক শুধুমাত্র অ্যারের সূচীগুলির জন্য আহ্বান করা হয়েছে যা মান নির্ধারণ করেছে; এটি সূচীগুলির জন্য আহ্বান করা হয় না যা মুছে ফেলা হয়েছে বা কোনও মান নির্ধারিত হয়নি।

এখানে যে MDN ডকুমেন্টেশন হয়।

অনুসন্ধান কার্যকারিতা এই কাজ করে।

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

লোডশ এর some ফাংশন ব্যবহার করুন।

এটা সংক্ষিপ্ত, সঠিক এবং মহান ক্রস প্ল্যাটফর্ম সমর্থন আছে।

গৃহীত উত্তর এমনকি প্রয়োজনীয়তা পূরণ না।

প্রয়োজনীয়তা: একটি জাভাস্ক্রিপ্ট অ্যারে একটি বস্তু রয়েছে কিনা তা খুঁজে বের করতে সবচেয়ে সংক্ষিপ্ত এবং কার্যকরী উপায় সুপারিশ করুন।

গ্রহণযোগ্য উত্তর:

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

আমার সুপারিশ:

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

নোট:

$ .inArray scalars একটি অ্যারে বিদ্যমান বিদ্যমান কিনা তা নির্ধারণ করার জন্য জরিমানা কাজ করে ...

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

... কিন্তু প্রশ্নটি অ্যারেতে থাকা কোন বস্তুটি নির্ণয় করার জন্য একটি কার্যকর পদ্ধতির জন্য স্পষ্টভাবে জিজ্ঞাসা করে।

উভয় scalars এবং বস্তু হ্যান্ডেল করার জন্য, আপনি এই কাজ করতে পারে:

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

indexOf সম্ভবত, কিন্তু এটি একটি "জাভাস্ক্রিপ্ট এক্সটেনশন ECMA-262 মানক; যেমন এটি স্ট্যান্ডার্ডের অন্যান্য বাস্তবায়নে উপস্থিত হতে পারে না।"

উদাহরণ:

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

AFICICS মাইক্রোসফ্ট এইরকম কোনও বিকল্প প্রস্তাব দেয় না , তবে আপনি যদি ইন্টারনেট এক্সপ্লোরার (এবং অন্যান্য ব্রাউজার যা indexOf সমর্থন করে না) এ অ্যারেগুলিতেও একই কার্যকারিতা যুক্ত করতে পারেন তবে দ্রুত গুগল অনুসন্ধানটি প্রকাশ করে (উদাহরণস্বরূপ, এটি এক )।


ব্যবহার করুন:

Array.prototype.contains = function(x){
  var retVal = -1;

  // x is a primitive type
  if(["string","number"].indexOf(typeof x)>=0 ){ retVal = this.indexOf(x);}

  // x is a function
  else if(typeof x =="function") for(var ix in this){
    if((this[ix]+"")==(x+"")) retVal = ix;
  }

  //x is an object...
  else {
    var sx=JSON.stringify(x);
    for(var ix in this){
      if(typeof this[ix] =="object" && JSON.stringify(this[ix])==sx) retVal = ix;
    }
  }

  //Return False if -1 else number if numeric otherwise string
  return (retVal === -1)?false : ( isNaN(+retVal) ? retVal : +retVal);
}

আমি জানি এটি যেতে সর্বোত্তম উপায় নয়, কিন্তু যেহেতু বস্তুগুলির মধ্যে ইন্টারঅ্যাক্ট করার জন্য কোনও স্থানীয় IComparable উপায় নেই, তাই আমি অনুমান করি যে এটি একটি অ্যারেতে দুটি সংস্থার তুলনা করতে পারে। এছাড়াও, অ্যারে অবজেক্টটি প্রসারিত করা বিজ্ঞতার কাজ নয় তবে কখনও কখনও এটি ঠিক আছে (যদি আপনি এটি সম্পর্কে সচেতন হন এবং ট্রেড-অফ)।


অন্যদের উল্লেখ করেছেন যে আপনি ব্যবহার করতে পারেন Array.indexOf, কিন্তু এটি সব ব্রাউজারে পাওয়া যায় না। https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf থেকে কোডটি এখানে পুরানো ব্রাউজারে একই কাজ করার জন্য।

indexOf ECMA-262 মানদণ্ডের সাম্প্রতিক সংযোজন; যেমন এটি সব ব্রাউজারে উপস্থিত হতে পারে না।আপনার স্ক্রিপ্টের শুরুতে নিচের কোডটি সন্নিবেশ করে আপনি এটির চারপাশে কাজ করতে পারেন, প্রয়োগগুলির প্রয়োগকে অনুমতি প্রদান করে যা এটি সমর্থন করে না। এই অ্যালগরিদম ঠিক ইসিএমএ -২6২, 5 ম সংস্করণে উল্লেখিত, বস্তু, টাইপ ইরেকর, সংখ্যা, Math.floor, Math.abs, এবং Math.max অনুমান করা তাদের মূল মান রয়েছে।

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
        "use strict";
        if (this == null) {
            throw new TypeError();
        }
        var t = Object(this);
        var len = t.length >>> 0;
        if (len === 0) {
            return -1;
        }
        var n = 0;
        if (arguments.length > 1) {
            n = Number(arguments[1]);
            if (n != n) { // shortcut for verifying if it's NaN
                n = 0;
            } else if (n != 0 && n != Infinity && n != -Infinity) {
                n = (n > 0 || -1) * Math.floor(Math.abs(n));
            }
        }
        if (n >= len) {
            return -1;
        }
        var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
        for (; k < len; k++) {
            if (k in t && t[k] === searchElement) {
                return k;
            }
        }
        return -1;
    }
}

ECMAScript 7 array.includes(value)

এটি এভাবে ব্যবহার করা যেতে পারে:

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

এটি fromIndex একটি ঐচ্ছিক দ্বিতীয় যুক্তি fromIndex :

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

indexOf বিপরীতে, যা কঠোর সমতা তুলনা ব্যবহার করে, SameValueZero সমতা অ্যালগরিদম ব্যবহার করে তুলনা করে। এটি একটি অ্যারে একটি NaN অন্তর্ভুক্ত যদি আপনি সনাক্ত করতে পারেন মানে:

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

indexOf , includes অনুপস্থিত সূচকগুলি বাদ দেয় না:

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

বর্তমানে এটি এখনও একটি খসড়া রয়েছে তবে এটি সমস্ত ব্রাউজারে কাজ করার জন্য polyfill করা যেতে পারে।


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

যদি পাওয়া যায় অ্যারে সূচী, বা -1 পাওয়া না



একটি lastIndexOf দ্রুত lastIndexOf / lastIndexOf বিকল্প ছাড়া

2015

নতুন পদ্ধতি array.includes(value) করা খুব সুন্দর, সমর্থন এখন জন্য মূলত শূন্য হয়।

এটি দীর্ঘ সময় আমি ধীর সূচী OF / lastIndex ফাংশন প্রতিস্থাপন করার উপায় চিন্তা ছিল।

একটি পারফরম্যান্স উপায় ইতিমধ্যে উপরের উত্তর খুঁজছেন, পাওয়া গেছে। তাদের থেকে আমি @ দামী জেকিক পোস্ট করেছেন contains ফাংশনটি বেছে নিলাম যা দ্রুততম হওয়া উচিত। কিন্তু এটিও বলে যে ২008 সাল থেকে বেঞ্চমার্কগুলি হয় এবং তাই পুরানো হয়।

আমি জন্য while পছন্দ, কিন্তু একটি নির্দিষ্ট কারণের জন্য আমি ফাংশন লেখার জন্য একটি লুপ সঙ্গে লেখা শেষ। এটা কিছু while -- সাথে সম্পন্ন করা যেতে পারে while --

আমি যখন অ্যারেয়ের উভয় দিক পরীক্ষা করে দেখি তখন পুনরাবৃত্তিটি অনেক ধীরে ধীরে হতবুদ্ধি ছিল। দৃশ্যত কোন, এবং তাই এই ফাংশন শীর্ষ ভোট বেশী বেশী প্রায় দুই গুণ দ্রুত। স্পষ্টত এটি একটি স্থানীয় চেয়ে আরও দ্রুত। এটি একটি বাস্তব বিশ্ব পরিবেশে, যেখানে আপনি যে মূল্যটি অনুসন্ধান করছেন তা শুরুতে বা অ্যারের শেষের দিকে আপনি কখনই জানেন না।

যখন আপনি জানেন যে আপনি কেবল একটি মান নিয়ে একটি অ্যারে ধাক্কা দিয়েছিলেন, সর্বশেষ ইন্ডেক্স ব্যবহার করে সম্ভবত সর্বোত্তম সমাধান অবশিষ্ট থাকে, তবে যদি আপনি বড় অ্যারে দিয়ে ভ্রমণ করতে চান এবং ফলাফলটি সর্বত্র হতে পারে, তবে এটি আরও দ্রুততর করার জন্য এটি একটি কঠিন সমাধান হতে পারে।

বিডায়ার্কিকাল ইন্ডেক্সঅফ / শেষ ইন্ডেক্সঅফ

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 এন্ট্রি সঙ্গে একটি অ্যারের তৈরি।

তিনটি প্রশ্ন: শুরুতে, মাঝখানে এবং অ্যারের শেষে।

আমি আপনি এই আকর্ষণীয় খুঁজে এবং কর্মক্ষমতা পরীক্ষা আশা করি।

দ্রষ্টব্য: আপনি দেখতে পারেন যে আমি সামঞ্জস্যপূর্ণ ফাংশনটি সামান্য ফাংশনটি সংশোধন করতে চাই indexOf এবং শেষ ইন্ডেক্স আউটপুট (সুতরাং মূলত index সাথে true এবং -1 দিয়ে false )। যে এটা ক্ষতি করা উচিত নয়।

অ্যারের প্রোটোটাইপ রূপান্তর

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





browser