Operațiile asincrone sunt operații neblocante, adică ele întorc un rezultat imediat, procesarea realizându-se în background.

În acest laborator vom utiliza funcții asincrone pentru a realiza operații ce necesită procesare (ex. citirea din fișier).

Node.js este un mediu de programare JavaScript care este caracterizat prin suportul pentru operații asincrone.

Pentru a instala node.js, accesați următorul link: https://nodejs.org/en/.

În node.js, o funcție asincronă are următorul format:

function foo ([p1, p2, ..., ]callbackFunction){
    <code>
    callbackFunction ([param1, param2,...]);
}

Practic, funcția asincronă primește ca parametru o altă funcție, pe care o apelează odată ce termină procesarea.

Apelul unei funcții asincrone arată astfel:

foo ([p1, p2, ...,] function ([param1, param2,...]){
    <code>
});

Același cod poate fi scris și astfel:

foo ([p1, p2, ...,] ([param1, param2,...])=>{
    <code>
});

Apelul unei funcții asincrone va întoarce imediat, iar programul va continua să execute alte apeluri de funcție. Între timp, sistemul de operare va procesa cererile funcțiilor anterioare. Când procesarea unei funcții este gata, funcția de callback va fi apelată și se va executa rutina asociată acesteia.

fs este modulul Node.js care suportă operații cu fișiere. Cele mai importate funcții expuse de acesta sunt:

• fs.readFile;
• fs.writeFile;
• fs.readDir.

Programul de mai jos folosește funcții asincrone pentru a scrie un fișier, după care citește conținutul acestuia:

const fs = require ('fs');
fs.writeFile ('myFile', 'my message', function (err){
  console.log ('Processing done');
  if (err){
    console.log ('There was an error writing the file');
  }
  else{
    fs.readFile ('myFile', function (err, data){
      if (err){
        console.log ('There was an error reading the file');
      }
      else{
        console.log (data.toString());
      }
    });
  }
});

child_process e modulul care permite crearea de procese copil și interacțiunea cu acestea.

Modulul expune următoarele funcții importante:

• execFile
• spawn

Diferența dintre cele două funcții este că execFile primește un callback ca parametru care va fi apelat odată de procesul copil își finalizează execuția, în timp de spawn întoarce o structură care prerezintă procesul copil, care înregistrează evenimente.

Următorul program lansează câte un proces folosind ambele funcții:

const child_process = require ('child_process');
child_process.execFile ('ls', function (err, stdout, stderr){
  if (err) console.log ('Execution had an error');
  console.log ('output messages'+stdout);
  console.log ('error messages'+stderr)
});
 
const proc = child_process.spawn ('ls');
proc.stdout.on ('data', function (data){
  console.log ('Spawn process output: '+data.toString());
});
 
proc.on ('exit', function (){
  console.log ('Spawn process closed.');
});

Creați un program care folosește modulul fs pentru a afișa conținutul a două fișiere text. Puteți alege oricare două fișiere text de pe sistem.

Rulați programul de mai multe ori și observați oridinea în care acestea sunt afișate.

Creați un program care afișează conținutul directorului părinte.

Creați un program care crează două fișiere, după care afișează conținutul acestora și conținutul directorului curent, unde trebuie să se observe fișierele generate.

Creați un program care rulează comanda pwd și apoi comanda ls ... Rezolvați cerința în două feluri.

Creați fișierul script.sh cu conținutul următor:

read text
echo $text

Creați un program care rulează scriptul de mai sus. Programul trebuie să îi transmită o linie de text scriptului. (Hint: subprocess.stdin).

Creați pe sistem un fișier care conține o linie de text. Modificați programul de mai sus astfel încât linia de text să fie cea citită din fișier.

Creați un program care încearcă citirea unui fișier inexistent. Afișați eroarea primită și extrageți codul acesteia.

Anulați dreptul de execuție al scriptului creat la exercițiul 5, după care încercați rularea acestuia. Afișați eroarea primită și extrageți codul acesteia.