Ինչպե՞ս պատճենել կամ ընդլայնել զանգվածը։

Ծրագրային ապահովման մշակման մեջ, զանգվածներ կամ զանգվածները ներկայացնում են ծրագրավորման էական մասը: Դրանք տվյալների կառուցվածքներ են, որոնք թույլ են տալիս մեզ նույն անվան տակ պահել տեղեկատվության մի շարք՝ հեշտացնելով մանիպուլյացիան և տվյալների հասանելիությունը: Անկախ տվյալների չափից և տեսակից, միշտ լինում են ժամանակներ, երբ ծրագրավորողները կարիք ունեն պատճենել կամ ընդլայնել զանգվածը. Հաջորդ հոդվածում մենք կկենտրոնանանք մանրամասն բացատրելու վրա, թե ինչպես կատարել այդ գործողությունները տարբեր ծրագրավորման լեզուներով:

Հասկանալով զանգվածը պատճենելու կամ ընդլայնելու անհրաժեշտությունը

Ծրագրավորման մեջ մենք հաճախ հայտնվում ենք այնպիսի իրավիճակներում, որտեղ մեզ անհրաժեշտ է պատճենել կամ ընդլայնել զանգվածը. Օրինակ, մեզ կարող է անհրաժեշտ լինել պահպանել պատճենը մի զանգվածի գործողություններ կատարել առանց սկզբնական զանգվածը փոխելու: Կամ գուցե մեր զանգվածը լցվել է, և մենք պետք է մեծացնենք դրա չափը՝ ավելի շատ տարրեր ավելացնելու համար: Այս դեպքերում զանգվածի պատճենման կամ ընդլայնման գործողությունը էական է: Այս ֆունկցիան ոչ միայն ծառայում է զանգվածը պատճենելու կամ մեծացնելու համար, այլ նաև կարող է օգնել մեզ նվազեցնել հիշողության օգտագործումը՝ պահպանելով միայն անհրաժեշտ տվյալները:

Մյուս կողմից, դա արժե այն նշեք, որ Java-ում զանգվածները անփոփոխ օբյեկտներ են, այսինքն, երբ զանգվածը ստեղծվել է, դրա չափը չի կարող փոխվել։ Java-ում զանգվածը «ընդլայնելու» համար մենք պետք է ստեղծեինք նոր ավելի մեծ զանգված և այնուհետև պատճենենք սկզբնական զանգվածի տարրերը նորին: Սա կարող է մի փոքր հոգնեցուցիչ լինել, բայց կան մեթոդներ, որոնք ներկառուցված են Java ստանդարտ գրադարանում, ինչպիսին է System.arraycopy() y Arrays.copyOf() որը կարող է հեշտացնել այս գործընթացը. Լեզուների համար, որոնք մշակում են դինամիկ տվյալների կառուցվածքները, ինչպիսիք են JavaScript-ը կամ Python-ը, գործընթացը շատ ավելի պարզ է, և կան մեթոդներ, ինչպիսիք են. push() y append() որոնք թույլ են տալիս տարրեր ավելացնել գոյություն ունեցող զանգվածին՝ առանց նորը ստեղծելու:

Խորանալով զանգվածները Javascript-ով պատճենելու մեթոդների մեջ

Javascript-ում զանգվածը պատճենելու կամ կրկնօրինակելու ամենատարածված մեթոդը օգտագործելն է slice() մեթոդը. Այս մեթոդը վերադարձնում է զանգվածի մակերեսային պատճենը սկզբի և վերջի ինդեքսների միջև ստեղծված ենթազանգվածից: Այն չի փոփոխում բնօրինակ զանգվածը և ամբողջությամբ մեկուսացնում է պատճենված զանգվածը սկզբնական զանգվածից։ Կարևոր է նշել, որ զանգվածի ներսում օբյեկտները պատճենելիս հղումներ են ստեղծվում բնօրինակ օբյեկտներին՝ նոր օրինակներ ստեղծելու փոխարեն: Սա նշանակում է, որ եթե դուք փոփոխում եք օբյեկտը պատճենված զանգվածում, այն նույնպես կփոփոխվի սկզբնական զանգվածում: Ահա մի քանի ծածկագիր՝ ցույց տալու համար.


let arrayOriginal = ['a', 'b', 'c', 'd', 'e'];
let arrayCopia = arrayOriginal.slice();


Եթե ​​այն, ինչ ձեզ անհրաժեշտ է, ընդլայնել զանգվածըՋավաՍկրիպտ այն մեզ առաջարկում է դա անելու մի քանի եղանակ: Մեթոդներից մեկը տարածման օպերատորի օգտագործումն է: Այս օպերատորը թույլ է տալիս ընդլայնել կրկնվող տարրերը զանգվածի ներսում ստեղծել նոր զանգված, որը պարունակում է սկզբնական զանգվածի տարրերը և լրացուցիչ տարրերը: Մեկ այլ մեթոդ concat() մեթոդն է, որը վերադարձնում է նոր զանգված, որը սկզբնական զանգվածին մեկ կամ մի քանի զանգվածներով կամ արժեքներով միացնելու արդյունք է։ Վերջապես, դուք կարող եք նաև օգտագործել push() մեթոդը, որն ավելացնում է մեկ կամ մի քանի տարրեր զանգվածի վերջում և վերադարձնում զանգվածի նոր երկարությունը: Ահա դուք ունեք որոշ օրինակներ:


