ජාවාස්ක්‍රිප්ට් අරාව ප්‍රකාශ කරන අතරතුර “අරාව ()” සහ “[]” අතර වෙනස කුමක්ද?

මේ ආකාරයට අරාවක් ප්‍රකාශ කිරීම අතර සැබෑ වෙනස කුමක්ද:

var myArray = new Array();

සහ

var myArray = [];

වෙනසක් ඇත, නමුත් එම උදාහරණයේ වෙනසක් නොමැත.

වඩාත් වාචික ක්‍රමය භාවිතා කිරීම: new Array()පරාමිතීන්හි එක් අමතර විකල්පයක් ඇත: ඔබ අංකයක් ඉදිකිරීම්කරු වෙත යැවුවහොත්, ඔබට එම දිගින් පෙළක් ලැබෙනු ඇත:

x = new Array(5);
alert(x.length); // 5

අරාවක් නිර්මාණය කිරීම සඳහා විවිධ ක්‍රම නිදර්ශනය කිරීම සඳහා:

var a = [],            // these are the same
    b = new Array(),   // a and b are arrays with length 0

    c = ['foo', 'bar'],           // these are the same
    d = new Array('foo', 'bar'),  // c and d are arrays with 2 strings

    // these are different:
    e = [3]             // e.length == 1, e[0] == 3
    f = new Array(3),   // f.length == 3, f[0] == undefined

;

තවත් වෙනසක් නම්, භාවිතා කරන විට new Array()ඔබට අරාවෙහි ප්‍රමාණය සැකසිය හැකි අතර එය තොගයේ ප්‍රමාණයට බලපායි. ඔබ තොග පිටාර ගැලීම් ලබා ගන්නේ නම් මෙය ප්‍රයෝජනවත් වේ ( Array.push vs Array.unshift හි කාර්ය සාධනය ) එය අරාවෙහි විශාලත්වය තොගයේ ප්‍රමාණය ඉක්මවා ගිය විට සිදු වන අතර එය නැවත නිර්මාණය කළ යුතුය. එබැවින් new Array()පිටාර ගැලීම වළක්වා ගත හැකි නිසා භාවිතා කිරීමේ අවස්ථාව අනුව කාර්ය සාධනය වැඩි විය හැකිය.

මෙම පිළිතුරෙහි පෙන්වා ඇති පරිදි , new Array(5)ඇත්ත වශයෙන්ම undefinedඅරාව වෙත අයිතම පහක් එකතු නොකරනු ඇත . එය හුදෙක් අයිතම පහක් සඳහා ඉඩක් එක් කරයි. Arrayමෙම ක්‍රමය භාවිතා array.lengthකිරීම ගණනය කිරීම් සඳහා විශ්වාසය තැබීම දුෂ්කර බව මතක තබා ගන්න .

ව්‍යංග අරාව සහ අරාව සාදන්නා සමඟ අරාවක් නිර්මාණය කිරීම අතර වෙනස සියුම් නමුත් වැදගත් ය.

ඔබ භාවිතා කර අරාවක් සාදන විට

var a = [];

ඔබ පරිවර්තකයාට කියන්නේ නව ධාවන කාල අරාවක් නිර්මාණය කරන ලෙසයි. අමතර සැකසුම් අවශ්‍ය නොවේ. සිදු විය.

ඔබ භාවිතා කරන්නේ නම්:

var a = new Array();

ඔබ පරිවර්තකයාට කියනවා, මට අවශ්‍ය වන්නේ ඉදිකිරීම්කරුට “ Array” අමතා වස්තුවක් ජනනය කිරීමට ය. එවිට එය ඔබගේ ක්‍රියාත්මක කිරීමේ සන්දර්භය හරහා සොයා බැලීමට ඉදිකිරීම්කරු සොයා ගැනීමට හැකි වන අතර එය අමතන්නේ ඔබේ අරාව නිර්මාණය කරමිනි.

"හොඳයි, මෙය කිසිසේත්ම ප්‍රශ්නයක් නොවේ. ඒවා එක හා සමානයි!" අවාසනාවට ඔබට එය සහතික කළ නොහැක.

පහත උදාහරණය ගන්න:

function Array() {
    this.is = 'SPARTA';
}

var a = new Array();
var b = [];

alert(a.is);  // => 'SPARTA'
alert(b.is);  // => undefined
a.push('Woa'); // => TypeError: a.push is not a function
b.push('Woa'); // => 1 (OK)

ඉහත උදාහරණයේ දී, පළමු ඇමතුම ඔබ බලාපොරොත්තු වන පරිදි 'ස්පාර්ටා' වෙත දැනුම් දෙනු ඇත. දෙවැන්න එසේ නොවේ. ඔබ නිර්වචනය නොකිරීම අවසන් වනු ඇත. B හි ස්වදේශික අරා වස්තු ශ්‍රිත සියල්ලම අඩංගු වන බව ඔබ සටහන් කරනු pushඇත.

මෙය සිදුවනු ඇතැයි ඔබ අපේක්ෂා කළද, එය නිරූපණය කරන්නේ []සමාන නොවන කාරණයකි new Array().

[]ඔබට අරාවක් අවශ්‍ය බව ඔබ දන්නේ නම් භාවිතා කිරීම වඩාත් සුදුසුය . වටේට ගොස් අරාව නැවත අර්ථ දැක්වීමට මම යෝජනා නොකරමි ...

කිසිදු පිළිතුරක් තවම සඳහන් කර නැති වැදගත් වෙනසක් තිබේ.

මේකෙන්:

new Array(2).length           // 2
new Array(2)[0] === undefined // true
new Array(2)[1] === undefined // true

new Array(2)එය සමාන යැයි ඔබ සිතනු ඇත [undefined, undefined], නමුත් එය එසේ නොවේ!

අපි උත්සාහ කරමු map():

[undefined, undefined].map(e => 1)  // [1, 1]
new Array(2).map(e => 1)            // "(2) [undefined × 2]" in Chrome

බලන්න? අර්ථ නිරූපණය සම්පූර්ණයෙන්ම වෙනස් ය! ඉතින් ඇයි ඒ?

ES6 පිරිවිතර 22.1.1.2 ට අනුව, කාර්යය Array(len)වන්නේ නව අරාවක් නිර්මාණය කිරීම පමණි, එහි දේපල lengthතර්කයට සකසා ඇති අතර lenඑය එයයි, එයින් අදහස් වන්නේ මෙම අලුතින් සාදන ලද අරාව තුළ සැබෑ අංගයක් නොමැති බවයි.

කාර්යය map(), 22.1.3.15 අයියා අනුව පලමුවෙන් පහත පරීක්ෂා කරන HasPropertyලද callback කතා නම්, නමුත් එම එය දුටුවේ:

new Array(2).hasOwnProperty(0) // false
[undefined, undefined].hasOwnProperty(0) // true

සාදන ලද අරා වල සුපුරුදු පරිදි ක්‍රියා කරන කිසිදු ක්‍රියාකාරීත්වයක් අපේක්ෂා කළ නොහැක්කේ එබැවිනිnew Array(len) .

BTW, Safari සහ Firefox මෙම තත්වයට වඩා හොඳ "මුද්‍රණයක්" ඇත:

// Safari
new Array(2)             // [](2)
new Array(2).map(e => 1) // [](2) 
[undefined, undefined]   // [undefined, undefined] (2) 

// Firefox
new Array(2)             // Array [ <2 empty slots> ]
new Array(2).map(e => 1) // Array [ <2 empty slots> ]
[undefined, undefined]   // Array [ undefined, undefined ]

මම දැනටමත් ක්‍රෝමියම් වෙත ප්‍රශ්නයක් ඉදිරිපත් කර ඇති අතර මෙම ව්‍යාකූල මුද්‍රණය නිවැරදි කරන ලෙස ඔවුන්ගෙන් ඉල්ලා සිටිමි: https://bugs.chromium.org/p/chromium/issues/detail?id=732021

යාවත්කාලීන කිරීම: එය දැනටමත් සවි කර ඇත. ක්‍රෝම් දැන් මුද්‍රණය කර ඇත්තේ:

new Array(2)             // (2) [empty × 2]

නියමාකාරයෙන්, ක්‍රෝම් new Array(size)වලට වඩා []2 ගුණයක් වේගවත් වන අතර එෆ්එෆ් සහ අයිඊ වල සමාන වේ (අරාව නිර්මාණය කිරීමෙන් හා පිරවීමෙන් මනිනු ලැබේ). එය වැදගත් වන්නේ අරාවෙහි ආසන්න ප්‍රමාණය ඔබ දන්නේ නම් පමණි. ඔබ ලබා දුන් දිගට වඩා වැඩි අයිතම එකතු කළහොත්, කාර්ය සාධනය ඉහළ යයි.

වඩාත් නිවැරදිව: Array(මතකය වෙන් නොකරන වේගවත් නියත කාල මෙහෙයුමක් වන අතර, වීරා []යනු වර්ගය සහ අගය නියම කරන රේඛීය කාල මෙහෙයුමකි.

වැඩි විස්තර සඳහා, ඔබ කිසි විටෙකත් භාවිතා නොකිරීමට හේතුව පහත පිටුවෙහි විස්තර කෙරේnew Array()

ඔබ කිසි විටෙකත් new Object()JavaScript හි භාවිතා කිරීමට අවශ්‍ය නොවේ . {} ඒ වෙනුවට වචනාර්ථයෙන් වස්තුව භාවිතා කරන්න . ඒ හා සමානව, භාවිතා නොකරන්න new Array(), [] ඒ වෙනුවට අරාව වචනානුසාරයෙන් භාවිතා කරන්න. ජාවාස්ක්‍රිප්ට් හි අරා ජාවාහි අරා මෙන් කිසිවක් ක්‍රියා නොකරන අතර ජාවා වැනි සින්ටැක්ස් භාවිතය ඔබව ව්‍යාකූල කරනු ඇත.

භාවිතා නොකරන්න new Number, new Stringහෝ new Boolean. මෙම ආකෘති අනවශ්‍ය වස්තු ආවරණ නිපදවයි. ඒ වෙනුවට සරල වචනාර්ථ භාවිතා කරන්න.

අදහස්ද බලන්න - new Array(length)පෝරමය කිසිදු ප්‍රයෝජනවත් අරමුණක් ඉටු නොකරයි (අවම වශයෙන් අද ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමේදී).

වඩා හොඳින් අවබෝධ කර ගැනීම සඳහා []සහ new Array():

> []
  []
> new Array()
  []
> [] == []
  false
> [] === []
  false
> new Array() == new Array()
  false
> new Array() === new Array()
  false
> typeof ([])
  "object"
> typeof (new Array())
  "object"
> [] === new Array()
  false
> [] == new Array()
  false

ඉහත ප්‍රති result ලය වින්ඩෝස් 7 හි ගූගල් ක්‍රෝම් කොන්සෝලයෙනි.

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

var array = new Array(5); //initialize with default length 5

දෙවැන්න ඔබට හිස් අරාවක් නිර්මාණය කිරීමේ හැකියාව ලබා දෙයි:

var array = [1, 2, 3]; // this array will contain numbers 1, 2, 3.

ෆ්‍රෙඩ්රික්ගේ හොඳ උදාහරණය මත පදනම් වූ මෙම උදාහරණයෙන් පටන් ගෙන මට වඩාත් නිශ්චිත ආකාරයකින් පැහැදිලි කළ හැකිය.

var test1 = [];
test1.push("value");
test1.push("value2");

var test2 = new Array();
test2.push("value");
test2.push("value2");

alert(test1);
alert(test2);
alert(test1 == test2);
alert(test1.value == test2.value);

මම අරා වලට තවත් අගයක් එකතු කර ඇඟවීම් හතරක් කළෙමි: පළමු හා දෙවැන්න නම් එක් එක් අරාව තුළ ගබඩා කර ඇති අගය අපට ලබා දීමයි. ඔවුන් නැවත එනු ඇත! දැන් තුන්වැන්න උත්සාහ කරන්න, එය අසත්‍යයක් බවට පත්වේ, එයට හේතුව

JS අමතා, test1 ලෙස අරා දත්ත වර්ගය සමග විචල්ය , සහ එය සලකන test2 ලෙස මාලාවක් ක්රියාකාරිත්වය සහිත වස්තුවක්, , මෙහි සුළු වෙනස්කම් කිහිපයක් තිබේ.

පළමු වෙනස වන්නේ අප ටෙස්ට් 1 අමතන විට එය සිතීමකින් තොරව විචල්‍යයක් ලෙස හැඳින්වීමයි, එය එහි දත්ත වර්ගය නොසලකා මෙම විචල්‍යයේ ගබඩා කර ඇති අගයන් නැවත ලබා දෙයි! නමුත්, අපි ටෙස්ට් 2 අමතන විට එය අරේ () ශ්‍රිතය ලෙස හඳුන්වන අතර එය අපගේ “තල්ලු කළ” අගයන් එහි “අගය” දේපලෙහි ගබඩා කරයි, තවද අපි ටෙස්ට් 2 ට අනතුරු ඇඟවූ විට එය සිදු වේ, එය අරාව වස්තුවේ “අගය” දේපල නැවත ලබා දෙයි .

එබැවින්, ටෙස්ට් 1 ටෙස්ට් 2 ට සමාන දැයි පරීක්ෂා කර බැලීමේදී ඒවා කිසි විටෙකත් සත්‍ය නොවනු ඇත, එකක් ශ්‍රිතයක් වන අතර අනෙක විචල්‍ය වේ (අරාව වර්ගයක් සහිත), ඒවාට සමාන අගයක් තිබුණත්!

ඒ ගැන සහතික වීමට, .value එයට එකතු කර 4 වන ඇඟවීම උත්සාහ කරන්න; එය සැබෑ වනු ඇත. මෙම අවස්ථාවේදී අපි JS ට කියමු "බහාලුම් වර්ගය නොසලකා එය ක්‍රියාකාරී හෝ විචල්‍ය වුවත්, කරුණාකර එක් එක් බහාලුම්වල ගබඩා කර ඇති අගයන් සංසන්දනය කර ඔබ දුටු දේ අපට කියන්න!" එය හරියටම සිදුවන්නේ එයයි.

මම හිතන්නේ මම ඒ පිටුපස ඇති අදහස පැහැදිලිව පැවසුවා, මගේ නරක ඉංග්‍රීසි ගැන කණගාටුයි.

ඔබ දිගකින් තොරව අරාව ආරම්භ කරන විට වෙනසක් නැත. ඉතින් var a = []& var b = new Array()සමානයි.

නමුත් ඔබ අරාව වැනි දිගකින් අරාව ආරම්භ කරන්නේ නම් var b = new Array(1);, එය අරාව වස්තුවේ දිග 1 ට සකසනු ඇත var b = []; b.length=1;. එබැවින් එය සමාන වේ .

ඔබ array_object.push කරන සෑම විටම මෙය ගැටළු සහගත වනු ඇත, එය අවසාන අංගයට පසුව අයිතමය එකතු කර දිග වැඩි කරයි.

var b = new Array(1);
b.push("hello world");
console.log(b.length); // print 2

එදිරිව

var v = [];
a.push("hello world");
console.log(b.length); // print 1

පළමුවැන්න පෙරනිමි වස්තු ඉදිකිරීම්කරු ඇමතුමයි. ගතික අගයන් සඳහා බොහෝ දුරට භාවිතා වේ.

var array = new Array(length); //initialize with default length

ස්ථිතික අගයන් නිර්මාණය කිරීමේදී දෙවන අරාව භාවිතා වේ

var array = [red, green, blue, yellow, white]; // this array will contain values.

විශාල වෙනසක් නැත, ඔවුන් මූලික වශයෙන් එකම දේ කරන නමුත් ඒවා විවිධ ආකාරවලින් සිදු කරයි, නමුත් කියවන්න, W3C හි මෙම ප්‍රකාශය දෙස බලන්න:

var cars = ["Saab", "Volvo","BMW"];

සහ

var cars = new Array("Saab", "Volvo", "BMW");

ඉහත උදාහරණ දෙක හරියටම සමාන වේ. නව අරාව () භාවිතා කිරීම අවශ්‍ය නොවේ.
සරල බව, කියවීමේ හැකියාව සහ ක්‍රියාත්මක කිරීමේ වේගය සඳහා, පළමු එක භාවිතා කරන්න (අරාව වචනාර්ථ ක්‍රමය).

නමුත් ඒ සමඟම, new Arrayනරක පුරුද්දක් ලෙස සැලකෙන සින්ටැක්ස් භාවිතයෙන් නව අරා නිර්මාණය කිරීම :

නව අරා () වලින් වළකින්න

ජාවාස්ක්‍රිප්ට් හි සාදන ලද අරාව සාදන්නා නව අරා () භාවිතා කිරීමට අවශ්‍ය නැත.
ඒ වෙනුවට [] භාවිතා කරන්න.
මෙම වෙනස් ප්‍රකාශ දෙකම ලකුණු සහිත නව හිස් අරාවක් නිර්මාණය කරයි:

var points = new Array();         // Bad
var points = [];                  // Good 

මෙම වෙනස් ප්‍රකාශ දෙකම අංක 6 කින් යුත් නව අරාවක් නිර්මාණය කරයි:

var points = new Array(40, 100, 1, 5, 25, 10); // Bad    
var points = [40, 100, 1, 5, 25, 10];          // Good

මෙම නව මූල පදය පමණක් කේතය පිලිබද. එය අනපේක්ෂිත ප්‍රති results ල ලබා දිය හැකිය:

var points = new Array(40, 100);  // Creates an array with two elements (40 and 100)

මම එක් අංගයක් ඉවත් කළහොත් කුමක් කළ යුතුද?

var points = new Array(40);       // Creates an array with 40 undefined elements !!!!!

එබැවින් මූලික වශයෙන් හොඳම පුහුණුව ලෙස නොසැලකේ, එහි එක් සුළු වෙනසක් ඇත, ඔබට මේ සඳහා දිග ගත කළ හැකිය new Array(length), එය නිර්දේශිත ක්‍රමයක් නොවේ.

භාවිතා කිරීමේ වෙනස

var arr = new Array(size);

හෝ

arr = [];
arr.length = size;

මෙම ප්රශ්නයේ ප්රමාණවත් ලෙස සාකච්ඡා කර ඇති පරිදි.

වේග ගැටළුව එක් කිරීමට මම කැමතියි - වර්තමාන වේගවත්ම ක්‍රමය, google chromeදෙවැන්නයි.

නමුත් අවධානය යොමු කරන්න, මේ දේවල් යාවත්කාලීන කිරීම් සමඟ බොහෝ වෙනස් වීමට නැඹුරු වේ. ධාවන කාලය විවිධ බ්‍රව්සර් අතර වෙනස් වේ.

උදාහරණයක් ලෙස - මා සඳහන් කළ 2 වන විකල්පය, මිලියන 2 ක් (තත්පරයට / තත්පරයට) ධාවනය වේ chrome, නමුත් ඔබ එය උත්සාහ කළහොත් ඔබට mozilla dev.පුදුම හිතෙන තරම් ඉහළ අනුපාතයක් මිලියන 23 ක් ලැබෙනු ඇත.

කොහොම උනත්, මම ඔබ එය පරීක්ෂා කර බලන්න, වෙනස් බ්රව්සර (සහ යන්ත්ර) මත, වෙබ් අඩවිය භාවිතා කරන යෝජනා කියලා ටික සෑම වරක් වැනි

මම diference දන්නා පරිදි ඔබ වැනි පෙත්තක් (හෝ Array අනෙක් funcitons) සොයා ගත හැකි code1 .ඒ code2 ඔබ පෙන්වන Array සහ ඔහුගේ අවස්ථා :

code1:

[].slice; // find slice here
var arr = new Array();
arr.slice // find slice here
Array.prototype.slice // find slice here

code2:

[].__proto__ == Array.prototype; // true
var arr = new Array();
arr.__proto__ == Array.prototype; // true

නිගමනය:

ඔබ දැකගත හැකි පරිදි []සහ new Array()Array.And නව උදාහරණයක් නිර්මාණය ඔවුන් සියලු පතිරූපක කාර්යයන් ලබාArray.prototype

ඒවා අරේගේ වෙනස් උදාහරණයකි [] != []

:)

