Hoe kinne jo gegevens opslaan yn in TXT-bestân yn Java

Yn 'e wrâld fan programmearring is it essensjeel om de mooglikheid te hawwen om gegevens te bewarjen en te lêzen út in bestân om taken út te fieren lykas konfiguraasjes opslaan, ynformaasje opslaan yn databases, of gewoan útfiere reservekopyen. Yn dit artikel sille wy ûndersykje hoe't jo gegevens kinne opslaan yn in TXT-bestân mei de programmeartaal Java. Wy sille leare hoe't te skriuwen effektive koade wêrmei ús te bewarjen en ophelje ynformaasje fan in effisjinte manier en maklik te begripen. Bliuw lêze om alle details út te finen!

1. Ynlieding foar it manipulearjen fan TXT-bestannen yn Java

Yn Java is it manipulearjen fan TXT-bestannen in mienskiplike taak wêrmei't wy ynformaasje kinne lêze en skriuwe nei in platte tekstbestân. Yn dit artikel sil ik jo liede stap foar stap oer hoe't jo TXT-bestannen yn Java kinne manipulearje. Derneist sil ik wat nuttige tips en praktyske foarbylden mei jo diele, sadat jo dizze funksjonaliteit kinne begripe en brûke. effektyf.

Om TXT-bestannen yn Java te manipulearjen, moatte jo de FileWriter-klasse brûke om nei in bestân te skriuwen en de FileReader-klasse om te lêzen fan in besteande bestân. Dizze klassen binne te finen yn it java.io-pakket, dus jo moatte dit pakket ymportearje yn jo koade.

As jo ​​​​ienris it java.io-pakket ymporteare hawwe, kinne jo in eksimplaar fan 'e FileWriter-klasse oanmeitsje om nei in spesifyk bestân te skriuwen. Jo kinne de FileWriter (String filePath) constructor brûke om it paad op te jaan fan it bestân dat jo wolle skriuwe. Soargje derfoar dat jo alle útsûnderingen behannelje dy't foarkomme kinne tidens it skriuwen fan bestân. As jo ​​klear binne mei it skriuwen nei it bestân, tink dan om it te sluten mei de metoade close ().

2. Iepenje en meitsje in TXT triem yn Java

Om in TXT-bestân yn Java te iepenjen en oan te meitsjen, binne d'r ferskate opsjes beskikber. Hjirûnder binne de stappen dy't nedich binne om dit te berikken:

Stap 1: Earst moatte jo derfoar soargje dat jo de Java-ûntwikkelingsomjouwing (lykas Eclipse of NetBeans) hawwe ynstalleare op jo systeem. Hjirmei kinne jo jo Java-koade skriuwe en kompilearje effisjint.

Stap 2: As jo ​​​​ienris jo ûntwikkelingsomjouwing ynsteld hawwe, kinne jo begjinne mei it skriuwen fan Java-koade om in TXT-bestân te iepenjen of te meitsjen. Om in besteande triem te iepenjen, kinne jo de klasse brûke FileReader o BufferedReaderBygelyks: FileReader archivo = new FileReader("archivo.txt");. Om te meitsjen in nije triem, kinne jo gebrûk meitsje fan de klasse FileWriter o BufferedWriterBygelyks: FileWriter archivo = new FileWriter("nuevoarchivo.txt");.

Stap 3: Nei it iepenjen of oanmeitsjen fan it bestân kinne jo ferskate operaasjes derop útfiere mei metoaden beskikber yn 'e oerienkommende klassen. Jo kinne bygelyks de ynhâld fan in bestân lêze mei de metoade read() yn de klasse FileReader en skriuw nei in bestân mei de metoaden write() o append() yn de klasse FileWriter. Ferjit net om it bestân te sluten nei't jo it brûke mei de metoade close().

3. It skriuwen fan gegevens nei in TXT triem yn Java

Om gegevens te skriuwen nei in teksttriem yn Java, moatte wy earst in objekt fan klasse meitsje File dat stiet foar it bestân yn it bestânsysteem. Dêrnei sille wy in objekt fan 'e klasse brûke FileWriter om de gegevens nei it bestân te skriuwen.

Hjir is in foarbyld fan hoe't jo it dwaan:

import java.io.FileWriter;
import java.io.IOException;

public class EscribirArchivoTXT {
    public static void main(String[] args) {
        String datos = "Estos son los datos que queremos escribir en el archivo.";

        try {
            FileWriter archivo = new FileWriter("ruta_del_archivo.txt");
            archivo.write(datos);
            archivo.close();
            System.out.println("Los datos se han escrito correctamente en el archivo.");
        } catch (IOException e) {
            System.out.println("Ha ocurrido un error al escribir en el archivo.");
            e.printStackTrace();
        }
    }
}

Yn dit foarbyld meitsje wy in eksimplaar fan 'e klasse FileWriter llamada archivo en wy spesifisearje it paad en namme fan it bestân dat wy wolle oanmeitsje. Dan brûke wy de metoade write() om de gegevens te skriuwen nei it bestân en de metoade close() om it bestân te sluten as wy klear binne mei skriuwen. As lêste litte wy in súksesberjocht sjen as de gegevens goed skreaun binne, of in flaterberjocht as der in probleem is.

It is wichtich om te merken dat by it brûken fan de klasse FileWriter, as de oantsjutte triem net bestiet, sil it automatysk oanmakke wurde. As de triem lykwols al bestiet, wurde de foarige gegevens wiske en ferfongen troch de nije gegevens dy't wy skriuwe. Dêrom is it oan te rieden om in te meitsjen reservekopy fan it bestân foardat jo skriuwoperaasjes útfiere om wichtige gegevens te ferliezen.

4. Sluten en bewarje feroarings oan in TXT triem yn Java

No't wy leard hawwe hoe't jo in TXT-bestân yn Java iepenje en lêze, is it wichtich om te witten hoe't jo de wizigingen kinne slute en bewarje dy't wy yn dat bestân makke hawwe. Gelokkich biedt Java ús in maklike manier om dit te dwaan.

Om in bestân te sluten, moatte wy gewoan de metoade 'close()' neame op it 'BufferedWriter'-objekt dat wy brûke om nei it bestân te skriuwen. Dit sil derfoar soargje dat alle wachtsjende wizigingen goed opslein wurde foardat it bestân sluten wurdt.

«`java
BufferedWriter skriuwer = null;
besykje {
writer = new BufferedWriter(new FileWriter("file.txt"));
// … koade om nei it bestân te skriuwen …
} catch (IOException e) {
// … útsûndering ôfhanneling …
} úteinlik {
if (skriuwer != null) {
besykje {
skriuwer.close();
} catch (IOException e) {
// … útsûndering ôfhanneling …
}
}
}
«`

It is wichtich om te soargjen dat it blok `writer.close()` binnen in `finally` blok is om te soargjen dat it wurdt útfierd sels as der in útsûndering foarkomt by it skriuwen nei it bestân.

5. Lêzen fan gegevens út in TXT triem yn Java

Om gegevens te lêzen fan in TXT-bestân yn Java, binne d'r ferskate opsjes beskikber. Ien fan 'e meast foarkommende manieren is om de klasse te brûken Scanner dat heart by it pakket java.util. Dizze klasse jout metoaden foar it lêzen fan ferskate soarten ynfiergegevens, ynklusyf tekstbestannen.

De earste stap om gegevens te lêzen fan in TXT-bestân is om in eksimplaar fan 'e klasse te meitsjen Scanner en trochjaan it objekt as argumint File dy't it bestân fertsjintwurdiget dat wy lêze wolle. Dan kinne wy ​​​​de metoaden fan 'e klasse brûke Scanner om gegevens fan 'e triem line foar rigel te lêzen of in spesifike skieding te brûken.

Sadree't wy hawwe lêzen de gegevens út it bestân, wy kinne ferwurkje it mei help fan de ark en techniken dy't it bêste passe ús easken. Wy kinne bygelyks gegevensstruktueren brûke lykas arrays of listen om de lêzengegevens op te slaan, of wy kinne tekstferwurkingsalgoritmen brûke om mear avansearre operaasjes út te fieren. Hjirûnder is in foarbyld fan hoe't jo gegevens lêze kinne fan in TXT-bestân mei de klasse Scanner:

6. Manipulearjen fan de struktuer fan in TXT triem yn Java

Yn Java kin it manipulearjen fan de struktuer fan in TXT-bestân tige nuttich wêze yn ferskate situaasjes. Fan it lêzen en skriuwen fan gegevens, oant it wizigjen en wiskjen fan ynhâld, witten hoe't jo dizze bestânstruktuer moatte behannelje is essensjeel foar applikaasjeûntwikkeling. De stappen dy't nedich binne om dizze operaasjes effektyf út te fieren sille hjirûnder wurde detaillearre.

1. Gegevens lêze: De earste stap yn it manipulearjen fan de struktuer fan in TXT-bestân is it lêzen fan besteande gegevens yn 'e triem. Om dit te dwaan, is it nedich om de klasse FileReader te brûken, wêrmei jo in tekstbestân kinne iepenje en de ynhâld lêze. Sadree't it bestân is iepene, kin syn ynhâld line foar rigel tagonklik wurde, it opslaan yn fariabelen foar lettere ferwurking.

2. Gegevens skriuwe: Neist it lêzen fan gegevens fan in TXT-bestân is it mooglik om nije gegevens nei te skriuwen. Om dit te dwaan, wurdt de klasse FileWriter brûkt, wêrtroch it skriuwen nei tekstbestannen mooglik is. By it iepenjen fan in bestân yn skriuwmodus kinne metoaden lykas write() of append() brûkt wurde om ynhâld ta te foegjen oan it bestân. It is wichtich om te notearjen dat, nei it foltôgjen fan it skriuwen, it bestân moat wurde sluten mei de metoade close() om te soargjen dat de wizigingen goed opslein wurde.

3. Feroarje en wiskjen fan ynhâld: Soms kin it nedich wêze om spesifike ynhâld te wizigjen of te wiskjen fan in TXT-bestân. Om dit te dwaan is it handich om struktueren te brûken lykas listen of arrays om de ynhâld fan it bestân tydlik op te slaan. As jo ​​​​in stikje gegevens wolle wizigje, kinne jo it tagong krije fia syn posysje yn 'e list of array, de nedige wizigingen oanmeitsje en dan de wizigingen opslaan yn it bestân. Om ynhâld te ferwiderjen, kinne jo de metoade remove () fan 'e klasse ArrayList brûke om spesifike eleminten te ferwiderjen of de metoade clear () om alle ynhâld út 'e triem te ferwiderjen.
[EIN

7. Mei help fan karakter streamt te bewarjen gegevens oan in TXT triem yn Java

Om gegevens te bewarjen yn in teksttriem (.txt) yn Java, kinne wy ​​​​karakterstreamen brûke. Karakterstreamen binne in handige manier om gegevens te lêzen en te skriuwen nei tekstbestannen. Yn Java wurde karakterstreamen fertsjintwurdige troch de FileReader- en FileWriter-klassen.

Om nei in teksttriem te skriuwen, meitsje wy earst in objekt fan 'e FileWriter-klasse en assosjearje it mei it bestimmingsbestân. Dan brûke wy de metoade skriuwe () om de gegevens nei it bestân te skriuwen. As lêste slute wy de stream mei de metoade slute ().

Veamos un ejemplo:

try {
FileWriter archivo = new FileWriter("datos.txt");
archivo.write("Este es un ejemplo de datos que se escriben en un archivo de texto en Java.");
archivo.close();
} catch (IOException e) {
e.printStackTrace();
}

Yn dit foarbyld skriuwe wy de tekenrige "Dit is in foarbyld fan gegevens dy't skreaun wurde nei in tekstbestân yn Java." yn de data.txt triem. Unthâld om alle útsûnderings te fangen en te behanneljen dy't foarkomme kinne tidens it skriuwen fan bestân.

8. Bytestreamen brûke om gegevens te bewarjen yn in TXT-bestân yn Java

Om gegevens te bewarjen yn in tekstbestân yn Java, kinne wy ​​​​bytestreamen brûke. Dizze streamen kinne ús sequentially lêze en skriuwe in sesje fan bytes nei in bestân. Earst moatte wy in útfiertriem oanmeitsje mei de klasse FileOutputStream. Wy kinne dan in gegevensstream brûke om de bytes nei it bestân te skriuwen. Wy kinne in blokje brûke try-catch om mooglike útsûnderings te behanneljen.

Sadree't de útfier triem is oanmakke, kinne wy ​​brûke de metoade write() fan 'e gegevensstream om de gegevens te skriuwen dy't wy wolle bewarje. Om in tekststring te skriuwen, kinne wy ​​it omsette yn bytes mei de metoade getBytes() en skriuw dan de bytes nei it bestân. Wy kinne ek gebrûk meitsje fan de metoade writeUTF() om tekststrings direkt yn UTF-8-formaat te skriuwen. As wy oare soarten gegevens skriuwe wolle, lykas heule getallen of desimalen, kinne wy ​​de klassen brûke DataOutputStream en harren oerienkommende metoaden.

Uteinlik is it wichtich om de gegevensstream te sluten en de boarnen frij te meitsjen mei de metoade close(). Dit soarget derfoar dat de gegevens goed opslein wurde yn it bestân en foarkomme ferlies fan ynformaasje. Derneist kinne wy ​​​​it blokje brûke finally om te soargjen dat de stream sletten is, sels as der in útsûndering foarkomt yn it skriuwproses. Mei dizze stappen kinne wy ​​bytestreamen brûke om gegevens effisjint en feilich te bewarjen yn in tekstbestân yn Java.

9. Feilich bewarje gegevens oan in TXT triem yn Java

Om gegevens te bewarjen yn in TXT-bestân feilich Yn Java is it wichtich om bepaalde stappen te folgjen en de juste ark te brûken. Yn dit artikel sille wy in stap-foar-stap tutorial leverje oer hoe't jo dit kinne berikke.

Earst moatte jo in objekt fan type FileWriter oanmeitsje om in ferbining te meitsjen mei it TXT-bestân. Dit wurdt berikt troch it brûken fan de FileWriter-konstruktor en it trochjaan fan it bestânpaad as argumint. It is oan te rieden om de File-klasse te brûken om in eksimplaar te meitsjen en it troch te jaan oan de FileWriter-konstruktor. Dit sil derfoar soargje dat it bestân goed is oanmakke en leit yn it opjûne paad.

Dan moatte jo in objekt fan type BufferedWriter brûke om nei it bestân te skriuwen effisjint. Dit objekt wurdt makke mei de BufferedWriter-konstruktor en it trochjaan fan it FileWriter-objekt as argumint. De BufferedWriter bewarret gegevens tydlik yn in buffer foardat it skriuwt nei it bestân, wat de prestaasjes fan it skriuwproses ferbettert. Sadree't de gegevens binne buffered, kin skreaun wurde nei it bestân mei de metoade skriuwe (). Ta beslút, it is wichtich om te sluten sawol de BufferedWriter en FileWriter mei help fan de close () metoaden, om te soargjen dat middels wurde útbrocht korrekt en gegevens wurde bewarre. feilich.

10. Wurkje mei grutte TXT triemmen yn Java

Wurkje mei grutte tekstbestannen yn Java kin útdaagjend wêze, benammen as de juste techniken net wurde brûkt. D'r binne lykwols ferskate strategyen en ark dy't dizze taak handiger en effisjinter meitsje kinne. Hjirûnder binne wat tips en oanpak dy't nuttich kinne wêze as jo wurkje mei grutte TXT-bestannen yn Java.

1. Lês de triem yn blokken: Ynstee fan besykjen om de hiele triem tagelyk te lêzen, is it oan te rieden om it yn lytsere blokken te lêzen. Dit helpt foar te kommen systeem overload en ferbetteret prestaasjes. Jo kinne dit dwaan mei de BufferedReader-klasse yn Java, wêrmei jo de triem line foar rigel of yn blokken fan definieare grutte kinne lêze.

2. Brûk ûnthâld effisjinte manier: By it wurkjen mei grutte bestannen, is it wichtich om ûnthâldgebrûk te optimalisearjen. Ien manier om dit te dwaan is om buffers te brûken om de gegevens te lêzen fan it bestân op te slaan. Op dizze manier kinne jo de gegevens yn blokken ferwurkje ynstee fan it hiele bestân yn it ûnthâld te laden.

3. Brûk concurrency: As de triem gegevens ferwurking is yntinsyf, kinne jo gebrûk meitsje fan concurrency te ferbetterjen prestaasjes. Jo kinne it bestân splitse yn lytsere seksjes en se tagelyk ferwurkje yn ferskate threads. Dit sil it proses fan it lêzen en ferwurkjen fan it bestân fersnelle.

Unthâld om yn gedachten te hâlden dizze tips en oanpakken as jo wurkje mei grutte TXT-bestannen yn Java. Troch dizze techniken út te fieren, kinne jo prestaasjes en effisjinsje ferbetterje by it behanneljen fan grutte tekstbestannen, foarkommen fan prestaasjesproblemen en ûnthâldoverload.

11. Manipulearje Java kodearre TXT triemmen

Soms is it nedich om Java-kodearre tekstbestannen te manipulearjen om ferskate taken út te fieren, lykas lêzen, skriuwen of wizigjen fan har ynhâld. Yn dit artikel sil ik jo sjen litte hoe't jo dit stap foar stap kinne dwaan, mei wat praktyske ark en techniken.

Earst is it wichtich om te neamen dat Java ferskate klassen en metoaden leveret dy't it maklik meitsje om kodearre tekstbestannen te manipulearjen. In gewoan brûkte metoade is FileInputStream om bestannen te lêzen, dy't kinne wurde brûkt yn kombinaasje mei InputStreamReader om ynhâld yn in spesifyk formaat te lêzen, lykas UTF-8 of ISO-8859-1.

As jo ​​​​ienris it kodearre tekstbestân lêzen hawwe, kinne jo in FileOutputStream brûke yn kombinaasje mei in OutputStreamWriter om nei it bestân te skriuwen. Derneist kinne jo de BufferedReader- of BufferedWriter-klasse brûke om rigel foar rigel nei de triem te lêzen en te skriuwen, wat nuttich kin wêze as jo wurkje mei grutte bestannen. Unthâld om de ynfier- en útfierstreamen te sluten neidat jo klear binne mei it lêzen of skriuwen nei it bestân om potinsjele problemen te foarkommen.

12. Omgean flaters by it bewarjen fan gegevens nei in TXT triem yn Java

By it bewarjen fan gegevens nei in TXT-bestân yn Java, is it wichtich om bewust te wêzen fan mooglike flaters dy't kinne foarkomme tidens dit proses. Dizze flaters kinne wurde feroarsake troch in ferskaat oan faktoaren, lykas problemen mei triem tagong, skriuwflaters of kodearringproblemen. Gelokkich binne d'r ferskate strategyen dy't kinne wurde folge om dizze flaters te kontrolearjen en op te lossen.

Ien fan 'e earste maatregels dy't jo kinne nimme om flaters te kontrolearjen by it bewarjen fan gegevens nei in TXT-bestân yn Java is om te kontrolearjen oft it bestân bestiet en as jo skriuwrjochten foar hawwe. Dit It kin dien wurde mei help fan de funksjes levere troch de klasse java.io.File. As it bestân net bestiet of jo net de nedige tagongsrjochten hawwe, kinne jo in flaterberjocht oan 'e brûker werjaan of de nedige aksjes nimme om it probleem op te lossen.

Derneist is it wichtich om rekken te hâlden mei mooglike flaters yn it proses fan skriuwen nei it bestân. Hjirfoar kinne jo de klasse brûke java.io.FileWriter wêrtroch wy gegevens kinne skriuwe nei in tekstbestân. It is oan te rieden om de koade foar it skriuwen nei it bestân yn in blok te wikkeljen try-catch om elke útsûndering te fangen dy't kin wurde smiten. As der in útsûndering foarkomt, kin in flaterberjocht oan de brûker werjûn wurde of kinne passende aksjes wurde nommen om it probleem op te lossen.

13. Optimalisearjen fan skriuwen gegevens nei in TXT triem yn Java

By it skriuwen fan gegevens nei in TXT-bestân yn Java, is it wichtich om it proses te optimalisearjen om effisjinte prestaasjes te garandearjen. D'r binne ferskate strategyen en techniken dy't brûkt wurde kinne om dit te berikken. Hjirûnder binne guon oanbefellings om skriuwgegevens te optimalisearjen nei in TXT-bestân yn Java.

1. Brûk in buffer datastream: It brûken fan in BufferedWriter kin de prestaasjes signifikant ferbetterje by it skriuwen nei in TXT-bestân. Dizze buffer datastream bewarret gegevens tydlik yn it ûnthâld foardat it skriuwt nei it bestân, wêrtroch it oantal skriuwoperaasjes dy't moatte wurde útfierd wurde fermindere.

2. Brûk de metoade fan flush() sparsam: It is wichtich om foarsichtich te wêzen as jo de metoade flush () brûke by it skriuwen nei in TXT-bestân. As dizze metoade te faak neamd wurdt, kin it de prestaasjes negatyf beynfloedzje. It is oan te rieden om te neamen flush () neidat jo hawwe foltôge in batch fan skriuwt of as jo klear skriuwe nei de triem.

3. Tink oan it gebrûk fan triedden: As jo ​​​​grutte hoemannichten gegevens moatte skriuwe nei in TXT-bestân, kinne jo prestaasjes ferbetterje troch thread te brûken. Meardere triedden kinne makke wurde dy't tagelyk skriuwe nei it bestân, sadat de wurkdruk ferdield wurdt en it skriuwproses fersnelt.

14. Oanfoljende biblioteken en boarnen foar in wurk mei TXT triemmen yn Java

Hjirûnder is in list mei ekstra biblioteken en boarnen dy't nuttich kinne wêze foar wurkjen mei TXT-bestannen yn Java:

1. Apache Commons IO-bibleteek: Dizze bibleteek wurdt in soad brûkt yn 'e Java-wrâld en jout in oantal nutsbedriuwen foar it wurkjen mei triemmen. Om te wurkjen mei TXT-bestannen, benammen as it giet om it lêzen en skriuwen fan gegevens, kinne jo de Apache Commons IO FileUtils-klasse brûke. Dizze klasse biedt metoaden lykas readFileToString () en writeStringToFile () dy't dizze taken ferienfâldigje.

2. OpenCSV: OpenCSV is in Java-bibleteek wêrmei it lêzen en skriuwen fan CSV (komma-ôfdielde) triemmen mooglik makket. Hoewol it net spesifyk foar TXT-bestannen is ûntworpen, kin it brûkt wurde om gegevens yn platte tekstformaat te lêzen en te skriuwen. Biedt in ienfâldige ynterface foar it lêzen fan tekstlinen en it splitsen fan fjilden basearre op in spesifike delimiter. Derneist kinne taken wurde útfierd lykas it oerslaan fan lege of kommentearre rigels. Jo kinne gebrûksfoarbylden en tutorials fine yn 'e offisjele OpenCSV-dokumintaasje.

3. Java FileReader en FileWriter: As jo ​​leaver gebrûk meitsje fan lânseigen Java-klassen om te wurkjen mei TXT-bestannen, kinne jo FileReader en FileWriter brûke. Dizze klassen jouwe in ienfâldige ynterface foar it lêzen en skriuwen fan karakters nei in tekstbestân. Jo kinne metoaden brûke lykas read(), write() en close() om dizze operaasjes út te fieren. It is lykwols wichtich om te beskôgjen dat dizze klassen wurkje op it karakternivo en gjin avansearre funksjonaliteiten biede dy't typysk binne foar de hjirboppe neamde bibleteken.

Unthâld dat dit mar in pear foarbylden binne fan ekstra biblioteken en boarnen dy't beskikber binne foar wurkjen mei TXT-bestannen yn Java. Ofhinklik fan jo spesifike behoeften kinne jo oare alternativen ferkenne en dejinge fine dy't it bêste by jo easken past.

Gearfetsjend is it proses fan it bewarjen fan gegevens nei in TXT-bestân yn Java essensjeel foar projekten dy't oanhâldende opslach fan ynformaasje nedich binne. Troch de FileInputStream- en FileOutputStream-klassen kinne TXT-bestannen effisjint tagonklik en manipulearre wurde. Derneist garandearje it gebrûk fan útsûnderings en it goede sluten fan boarnen gegevensintegriteit en programmaprestaasjes.

It is wichtich om te betinken dat bestânôfhanneling yn Java it ymplementearjen fan goede praktiken omfettet, lykas goede útsûnderingshanneling, kontrolearjen fan it bestean en tagongsrjochten fan bestannen, en it korrekt sluten fan boarnen. Likemin is it oan te rieden om prestaasjes en effisjinsje te beskôgjen by it behanneljen fan grutte voluminten gegevens.

Gearfetsjend, it bewarjen fan gegevens yn in TXT-bestân yn Java is in fûnemintele aspekt fan softwareûntwikkeling en it behearjen fan dizze techniken sil programmeurs effisjinter en profesjoneeler kinne wurkje.