let array1 = [1, 2, 3];
let array2 = [...array1, 4, 5, 6]; // array2 ahora es [1, 2, 3, 4, 5, 6]



let array3 = [1, 2, 3];
let array4 = array3.concat([4, 5, 6]); // array4 ahora es [1, 2, 3, 4, 5, 6]



let array5 = [1, 2, 3];
array5.push(4, 5, 6); // array5 ahora es [1, 2, 3, 4, 5, 6]


Զանգվածի ընդլայնում. առաջարկվող տեխնիկա և այլ տարբերակներ

Զանգվածի ընդլայնումը սովորական խնդիր է ծրագրավորման մեջ, հատկապես, երբ խոսքը վերաբերում է մեծ քանակությամբ տվյալների պահպանմանն ու շահարկմանը: Այնուամենայնիվ, առաջադրանքը կարող է դժվար լինել, եթե ճիշտ տեխնիկան հայտնի չէ: Այստեղ մենք կքննարկենք որոշ առաջարկվող տեխնիկա և զանգվածի ընդլայնման այլ տարբերակներ: Առաջին հերթին, դուք կարող եք օգտագործել գործառույթը Array.prototype.concat(). Այս ֆունկցիան միավորում է երկու կամ ավելի զանգված մեկում մատրիցա. Ավելին, այն չի փոփոխում սկզբնական մատրիցները, ինչը նշանակում է, որ տվյալների ամբողջականությունը պահպանվում է. Ահա մի օրինակ, թե ինչպես օգտագործել Array.prototype.concat():

let array1 = [1, 2, 3];
let array2 = [4, 5, 6];
let newArray = array1.concat(array2);

// newArray ahora es [1, 2, 3, 4, 5, 6]

Մեկ այլ տարբերակ օպերատորի տեխնիկայի օգտագործումն է տարածվել (…) . Այս օպերատորը թույլ է տալիս տարրեր վերցնել զանգվածից և տեղադրել դրանք նոր զանգվածում։ Ի տարբերություն Array.prototype.concat(-ի), spread օպերատորը լավ է աշխատում զանգվածների և օբյեկտների հետ։ Այն կարող է օգտագործվել նաև զանգված պատճենելու համար: Ահա մի օրինակ, թե ինչպես օգտագործել տարածման օպերատորը.

let array1 = [1, 2, 3];
let newArray = [...array1, 4, 5, 6];

// newArray ahora es [1, 2, 3, 4, 5, 6]

Ի վերջո, ընտրելով, թե որ մեթոդն օգտագործել, կախված կլինի ձեր նախագծի կոնկրետ կարիքներից: Այնուամենայնիվ, և՛ Array.prototype.concat()-ը, և՛ spread օպերատորը զանգվածների ընդլայնման արդյունավետ տեխնիկա են:

Արդյունավետ զանգվածների կառավարում. հետևանքներ կոդի կատարման համար

Զանգվածների հետ աշխատելիս ա բաժնետոմսերի Ամենատարածվածը դրանց պատճենումն է կամ ընդլայնումը: Այնուամենայնիվ, կարևոր է իմանալ, թե ինչպես կատարել այս գործողությունները արդյունավետորեն կոդի լավ կատարում ապահովելու համար: Այսպիսով, մենք պատրաստվում ենք վերլուծել երկու հիմնական մեթոդ. Array.prototype.slice() y Array.prototype.concat().

Երբ մեզ անհրաժեշտ է զանգված պատճենել, կարող ենք օգտագործել ֆունկցիան կտոր(). Այս մեթոդը թույլ է տալիս մեզ ստեղծել զանգվածի մի մասի մակերեսային պատճենը նոր զանգվածի օբյեկտի մեջ: Մեր զանգվածի ամբողջական կրկնօրինակման համար մենք պարզապես օգտագործում ենք հատված առանց որևէ փաստարկի, ինչպես հետևյալը.

բնօրինակ var = [1, 2, 3, 4, 5]; var copy = original.slice();

Սա մեզ կտա նոր «պատճեն» զանգված՝ նույն արժեքներով, ինչ «բնօրինակ» զանգվածը: Այնուամենայնիվ, պետք է հաշվի առնել, որ այս մեթոդն ամենաարդյունավետը չէ մեծ զանգվածների համար, քանի որ այն կարող է հանգեցնել հիշողության ավելորդ օգտագործման և կոդի դանդաղեցմանը:

Ինչ վերաբերում է զանգվածների ընդլայնմանը, ապա առաջարկում ենք օգտագործել ֆունկցիան կոնկատ(). Այս մեթոդը օգտագործվում է երկու կամ ավելի զանգվածներ միացնելու և նոր զանգված վերադարձնելու համար։ Եկեք պատկերացնենք, որ մենք ունենք երկու զանգված՝ «array1» և «array2», որոնց ցանկանում ենք միանալ: Այսպիսով, մենք կարող ենք օգտագործել concat հետևյալ կերպ.

var array1 = [1, 2, 3]; var array2 = [4, 5, 6]; var extended = array1.concat(array2);

Սա կվերադարձնի «ընդլայնված» զանգված [1, 2, 3, 4, 5, 6] արժեքներով: Անպայման հիշեք դա, մինչդեռ միացում հիանալի է փոքր զանգվածների միաձուլման համար, այն կարող է շատ հիշողություն սպառել ավելի մեծ զանգվածների հետ գործ ունենալիս: