From f114998016c846c79daccb42c557505c40cf8023 Mon Sep 17 00:00:00 2001
From: "toader.marinaloredana@gmail.com" <toader.marinaloredana@gmail.com>
Date: Wed, 18 Jan 2023 18:39:28 +0200
Subject: [PATCH 1/5] Functions

---
 .../1-if-else-required/solution.md            |   2 +-
 .../1-if-else-required/task.md                |  14 +-
 .../solution.md                               |  10 +-
 .../2-rewrite-function-question-or/task.md    |  16 +-
 .../15-function-basics/3-min/solution.md      |   6 +-
 .../15-function-basics/3-min/task.md          |   6 +-
 .../15-function-basics/4-pow/solution.md      |   2 +-
 .../15-function-basics/4-pow/task.md          |   8 +-
 .../15-function-basics/article.md             | 260 +++++++++---------
 9 files changed, 162 insertions(+), 162 deletions(-)

diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
index e41c80418..d7c9d14de 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
@@ -1 +1 @@
-No difference.
\ No newline at end of file
+Nicio diferenta.
\ No newline at end of file
diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
index 4f69a5c8c..04a4906d8 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
@@ -2,11 +2,11 @@ importance: 4
 
 ---
 
-# Is "else" required?
+# Este "else" necesar?
 
-The following function returns `true` if the parameter `age` is greater than `18`.
+Următoarea funcție returnează `true` dacă parametrul `age` este mai mare decât `18`.
 
-Otherwise it asks for a confirmation and returns its result:
+În caz contrar, solicită o confirmare și returnează rezultatul:
 
 ```js
 function checkAge(age) {
@@ -15,13 +15,13 @@ function checkAge(age) {
 *!*
   } else {
     // ...
-    return confirm('Did parents allow you?');
+    return confirm('Ți-au permis părinții?');
   }
 */!*
 }
 ```
 
-Will the function work differently if `else` is removed?
+Funcția va funcționa diferit dacă `else` este eliminat?
 
 ```js
 function checkAge(age) {
@@ -30,9 +30,9 @@ function checkAge(age) {
   }
 *!*
   // ...
-  return confirm('Did parents allow you?');
+  return confirm('Ți-au permis părinții?');
 */!*
 }
 ```
 
-Is there any difference in the behavior of these two variants?
+Există vreo diferență în comportamentul acestor două variante?
diff --git a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md
index e48502642..ad5c2c669 100644
--- a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md
+++ b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/solution.md
@@ -1,17 +1,17 @@
-Using a question mark operator `'?'`:
+Folosind un operator de semn de întrebare `'?'`:
 
 ```js
 function checkAge(age) {
-  return (age > 18) ? true : confirm('Did parents allow you?');
+  return (age > 18) ? true : confirm('Ți-au permis părinții?');
 }
 ```
 
-Using OR `||` (the shortest variant):
+Folosind SAU `||` (cea mai scurtă variantă):
 
 ```js
 function checkAge(age) {
-  return (age > 18) || confirm('Did parents allow you?');
+  return (age > 18) || confirm('Ți-au permis părinții?');
 }
 ```
 
-Note that the parentheses around `age > 18` are not required here. They exist for better readability.
+Rețineți că parantezele din jurul `age > 18` nu sunt necesare aici. Ele există pentru o mai bună lizibilitate.
diff --git a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md
index 46da079c0..0f6b48ab9 100644
--- a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md
+++ b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md
@@ -2,25 +2,25 @@ importance: 4
 
 ---
 
-# Rewrite the function using '?' or '||'
+# Rescrieți funcția folosind '?' sau '||'
 
-The following function returns `true` if the parameter `age` is greater than `18`.
+Următoarea funcție returnează `true` dacă parametrul `age` este mai mare decât `18`.
 
-Otherwise it asks for a confirmation and returns its result.
+În caz contrar, solicită o confirmare și returnează rezultatul.
 
 ```js
 function checkAge(age) {
   if (age > 18) {
     return true;
   } else {
-    return confirm('Did parents allow you?');
+    return confirm('Ți-au permis părinții?');
   }
 }
 ```
 
-Rewrite it, to perform the same, but without `if`, in a single line.
+Rescrie-l, pentru a efectua la fel, dar fără `if`, într-o singură linie.
 
-Make two variants of `checkAge`:
+Faceți două variante de `checkAge`:
 
-1. Using a question mark operator `?`
-2. Using OR `||`
+1. Folosind un operator de semn de întrebare `?`
+2. Folosind SAU `||`
diff --git a/1-js/02-first-steps/15-function-basics/3-min/solution.md b/1-js/02-first-steps/15-function-basics/3-min/solution.md
index 2236d9203..7fffcb4d0 100644
--- a/1-js/02-first-steps/15-function-basics/3-min/solution.md
+++ b/1-js/02-first-steps/15-function-basics/3-min/solution.md
@@ -1,4 +1,4 @@
-A solution using `if`:
+O soluție folosind `if`:
 
 ```js
 function min(a, b) {
@@ -10,7 +10,7 @@ function min(a, b) {
 }
 ```
 
-A solution with a question mark operator `'?'`:
+O soluție cu un operator de semn de întrebare `'?'`:
 
 ```js
 function min(a, b) {
@@ -18,4 +18,4 @@ function min(a, b) {
 }
 ```
 
-P.S. In the case of an equality `a == b` it does not matter what to return.
\ No newline at end of file
+P.S. În cazul unei egalităţi `a == b` nu contează ce returnează.
\ No newline at end of file
diff --git a/1-js/02-first-steps/15-function-basics/3-min/task.md b/1-js/02-first-steps/15-function-basics/3-min/task.md
index 50edd0d36..5ff9d13cd 100644
--- a/1-js/02-first-steps/15-function-basics/3-min/task.md
+++ b/1-js/02-first-steps/15-function-basics/3-min/task.md
@@ -2,11 +2,11 @@ importance: 1
 
 ---
 
-# Function min(a, b)
+# Funcția min(a, b)
 
-Write a function `min(a,b)` which returns the least of two numbers `a` and `b`.
+Scrieți o funcție `min(a,b)` care returnează cel mai mic dintre două numere `a` și `b`.
 
-For instance:
+De exemplu:
 
 ```js
 min(2, 5) == 2
diff --git a/1-js/02-first-steps/15-function-basics/4-pow/solution.md b/1-js/02-first-steps/15-function-basics/4-pow/solution.md
index 19fe9011f..b047bbe96 100644
--- a/1-js/02-first-steps/15-function-basics/4-pow/solution.md
+++ b/1-js/02-first-steps/15-function-basics/4-pow/solution.md
@@ -14,7 +14,7 @@ let x = prompt("x?", '');
 let n = prompt("n?", '');
 
 if (n < 1) {
-  alert(`Power ${n} is not supported, use a positive integer`);
+  alert(`Puterea ${n} nu este acceptată, utilizați un număr întreg pozitiv`);
 } else {
   alert( pow(x, n) );
 }
diff --git a/1-js/02-first-steps/15-function-basics/4-pow/task.md b/1-js/02-first-steps/15-function-basics/4-pow/task.md
index f569320c7..8e0da9c08 100644
--- a/1-js/02-first-steps/15-function-basics/4-pow/task.md
+++ b/1-js/02-first-steps/15-function-basics/4-pow/task.md
@@ -2,9 +2,9 @@ importance: 4
 
 ---
 
-# Function pow(x,n)
+# Funcţia pow(x,n)
 
-Write a function `pow(x,n)` that returns `x` in power `n`. Or, in other words, multiplies `x` by itself `n` times and returns the result.
+Scrieți o funcție `pow(x,n)` care returnează `x` la puterea `n`. Sau, cu alte cuvinte, se înmulțește `x` cu el însuși de `n` ori și returnează rezultatul.
 
 ```js
 pow(3, 2) = 3 * 3 = 9