[] භාවිතා කරමින් මම අමුතු හැසිරීමකට මුහුණ දී සිටිමි.

අපට කිසියම් අගයකට ආරම්භක ක්ෂේත්‍ර සහිත ආදර්ශ "පන්ති" ඇත. උදා:

require([
  "dojo/_base/declare",
  "dijit/_WidgetBase",
], function(declare, parser, ready, _WidgetBase){

   declare("MyWidget", [_WidgetBase], {
     field1: [],
     field2: "",
     function1: function(),
     function2: function()
   });    
});

ක්ෂේත්‍ර ආරම්භ කළ []විට එය සියලු ආදර්ශ වස්තු විසින් බෙදා ගනු ඇති බව මට පෙනී ගියේය . එක් අයෙකුට වෙනස්කම් කිරීම අනෙක් සියල්ලන්ටම බලපායි.

මෙය ආරම්භ කිරීමෙන් මෙය සිදු නොවේ new Array(). වස්තූන් ආරම්භ කිරීම සඳහා සමාන වේ ( {}එදිරිව නව Object())

TBH අප භාවිතා කළ රාමුව ( ඩොජෝ ) සමඟ එය ගැටළුවක් දැයි මට විශ්වාස නැත

ඇසට පෙනෙන දේට වඩා මේ සඳහා තවත් බොහෝ දේ ඇත. අනෙක් බොහෝ පිළිතුරු නිවැරදි නමුත් වෙනත් ..

new Array(n)

• nමූලද්‍රව්‍ය සඳහා අවකාශය නැවත වෙන් කිරීමට එන්ජිමට ඉඩ දෙන්න
• අරාව නිර්මාණය සඳහා ප්‍රශස්ත කර ඇත
• සාදන ලද අරාව අවම ක්‍රියාකාරී අරා මෙහෙයුම් ඇති විරල ලෙස සලකුණු කර ඇත, එයට හේතුව එක් එක් දර්ශක ප්‍රවේශයට සීමාවන් පරික්ෂා කිරීම, අගය තිබේදැයි බැලීමට සහ මූලාකෘති දාමය ගමන් කිරීම ය.
• අරාව විරල ලෙස සලකුණු කර ඇත්නම්, ආපසු යා හැකි මාර්ගයක් නොමැත (අවම වශයෙන් V8 හි), එය එහි ජීවිත කාලය තුළ සෑම විටම මන්දගාමී වනු ඇත, ඔබ එය අන්තර්ගතයෙන් (ඇසුරුම් කළ අරාව) 1ms හෝ පැය 2 කට පසුව පුරවා ගත්තද, කමක් නැත

[1, 2, 3] || []

• සාදන ලද අරාව ඇසුරුම් කර ඇති බව සලකුණු කර ඇත (ඔබ භාවිතා කරන්නේ deleteහෝ [1,,3]වාක්‍ය ඛණ්ඩය හැර)
• අරාව සඳහා නිපැදවුන මෙහෙයුම් ( for .., forEach, map, ආදී)
• අරාව වර්ධනය වන විට එන්ජිමට අවකාශය නැවත වෙන් කිරීම අවශ්‍ය වේ

මෙම බොහෝ විට පැරණි බ්රවුසරයක් සංස්කරණ / බ්රවුසර සඳහා එසේ නොවේ.

හොඳයි, සමහර විශේෂාංග var x = new Array()වලට වඩා var x = []වෙනස් වේ මම ඒවායින් වඩාත්ම ප්‍රයෝජනවත් දෙක (මගේ මතය අනුව) පැහැදිලි කරන්නම්.

වෙනස්කම් පැහැදිලි කිරීමට පෙර, මම පළමුව පදනමක් තබමි; අප භාවිතා කරන විට x = []දත්ත වර්ගයේ අරාව සමඟ නව විචල්‍යයක් නිර්වචනය කරන අතර, එය අරාව මූලාකෘතියට අයත් සියලු ක්‍රම උරුම කර ගනී, එය පන්තියක් දීර් ing කිරීමට සමාන (නමුත් හරියටම නොවේ). කෙසේ වෙතත්, අප x = new Array()එය භාවිතා කරන විට විචල්‍යයට පවරා ඇති අරාව මූලාකෘතියේ ක්ලෝනයක් ආරම්භ කරයි x.

දැන් අපි බලමු වෙනස මොකක්ද කියලා

පළමු වෙනස නම් පූර්ණ සංඛ්‍යාවක් ඇති new Array(x)තැන භාවිතා xකිරීම, xනිර්වචනය නොකළ අගයන් new Array(16)රාශියක් ආරම්භ කිරීමයි , නිදසුනක් ලෙස අයිතම 16 ක් සහිත අරාවක් ආරම්භ කරනු ඇත. ඔබ පූර්ව නිශ්චිත දිගකින් පෙළක් අසමමුහුර්තව පුරවන විට මෙය ඉතා ප්‍රයෝජනවත් වේ. උදාහරණයක් ලෙස (නැවතත් :)) අපි ඔබට තරඟකරුවන් 100 දෙනෙකුගේ ප්‍රති results ල ලබා ගනිමු යැයි කියමු, ඔබ ඒවා දුරස්ථ පද්ධතියකින් හෝ ඩීබී එකකින් අසමසම ලෙස ලබා ගනී, එවිට ඔබට ලැබුණු පසු ඒවා ශ්‍රේණිගත කිරීම අනුව පෙළට වෙන් කළ යුතුය. එක් එක් ප්රති result ලය. මෙම ඉතා දුර්ලභ අවස්ථාවෙහිදී ඔබ එවැනි දෙයක් කරනු ඇත myArray[result.rank - 1] = result.name, එබැවින් 1 ශ්‍රේණිය දර්ශකය 0 වෙත සකසනු ඇත.

දෙවන වෙනස නම්, new Array()ඔබ දැනටමත් දන්නා පරිදි භාවිතා කිරීම, අරාව මූලාකෘතියේ නව ක්ලෝනයක් ක්ෂණිකව ස්ථාපනය කර එය ඔබේ විචල්‍යයට පවරන අතර එමඟින් ඔබට මැජික් කිහිපයක් කිරීමට ඉඩ ලබා දේ (නිර්දේශිත btw). මෙම මැජික් යනු ඔබට උරුම අරා ක්‍රමවල නිශ්චිත ක්‍රමයක් නැවත ලිවිය හැකිය. ඉතින්, උදාහරණයක් ලෙස ඔබට Array.pushනව අගය අවසානය වෙනුවට අරාවේ ආරම්භයට තල්ලු කිරීමේ ක්‍රමය සැකසිය හැකි අතර, අරේ මූලාකෘතියේ මෙම විශේෂිත ක්ලෝනයට නව ක්‍රම (මෙය වඩා හොඳ) එකතු කළ හැකිය. එමඟින් ඔබේ ව්‍යාපෘතිය පුරා වඩාත් සංකීර්ණ ආකාරයේ අරා වර්ග ඔබේම එකතු කළ ක්‍රම මගින් නිර්වචනය කර එය පන්තියක් ලෙස භාවිතා කිරීමට ඉඩ ලබා දේ.

අවසාන දෙය නම්, ඔබ ඔබේ යෙදුමේ පොදු කාර්ය සහ මතක පරිභෝජනය සැකසීමට සැලකිලිමත් වන ඉතා සුළු පිරිසකගෙන් (මම සැබවින්ම ආදරය කරන) නම්, new Array()එය භාවිතා කිරීමට මංමුලා සහගත නොවී ඔබ කිසි විටෙකත් දැඩි නොවනු ඇත :).

මෘගයා ගැන එය ප්‍රමාණවත් ලෙස පැහැදිලි කර ඇතැයි මම බලාපොරොත්තු වෙමි new Array():)

මට සෑහෙන්න අමාරු වූ ඉදිකිරීම් දෙක අතර එක් වෙනසක් මට හමු විය.

මා සතුව ඇතැයි කියමු:

function MyClass(){
  this.property1=[];
  this.property2=new Array();
};
var MyObject1=new MyClass();
var MyObject2=new MyClass();

සැබෑ ජීවිතයේ දී, මම මෙය කරන්නේ නම්:

MyObject1.property1.push('a');
MyObject1.property2.push('b');
MyObject2.property1.push('c');
MyObject2.property2.push('d');

මා අවසන් කරන්නේ මෙයයි:

MyObject1.property1=['a','c']
MyObject1.property2=['b']
MyObject2.property1=['a','c']
MyObject2.property2=['d']

භාෂා පිරිවිතරයෙන් සිදුවිය යුත්තේ කුමක්දැයි මම නොදනිමි, නමුත් මගේ වස්තූන් දෙක මගේ වස්තූන් තුළ අද්විතීය දේපල අරා තිබිය යුතු නම්, මම භාවිතා කළ new Array()යුතුය.

අරේ ඉදිකිරීම්කරු භාවිතා කිරීමෙන් අපේක්ෂිත දිගෙහි නව පෙළක් සාදනු ලබන අතර එක් එක් දර්ශක නිර්වචනය නොකෙරේ.