ජාවාස්ක්‍රිප්ට් හි අරාවක් හිස් කරන්නේ කෙසේද?

අරාව හිස් කිරීමට ක්‍රමයක් .remove()තිබේද?

උදාහරණයක් වශයෙන්,

A = [1,2,3,4];

මම එය හිස් කරන්නේ කෙසේද?

පවතින අරාව ඉවත් කිරීමට ක්‍රම A:

ක්රමය 1

(මෙය මගේ මුල් පිළිතුර විය)

A = [];

මෙම කේතය විචල්‍යය Aනව හිස් අරාවකට සකසනු ඇත . ඔබට වෙනත් තැනක මුල් අරාව පිළිබඳ සඳහනක්A නොමැති නම් මෙය පරිපූර්ණ වේ, මන්ද මෙය සැබවින්ම අළුත් (හිස්) අරාවක් නිර්මාණය කරයි. ඔබ මෙම ක්‍රමවේදය ගැන සැලකිලිමත් විය යුත්තේ ඔබ මෙම අරාව වෙනත් විචල්‍යයකින් හෝ දේපලකින් යොමු කර ඇත්නම්, මුල් අරාව නොවෙනස්ව පවතින බැවිනි. ඔබ අරාව එහි මුල් විචල්‍යයෙන් පමණක් සඳහන් කරන්නේ නම් පමණක් මෙය භාවිතා කරන්නA .

මෙයද වේගවත්ම විසඳුමයි.

මෙම ක්‍රමය භාවිතා කිරීමේදී ඔබට මුහුණ දිය හැකි ගැටළුව මෙම කේත නියැදිය මඟින් පෙන්වයි:

var arr1 = ['a','b','c','d','e','f'];
var arr2 = arr1;  // Reference arr1 by another variable 
arr1 = [];
console.log(arr2); // Output ['a','b','c','d','e','f']

ක්රමය 2 ( මැතිව් ක්‍රම්ලි යෝජනා කළ පරිදි )

A.length = 0

මෙය දැනට පවතින අරාවෙහි දිග 0 ලෙස සැකසීමෙන් ඉවත් කරනු ඇත. සමහරු තර්ක කර ඇත්තේ මෙය ජාවාස්ක්‍රිප්ට් හි සියලුම ක්‍රියාත්මක කිරීම් වලදී ක්‍රියා නොකරනු ඇති බවයි, නමුත් එය එසේ නොවන බව පෙනේ. ECMAScript 5 හි "දැඩි මාදිලිය" භාවිතා කරන විටද එය ක්‍රියාත්මක වේ, මන්ද අරාවෙහි දිග ගුණාංගය කියවීමේ / ලිවීමේ ගුණාංගයකි.

ක්රමය 3 ( ඇන්තනි යෝජනා කළ පරිදි )

A.splice(0,A.length)

භාවිතා .splice()කිරීම පරිපූර්ණ ලෙස .splice()ක්‍රියා කරනු ඇත , නමුත් ශ්‍රිතය ඉවත් කරන ලද සියලුම අයිතම සමඟ අරාවක් ලබා දෙන බැවින්, එය ඇත්ත වශයෙන්ම මුල් අරාවේ පිටපතක් ලබා දෙනු ඇත. මිණුම් සලකුණු යෝජනා කරන්නේ මෙය කාර්ය සාධනය කෙරෙහි කිසිදු බලපෑමක් නොකරන බවයි.

ක්රමය 4 ( tanguy_k යෝජනා කළ පරිදි )

while(A.length > 0) {
    A.pop();
}

මෙම විසඳුම ඉතා සංක්ෂිප්ත නොවන අතර මුල් පිළිතුරෙහි සඳහන් කර ඇති කලින් මිණුම් සලකුණු වලට පටහැනිව එය මන්දගාමී විසඳුම ද වේ.

කාර්ය සාධනය

පවත්නා අරාව ඉවත් කිරීමේ සියලු ක්‍රම අතුරින් , 2 සහ 3 ක්‍රම ක්‍රියාකාරීත්වයේ ඉතා සමාන වන අතර ක්‍රම 4 ට වඩා වේගවත් වේ. මෙම මිණුම් ලකුණ බලන්න . .

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

පහත දැක්වෙන මිණුම් ලකුණ මෙම දෝෂය නිරාකරණය කරයි: http://jsben.ch/#/hyj65 . # 2 (දිග දේපල) සහ # 3 (බෙදීම්) ක්‍රම වේගවත් බව එය පැහැදිලිව පෙන්වයි (මුල් අරාව වෙනස් නොකරන # 1 ගණනය කිරීමේ ක්‍රමය නොවේ).

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

ඔබට මුල් අරාව තබා ගැනීමට අවශ්‍ය නම් එය යාවත්කාලීන කළ යුතු වෙනත් යොමු කිරීම් ඇති බැවින්, එහි දිග බිංදුවට සැකසීමෙන් නව අරාවක් නිර්මාණය නොකර ඔබට එය ඉවත් කළ හැකිය:

A.length = 0;

මෙහි වේගවත්ම වැඩ ක්රියාත්මක කිරීම අතර එම අරාව තබා ( "mutable"):

function clearArray(array) {
  while (array.length) {
    array.pop();
  }
}

FYI එය සරල කළ නොහැක while (array.pop()): පරීක්ෂණ අසාර්ථක වනු ඇත.

FYI සිතියම සහ සෙට් අර්ථ දැක්වීම clear(), අරාවclear() සඳහා ද එය තාර්කික යැයි පෙනේ .

ටයිප්ස්ක්‍රිප්ට් අනුවාදය:

function clearArray<T>(array: T[]) {
  while (array.length) {
    array.pop();
  }
}

අනුරූප පරීක්ෂණ:

describe('clearArray()', () => {
  test('clear regular array', () => {
    const array = [1, 2, 3, 4, 5];
    clearArray(array);
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });

  test('clear array that contains undefined and null', () => {
    const array = [1, undefined, 3, null, 5];
    clearArray(array);
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
});

මෙන්න යාවත්කාලීන කරන ලද jsPerf: http://jsperf.com/array-destroy/32 http://jsperf.com/array-destroy/152

වඩාත් හරස් බ්‍රව්සර් හිතකාමී සහ වඩාත් ප්‍රශස්ත විසඳුමක් වනුයේ spliceපහත දැක්වෙන පරිදි A අරාවෙහි අන්තර්ගතය හිස් කිරීමට ක්‍රමය භාවිතා කිරීමයි :

A.splice(0, A.length);

මේ වන විට ඉහළ නංවා ඇති 2739 ට නොඅඩු පිළිතුරු නොමඟ යවන සහ වැරදි ය.

ප්‍රශ්නය: "ඔබ දැනට පවතින අරාව හිස් කරන්නේ කෙසේද?" උදා A = [1,2,3,4].

1. “ A = []පිළිතුර” යැයි පැවසීම නොදැනුවත්කම සහ සම්පූර්ණයෙන්ම වැරදිය. [] == []වන බොරු .

   මෙයට හේතුව මෙම අරා දෙක වෙන වෙනම, තනි වස්තූන් දෙකක් වන අතර, ඔවුන්ගේම අනන්‍යතා දෙකක් ඇති, ඩිජිටල් ලෝකයේ තමන්ගේම ඉඩක් ලබා ගනී.

කුණු කූඩය හිස් කරන්න කියා ඔබේ මව ඔබෙන් ඉල්ලා සිටිමු.

• ඔබ ඉල්ලූ දේ ඔබ කළාක් මෙන් ඔබ නව එකක් ගෙන එන්නේ නැත.
• ඒ වෙනුවට, ඔබ කුණු කූඩය හිස් කරන්න.
• ඔබ පුරවා ඇති එක නව හිස් කෑන් එකකින් ආදේශ නොකරන්න, ඔබ පුරවා ඇති කෑන් එකෙන් “ඒ” ලේබලය ගෙන එය නව එකක් මෙන් ඇලවීම නොකරන්න A = [1,2,3,4]; A = [];

අරාව වස්තුවක් හිස් කිරීම මෙතෙක් ඇති පහසුම දෙයයි:

A.length = 0;

මේ ආකාරයෙන්, "ඒ" යටතේ ඇති කෑන් හිස් පමණක් නොව, අළුත් තරම් පිරිසිදු ය!

2. තවද, කෑන් එක හිස් වන තුරු අතින් කුණු ඉවත් කිරීමට ඔබට අවශ්‍ය නොවේ! පවත්නා එක හිස් කරන්නැයි ඔබෙන් ඉල්ලා සිටින අතර, සම්පූර්ණයෙන්ම, එක් අතකින්, කෑන් හිස් වන තුරු කුණු කූඩයට නොගන්න.

   while(A.length > 0) {
       A.pop();
   }

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

   A.splice(0, A.length);

නැත, එය හිස් කිරීමට ඔබෙන් ඉල්ලා සිටියේය:

A.length = 0;

දී ඇති ජාවාස්ක්‍රිප්ට් අරාවෙහි අන්තර්ගතය නිවැරදිව හිස් කරන එකම කේතය මෙයයි.

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

http://jsperf.com/array-clear-methods/3

a = []; // 37% slower
a.length = 0; // 89% slower
a.splice(0, a.length)  // 97% slower
while (a.length > 0) {
    a.pop();
} // Fastest

ඔබේ අරා "ඉවත් කිරීමට" ඉඩ දීම සඳහා ඔබට මෙය ඔබගේ ජාවාස්ක්‍රිප්ට් ගොනුවට එක් කළ හැකිය:

Array.prototype.clear = function() {
    this.splice(0, this.length);
};

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

var list = [1, 2, 3];
list.clear();

නැතහොත් ඔබට යමක් විනාශ නොවන බවට සහතික වීමට අවශ්‍ය නම්:

if (!Array.prototype.clear) {
    Array.prototype.clear = function() {
       this.splice(0, this.length);
    };
}

බොහෝ අය සිතන්නේ ඔබ ස්වදේශික වස්තූන් (අරා වැනි) වෙනස් නොකළ යුතු බවයි, මම එයට එකඟ වීමට කැමැත්තෙමි. මෙය හැසිරවිය යුතු ආකාරය තීරණය කිරීමේදී කරුණාකර ප්‍රවේශම් වන්න.

කාලය සම්බන්ධයෙන් බොහෝ ව්‍යාකූලතා සහ වැරදි තොරතුරු තිබේ; පිළිතුරු සහ අදහස් යන දෙකෙහිම පොප් / මාරුව කාර්ය සාධනය. කාලය / පොප් විසඳුම (අපේක්ෂා කළ පරිදි) නරකම කාර්ය සාධනය ඇත. ඇත්ත වශයෙන්ම සිදුවන්නේ, සැකසුම ක්‍රියාත්මක වන්නේ එක් එක් නියැදිය සඳහා එක් වරක් පමණි. උදා:

var arr = [];

for (var i = 0; i < 100; i++) { 
    arr.push(Math.random()); 
}

for (var j = 0; j < 1000; j++) {
    while (arr.length > 0) {
        arr.pop(); // this executes 100 times, not 100000
    }
}

මම නිවැරදිව ක්‍රියා කරන නව පරීක්ෂණයක් නිර්මාණය කර ඇත:

http://jsperf.com/empty-javascript-array-redux

අවවාදයයි: පරීක්ෂණයේ මෙම අනුවාදයේ පවා ඔබට සැබෑ වෙනස නොපෙනේ, මන්ද අරාව ක්ලෝන කිරීම පරීක්ෂණ කාලය වැඩි කාලයක් ගත වන බැවිනි. එය තවමත් පෙන්වන්නේ spliceඅරාව ඉවත් කිරීමට වේගවත්ම ක්‍රමය එය බවයි (සැලකිල්ලට නොගැනීම []මන්ද එය වේගවත්ම වන අතර එය ඇත්ත වශයෙන්ම පවතින අරාව ඉවත් නොකිරීමයි).

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

(ඉහත සඳහන් ටැබයට හැඳින්වීමක් සඳහා ඔබට මෙහි පරීක්ෂා කළ හැකිය )

Stackoverflow මට jsfiddle පිටපත් කිරීමට බල කරයි, එබැවින් මෙහි එය:

<html>
<script>
var size = 1000*100
window.onload = function() {
  document.getElementById("quantifier").value = size
}

function scaffold()
{
  console.log("processing Scaffold...");
  a = new Array
}
function start()
{
  size = document.getElementById("quantifier").value
  console.log("Starting... quantifier is " + size);
  console.log("starting test")
  for (i=0; i<size; i++){
    a[i]="something"
  }
  console.log("done...")
}

function tearDown()
{
  console.log("processing teardown");
  a.length=0
}

</script>
<body>
    <span style="color:green;">Quantifier:</span>
    <input id="quantifier" style="color:green;" type="text"></input>
    <button onclick="scaffold()">Scaffold</button>
    <button onclick="start()">Start</button>
    <button onclick="tearDown()">Clean</button>
    <br/>
</body>
</html>

ජාවාස්ක්‍රිප්ට් වෙනත් ප්‍රාථමික වර්ග වලට වඩා වෙනස් ලෙස නූල් කළමනාකරණය කරන බැවින් එය අරාව මූලද්‍රව්‍ය වර්ගය මත රඳා පවතින බව ඔබ සැලකිල්ලට ගත යුතුය. වර්ගය සිදුවීමට බලපායි.

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

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

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

හරි, මෙය සරලව ක්‍රියාත්මක කරන්න:

arr.length = 0; //change the length

ප්‍රති result ලය වන්නේ:

[] //result

අරාව හිස් කිරීමට පහසුම ක්‍රමය ...

අවශ්‍ය නොවන නමුත් එය කිරීමට තවත් ක්‍රමයක් වන ලූප භාවිතා කිරීම:

/* could be arr.pop() or arr.splice(0)
don't need to return as main array get changed */

function remove(arr) {
  while(arr.length) {
    arr.shift(); 
  }
}

ඔබට සිතිය හැකි උපක්‍රමශීලී ක්‍රම ද ඇත, උදාහරණයක් ලෙස මෙවැනි දෙයක්:

arr.splice(0, arr.length); //[]

Ar හි අයිතම 5 ක් තිබේ නම්, එය 0 සිට අයිතම 5 ක් බෙදනු ඇත, එයින් අදහස් වන්නේ අරාවෙහි කිසිවක් නොපවතින බවයි.

උදාහරණයක් ලෙස අරාව නැවත පැවරීම වැනි වෙනත් ක්‍රම:

arr = []; //[]

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

මා මුලින් කී පරිදි, ඔබේ ප්‍රශ්නයට පිළිතුර ලෙස ඔබට මූලාකෘති ඉවත් කිරීම () කළ හැකිය. ඔබට ඉහත ක්‍රම වලින් එකක් තෝරාගෙන එය ජාවාස්ක්‍රිප්ට් හි අරේ වස්තුවට මූලාකෘතිගත කළ හැකිය, වැනි දෙයක්:

Array.prototype.remove = Array.prototype.remove || function() {
  this.splice(0, this.length);
};

ඔබගේ ජාවාස්ක්‍රිප්ට් යෙදුමේ ඕනෑම අරාවක් හිස් කිරීම සඳහා ඔබට මෙය සරලව හැඳින්විය හැකිය:

arr.remove(); //[]

Array.prototype.clear = function() {
    this.length = 0;
};

එය අමතන්න: array.clear();

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

a = []; 

එවිට ඔබ a වෙත නව අරාව යොමු කිරීමක් ලබා දී ඇත, a හි සඳහනක් දැනටමත් වෙනත් විචල්‍යයකට පවරා තිබේ නම්, එය එම අරාවද හිස් නොකරනු ඇති අතර එම නිසා කසළ එකතු කරන්නා එම මතකය එකතු නොකරයි.

හිටපු සඳහා.

var a=[1,2,3];
var b=a;
a=[];
console.log(b);// It will print [1,2,3];

හෝ

a.length = 0;

අප විසින් නියම කරන විට a.length, අපි අරාවෙහි මායිම් නැවත සකස් කරමින් සිටින අතර ඉතිරි අරාව මූලද්‍රව්‍ය සඳහා මතකය කුණු එකතු කරන්නා විසින් සම්බන්ධ කරනු ලැබේ.

මෙම විසඳුම් දෙක වෙනුවට වඩා හොඳය.

a.splice(0,a.length)

සහ

while(a.length > 0) {
    a.pop();
}

Kenshou.html හි පෙර පිළිතුරට අනුව, දෙවන ක්‍රමය වේගවත් වේ.

A.splice(0);

මම මෙය කරන්නේ මා වැඩ කරන කේතයකිනි. එය අරාව ඉවත් කළේය.

ජෑන් ගේ මූලික යෝජනාවේ නවීකරණය කරන ලද අනුවාදයක් භාවිතා කරන්න :

var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
     A.pop();
}

ඔබ නියතයන් භාවිතා කරන්නේ නම් ඔබට වෙනත් විකල්පයක් නොමැත:

const numbers = [1, 2, 3]

ඔබට නැවත සකස් කළ නොහැක:

numbers = []

ඔබට කප්පාදු කළ හැක්කේ:

numbers.length = 0

අරාව භාවිතයේ වත්මන් මතක ස්ථානයක් හිස් කිරීම සඳහා: 'myArray.length = 0'හෝ'myArray.pop() UN-till its length is 0'

• length: ඔබට ඕනෑම වේලාවක අරාව කපා දැමීමට දිග දේපල සැකසිය හැකිය. ඔබ අරාවෙහි දිග ගුණාංග වෙනස් කිරීමෙන් එය දිගු කරන විට සත්‍ය මූලද්‍රව්‍ය ගණන වැඩිවේ.
• pop() : පොප් ක්‍රමය මඟින් අරාවකින් අවසාන අංගය ඉවත් කර ඉවත් කළ අගය නැවත ලබා දෙයි.
• shift(): මාරුවීමේ ක්‍රමය ශුන්‍ය දර්ශකයේ ඇති මූලද්‍රව්‍යය ඉවත් කර අඛණ්ඩ දර්ශකවල අගයන් පහළට මාරු කර ඉවත් කළ අගය නැවත ලබා දෙයි.

උදාහරණයක්:

var arr = ['77'];
arr.length = 20;
console.log("Increasing : ", arr); // (20) ["77", empty × 19]
arr.length = 12;
console.log("Truncating : ", arr); // (12) ["77", empty × 11]

var mainArr = new Array();
mainArr = ['1', '2', '3', '4'];

var refArr = mainArr;
console.log('Current', mainArr, 'Refered', refArr);

refArr.length = 3;
console.log('Length: ~ Current', mainArr, 'Refered', refArr);

mainArr.push('0');
console.log('Push to the End of Current Array Memory Location \n~ Current', mainArr, 'Refered', refArr);

mainArr.poptill_length(0);
console.log('Empty Array \n~ Current', mainArr, 'Refered', refArr);

Array.prototype.poptill_length = function (e) {
  while (this.length) {
    if( this.length == e ) break;

    console.log('removed last element:', this.pop());
  }
};

• new Array() | [] භාවිතා කිරීමෙන් Array constructorහෝ නව මතක ස්ථානයක් සහිත අරාවක් සාදන්න array literal.

  mainArr = []; // a new empty array is addressed to mainArr.
  
  var arr = new Array('10'); // Array constructor
  arr.unshift('1'); // add to the front
  arr.push('15'); // add to the end
  console.log("After Adding : ", arr); // ["1", "10", "15"]
  
  arr.pop(); // remove from the end
  arr.shift(); // remove from the front
  console.log("After Removing : ", arr); // ["10"]
  
  var arrLit = ['14', '17'];
  console.log("array literal « ", indexedItem( arrLit ) ); // {0,14}{1,17}
  
  function indexedItem( arr ) {
      var indexedStr = "";
      arr.forEach(function(item, index, array) {
          indexedStr += "{"+index+","+item+"}";
          console.log(item, index);
      });
      return indexedStr;
  }

• slice() : ස්ලයිස් ශ්‍රිතය භාවිතා කිරීමෙන් අපට නව මතක ලිපිනයක් සහිත මුල් අරාවේ මූලද්‍රව්‍යවල නොගැඹුරු පිටපතක් ලැබෙනු ඇත, එවිට ක්ලෝනආර් හි ඕනෑම වෙනස් කිරීමක් සත්‍ය | මුල් අරාවකට බලපාන්නේ නැත.

  var shallowCopy = mainArr.slice(); // this is how to make a copy
  
  var cloneArr = mainArr.slice(0, 3); 
  console.log('Main', mainArr, '\tCloned', cloneArr);
  
  cloneArr.length = 0; // Clears current memory location of an array.
  console.log('Main', mainArr, '\tCloned', cloneArr);

කිසිවෙකු තවමත් මෙය යෝජනා නොකිරීම ගැන මට පුදුමයි:

let xs = [1,2,3,4];
for (let i in xs)
    delete xs[i];

මෙය අනෙක් විසඳුම් වලට වඩා වෙනස් තත්වයක අරාවක් ලබා දෙයි. එක් අතකින්, අරාව 'හිස්' කර ඇත:

xs
=> Array [ <4 empty slots> ]

[...xs]
=> Array [ undefined, undefined, undefined, undefined ]

xs.length
=> 4

xs[0]
=> ReferenceError: reference to undefined property xs[0]

ඔබට [,,,,]හෝ සමඟ සමාන අරාවක් නිෂ්පාදනය කළ හැකියArray(4)

ඔබට කෝණික 2+ FormArray හිස් කිරීමට අවශ්‍ය නම් පහත භාවිතා කරන්න.

public emptyFormArray(formArray:FormArray) {
    for (let i = formArray.controls.length - 1; i >= 0; i--) {
        formArray.removeAt(i);
    }
}