Összefűzés (Concatenation) magyarázata a programozásban

A programozás világában az összefűzés, vagy angolul concatenation, egy alapvető művelet, amely lehetővé teszi számunkra, hogy két vagy több különálló adatelemet egyesítsünk egyetlen, koherens egésszé. Leggyakrabban karakterláncok, azaz stringek kombinálására használjuk, de a koncepció jóval túlmutat ezen, és számos más adatszerkezet, például listák, tömbök vagy akár bináris adatok kezelése során is kulcsszerepet játszik. Ez a képesség elengedhetetlen a dinamikus tartalomgeneráláshoz, a felhasználói felületek építéséhez, a fájlrendszerbeli útvonalak konstruálásához, és gyakorlatilag minden olyan esetben, ahol rugalmasan kell adatokat manipulálnunk és megjelenítenünk.

Az összefűzés nem csupán egy technikai lépés, hanem a programozói gondolkodásmód szerves része. Segítségével képesek vagyunk komplexebb adatstruktúrákat építeni egyszerűbb elemekből, ami a moduláris és olvasható kód alapját képezi. Gondoljunk csak bele, mennyire nehéz lenne értelmes üzeneteket, URL-eket vagy adatbázis-lekérdezéseket összeállítani, ha nem tudnánk szövegrészeket és változókat dinamikusan összekapcsolni. Ez a művelet a programozás egyik leggyakrabban használt eszköze, melynek mélyreható ismerete elengedhetetlen minden fejlesztő számára, függetlenül attól, hogy milyen nyelven dolgozik.

A különböző programozási nyelvek eltérő szintaxist és mechanizmusokat kínálnak az összefűzésre. Míg egyes nyelvek egyszerű operátorokat használnak, addig mások dedikált függvényeket vagy objektumokat biztosítanak a hatékonyabb és biztonságosabb műveletekhez. A választott módszernek jelentős hatása lehet a program teljesítményére, olvashatóságára és még a biztonságára is. Egy rosszul megválasztott összefűzési stratégia memóriaszivárgáshoz, lassú végrehajtáshoz vagy akár komoly biztonsági résekhez is vezethet. Ezért létfontosságú, hogy ne csak tudjuk, hogyan kell összefűzni, hanem azt is, mikor és milyen módon érdemes ezt tenni.

Karakterláncok összefűzése: a kezdetek

A karakterlánc összefűzés kétségkívül a leggyakoribb formája ennek a műveletnek. A legtöbb programozási nyelv biztosít valamilyen egyszerű módot két vagy több string egyesítésére. Ezek a módszerek általában operátorok vagy beépített függvények formájában jelennek meg, és céljuk, hogy a fejlesztő számára intuitív és könnyen használható legyen a stringek kombinálása.

A legegyszerűbb megközelítés gyakran egy speciális operátor használatát jelenti, mint például a plusz jel (+), a pont (.), vagy az ampersand (&). Ezek az operátorok a legtöbb esetben balról jobbra értékelődnek ki, és sorban egymás után fűzik össze a megadott stringeket. Nézzünk néhány példát a legnépszerűbb programozási nyelvekben.

Python

A Pythonban az összefűzésre a + operátor a leggyakrabban használt módszer. Egyszerű és olvasható, különösen rövid stringek esetén. Ezenkívül a Python kínál más, gyakran hatékonyabb és rugalmasabb megoldásokat is, mint például az .join() metódus vagy az f-stringek, de a + operátor az alapvető megközelítés.

nev = "Kiss"
keresztnev = "Péter"
teljes_nev = nev + " " + keresztnev
print(teljes_nev) # Kimenet: Kiss Péter

A Pythonban a stringek immutábilisek, ami azt jelenti, hogy minden összefűzési művelet egy teljesen új string objektumot hoz létre. Ez rövid stringek esetén nem okoz problémát, de hosszú stringek ismételt összefűzésekor teljesítményproblémákhoz vezethet, mivel sok ideiglenes string objektum keletkezik a memóriában. Ilyenkor az .join() metódus sokkal hatékonyabb.

JavaScript

A JavaScript is a + operátort használja a stringek összefűzésére. Ez a nyelv különösen rugalmas a típuskonverzió terén, ami néha meglepő eredményekhez vezethet, ha számokat is bevonunk az összefűzésbe. A modern JavaScript emellett bevezette a template literalokat, amelyek sokkal olvashatóbbá teszik a komplex stringek összeállítását.

let elsoResz = "Helló";
let masodikResz = "Világ";
let uzenet = elsoResz + ", " + masodikResz + "!";
console.log(uzenet); // Kimenet: Helló, Világ!

A template literalok (visszafelé dőlő aposztrófok, azaz backtickek között) lehetővé teszik a változók közvetlen beágyazását ${variable} szintaxissal, ami nagyban javítja az olvashatóságot és elkerüli a sok + operátor használatát.

let nev = "Anna";
let kor = 30;
let bemutatkozas = `Szia, a nevem ${nev} és ${kor} éves vagyok.`;
console.log(bemutatkozas); // Kimenet: Szia, a nevem Anna és 30 éves vagyok.

Java

A Java is a + operátort alkalmazza a stringek összefűzésére. A Pythonhoz hasonlóan a Java stringjei is immutábilisek. Ezért a Java futásidejű környezete (JVM) optimalizációkat végez, és belsőleg gyakran a StringBuilder osztályt használja, ha több stringet fűzünk össze egyetlen kifejezésben. Azonban ciklusokban történő ismételt összefűzés esetén továbbra is érdemes manuálisan a StringBuilder-t használni a teljesítmény optimalizálása érdekében.

String elso = "Programozás";
String masodik = "Világ";
String osszefuzott = elso + " a " + masodik + "ban.";
System.out.println(osszefuzott); // Kimenet: Programozás a Világban.

A StringBuilder használata:

StringBuilder sb = new StringBuilder();
sb.append("Ez egy ");
sb.append("hatékony ");
sb.append("összefűzés.");
String eredmeny = sb.toString();
System.out.println(eredmeny); // Kimenet: Ez egy hatékony összefűzés.

C#

A C# szintén a + operátort használja a string összefűzésre, és itt is immutábilisek a stringek, akárcsak Javában. A .NET keretrendszer is optimalizálja az összefűzéseket, de a StringBuilder osztály használata javasolt a teljesítménykritikus esetekben, különösen ciklusokban. Emellett a C# is kínál string interpolációt (hasonlóan a Python f-stringjeihez és a JavaScript template literaljaihoz), ami rendkívül olvashatóvá teszi a komplex stringek összeállítását.

string elso = "C#";
string masodik = "Fejlesztés";
string osszefuzott = elso + " és " + masodik;
Console.WriteLine(osszefuzott); // Kimenet: C# és Fejlesztés

String interpoláció C#-ban (a string elé egy $ jelet kell tenni):

string termekNev = "Laptop";
decimal ar = 1200.50m;
string leiras = $"A termék neve: {termekNev}, ára: {ar:C}."; // :C formázza pénznemként
Console.WriteLine(leiras); // Kimenet: A termék neve: Laptop, ára: 1 200,50 Ft. (vagy lokálétől függően más pénznem)

PHP

A PHP a . (pont) operátort használja a stringek összefűzésére. Ez a nyelv dinamikusan típusos, és a string konverzió is automatikusan megtörténik, ha más típusú adatot fűzünk stringhez. A PHP emellett támogatja a változók közvetlen beágyazását a duplán idézőjeles stringekbe, ami szintén egyfajta „implicit” összefűzésnek tekinthető.

$elso = "Szia";
$masodik = "PHP";
$uzenet = $elso . ", " . $masodik . " fejlesztő!";
echo $uzenet; // Kimenet: Szia, PHP fejlesztő!

Változók beágyazása duplán idézőjeles stringekbe:

$felhasznalo = "János";
$eletkor = 25;
echo "Üdvözöllek, $felhasznalo! Te $eletkor éves vagy."; // Kimenet: Üdvözöllek, János! Te 25 éves vagy.

C++

A C++ a std::string osztály bevezetésével modernizálta a stringek kezelését. Korábban C-stílusú karaktertömbökkel dolgoztak, ami manuális memóriakezelést és függvényeket (pl. strcat) igényelt. A std::string-ekkel a + operátor használható az összefűzésre, hasonlóan a Java vagy C# nyelvekhez. A C++ stringjei is immutábilisek, de a modern fordítók és szabványos könyvtárak optimalizálják az összefűzési műveleteket.

#include <iostream>
#include <string>

int main() {
    std::string elso = "C++";
    std::string masodik = "programozás";
    std::string teljes = elso + " " + masodik + " remek!";
    std::cout << teljes << std::endl; // Kimenet: C++ programozás remek!
    return 0;
}

A C++-ban is létezik a std::stringstream, amely hasonlóan a Java StringBuilder-hez, hatékonyabb lehet nagyszámú string összefűzésekor, különösen ciklusokban.

#include <iostream>
#include <string>
#include <sstream>

int main() {
    std::stringstream ss;
    ss << "Ez egy " << "stream alapú " << "összefűzés.";
    std::string eredmeny = ss.str();
    std::cout << eredmeny << std::endl; // Kimenet: Ez egy stream alapú összefűzés.
    return 0;
}

Az összefűzés alapvető fontosságú a dinamikus tartalom előállításában, legyen szó felhasználói felületekről, naplóüzenetekről vagy adatbázis-lekérdezésekről.

Teljesítmény és memóriahatékonyság: mélyebb betekintés

Az összefűzés egyszerűnek tűnő művelet, de a motorháztető alatt komoly teljesítménybeli és memóriahatékonysági megfontolásokat rejt. Különösen igaz ez a stringek immutabilitására, amely számos modern programozási nyelvben alapvető jellemző. Ennek megértése kulcsfontosságú a hatékony és skálázható alkalmazások fejlesztéséhez.

A stringek immutabilitása

Sok programozási nyelvben (pl. Java, C#, Python, JavaScript, C++) a stringek immutábilisek. Ez azt jelenti, hogy miután egy string objektum létrejött, annak tartalma nem módosítható. Amikor egy összefűzési műveletet hajtunk végre, például stringA + stringB, a rendszer nem módosítja a stringA vagy stringB objektumokat. Ehelyett egy teljesen új string objektumot hoz létre a memóriában, amely stringA és stringB tartalmát is tartalmazza. Az eredeti string objektumok érintetlenek maradnak.

Ez a viselkedés számos előnnyel jár, például a szálbiztonsággal (thread-safety), mivel több szál is olvashatja ugyanazt a stringet anélkül, hogy aggódni kellene a tartalom módosítása miatt. Azonban hátrányai is vannak, különösen, ha nagyszámú összefűzési műveletet végzünk el egy ciklusban. Minden egyes összefűzés egy új string objektumot generál, ami memóriafoglalást és -felszabadítást von maga után, ez pedig jelentős teljesítménycsökkenést okozhat, és növelheti a szemétgyűjtő (garbage collector) terhelését.

Képzeljük el, hogy egy hosszú stringet építünk fel sok kis darabból egy ciklusban. Minden iterációban:

1. Létrejön egy új string objektum.
2. A régi string tartalma és az új darab tartalma átmásolódik ebbe az új stringbe.
3. A régi string objektum potenciálisan szemétté válik és felszabadításra vár.

Ez a folyamat rendkívül pazarló lehet erőforrás szempontjából.

Hatékony összefűzési stratégiák

A fent említett teljesítményproblémák elkerülése érdekében a programozási nyelvek és keretrendszerek gyakran kínálnak alternatív, hatékonyabb összefűzési mechanizmusokat. Ezek a módszerek általában úgy működnek, hogy előre lefoglalnak egy nagyobb memóriaterületet, vagy dinamikusan növelik azt, és a string darabokat ebbe az előre lefoglalt pufferbe másolják, elkerülve a sok ideiglenes string objektum létrehozását.

Nézzünk néhány példát a különböző nyelvekben:

Java és C#: StringBuilder

Mind a Java, mind a C# rendelkezik egy StringBuilder (Java) vagy System.Text.StringBuilder (C#) osztállyal, amelyet kifejezetten a modifikálható stringek hatékony kezelésére terveztek. Ezek az osztályok belsőleg egy változtatható karaktertömböt használnak, amely dinamikusan növekszik, ha szükséges. Az összefűzési műveletek (pl. append() metódus) nem hoznak létre új string objektumot minden lépésben, hanem a belső tömböt módosítják.

// Java példa
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("Adat_").append(i).append(" ");
}
String eredmeny = sb.toString(); // Ekkor jön létre a végleges string

// C# példa
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.Append("Adat_").Append(i).Append(" ");
}
string eredmeny = sb.ToString(); // Ekkor jön létre a végleges string

A StringBuilder használatával jelentősen csökkenthető a memóriafoglalás és a szemétgyűjtő terhelése, ami drámai teljesítménynövekedést eredményezhet nagyszámú összefűzés esetén.

Python: .join() metódus

A Pythonban az .join() metódus a leginkább ajánlott és leggyorsabb módja a stringek listájának összefűzésére. A join() metódus egy iterálható objektumot (pl. listát) vesz alapul, amely stringeket tartalmaz, és a metódust hívó stringet használja elválasztóként a listaelemek között. Mivel a join() egyszerre kapja meg az összes összefűzendő elemet, képes előre kiszámítani a végeredmény string méretét és csak egyszer foglal memóriát, elkerülve a sok ideiglenes objektumot.

darabok = ["Ez", "egy", "hatékony", "Python", "összefűzés."]
elvalaszto = " "
eredmeny = elvalaszto.join(darabok)
print(eredmeny) # Kimenet: Ez egy hatékony Python összefűzés.

Ez a módszer sokkal hatékonyabb, mint a + operátor használata egy ciklusban:

# Kevésbé hatékony Python példa (kerülendő nagy adatmennyiségnél)
eredmeny_rossz = ""
for i in range(1000):
    eredmeny_rossz += "Adat_" + str(i) + " "

# Sokkal hatékonyabb Python példa
darabok = []
for i in range(1000):
    darabok.append("Adat_" + str(i))
eredmeny_jo = " ".join(darabok)

JavaScript: Array.prototype.join() és template literalok

JavaScriptben, ha több stringet kell összefűzni, az Array.prototype.join() metódus hasonlóan hatékony, mint a Pythonban. Először gyűjtsük össze a string darabokat egy tömbbe, majd fűzzük össze a join() segítségével.

let darabok = ["Ez", "egy", "hatékony", "JavaScript", "összefűzés."];
let eredmeny = darabok.join(" ");
console.log(eredmeny); // Kimenet: Ez egy hatékony JavaScript összefűzés.

A modern JavaScript template literaljai (`string ${variable}`) szintén optimalizáltak, és a legtöbb esetben elegendőek az olvasható és hatékony stringépítéshez. A JavaScript motorok belsőleg optimalizálják ezeket a műveleteket, így ritkán van szükség manuális join()-ra, hacsak nem egy dinamikusan növekvő listát kell összefűzni.

PHP: implode() és sprintf()

PHP-ban az implode() függvény hasonlóan működik a Python .join() és a JavaScript Array.prototype.join() metódusaihoz. Egy tömb elemeit fűzi össze egy stringgé, egy megadott elválasztó karakterlánc segítségével.

$darabok = ["Ez", "egy", "hatékony", "PHP", "összefűzés."];
$eredmeny = implode(" ", $darabok);
echo $eredmeny; // Kimenet: Ez egy hatékony PHP összefűzés.

A sprintf() függvény (és rokonai, mint a printf()) is rendkívül hasznos a formázott stringek létrehozásához. Ez a C nyelvből ismert függvény egy formátum stringet vesz alapul, és abba helyettesíti be a változókat. Bár nem szigorúan összefűzés, de gyakran használják stringek dinamikus összeállítására, és általában hatékonyabb, mint a sok . operátor használata.

$nev = "László";
$kor = 42;
$uzenet = sprintf("A felhasználó neve: %s, életkora: %d év.", $nev, $kor);
echo $uzenet; // Kimenet: A felhasználó neve: László, életkora: 42 év.

A stringek immutabilitása miatt a teljesítménykritikus alkalmazásokban elengedhetetlen a megfelelő összefűzési stratégia megválasztása.

Típuskonverzió és implicit összefűzés

Amikor stringeket fűzünk össze más típusú adatokkal, gyakran szembesülünk a típuskonverzió jelenségével. Ez azt jelenti, hogy a nem string típusú adatokat (pl. számok, boolean értékek, objektumok) a programozási nyelv automatikusan vagy explicit módon stringgé alakítja, mielőtt az összefűzés megtörténne. Ennek megértése kulcsfontosságú a váratlan hibák elkerülése és a kód helyes működésének biztosítása érdekében.

Automatikus típuskonverzió (implicit)

Számos programozási nyelv, különösen a dinamikusan típusos nyelvek, automatikus, vagy más néven implicit típuskonverziót hajt végre, amikor egy stringet más típusú adattal fűzünk össze. Ez kényelmes lehet, de néha zavaros vagy hibás eredményekhez vezethet.

JavaScript példa

A JavaScript talán az egyik legismertebb példa az implicit típuskonverzióra. A + operátor a JavaScriptben vagy aritmetikai összeadást, vagy string összefűzést végez, attól függően, hogy melyik operandus a string. Ha legalább az egyik operandus string, akkor az összes többi operandus is stringgé konvertálódik, és összefűzés történik.

console.log("A szám: " + 10);     // Kimenet: A szám: 10 (szám -> string)
console.log(5 + " alma");         // Kimenet: 5 alma (szám -> string)
console.log("10" + 20);           // Kimenet: 1020 (szám -> string, majd összefűzés)
console.log(true + " igaz");      // Kimenet: true igaz (boolean -> string)
console.log(null + " nulla");     // Kimenet: null nulla (null -> string)
console.log(undefined + " undef"); // Kimenet: undefined undef (undefined -> string)

Ez a viselkedés azonban meglepő lehet, ha nem vagyunk tisztában vele:

console.log(1 + 2 + "3"); // Kimenet: 33 (1+2=3, majd "3" + "3" = "33")
console.log("1" + 2 + 3); // Kimenet: 123 ("1" + 2 = "12", majd "12" + 3 = "123")

Látható, hogy az operátorok kiértékelési sorrendje és a típusok jelenléte alapvetően befolyásolja a végeredményt. A + operátor balról jobbra értékelődik ki, így az első példában először az aritmetikai összeadás történik meg, majd az eredményt fűzi össze a stringgel. A második példában viszont az első + operátor string összefűzést végez, mert az első operandus string, így a további műveletek is string összefűzések lesznek.

PHP példa

A PHP is rugalmas az implicit típuskonverzióval. A . (pont) operátor mindig string összefűzést végez, így bármilyen típusú operandust stringgé konvertál:

echo "A szám: " . 10;     // Kimenet: A szám: 10
echo 5 . " alma";         // Kimenet: 5 alma
echo true . " igaz";      // Kimenet: 1 igaz (true -> "1")
echo false . " hamis";    // Kimenet: hamis (false -> "")
echo null . " nulla";     // Kimenet: nulla (null -> "")

Érdemes megjegyezni, hogy a PHP-ban a true értéke „1”-re, a false és a null pedig üres stringre konvertálódik string összefűzés esetén. Ez is fontos részlet, amit figyelembe kell venni.

Explicit konverzió szükségessége

Ahol az implicit konverzió nem kívánatos, vagy a nyelv szigorúbban típusos, ott explicit konverzióra van szükség. Ez azt jelenti, hogy a fejlesztőnek manuálisan kell átalakítania az adatot stringgé, mielőtt az összefűzés megtörténne. Ezáltal a kód egyértelműbbé és kevésbé hibalehetőséggel telivé válik.

Java és C# példa

Javában és C#-ban a + operátor a string összefűzésre is használható, és ha az egyik operandus string, a többi automatikusan stringgé konvertálódik. Azonban, ha egy objektumot fűzünk stringhez, akkor annak toString() (Java) vagy ToString() (C#) metódusa hívódik meg. Ha ez a metódus nincs felülírva, akkor az alapértelmezett implementáció (ami gyakran az objektum típusának és memóriacímének string reprezentációja) kerül felhasználásra, ami ritkán hasznos.

// Java példa
class Szemely {
    String nev;
    int kor;
    public Szemely(String nev, int kor) {
        this.nev = nev;
        this.kor = kor;
    }
    // toString() felülírása a releváns információk kiírásához
    @Override
    public String toString() {
        return "Személy [nev=" + nev + ", kor=" + kor + "]";
    }
}

Szemely p = new Szemely("Éva", 28);
System.out.println("Adatok: " + p); // Kimenet: Adatok: Személy [nev=Éva, kor=28] (a felülírt toString() miatt)

// Ha nincs felülírva a toString():
// System.out.println("Adatok: " + p); // Kimenet: Adatok: Szemely@15db9742 (vagy hasonló)

Az explicit konverzió általában a String.valueOf() (Java) vagy .ToString() (C#) metódusok hívásával történik:

// Java példa
int szam = 123;
String szamString = String.valueOf(szam);
String osszefuzott = "A szám: " + szamString;

// C# példa
int szamC = 456;
string szamStringC = szamC.ToString();
string osszefuzottC = "A szám: " + szamStringC;

Python példa

A Pythonban a + operátor csak stringeket tud összefűzni stringekkel. Ha számot vagy más típust akarunk stringhez fűzni, explicit konverzióra van szükség a str() függvénnyel:

szam = 123
# print("A szám: " + szam) # Hiba: TypeError: can only concatenate str (not "int") to str
print("A szám: " + str(szam)) # Kimenet: A szám: 123

Ez a szigorúság segít megelőzni a váratlan típuskonverziós hibákat, és arra ösztönzi a fejlesztőket, hogy explicit módon kezeljék a típusokat. Természetesen az f-stringek és a .format() metódusok elegánsan kezelik ezt, mivel ők belsőleg elvégzik a szükséges konverziót.

nev = "Gábor"
kor = 35
print(f"Név: {nev}, Kor: {kor}") # Az f-string automatikusan konvertálja a 'kor'-t

Az explicit típuskonverzióval a kód robusztusabbá válik, és csökken a rejtett hibák lehetősége. Bár az implicit konverzió kényelmes lehet, a fejlesztőnek mindig tisztában kell lennie a nyelv viselkedésével, hogy elkerülje a váratlan eredményeket.

A típuskonverzió az összefűzés során a programozási nyelvek egyik leggyakrabban félreértett aspektusa, amely jelentősen befolyásolhatja a programok működését és megbízhatóságát.

Az összefűzés túlmutat a stringeken: adatszerkezetek kombinálása

Bár a string összefűzés a leggyakoribb alkalmazási területe az összefűzésnek, a koncepció jóval szélesebb körben értelmezhető. Számos programozási nyelv biztosít mechanizmusokat különböző adatszerkezetek, például listák, tömbök, tuple-ök vagy akár halmazok kombinálására, amelyek lényegében az összefűzés egy másik formáját képviselik.

Ezek a műveletek lehetővé teszik számunkra, hogy több kisebb gyűjteményből egy nagyobb, egységes gyűjteményt hozzunk létre, megőrizve az adatok sorrendjét (ha releváns) és típusát. Ez rendkívül hasznos adatfeldolgozás, gyűjteménykezelés és algoritmusok implementálása során.

Listák és tömbök összefűzése

A listák (vagy tömbök, attól függően, hogy az adott nyelv mit preferál) összefűzése azt jelenti, hogy két vagy több listát egyesítünk egyetlen új listává. Ez a művelet általában az eredeti listák sorrendjét megtartja.

Python: listák összefűzése

Pythonban a listák összefűzésére több módszer is létezik:

1. + operátor: Ez a legközvetlenebb módja két vagy több lista összefűzésének. Egy új listát hoz létre, amely az eredeti listák elemeit tartalmazza.

lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
osszefuzott_lista = lista1 + lista2
print(osszefuzott_lista) # Kimenet: [1, 2, 3, 4, 5, 6]

Hasonlóan a stringekhez, a + operátor itt is egy új listát hoz létre, ami nagy listák ismételt összefűzésekor teljesítményproblémákat okozhat.

2. .extend() metódus: Ez a metódus az egyik listát a másikhoz fűzi hozzá, az eredeti lista módosításával (in-place). Hatékonyabb lehet, ha nem szükséges az eredeti lista érintetlenül hagyása.

lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
lista1.extend(lista2)
print(lista1) # Kimenet: [1, 2, 3, 4, 5, 6]

3. Csillag operátor (*) vagy unpacking operátor (*): Python 3.5+ verzióban a csillag operátorral is összefűzhetünk listákat literálokon belül.

lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
osszefuzott_lista = [*lista1, *lista2]
print(osszefuzott_lista) # Kimenet: [1, 2, 3, 4, 5, 6]

JavaScript: