වස්තුවක් අරාවක් දැයි පරීක්ෂා කරන්නේ කෙසේද?

මම උත්සාහ කරන්නේ එක්කෝ නූල් ලැයිස්තුවක් හෝ තනි නූලක් පිළිගන්නා ශ්‍රිතයක් ලිවීමට ය. එය නූලක් නම්, එක් අයිතමයක් සමඟ එය අරාවකට පරිවර්තනය කිරීමට මට අවශ්‍යය, එබැවින් දෝෂයකට බිය නොවී මට එය උඩින් ලූප කළ හැකිය.

විචල්‍යය අරාවක් දැයි මා පරීක්ෂා කරන්නේ කෙසේද?

මම පහත විවිධ විසඳුම් සකස් කර jsperf පරීක්ෂණයක් නිර්මාණය කර ඇත්තෙමි . ඒවා සියල්ලම වේගවත් ය, එබැවින් භාවිතා කරන්න Array.isArray- එය දැන් හොඳින් සහාය වන අතර රාමු හරහා ක්‍රියා කරයි .

නවීන බ්‍රව්සර් වලදී ඔබට කළ හැකිය

Array.isArray(obj)

( සහාය ක්රෝම් 5, ෆයර්ෆොක්ස් 4.0, IE 9, ඔපෙරා 10.5 සහ සෆාරි 5)

පසුගාමී අනුකූලතාව සඳහා ඔබට පහත සඳහන් දෑ එකතු කළ හැකිය

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

ඔබ jQuery භාවිතා කරන්නේ නම් ඔබට භාවිතා කළ හැකි jQuery.isArray(obj)හෝ $.isArray(obj). ඔබ අවධාරනය කරන්නේ නම් ඔබට භාවිතා කළ හැකිය_.isArray(obj)

විවිධ රාමු වලින් සාදන ලද අරා හඳුනා ගැනීමට ඔබට අවශ්‍ය නැතිනම් ඔබටද භාවිතා කළ හැකිය instanceof

obj instanceof Array

වස්තුවේ පන්තිය සොයා ගැනීම සඳහා ECMAScript ප්‍රමිතියෙන් ලබා දී ඇති toStringක්‍රමය නම් ක්‍රමය භාවිතා කිරීමයි Object.prototype.

if( Object.prototype.toString.call( someVar ) === '[object Array]' ) {
    alert( 'Array!' );
}

නැතහොත් typeofඑය නූලක් දැයි පරීක්ෂා කිරීමට ඔබට භාවිතා කළ හැකිය :

if( typeof someVar === 'string' ) {
    someVar = [ someVar ];
}

නැතහොත් ඔබ කාර්ය සාධනය ගැන තැකීමක් නොකරන්නේ නම්, ඔබට concatනව හිස් අරාවකට කළ හැකිය.

someVar = [].concat( someVar );

ඔබට කෙලින්ම විමසිය හැකි ඉදිකිරීම්කරු ද ඇත:

if (somevar.constructor.name == "Array") {
    // do something
}

JTJ Crowder's වෙතින් සම්පූර්ණ ප්‍රතිකාරයක් බලන්න පහත ප්රකාශනය කින් පල ලෙස, බ්ලොග්.

වඩා හොඳ වන්නේ කුමන ක්‍රමයද යන්න පිළිබඳ අදහසක් ලබා ගැනීමට මෙම මිණුම් ලකුණ බලන්න : http://jsben.ch/#/QgYAV

Hara භාරත් වෙතින් ඇසූ ප්‍රශ්නය සඳහා Es6 භාවිතා කරමින් නූල් අරාව බවට පරිවර්තනය කරන්න:

const convertStringToArray = (object) => {
   return (typeof object === 'string') ? Array(object) : object 
}

සිතමු:

let m = 'bla'
let n = ['bla','Meow']
let y = convertStringToArray(m)
let z = convertStringToArray(n)
console.log('check y: '+JSON.stringify(y)) . // check y: ['bla']
console.log('check y: '+JSON.stringify(z)) . // check y: ['bla','Meow']

ඔබේ ක්‍රියාත්මක කිරීම සඳහා සහය ලැබේදැයි මම පළමුව පරීක්ෂා කරමි isArray:

if (Array.isArray)
    return Array.isArray(v);

ඔබට instanceofක්‍රියාකරු භාවිතා කිරීමටද උත්සාහ කළ හැකිය

v instanceof Array

jQuery ද $.isArray()ක්‍රමයක් ඉදිරිපත් කරයි :

var a = ["A", "AA", "AAA"];

if($.isArray(a)) {
  alert("a is an array!");
} else {
  alert("a is not an array!");
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

සියලුම ක්‍රම අතර වේගවත්ම වේ (සියලුම බ්‍රව්සර් සඳහා සහය දක්වයි):

function isArray(obj){
    return !!obj && obj.constructor === Array;
}

ඔබට මෙම අරාව පහතින් ඇතැයි සිතන්න :

var arr = [1,2,3,4,5];

ජාවාස්ක්‍රිප්ට් (නව සහ පැරණි බ්‍රව්සර්):

function isArray(arr) {
  return arr.constructor.toString().indexOf("Array") > -1;
}

හෝ

function isArray(arr) {
  return arr instanceof Array;
}

හෝ

function isArray(arr) {
  return Object.prototype.toString.call(arr) === '[object Array]';
}

ඉන්පසු එය මේ ආකාරයට අමතන්න:

isArray(arr);

ජාවාස්ක්‍රිප්ට් (IE9 +, Ch5 +, FF4 +, Saf5 +, Opera10.5 +)

Array.isArray(arr);

jQuery:

$.isArray(arr);

කෝණික:

angular.isArray(arr);

යටි ඉරි සහ ලොඩාෂ්:

_.isArray(arr);

Array.isArray වේගයෙන් ක්‍රියා කරයි, නමුත් එයට බ්‍රව්සර් වල සියලුම අනුවාදයන් සහාය නොදක්වයි. එබැවින් ඔබට අන් අයට ව්‍යතිරේකයක් කර විශ්වීය ක්‍රමයක් භාවිතා කළ හැකිය:

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }

මෙය පරීක්ෂා කිරීම සඳහා සරල කාර්යයක්:

function isArray(object)
{
    return object.constructor === Array;
}

එම්ඩීඑන් මෙහි පවසන පරිදි :

භාවිතා Array.isArray හෝ Object.prototype.toString.call පෙලගැස්මක් සිට නිත්ය වස්තූන් හඳුනා ගැනීමට

මෙවැනි:

• Object.prototype.toString.call(arr) === '[object Array]', හෝ

• Array.isArray(arr)

මෙම ප්‍රශ්නයට ඇත්තේ එක් පේළියක් පමණි

x instanceof Array

x යනු විචල්‍යය වන විට x යනු අරාව නම් එය සත්‍ය වේ.

ඔබේ විචල්යයේ වර්ගය එය සමඟ අරාවක් දැයි ඔබට පරීක්ෂා කළ හැකිය;

var myArray=[];

if(myArray instanceof Array)
{
....
}

ඔබ කටයුතු කරන වස්තුව වර්ගය පරීක්ෂා කිරීමට මම ශ්‍රිතයක් කරමි ...

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }

// tests
console.log(
  whatAmI(["aiming","@"]),
  whatAmI({living:4,breathing:4}),
  whatAmI(function(ing){ return ing+" to the global window" }),
  whatAmI("going to do with you?")
);

// output: Array Object Function String

එවිට ඔබට සරල නම් ප්‍රකාශයක් ලිවිය හැකිය ...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}

මම මෙය ඉතා සරල ආකාරයකින් කරන්නෙමි. මා වෙනුවෙන් වැඩ කරයි. අඩුපාඩු තිබේද?

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)

අදහස් සැලකිල්ලට ගනිමින් මෙම පිළිතුර වැඩිදියුණු කිරීමට මා ගත් උත්සාහය මෙයයි :

var isArray = myArray && myArray.constructor === Array;

එය if / else වලින් ඉවත් වන අතර අරාව ශුන්‍ය හෝ නිර්වචනය නොකිරීමේ හැකියාව සඳහා හේතු වේ

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray

Array.isArray = Array.isArray || function (vArg) {
    return Object.prototype.toString.call(vArg) === "[object Array]";
};

මම jsperf ෆෙඩලය විකල්ප ක්‍රම දෙකකින් මෙන්ම දෝෂ පරීක්ෂා කිරීමෙන් යාවත්කාලීන කර ඇත .

'වස්තුව' සහ 'අරාව' මූලාකෘතිවල නියත අගයක් අර්ථ දක්වන ක්‍රමය අනෙක් ක්‍රමවලට වඩා වේගවත් බව පෙනේ. එය තරමක් පුදුම සහගත ප්‍රති .ලයකි.

/* Initialisation */
Object.prototype.isArray = function() {
  return false;
};
Array.prototype.isArray = function() {
  return true;
};
Object.prototype._isArray = false;
Array.prototype._isArray = true;

var arr = ["1", "2"];
var noarr = "1";

/* Method 1 (function) */
if (arr.isArray()) document.write("arr is an array according to function<br/>");
if (!noarr.isArray()) document.write("noarr is not an array according to function<br/>");
/* Method 2 (value) - **** FASTEST ***** */
if (arr._isArray) document.write("arr is an array according to member value<br/>");
if (!noarr._isArray) document.write("noarr is not an array according to member value<br/>");

විචල්‍යය නිර්වචනය නොකළ අගය ගනී නම් මෙම ක්‍රම දෙක ක්‍රියා නොකරයි, නමුත් ඒවාට වටිනාකමක් ඇති බව ඔබට විශ්වාස නම් ඒවා ක්‍රියාත්මක වේ. අගය අරාවක් හෝ තනි අගයක් දැයි කාර්ය සාධනය මනසේ තබාගෙන පරීක්ෂා කිරීම සම්බන්ධයෙන්, දෙවන ක්‍රමය වලංගු වේගවත් ක්‍රමයක් ලෙස පෙනේ. ඉන්ටර්නෙට් එක්ස්ප්ලෝරර්, ඔපෙරා සහ සෆාරි (මගේ යන්ත්‍රයේ) හි දෙවන හොඳම ක්‍රමය මෙන් දෙගුණයක් වේගවත් වන එය ක්‍රෝම් හි 'ඉන්ස්ටෝන්ෆ්' ට වඩා තරමක් වේගවත් ය.

මම දන්නවා, මිනිස්සු යම් ආකාරයක අමු ජාවාස්ක්‍රිප්ට් ප්‍රවේශයක් සොයන බව. නමුත් ඔබට අඩුවෙන් සිතීමට අවශ්‍ය නම්, මෙහි බලන්න: http://underscorejs.org/#isArray

_.isArray(object) 

වස්තුව අරා නම් සත්‍ය වේ.

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true

මෙම ශ්‍රිතයට ලබා දිය හැකි එකම වර්ග දෙකේ අගයන් නූල් හෝ නූල් සමූහයක් නම්, එය සරලව තබාගෙන typeofනූල් හැකියාව සඳහා චෙක්පතක් භාවිතා කරන්න:

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}

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

ටීඑල්; ඩීආර් අනුවාදය පහතින් ඇත, නමුත් ලිපිය ගැටලුව පිළිබඳ විශාල සාකච්ඡාවක් වන බැවින් ඔබට කාලය ඇත්නම් එය කියවිය යුතුය.

Object.toType = function(obj) {
    return ({}).toString.call(obj).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
// ... and usage:
Object.toType([1,2,3]); //"array" (all browsers)

// or to test...
var shouldBeAnArray = [1,2,3];
if(Object.toType(shouldBeAnArray) === 'array'){/* do stuff */};

මෙන්න මගේ කම්මැලි ප්රවේශය:

if (Array.prototype.array_ === undefined) {
  Array.prototype.array_ = true;
}

// ...

var test = [],
    wat = {};

console.log(test.array_ === true); // true
console.log(wat.array_ === true);  // false

මූලාකෘතිය "අවුල් කිරීම" පූජනීය බව මම දනිමි, නමුත් එය නිර්දේශිත toStringක්‍රමයට වඩා සැලකිය යුතු ලෙස ක්‍රියා කරන බව පෙනේ .

සටහන: මෙම ප්‍රවේශයේ අවාසියiframe නම් එය සීමාවන් ඉක්මවා ක්‍රියා නොකිරීමයි, නමුත් මගේ භාවිතය සඳහා මෙය ගැටළුවක් නොවේ.

ස්ටොයාන් ස්ටෙෆනොව්ගේ ජාවාස්ක්‍රිප්ට් රටා පොතේ හොඳ උදාහරණයක් තිබේ, එය හැකි සෑම ගැටලුවක්ම විසඳා ගැනීමට මෙන්ම ECMAScript 5 ක්‍රමය Array.isArray () භාවිතා කිරීමට උපකාරී වේ. වේ.

ඉතින් මෙන්න එයයි:

if (typeof Array.isArray === "undefined") {
    Array.isArray = function (arg) {
        return Object.prototype.toString.call(arg) === "[object Array]";
    };
}

මාර්ගය වන විට, ඔබ jQuery භාවිතා කරන්නේ නම්, ඔබට එය භාවිතා කළ හැකිය is .isArray ()

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

 var arr = [];
  arr.constructor.name ==='Array'  //return true;

හෝ

arr.constructor ===Array //return true;

හෝ ඔබට උපයෝගිතා ශ්‍රිතයක් කළ හැකිය:

function isArray(obj){ return obj && obj.constructor ===Array}

භාවිතය:

isArray(arr); //return true

ඔබේ වස්තුවට සංයුක්ත ක්‍රමයක් නොමැති බව ඔබ දන්නේ නම් පහත සඳහන් දෑ භාවිතා කළ හැකිය.

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an array");
}

ඔබට හැකි වන්නේ isArray ක්‍රමය නමුත් මම පරීක්ෂා කිරීමට කැමැත්තෙමි

Object.getPrototypeOf(yourvariable) === Array.prototype

A = [1,2,3]
console.log(A.map==[].map)

මෙහි කෙටිම අනුවාදය සෙවීමේදී මට මෙතෙක් ලැබී ඇත්තේ එයයි.

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

function isArray(value) {
    if (value) {
        if (typeof value === 'object') {
            return (Object.prototype.toString.call(value) == '[object Array]')
        }
    }
    return false;
}

var ar = ["ff","tt"]
alert(isArray(ar))

ආදාන අගය අරාවක් දැයි පරීක්ෂා කිරීම සඳහා සරල කාර්යයක් පහත දැක්වේ:

function isArray(value)
{
  return Object.prototype.toString.call(value) === '[object Array]';
}

මෙය හරස් බ්‍රව්සරයේ සහ පැරණි බ්‍රව්සර් සමඟ ක්‍රියා කරයි. මෙය ටී.ජේ ක්‍රෝඩර්ස්ගේ බ්ලොග් සටහනෙන් ඉවත් කර ඇත

ඔබට මෙය උත්සාහ කළ හැකිය:

var arr = []; (or) arr = new Array();
var obj = {}; (or) arr = new Object();

arr.constructor.prototype.hasOwnProperty('push') //true

obj.constructor.prototype.hasOwnProperty('push') // false

මෙම ශ්‍රිතය ඕනෑම දෙයක් පාහේ අරාව බවට පත් කරයි:

function arr(x) {
    if(x === null || x === undefined) {
        return [];
    }
    if(Array.isArray(x)) {
        return x;
    }
    if(isString(x) || isNumber(x)) {
        return [x];
    }
    if(x[Symbol.iterator] !== undefined || x.length !== undefined) {
        return Array.from(x);
    }
    return [x];
}

function isString(x) {
    return Object.prototype.toString.call(x) === "[object String]"
}

function isNumber(x) {
    return Object.prototype.toString.call(x) === "[object Number]"
}

එය නවතම බ්‍රව්සර් විශේෂාංග කිහිපයක් භාවිතා කරයි, එබැවින් ඔබට උපරිම සහාය සඳහා මෙය බහු පිරවීමට අවශ්‍ය විය හැකිය.

උදාහරණ:

> arr(null);
[]
> arr(undefined)
[]
> arr(3.14)
[ 3.14 ]
> arr(1/0)
[ Infinity ]
> gen = function*() { yield 1; yield 2; yield 3; }
[Function: gen]
> arr(gen())
[ 1, 2, 3 ]
> arr([4,5,6])
[ 4, 5, 6 ]
> arr("foo")
[ 'foo' ]

එන්බී නූල් අක්ෂර මාලාවක් වෙනුවට තනි මූලද්‍රව්‍යයක් සහිත අරාවක් බවට පරිවර්තනය වේ. මකන්නisStringඔබ වෙනත් ආකාරයකින් කැමති නම් චෙක්පත .

මම Array.isArrayමෙහි භාවිතා කර ඇත්තේ එය වඩාත්ම ශක්තිමත් හා සරලම බැවිනි.

ඔබේ නඩුවේදී ඔබට තනි වස්තූන් මෙන්ම අරාව (සහ ඒකාබද්ධ) පවා පිළිගත හැකි අරාconcat ක්‍රමය භාවිතා කළ හැකිය:

function myFunc(stringOrArray)
{
  var arr = [].concat(stringOrArray);

  console.log(arr);

  arr.forEach(function(item, i)
  {
    console.log(i, "=", item);
  })
}

myFunc("one string");

myFunc(["one string", "second", "third"]);

concat අරේ හි පැරණිතම ක්‍රමවලින් එකක් ලෙස පෙනේ (IE 5.5 පවා එය හොඳින් දනී).