@@ -12,8 +12,8 @@ pow(3, 3) = 3 * 3 * 3 = 27
 pow(1, 100) = 1 * 1 * ...* 1 = 1
 ```
 
-Create a web-page that prompts for `x` and `n`, and then shows the result of `pow(x,n)`.
+Creați o pagină web care solicită `x` și `n`, iar apoi arată rezultatul `pow(x,n)`.
 
 [demo]
 
-P.S. In this task the function should support only natural values of `n`: integers up from `1`.
+P.S. În această sarcină, funcția ar trebui să susțină numai valorile naturale ale lui `n`: numere întregi de la `1` în sus.
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index b46f42924..5f5b6b51d 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -1,26 +1,26 @@
-# Functions
+# Funcții
 
-Quite often we need to perform a similar action in many places of the script.
+Destul de des avem nevoie să realizăm o acțiune similară în multe locuri ale secvenței de instrucțiuni.
 
-For example, we need to show a nice-looking message when a visitor logs in, logs out and maybe somewhere else.
+De exemplu, avem nevoie să arătăm un mesaj frumos când un vizitator se conectează, se deconectează și poate în altă parte.
 
-Functions are the main "building blocks" of the program. They allow the code to be called many times without repetition.
+Funcțiile sunt principalele "blocuri de construcție" ale programului. Ele permit apelarea codului de mai multe ori fără repetare.
 
-We've already seen examples of built-in functions, like `alert(message)`, `prompt(message, default)` and `confirm(question)`. But we can create functions of our own as well.
+Am văzut deja exemple de funcții încorporate, precum `alert(message)`, `prompt(message, default)` și `confirm(question)`. Dar putem crea și funcții proprii.
 
-## Function Declaration
+## Declararea Funcției
 
-To create a function we can use a *function declaration*.
+Pentru a crea o funcție putem folosi  *declararea funcției*.
 
-It looks like this:
+Arata cam așa:
 
 ```js
 function showMessage() {
-  alert( 'Hello everyone!' );
+  alert( 'Bună ziua tuturor!' );
 }
 ```
 
-The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (comma-separated, empty in the example above, we'll see examples later) and finally the code of the function, also named "the function body", between curly braces.
+Cuvântul cheie `function` este primul, apoi urmează *numele funcției*, apoi o listă de *parametrii* între paranteze (separate prin virgulă, gol în exemplul de mai sus, vom vedea exemple mai târziu) și în final codul funcției, numit de asemenea "corpul funcției", între acolade.
 
 ```js
 function name(parameter1, parameter2, ... parameterN) {
@@ -28,13 +28,13 @@ function name(parameter1, parameter2, ... parameterN) {
 }
 ```
 
-Our new function can be called by its name: `showMessage()`.
+Noua noastră funcție poate fi apelată după numele ei: `showMessage()`.
 
-For instance:
+De exemplu:
 
 ```js run
 function showMessage() {
-  alert( 'Hello everyone!' );
+  alert( 'Bună ziua tuturor!' );
 }
 
 *!*
@@ -43,22 +43,22 @@ showMessage();
 */!*
 ```
 
-The call `showMessage()` executes the code of the function. Here we will see the message two times.
+Apelul `showMessage()` execută codul funcției. Aici vom vedea mesajul de două ori.
 
-This example clearly demonstrates one of the main purposes of functions: to avoid code duplication.
+Acest exemplu demonstrează în mod clar unul dintre scopurile principale ale funcțiilor: să evite duplicarea codului.
 
-If we ever need to change the message or the way it is shown, it's enough to modify the code in one place: the function which outputs it.
+Dacă trebuie vreodată să schimbăm mesajul sau modul în care este afișat, este suficient să modifici codul într-un singur loc: funcția care îl emite.
 
-## Local variables
+## Variabile locale
 
-A variable declared inside a function is only visible inside that function.
+O variabilă declarată în interiorul unei funcții este vizibilă numai în interiorul acelei funcții.
 
-For example:
+De exemplu:
 
 ```js run
 function showMessage() {
 *!*
-  let message = "Hello, I'm JavaScript!"; // local variable
+  let message = "Bună, sunt JavaScript!"; // local variable
 */!*
 
   alert( message );
@@ -69,24 +69,24 @@ showMessage(); // Hello, I'm JavaScript!
 alert( message ); // <-- Error! The variable is local to the function
 ```
 
-## Outer variables
+## Variabile exterioare
 
-A function can access an outer variable as well, for example:
+O funcție poate accesa și o variabilă exterioară, de exemplu:
 
 ```js run no-beautify
 let *!*userName*/!* = 'John';
 
 function showMessage() {
-  let message = 'Hello, ' + *!*userName*/!*;
+  let message = 'Bună, ' + *!*userName*/!*;
   alert(message);
 }
 
 showMessage(); // Hello, John
 ```
 
-The function has full access to the outer variable. It can modify it as well.
+Funcția are acces complet la variabila exterioară. Il poate modifica si ea.
 
-For instance:
+De exemplu:
 
 ```js run
 let *!*userName*/!* = 'John';
@@ -94,7 +94,7 @@ let *!*userName*/!* = 'John';
 function showMessage() {
   *!*userName*/!* = "Bob"; // (1) changed the outer variable
 
-  let message = 'Hello, ' + *!*userName*/!*;
+  let message = 'Bună, ' + *!*userName*/!*;
   alert(message);
 }
 
@@ -105,9 +105,9 @@ showMessage();
 alert( userName ); // *!*Bob*/!*, the value was modified by the function
 ```
 
-The outer variable is only used if there's no local one.
+Variabila exterioară este utilizată numai dacă nu există una locală.
 
-If a same-named variable is declared inside the function then it *shadows* the outer one. For instance, in the code below the function uses the local `userName`. The outer one is ignored:
+Dacă o variabilă cu același nume este declarată în interiorul funcției, atunci aceasta *pune în umbră* pe cea exterioară. De exemplu, în codul de mai jos, funcția folosește localul `userName`. Cel exterior este ignorat:
 
 ```js run
 let userName = 'John';
@@ -117,7 +117,7 @@ function showMessage() {
   let userName = "Bob"; // declare a local variable
 */!*
 
-  let message = 'Hello, ' + userName; // *!*Bob*/!*
+  let message = 'Bună, ' + userName; // *!*Bob*/!*
   alert(message);
 }
 
@@ -127,32 +127,32 @@ showMessage();
 alert( userName ); // *!*John*/!*, unchanged, the function did not access the outer variable
 ```
 
-```smart header="Global variables"
-Variables declared outside of any function, such as the outer `userName` in the code above, are called *global*.
+```smart header="Variabile globale"
+Variabile declarate în afara oricărei funcții, precum cel exterior `userName` în codul de mai sus, se numesc *globale*.
 
-Global variables are visible from any function (unless shadowed by locals).
+Variabilele globale sunt vizibile din orice funcție (dacă nu sunt umbrite de cele locale).
 
-It's a good practice to minimize the use of global variables. Modern code has few or no globals. Most variables reside in their functions. Sometimes though, they can be useful to store project-level data.
+Este o bună practică pentru a minimiza utilizarea variabilelor globale. Codul modern are puține globale sau deloc. Majoritatea variabilelor aparțin funcțiilor lor. Totuși, pot fi utile pentru a stoca date la nivel de proiect.
 ```
 
-## Parameters
+## Parametrii
 
-We can pass arbitrary data to functions using parameters.
+Putem transmite date arbitrare funcțiilor folosind parametri.
 
-In the example below, the function has two parameters: `from` and `text`.
+În exemplul de mai jos, funcția are doi parametri: `from` și `text`.
 
 ```js run
 function showMessage(*!*from, text*/!*) { // parameters: from, text
   alert(from + ': ' + text);
 }
 
-*!*showMessage('Ann', 'Hello!');*/!* // Ann: Hello! (*)
-*!*showMessage('Ann', "What's up?");*/!* // Ann: What's up? (**)
+*!*showMessage('Ann', 'Bună!');*/!* // Ann: Hello! (*)
+*!*showMessage('Ann', "Ce faci?");*/!* // Ann: What's up? (**)
 ```
 
-When the function is called in lines `(*)` and `(**)`, the given values are copied to local variables `from` and `text`. Then the function uses them.
+Când funcția este apelată în liniile `(*)` și `(**)`, valorile date sunt copiate în variabilele locale `from` și `text`. Atunci funcția le folosește.
 
-Here's one more example: we have a variable `from` and pass it to the function. Please note: the function changes `from`, but the change is not seen outside, because a function always gets a copy of the value:
+Iată încă un exemplu: avem o variabilă `from` și este transmis funcției. Vă rugăm să rețineți: functia schimbă `from`, dar schimbarea nu se vede afară, deoarece o funcție primește întotdeauna o copie a valorii:
 
 ```js run
 function showMessage(from, text) {
@@ -166,49 +166,49 @@ function showMessage(from, text) {
 
 let from = "Ann";
 
-showMessage(from, "Hello"); // *Ann*: Hello
+showMessage(from, "Bună"); // *Ann*: Hello
 
 // the value of "from" is the same, the function modified a local copy
 alert( from ); // Ann
 ```
 
-When a value is passed as a function parameter, it's also called an *argument*.
+Când o valoare este transmisă ca parametru de funcție, se mai numește *argument*.
 
-In other words, to put these terms straight:
+Cu alte cuvinte, pentru a clarifica acești termeni:
 
-- A parameter is the variable listed inside the parentheses in the function declaration (it's a declaration time term)
-- An argument is the value that is passed to the function when it is called (it's a call time term).
+- Un parametru este variabila listată între paranteze în declarația funcției (este un termen de declarare)
+- Un argument este valoarea care este transmisă funcției atunci când este apelată (este un termen de apelare).
 
-We declare functions listing their parameters, then call them passing arguments.
+Declarăm funcții care listează parametrii lor, apoi le numim argumente de trecere.
 
-In the example above, one might say: "the function `showMessage` is declared with two parameters, then called with two arguments: `from` and `"Hello"`".
+În exemplul de mai sus, s-ar putea spune : "funcția `showMessage` este declarată cu doi parametri, apoi apelată cu două argumente: `from` și `"Bună"`".
 
 
-## Default values
+## Valori implicite
 
-If a function is called, but an argument is not provided, then the corresponding value becomes `undefined`.
+Dacă o funcție este apelată, dar nu este oferit un argument, atunci valoarea corespunzătoare devine `nedefinită`.
 
-For instance, the aforementioned function `showMessage(from, text)` can be called with a single argument:
+De exemplu, funcția menționată mai sus `showMessage(from, text)` poate fi apelată cu un singur argument:
 
 ```js
 showMessage("Ann");
 ```
 
-That's not an error. Such a call would output `"*Ann*: undefined"`. As the value for `text` isn't passed, it becomes `undefined`.
+Asta nu este o eroare. Un astfel de apel ar ieși `"*Ann*: nedefinită"`. Ca valoare pentru `text` nu este trecută, ea devine `nedefinită`.
 
-We can specify the so-called "default" (to use if omitted) value for a parameter in the function declaration, using `=`:
+Putem preciza așa-numitul "implicit" (de utilizat dacă este omisă) valoare pentru un parametru din declarația funcției, folosind `=`:
 
 ```js run
-function showMessage(from, *!*text = "no text given"*/!*) {
+function showMessage(from, *!*text = "nu este dat niciun text"*/!*) {
   alert( from + ": " + text );
 }
 
 showMessage("Ann"); // Ann: no text given
 ```
 
-Now if the `text` parameter is not passed, it will get the value `"no text given"`
+Acum, dacă parametrul`text` nu este trecut, va primi valoarea `"nu este dat niciun text"`
 
-Here `"no text given"` is a string, but it can be a more complex expression, which is only evaluated and assigned if the parameter is missing. So, this is also possible:
+Aici `"nu este dat niciun text"` este un șir, dar poate fi o expresie mai complexă, care este evaluată și atribuită doar dacă parametrul lipsește. Deci, acest lucru este posibil:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {
@@ -217,19 +217,19 @@ function showMessage(from, text = anotherFunction()) {
 }
 ```
 
-```smart header="Evaluation of default parameters"
-In JavaScript, a default parameter is evaluated every time the function is called without the respective parameter.
+```smart header="Evaluarea parametrilor impliciți"
+În JavaScript, un parametru implicit este evaluat de fiecare dată când funcția este apelată fără parametrul respectiv.
 
-In the example above, `anotherFunction()` isn't called at all, if the `text` parameter is provided.
+În exemplul de mai sus, `anotherFunction()` nu este apelat deloc, dacă este furnizat parametrul `text`.
 
-On the other hand, it's independently called every time when `text` is missing.
+Pe de altă parte, este numit independent de fiecare dată când lipsește `text`.
 ```
 
-### Alternative default parameters
+### Parametri impliciți alternativi
 
-Sometimes it makes sense to assign default values for parameters not in the function declaration, but at a later stage.
+Uneori este logic să atribuiți valori implicite pentru parametrii nu în declarația funcției, ci într-o etapă ulterioară.
 
-We can check if the parameter is passed during the function execution, by comparing it with `undefined`:
+Putem verifica dacă parametrul este transmis în timpul execuției funcției, comparându-l cu `undefined`:
 
 ```js run
 function showMessage(text) {
@@ -237,7 +237,7 @@ function showMessage(text) {
 
 *!*
   if (text === undefined) { // if the parameter is missing
-    text = 'empty message';
+    text = 'mesaj gol';
   }
 */!*
 
@@ -247,7 +247,7 @@ function showMessage(text) {
 showMessage(); // empty message
 ```
 
-...Or we could use the `||` operator:
+...Sau am putea folosi operatorul `||`:
 
 ```js
 function showMessage(text) {
@@ -257,7 +257,7 @@ function showMessage(text) {
 }
 ```
 
-Modern JavaScript engines support the [nullish coalescing operator](info:nullish-coalescing-operator) `??`, it's better when most falsy values, such as `0`, should be considered "normal":
+Motoarele JavaScript moderne acceptă [nullish coalescing operator](info:nullish-coalescing-operator) `??`, este mai bine atunci când majoritatea valorilor false, cum ar fi `0`, ar trebui considerate „normale”:
 
 ```js run
 function showCount(count) {
@@ -270,11 +270,11 @@ showCount(null); // unknown
 showCount(); // unknown
 ```
 
-## Returning a value
+## Returnarea unei valori
 
-A function can return a value back into the calling code as the result.
+O funcție poate returna înapoi o valoare în codul de apelare ca rezultat.
 
-The simplest example would be a function that sums two values:
+Cel mai simplu exemplu ar fi o funcție care însumează două valori:
 
 ```js run no-beautify
 function sum(a, b) {
@@ -285,9 +285,9 @@ let result = sum(1, 2);
 alert( result ); // 3
 ```
 
-The directive `return` can be in any place of the function. When the execution reaches it, the function stops, and the value is returned to the calling code (assigned to `result` above).
+Directiva `return` poate fi în orice loc al funcției. Când execuția ajunge la el, funcția se oprește, iar valoarea este returnată codului de apelare (atribuit lui `result`).
 
-There may be many occurrences of `return` in a single function. For instance:
+Pot exista multe apariții ale lui `return` întro singura funcție. De exemplu:
 
 ```js run
 function checkAge(age) {
@@ -297,23 +297,23 @@ function checkAge(age) {
 */!*
   } else {
 *!*
-    return confirm('Do you have permission from your parents?');
+    return confirm('Ai permisiunea părinților tăi?');
 */!*
   }
 }
 
-let age = prompt('How old are you?', 18);
+let age = prompt('Câți ani ai?', 18);
 
 if ( checkAge(age) ) {
-  alert( 'Access granted' );
+  alert( 'Acces permis' );
 } else {
-  alert( 'Access denied' );
+  alert( 'Acces interzis' );
 }
 ```
 
-It is possible to use `return` without a value. That causes the function to exit immediately.
+Este posibil să utilizați `return` făra o valoare. Acesta face ca funcția să iasă imediat.
 
-For example:
+De exemplu:
 
 ```js
 function showMovie(age) {
@@ -323,15 +323,15 @@ function showMovie(age) {
 */!*
   }
 
-  alert( "Showing you the movie" ); // (*)
+  alert( "Vă arăt filmul" ); // (*)
   // ...
 }
 ```
 
-In the code above, if `checkAge(age)` returns `false`, then `showMovie` won't proceed to the `alert`.
+În codul de mai sus, dacă `checkAge(age)` returnează `false`, atunci `showMovie` nu va trece la `alert`.
 
-````smart header="A function with an empty `return` or without it returns `undefined`"
-If a function does not return a value, it is the same as if it returns `undefined`:
+```smart header=" O funcție cu un 'return' gol sau fara o returnare este 'undefined'"
+Dacă o funcție nu returnează o valoare, este la fel ca și când returnează `undefined`:
 
 ```js run
 function doNothing() { /* empty */ }
@@ -339,7 +339,7 @@ function doNothing() { /* empty */ }
 alert( doNothing() === undefined ); // true
 ```
 
-An empty `return` is also the same as `return undefined`:
+Un `return` gol este același cu `return undefined`:
 
 ```js run
 function doNothing() {
@@ -350,23 +350,23 @@ alert( doNothing() === undefined ); // true
 ```
 ````
 
-````warn header="Never add a newline between `return` and the value"
-For a long expression in `return`, it might be tempting to put it on a separate line, like this:
+````warn header="Nu adăugați niciodată o linie nouă între `return` și o valoare"
+Pentru o expresie lungă în `return`, ai putea fi tentant să-l pui pe o linie separată, așa:
 
 ```js
 return
  (some + long + expression + or + whatever * f(a) + f(b))
 ```
-That doesn't work, because JavaScript assumes a semicolon after `return`. That'll work the same as:
+Asta nu funcționează, deoarece JavaScript presupune un punct și virgulă după `return`. Asta va funcționa la fel ca:
 
 ```js
 return*!*;*/!*
  (some + long + expression + or + whatever * f(a) + f(b))
 ```
 
-So, it effectively becomes an empty return.
+Deci, devine efectiv un 'return' gol.
 
-If we want the returned expression to wrap across multiple lines, we should start it at the same line as `return`. Or at least put the opening parentheses there as follows:
+Dacă dorim ca expresia returnată să se înfășoare pe mai multe linii, ar trebui să o începem pe aceeași linie cu`return`. Sau cel puțin puneți parantezele de deschidere acolo, după cum urmează:
 
 ```js
 return (
@@ -375,25 +375,25 @@ return (
   whatever * f(a) + f(b)
   )
 ```
-And it will work just as we expect it to.
+Și va funcționa așa cum ne așteptăm.
 ````
 
-## Naming a function [#function-naming]
+## Denumirea unei funcții [#function-naming]
 
-Functions are actions. So their name is usually a verb. It should be brief, as accurate as possible and describe what the function does, so that someone reading the code gets an indication of what the function does.
+Funcțiile sunt acțiuni. Deci, numele lor este de obicei un verb. Ar trebui să fie scurt, cât mai precis posibil și să descrie ceea ce face funcția, astfel încât cineva care citește codul să obțină o indicație despre ceea ce face funcția.
 
-It is a widespread practice to start a function with a verbal prefix which vaguely describes the action. There must be an agreement within the team on the meaning of the prefixes.
+Este o practică larg răspândită de a începe o funcție cu un prefix verbal care descrie vag acțiunea. Trebuie să existe un acord în cadrul echipei cu privire la semnificația prefixelor.
 
-For instance, functions that start with `"show"` usually show something.
+De exemplu, funcțiile care încep cu `"show"` de obicei afișază ceva.
 
-Function starting with...
+Funcția care începe cu...
 
-- `"get…"` -- return a value,
-- `"calc…"` -- calculate something,
-- `"create…"` -- create something,
-- `"check…"` -- check something and return a boolean, etc.
+- `"get…"` -- returnează o valoare,
+- `"calc…"` -- calculează ceva,
+- `"create…"` -- crează ceva,
+- `"check…"` -- verifică ceva și returnează un boolean, etc.
 
-Examples of such names:
+Exemple de astfel de nume:
 
 ```js no-beautify
 showMessage(..)     // shows a message
@@ -403,39 +403,39 @@ createForm(..)      // creates a form (and usually returns it)
 checkPermission(..) // checks a permission, returns true/false
 ```
 
-With prefixes in place, a glance at a function name gives an understanding what kind of work it does and what kind of value it returns.
+Cu prefixele la loc, o privire asupra numelui unei funcții oferă o înțelegere a ce fel de activitate face și ce fel de valoare returnează.
 
-```smart header="One function -- one action"
-A function should do exactly what is suggested by its name, no more.
+```smart header="O funcție -- o acțiune"
+O funcție ar trebui să facă exact ceea ce este sugerat de numele ei, nu mai mult.
 
-Two independent actions usually deserve two functions, even if they are usually called together (in that case we can make a 3rd function that calls those two).
+Două acțiuni independente deservesc de obicei două funcții, chiar dacă de obicei sunt apelate împreună (în acest caz, putem face o a treia funcție care le apelează pe cele două).
 
-A few examples of breaking this rule:
+Câteva exemple de încălcare a acestei reguli:
 
-- `getAge` -- would be bad if it shows an `alert` with the age (should only get).
-- `createForm` -- would be bad if it modifies the document, adding a form to it (should only create it and return).
-- `checkPermission` -- would be bad if it displays the `access granted/denied` message (should only perform the check and return the result).
+- `getAge` -- ar fi rău dacă arată o `alertă` cu vârsta (ar trebui doar să obțină).
+- `createForm` -- ar fi rău dacă ar modifica documentul, adăugându-i o formă (ar trebui doar să-l creeze și să-l returneze).
+- `checkPermission` -- ar fi rău dacă afișează mesajul „acces acordat/refuzat”. (ar trebui să efectueze doar verificarea și să returneze rezultatul).
 
-These examples assume common meanings of prefixes. You and your team are free to agree on other meanings, but usually they're not much different. In any case, you should have a firm understanding of what a prefix means, what a prefixed function can and cannot do. All same-prefixed functions should obey the rules. And the team should share the knowledge.
+Aceste exemple presupun semnificații comune ale prefixelor. Tu și echipa ta sunteți liberi să vă puneți de acord asupra altor semnificații, dar de obicei nu sunt foarte diferite. În orice caz, ar trebui să înțelegeți ferm ce înseamnă un prefix, ce poate și ce nu poate face o funcție prefixată. Toate funcțiile cu același prefix ar trebui să respecte regulile. Și echipa ar trebui să împărtășească cunoștințele.
 ```
 
-```smart header="Ultrashort function names"
-Functions that are used *very often* sometimes have ultrashort names.
+```smart header="Nume de funcții ultrascurte"
+Funcțiile care sunt folosite *foarte des* au uneori nume ultrascurte.
 
-For example, the [jQuery](http://jquery.com) framework defines a function with `$`. The [Lodash](http://lodash.com/) library has its core function named `_`.
+Ca de exemplu, framework-ul [jQuery](http://jquery.com) definește o funcție cu `$`. Librăria [Lodash](http://lodash.com/) are funcția sa de bază numită `_`.
 
-These are exceptions. Generally function names should be concise and descriptive.
+Acestea sunt excepții. În general, numele funcțiilor ar trebui să fie concise și descriptive.
 ```
 
-## Functions == Comments
+## Funcții == Comentarii
 
-Functions should be short and do exactly one thing. If that thing is big, maybe it's worth it to split the function into a few smaller functions. Sometimes following this rule may not be that easy, but it's definitely a good thing.
+Funcțiile ar trebui să fie scurte și să facă un lucru exact. Dacă acel lucru este mare, poate că merită să împărțiți funcția în câteva funcții mai mici. Uneori, respectarea acestei reguli poate să nu fie atât de ușoară, dar cu siguranță este un lucru bun.
 
-A separate function is not only easier to test and debug -- its very existence is a great comment!
+O funcție separată este mai ușor de testat și de depanat -- însăși existența sa este un comentariu grozav!
 
-For instance, compare the two functions `showPrimes(n)` below. Each one outputs [prime numbers](https://en.wikipedia.org/wiki/Prime_number) up to `n`.
+De exemplu, compara cele două funcții `showPrimes(n)` de mai jos. Fiecare iese [prime numbers](https://en.wikipedia.org/wiki/Prime_number) pâna la`n`.
 
-The first variant uses a label:
+Prima variantă folosește o etichetă:
 
 ```js
 function showPrimes(n) {
@@ -450,7 +450,7 @@ function showPrimes(n) {
 }
 ```
 
-The second variant uses an additional function `isPrime(n)` to test for primality:
+A doua variantă folosește o funcție suplimentară `isPrime(n)` pentru a testa primalitatea:
 
 ```js
 function showPrimes(n) {
@@ -470,13 +470,13 @@ function isPrime(n) {
 }
 ```
 
-The second variant is easier to understand, isn't it? Instead of the code piece we see a name of the action (`isPrime`). Sometimes people refer to such code as *self-describing*.
+A doua variantă este mai ușor de înțeles, nu-i aşa? În loc de piesa de cod, vedem un nume al acțiunii (`isPrime`). Uneori, oamenii se referă la un astfel de cod ca la *auto-descriere*.
 
-So, functions can be created even if we don't intend to reuse them. They structure the code and make it readable.
+Deci, funcțiile pot fi create chiar dacă nu intenționăm să le reutilizam. Ele structurează codul și îl fac lizibil.
 
-## Summary
+## Rezumat
 
-A function declaration looks like this:
+O declarație de funcție arată astfel:
 
 ```js
 function name(parameters, delimited, by, comma) {
@@ -484,18 +484,18 @@ function name(parameters, delimited, by, comma) {
 }
 ```
 
-- Values passed to a function as parameters are copied to its local variables.
-- A function may access outer variables. But it works only from inside out. The code outside of the function doesn't see its local variables.
-- A function can return a value. If it doesn't, then its result is `undefined`.
+- Valorile transmise unei funcții ca parametri sunt copiate în variabilele locale.
+- funcția poate accesa variabile exterioare. Dar funcționează numai din interior spre exterior. Codul din afara funcției nu vede variabilele locale.
+- O funcție poate returna o valoare. Dacă nu, atunci rezultatul ei este `undefined`.
 
-To make the code clean and easy to understand, it's recommended to use mainly local variables and parameters in the function, not outer variables.
+Pentru a face codul curat și ușor de înțeles, este recomandat să folosiți în principal variabile și parametri locali în funcție, nu variabile exterioare.
 
-It is always easier to understand a function which gets parameters, works with them and returns a result than a function which gets no parameters, but modifies outer variables as a side-effect.
+Este întotdeauna mai ușor de înțeles o funcție care primește parametri, lucrează cu ele și returnează un rezultat, decât o funcție care nu primește niciun parametru, dar modifică variabilele exterioare ca efect secundar.
 
-Function naming:
+Denumirea funcției:
 
-- A name should clearly describe what the function does. When we see a function call in the code, a good name instantly gives us an understanding what it does and returns.
-- A function is an action, so function names are usually verbal.
-- There exist many well-known function prefixes like `create…`, `show…`, `get…`, `check…` and so on. Use them to hint what a function does.
+- Un nume ar trebui să descrie clar ceea ce face funcția. Când vedem un apel de funcție în cod, un nume bun ne oferă instantaneu o înțelegere a ceea ce face și returnează.
+- O funcție este o acțiune, deci numele funcțiilor sunt de obicei verbale.
+- Există multe prefixe de funcții binecunoscute, cum ar fi `create…`, `show…`, `get…`, `check…` și așa mai departe. Folosiți-le pentru a indica ce face o funcție.
 
-Functions are the main building blocks of scripts. Now we've covered the basics, so we actually can start creating and using them. But that's only the beginning of the path. We are going to return to them many times, going more deeply into their advanced features.
+Funcțiile sunt principalele blocuri de construcție ale scripturilor. Acum am acoperit elementele de bază, astfel încât să putem începe să le creăm și să le folosim. Dar acesta este doar începutul drumului. Ne vom întoarce la ele de multe ori, mergând mai adânc în caracteristicile lor avansate.

From ad10bf3ca4a217f16fb0b89b3c00a37118da7732 Mon Sep 17 00:00:00 2001
From: "toader.marinaloredana@gmail.com" <toader.marinaloredana@gmail.com>
Date: Tue, 24 Jan 2023 13:48:32 +0200
Subject: [PATCH 2/5] adjusted

---
 .../1-if-else-required/task.md                |   2 +-
 .../2-rewrite-function-question-or/task.md    |   2 +-
 .../15-function-basics/4-pow/solution.md      |   2 +-
 .../15-function-basics/article.md             | 114 +++++++++---------
 4 files changed, 60 insertions(+), 60 deletions(-)

diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
index 04a4906d8..62cd27eee 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/task.md
@@ -6,7 +6,7 @@ importance: 4
 
 Următoarea funcție returnează `true` dacă parametrul `age` este mai mare decât `18`.
 
-În caz contrar, solicită o confirmare și returnează rezultatul:
+În caz contrar aceasta cere o confirmare și îi returnează rezultatul:
 
 ```js
 function checkAge(age) {
diff --git a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md
index 0f6b48ab9..523d5b9ec 100644
--- a/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md
+++ b/1-js/02-first-steps/15-function-basics/2-rewrite-function-question-or/task.md
@@ -6,7 +6,7 @@ importance: 4
 
 Următoarea funcție returnează `true` dacă parametrul `age` este mai mare decât `18`.
 
-În caz contrar, solicită o confirmare și returnează rezultatul.
+În caz contrar aceasta cere o confirmare și îi returnează rezultatul.
 
 ```js
 function checkAge(age) {
diff --git a/1-js/02-first-steps/15-function-basics/4-pow/solution.md b/1-js/02-first-steps/15-function-basics/4-pow/solution.md
index b047bbe96..482eea855 100644
--- a/1-js/02-first-steps/15-function-basics/4-pow/solution.md
+++ b/1-js/02-first-steps/15-function-basics/4-pow/solution.md
@@ -14,7 +14,7 @@ let x = prompt("x?", '');
 let n = prompt("n?", '');
 
 if (n < 1) {
-  alert(`Puterea ${n} nu este acceptată, utilizați un număr întreg pozitiv`);
+  alert(`Puterea ${n} nu este susținută, utilizați un număr întreg pozitiv`);
 } else {
   alert( pow(x, n) );
 }
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index 5f5b6b51d..a7117ffd2 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -1,16 +1,16 @@
 # Funcții
 
-Destul de des avem nevoie să realizăm o acțiune similară în multe locuri ale secvenței de instrucțiuni.
+Destul de des avem nevoie să realizăm o acțiune similară în multe locuri ale script-ului.
 
 De exemplu, avem nevoie să arătăm un mesaj frumos când un vizitator se conectează, se deconectează și poate în altă parte.
 
 Funcțiile sunt principalele "blocuri de construcție" ale programului. Ele permit apelarea codului de mai multe ori fără repetare.
 
-Am văzut deja exemple de funcții încorporate, precum `alert(message)`, `prompt(message, default)` și `confirm(question)`. Dar putem crea și funcții proprii.
+Am văzut deja exemple de funcții încorporate, precum `alert(message)`, `prompt(message, default)` și `confirm(question)`. Dar putem crea și funcții proprii de asemenea.
 
-## Declararea Funcției
+## Funcție Declarată
 
-Pentru a crea o funcție putem folosi  *declararea funcției*.
+Pentru a crea o funcție putem folosi o *funcție declarată*.
 
 Arata cam așa:
 
@@ -58,15 +58,15 @@ De exemplu:
 ```js run
 function showMessage() {
 *!*
-  let message = "Bună, sunt JavaScript!"; // local variable
+   let message = "Bună, sunt JavaScript!"; // variabilă locală
 */!*
 
   alert( message );
 }
 
-showMessage(); // Hello, I'm JavaScript!
+showMessage(); // Bună, sunt JavaScript!
 
-alert( message ); // <-- Error! The variable is local to the function
+alert( message ); // <-- Eroare! Variabila este locală funcției
 ```
 
 ## Variabile exterioare
@@ -81,7 +81,7 @@ function showMessage() {
   alert(message);
 }
 
-showMessage(); // Hello, John
+showMessage(); // Bună, John
 ```
 
 Funcția are acces complet la variabila exterioară. Il poate modifica si ea.
@@ -92,43 +92,43 @@ De exemplu:
 let *!*userName*/!* = 'John';
 
 function showMessage() {
-  *!*userName*/!* = "Bob"; // (1) changed the outer variable
+  *!*userName*/!* = "Bob"; // (1) a schimbat variabila exterioară
 
   let message = 'Bună, ' + *!*userName*/!*;
   alert(message);
 }
 
-alert( userName ); // *!*John*/!* before the function call
+alert( userName ); // *!*John*/!* înainte de apelul funcției
 
 showMessage();
 
-alert( userName ); // *!*Bob*/!*, the value was modified by the function
+alert( userName ); // *!*Bob*/!*, valoarea a fost modificată de funcție
 ```
 
 Variabila exterioară este utilizată numai dacă nu există una locală.
 
-Dacă o variabilă cu același nume este declarată în interiorul funcției, atunci aceasta *pune în umbră* pe cea exterioară. De exemplu, în codul de mai jos, funcția folosește localul `userName`. Cel exterior este ignorat:
+Dacă o variabilă cu același nume este declarată în interiorul funcției atunci aceasta o *pune în umbră* pe cea exterioară. De exemplu, în codul de mai jos funcția folosește `userName`-ul local. Cel exterior este ignorat:
 
 ```js run
 let userName = 'John';
 
 function showMessage() {
 *!*
-  let userName = "Bob"; // declare a local variable
+  let userName = "Bob"; // declară o variabilă locală
 */!*
 
   let message = 'Bună, ' + userName; // *!*Bob*/!*
   alert(message);
 }
 
-// the function will create and use its own userName
+// funcția va crea și va folosi propriul userName
 showMessage();
 
-alert( userName ); // *!*John*/!*, unchanged, the function did not access the outer variable
+alert( userName ); // *!*John*/!*, neschimbat, funcția nu a accesat variabila exterioară
 ```
 
 ```smart header="Variabile globale"
-Variabile declarate în afara oricărei funcții, precum cel exterior `userName` în codul de mai sus, se numesc *globale*.
+Variabile declarate în afara oricărei funcții, precum acel `userName` exterior în codul de mai sus, se numesc *globale*.
 
 Variabilele globale sunt vizibile din orice funcție (dacă nu sunt umbrite de cele locale).
 
@@ -142,15 +142,15 @@ Putem transmite date arbitrare funcțiilor folosind parametri.
 În exemplul de mai jos, funcția are doi parametri: `from` și `text`.
 
 ```js run
-function showMessage(*!*from, text*/!*) { // parameters: from, text
+function showMessage(*!*from, text*/!*) { // parametrii: from, text
   alert(from + ': ' + text);
 }
 
-*!*showMessage('Ann', 'Bună!');*/!* // Ann: Hello! (*)
-*!*showMessage('Ann', "Ce faci?");*/!* // Ann: What's up? (**)
+*!*showMessage('Ann', 'Bună!');*/!* // Ann: Bună! (*)
+*!*showMessage('Ann', "Ce faci?");*/!* // Ann: Ce faci? (**)
 ```
 
-Când funcția este apelată în liniile `(*)` și `(**)`, valorile date sunt copiate în variabilele locale `from` și `text`. Atunci funcția le folosește.
+Când funcția este apelată în liniile `(*)` și `(**)`, valorile date sunt copiate în variabile locale `from` și `text`. Atunci funcția le folosește.
 
 Iată încă un exemplu: avem o variabilă `from` și este transmis funcției. Vă rugăm să rețineți: functia schimbă `from`, dar schimbarea nu se vede afară, deoarece o funcție primește întotdeauna o copie a valorii:
 
@@ -158,7 +158,7 @@ Iată încă un exemplu: avem o variabilă `from` și este transmis funcției. V
 function showMessage(from, text) {
 
 *!*
-  from = '*' + from + '*'; // make "from" look nicer
+  from = '*' + from + '*'; // face ca "from" să pară mai frumos
 */!*
 
   alert( from + ': ' + text );
@@ -166,9 +166,9 @@ function showMessage(from, text) {
 
 let from = "Ann";
 
-showMessage(from, "Bună"); // *Ann*: Hello
+showMessage(from, "Bună"); // *Ann*: Bună
 
-// the value of "from" is the same, the function modified a local copy
+// valoarea lui "from" este aceeași, funcția a modificat o copie locală
 alert( from ); // Ann
 ```
 
@@ -176,8 +176,8 @@ Când o valoare este transmisă ca parametru de funcție, se mai numește *argum
 
 Cu alte cuvinte, pentru a clarifica acești termeni:
 
-- Un parametru este variabila listată între paranteze în declarația funcției (este un termen de declarare)
-- Un argument este valoarea care este transmisă funcției atunci când este apelată (este un termen de apelare).
+- Un parametru este variabila listată între paranteze în funcția declarată (este un termen din timpul declarației)
+-Un argument este valoarea care este transmisă funcției atunci când este apelată (este un termen din timpul apelării).
 
 Declarăm funcții care listează parametrii lor, apoi le numim argumente de trecere.
 
@@ -203,17 +203,17 @@ function showMessage(from, *!*text = "nu este dat niciun text"*/!*) {
   alert( from + ": " + text );
 }
 
-showMessage("Ann"); // Ann: no text given
+showMessage("Ann"); // Ann: nu este dat niciun text
 ```
 
-Acum, dacă parametrul`text` nu este trecut, va primi valoarea `"nu este dat niciun text"`
+Acum dacă parametrul`text` nu este trecut, va primi valoarea `"nu este dat niciun text"
 
 Aici `"nu este dat niciun text"` este un șir, dar poate fi o expresie mai complexă, care este evaluată și atribuită doar dacă parametrul lipsește. Deci, acest lucru este posibil:
 
 ```js run
 function showMessage(from, text = anotherFunction()) {
-  // anotherFunction() only executed if no text given
-  // its result becomes the value of text
+  // anotherFunction() executat numai dacă nu este dat text
+  // rezultatul său devine valoarea textului
 }
 ```
 
@@ -222,7 +222,7 @@ function showMessage(from, text = anotherFunction()) {
 
 În exemplul de mai sus, `anotherFunction()` nu este apelat deloc, dacă este furnizat parametrul `text`.
 
-Pe de altă parte, este numit independent de fiecare dată când lipsește `text`.
+Pe de altă parte, este apelat independent de fiecare dată când lipsește `text`.
 ```
 
 ### Parametri impliciți alternativi
@@ -236,7 +236,7 @@ function showMessage(text) {
   // ...
 
 *!*
-  if (text === undefined) { // if the parameter is missing
+  if (text === undefined) { // dacă parametrul lipsește
     text = 'mesaj gol';
   }
 */!*
@@ -244,30 +244,30 @@ function showMessage(text) {
   alert(text);
 }
 
-showMessage(); // empty message
+showMessage(); // mesaj gol
 ```
 
 ...Sau am putea folosi operatorul `||`:
 
 ```js
 function showMessage(text) {
-  // if text is undefined or otherwise falsy, set it to 'empty'
+  // dacă textul este nedefinit sau fals, setați-l ca „gol”
   text = text || 'empty';
   ...
 }
 ```
 
-Motoarele JavaScript moderne acceptă [nullish coalescing operator](info:nullish-coalescing-operator) `??`, este mai bine atunci când majoritatea valorilor false, cum ar fi `0`, ar trebui considerate „normale”:
+Motoarele JavaScript moderne susțin [nullish coalescing operator](info:nullish-coalescing-operator) `??`, este mai bine atunci când majoritatea valorilor false, cum ar fi `0`, ar trebui considerate „normale”:
 
 ```js run
 function showCount(count) {
-  // if count is undefined or null, show "unknown"
+  // dacă numărul este nedefinit sau nul, afișază „necunoscut”
   alert(count ?? "unknown");
 }
 
 showCount(0); // 0
-showCount(null); // unknown
-showCount(); // unknown
+showCount(null); // necunoscut
+showCount(); // necunoscut
 ```
 
 ## Returnarea unei valori
@@ -285,7 +285,7 @@ let result = sum(1, 2);
 alert( result ); // 3
 ```
 
-Directiva `return` poate fi în orice loc al funcției. Când execuția ajunge la el, funcția se oprește, iar valoarea este returnată codului de apelare (atribuit lui `result`).
+Directiva `return` poate fi în orice loc al funcției. Când execuția ajunge la el, funcția se oprește, iar valoarea este returnată codului de apelare (atribuit lui `result` de mai sus).
 
 Pot exista multe apariții ale lui `return` întro singura funcție. De exemplu:
 
@@ -311,7 +311,7 @@ if ( checkAge(age) ) {
 }
 ```
 
-Este posibil să utilizați `return` făra o valoare. Acesta face ca funcția să iasă imediat.
+Este posibil să utilizați `return` făra o valoare. Acesta face ca funcția să se încheie imediat.
 
 De exemplu:
 
@@ -330,13 +330,13 @@ function showMovie(age) {
 
 În codul de mai sus, dacă `checkAge(age)` returnează `false`, atunci `showMovie` nu va trece la `alert`.
 
-```smart header=" O funcție cu un 'return' gol sau fara o returnare este 'undefined'"
+````smart header=" O funcție cu un 'return' gol sau fara o returnare este 'undefined'"
 Dacă o funcție nu returnează o valoare, este la fel ca și când returnează `undefined`:
 
 ```js run
 function doNothing() { /* empty */ }
 
-alert( doNothing() === undefined ); // true
+alert( doNothing() === undefined ); // adevărat
 ```
 
 Un `return` gol este același cu `return undefined`:
@@ -346,7 +346,7 @@ function doNothing() {
   return;
 }
 
-alert( doNothing() === undefined ); // true
+alert( doNothing() === undefined ); // adevărat
 ```
 ````
 
@@ -364,7 +364,7 @@ return*!*;*/!*
  (some + long + expression + or + whatever * f(a) + f(b))
 ```
 
-Deci, devine efectiv un 'return' gol.
+Deci, devine efectiv un `return` gol.
 
 Dacă dorim ca expresia returnată să se înfășoare pe mai multe linii, ar trebui să o începem pe aceeași linie cu`return`. Sau cel puțin puneți parantezele de deschidere acolo, după cum urmează:
 
@@ -380,7 +380,7 @@ return (
 
 ## Denumirea unei funcții [#function-naming]
 
-Funcțiile sunt acțiuni. Deci, numele lor este de obicei un verb. Ar trebui să fie scurt, cât mai precis posibil și să descrie ceea ce face funcția, astfel încât cineva care citește codul să obțină o indicație despre ceea ce face funcția.
+Funcțiile sunt acțiuni. Deci numele lor este de obicei un verb. Ar trebui să fie scurt, cât mai precis posibil și să descrie ceea ce face funcția, astfel încât cineva care citește codul să obțină o indicație despre ceea ce face funcția.
 
 Este o practică larg răspândită de a începe o funcție cu un prefix verbal care descrie vag acțiunea. Trebuie să existe un acord în cadrul echipei cu privire la semnificația prefixelor.
 
@@ -396,11 +396,11 @@ Funcția care începe cu...
 Exemple de astfel de nume:
 
 ```js no-beautify
-showMessage(..)     // shows a message
-getAge(..)          // returns the age (gets it somehow)
-calcSum(..)         // calculates a sum and returns the result
-createForm(..)      // creates a form (and usually returns it)
-checkPermission(..) // checks a permission, returns true/false
+showMessage(..)     // arată un mesaj
+getAge(..)          // returnează vârsta (o primește cumva)
+calcSum(..)         // calculează o sumă și returnează rezultatul
+createForm(..)      // creează un Form (și de obicei îl returnează)
+checkPermission(..) // verifică o permisiune, returnează true/false
 ```
 
 Cu prefixele la loc, o privire asupra numelui unei funcții oferă o înțelegere a ce fel de activitate face și ce fel de valoare returnează.
@@ -412,7 +412,7 @@ Două acțiuni independente deservesc de obicei două funcții, chiar dacă de o
 
 Câteva exemple de încălcare a acestei reguli:
 
-- `getAge` -- ar fi rău dacă arată o `alertă` cu vârsta (ar trebui doar să obțină).
+- `getAge` -- ar fi rău dacă arată o `alert` cu vârsta (ar trebui doar să obțină).
 - `createForm` -- ar fi rău dacă ar modifica documentul, adăugându-i o formă (ar trebui doar să-l creeze și să-l returneze).
 - `checkPermission` -- ar fi rău dacă afișează mesajul „acces acordat/refuzat”. (ar trebui să efectueze doar verificarea și să returneze rezultatul).
 
@@ -433,7 +433,7 @@ Funcțiile ar trebui să fie scurte și să facă un lucru exact. Dacă acel luc
 
 O funcție separată este mai ușor de testat și de depanat -- însăși existența sa este un comentariu grozav!
 
-De exemplu, compara cele două funcții `showPrimes(n)` de mai jos. Fiecare iese [prime numbers](https://en.wikipedia.org/wiki/Prime_number) pâna la`n`.
+De exemplu, compară cele două funcții `showPrimes(n)` de mai jos. Fiecare emite [numere prime](https://ro.wikipedia.org/wiki/Num%C4%83r_prim) pâna la`n`.
 
 Prima variantă folosește o etichetă:
 
@@ -450,7 +450,7 @@ function showPrimes(n) {
 }
 ```
 
-A doua variantă folosește o funcție suplimentară `isPrime(n)` pentru a testa primalitatea:
+A doua variantă folosește o funcție adițională `isPrime(n)` pentru a testa primalitatea:
 
 ```js
 function showPrimes(n) {
@@ -470,7 +470,7 @@ function isPrime(n) {
 }
 ```
 
-A doua variantă este mai ușor de înțeles, nu-i aşa? În loc de piesa de cod, vedem un nume al acțiunii (`isPrime`). Uneori, oamenii se referă la un astfel de cod ca la *auto-descriere*.
+A doua variantă este mai ușor de înțeles, nu-i aşa? În loc de piesa de cod, vedem un nume al acțiunii (`isPrime`). Uneori, oamenii se referă la un astfel de cod ca *auto-descriptiv*.
 
 Deci, funcțiile pot fi create chiar dacă nu intenționăm să le reutilizam. Ele structurează codul și îl fac lizibil.
 
@@ -479,18 +479,18 @@ Deci, funcțiile pot fi create chiar dacă nu intenționăm să le reutilizam. E
 O declarație de funcție arată astfel:
 
 ```js
-function name(parameters, delimited, by, comma) {
-  /* code */
+function name(parametri, delimitați, de, virgulă) {
+  /* cod */
 }
 ```
 
 - Valorile transmise unei funcții ca parametri sunt copiate în variabilele locale.
-- funcția poate accesa variabile exterioare. Dar funcționează numai din interior spre exterior. Codul din afara funcției nu vede variabilele locale.
+- Funcția poate accesa variabile exterioare. Dar funcționează numai din interior spre exterior. Codul din afara funcției nu vede variabilele locale.
 - O funcție poate returna o valoare. Dacă nu, atunci rezultatul ei este `undefined`.
 
 Pentru a face codul curat și ușor de înțeles, este recomandat să folosiți în principal variabile și parametri locali în funcție, nu variabile exterioare.
 
-Este întotdeauna mai ușor de înțeles o funcție care primește parametri, lucrează cu ele și returnează un rezultat, decât o funcție care nu primește niciun parametru, dar modifică variabilele exterioare ca efect secundar.
+Este întotdeauna mai ușor de înțeles o funcție care primește parametri, lucrează cu ei și returnează un rezultat, decât o funcție care nu primește niciun parametru, dar modifică variabilele exterioare ca efect secundar.
 
 Denumirea funcției:
 

From 981af4d68ca033128313cc1d870124bbe81c7330 Mon Sep 17 00:00:00 2001
From: "toader.marinaloredana@gmail.com" <toader.marinaloredana@gmail.com>
Date: Wed, 25 Jan 2023 12:14:52 +0200
Subject: [PATCH 3/5] adjusted

---
 .../1-if-else-required/solution.md                   |  4 +++-
 1-js/02-first-steps/15-function-basics/article.md    | 12 ++++++------
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
index d7c9d14de..447402fbe 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
@@ -1 +1,3 @@
-Nicio diferenta.
\ No newline at end of file
+Nicio diferenta.
+
+În ambele cazuri, `return confirmă('Ți-au permis părinții?')` se execută exact când condiția `if` este falsă.
\ No newline at end of file
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index a7117ffd2..e863786d5 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -58,7 +58,7 @@ De exemplu:
 ```js run
 function showMessage() {
 *!*
-   let message = "Bună, sunt JavaScript!"; // variabilă locală
+  let message = "Bună, sunt JavaScript!"; // variabilă locală
 */!*
 
   alert( message );
@@ -186,7 +186,7 @@ Declarăm funcții care listează parametrii lor, apoi le numim argumente de tre
 
 ## Valori implicite
 
-Dacă o funcție este apelată, dar nu este oferit un argument, atunci valoarea corespunzătoare devine `nedefinită`.
+Dacă o funcție este apelată, dar nu este oferit un argument, atunci valoarea corespunzătoare devine `undefined`.
 
 De exemplu, funcția menționată mai sus `showMessage(from, text)` poate fi apelată cu un singur argument:
 
@@ -330,7 +330,7 @@ function showMovie(age) {
 
 În codul de mai sus, dacă `checkAge(age)` returnează `false`, atunci `showMovie` nu va trece la `alert`.
 
-````smart header=" O funcție cu un 'return' gol sau fara o returnare este 'undefined'"
+````smart header=" O funcție cu un 'return' gol sau fara o returnare este `undefined`"
 Dacă o funcție nu returnează o valoare, este la fel ca și când returnează `undefined`:
 
 ```js run
@@ -350,7 +350,7 @@ alert( doNothing() === undefined ); // adevărat
 ```
 ````
 
-````warn header="Nu adăugați niciodată o linie nouă între `return` și o valoare"
+````warn header="Nu adăugați niciodată o linie nouă între `return` și valoare"
 Pentru o expresie lungă în `return`, ai putea fi tentant să-l pui pe o linie separată, așa:
 
 ```js
@@ -364,7 +364,7 @@ return*!*;*/!*
  (some + long + expression + or + whatever * f(a) + f(b))
 ```
 
-Deci, devine efectiv un `return` gol.
+Deci, devine efectiv un return gol.
 
 Dacă dorim ca expresia returnată să se înfășoare pe mai multe linii, ar trebui să o începem pe aceeași linie cu`return`. Sau cel puțin puneți parantezele de deschidere acolo, după cum urmează:
 
@@ -378,7 +378,7 @@ return (
 Și va funcționa așa cum ne așteptăm.
 ````
 
-## Denumirea unei funcții [#function-naming]
+## Denumind o funcție [#function-naming]
 
 Funcțiile sunt acțiuni. Deci numele lor este de obicei un verb. Ar trebui să fie scurt, cât mai precis posibil și să descrie ceea ce face funcția, astfel încât cineva care citește codul să obțină o indicație despre ceea ce face funcția.
 

From cd597857db74c24bd17dd700fba15d79ddadae3d Mon Sep 17 00:00:00 2001
From: "toader.marinaloredana@gmail.com" <toader.marinaloredana@gmail.com>
Date: Wed, 25 Jan 2023 18:09:33 +0200
Subject: [PATCH 4/5] ajusted

---
 .../1-if-else-required/solution.md            |  4 +-
 .../15-function-basics/article.md             | 37 ++++++++++---------
 2 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
index b937b429a..754a9a300 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
@@ -1 +1,3 @@
-Nicio diferență.
\ No newline at end of file
+Nicio diferență.
+
+În ambele cazuri, `return confirmă('Ți-au permis părinții?')` se execută exact când condiția `if` este falsă.
\ No newline at end of file
diff --git a/1-js/02-first-steps/15-function-basics/article.md b/1-js/02-first-steps/15-function-basics/article.md
index 10cae8575..c03685f0b 100644
--- a/1-js/02-first-steps/15-function-basics/article.md
+++ b/1-js/02-first-steps/15-function-basics/article.md
@@ -208,10 +208,10 @@ showMessage("Ann"); // Ann: nu este dat niciun text
 
 Acum dacă parametrul `text` nu este trecut, va primi valoarea `"nu este dat niciun text"
 
-The default value also jumps in if the parameter exists, but strictly equals `undefined`, like this:
+Valoarea implicită apare și în cazul în care parametrul există, dar este strict egal cu `undefined`, astfel:
 
 ```js
-showMessage("Ann", undefined); // Ann: no text given
+showMessage("Ann", undefined); // Ann: nu a fost dat niciun text
 ```
 
 Aici `"nu este dat niciun text"` este un șir, dar poate fi o expresie mai complexă, care este evaluată și atribuită doar dacă parametrul lipsește. Deci, acest lucru este posibil:
@@ -231,18 +231,18 @@ function showMessage(from, text = anotherFunction()) {
 Pe de altă parte, este apelat independent de fiecare dată când lipsește `text`.
 ```
 
-````smart header="Default parameters in old JavaScript code"
-Several years ago, JavaScript didn't support the syntax for default parameters. So people used other ways to specify them.
+````smart header="Parametrii impliciți în vechiul cod JavaScript"
+Cu câțiva ani în urmă, JavaScript nu a acceptat sintaxa pentru parametrii impliciți. Deci oamenii au folosit alte moduri de a le specifica.
 
-Nowadays, we can come across them in old scripts.
+În zilele noastre, le putem întâlni în scripturi vechi.
 
-For example, an explicit check for `undefined`:
+De exemplu, o verificare explicită pentru `undefined`:
 
 ```js
 function showMessage(from, text) {
 *!*
   if (text === undefined) {
-    text = 'no text given';
+    text = 'nu a fost dat niciun text';
   }
 */!*
 
@@ -250,22 +250,22 @@ function showMessage(from, text) {
 }
 ```
 
-...Or using the `||` operator:
+...Sau folosind operatorul `||`:
 
 ```js
 function showMessage(from, text) {
-  // If the value of text is falsy, assign the default value
-  // this assumes that text == "" is the same as no text at all
-  text = text || 'no text given';
+  // Dacă valoarea textului este falsă, atribuiți valoarea implicită
+  // aceasta presupune că text == "" este la fel ca nici un text
+  text = text || 'nu a fost dat niciun text';
   ...
 }
 ```
 ````
 
 
-### Alternative default parameters
+### Parametri impliciți alternativi
 
-Sometimes it makes sense to assign default values for parameters at a later stage after the function declaration.
+Uneori este logic să atribuiți valori implicite pentru parametrii într-o etapă ulterioară după declararea funcției.
 
 Putem verifica dacă parametrul este transmis în timpul execuției funcției, comparându-l cu `undefined`:
 
@@ -289,17 +289,18 @@ showMessage(); // mesaj gol
 
 ```js
 function showMessage(text) {
-  // dacă textul este nedefinit sau fals, setați-l ca „gol”
+  // dacă textul este nedefinit sau fals, setați-l ca 'empty'
+
   text = text || 'empty';
   ...
 }
 ```
 
-Motoarele JavaScript moderne susțin [nullish coalescing operator](info:nullish-coalescing-operator) `??`, este mai bine atunci când majoritatea valorilor false, cum ar fi `0`, ar trebui considerate „normale”:
+Motoarele JavaScript moderne susțin [nullish coalescing operator](info:nullish-coalescing-operator) `??`, este mai bine atunci când majoritatea valorilor false, cum ar fi `0`, ar trebui considerate "normale":
 
 ```js run
 function showCount(count) {
-  // dacă numărul este nedefinit sau nul, afișază „necunoscut”
+  // dacă numărul este nedefinit sau nul, afișază "necunoscut"
   alert(count ?? "unknown");
 }
 
@@ -393,13 +394,13 @@ Pentru o expresie lungă în `return`, ai putea fi tentant să-l pui pe o linie
 
 ```js
 return
- (some + long + expression + or + whatever * f(a) + f(b))
+ (unele + lung + expresie + sau + orice * f(a) + f(b))
 ```
 Asta nu funcționează, deoarece JavaScript presupune un punct și virgulă după `return`. Asta va funcționa la fel ca:
 
 ```js
 return*!*;*/!*
- (some + long + expression + or + whatever * f(a) + f(b))
+ (unele + lung + expresie + sau + orice * f(a) + f(b))
 ```
 
 Deci, devine efectiv un return gol.

From 0101de4eb9b380e892534700bd61151105dd8f83 Mon Sep 17 00:00:00 2001
From: MarinaG <marina.gabor@phoenixmedia.ro>
Date: Wed, 10 Jul 2024 15:32:34 +0300
Subject: [PATCH 5/5] Update solution.md

---
 .../15-function-basics/1-if-else-required/solution.md            | 1 -
 1 file changed, 1 deletion(-)

diff --git a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
index 754a9a300..475265bb1 100644
--- a/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
+++ b/1-js/02-first-steps/15-function-basics/1-if-else-required/solution.md
@@ -1,3 +1,2 @@
 Nicio diferență.
-
 În ambele cazuri, `return confirmă('Ți-au permis părinții?')` se execută exact când condiția `if` este falsă.
\ No newline at end of file