From ed3dc39d3ceeb1a39fce6277800765447dc911b4 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Thu, 1 Dec 2022 20:56:39 +0200 Subject: [PATCH 01/31] variables --- .../1-hello-variables/solution.md | 3 +- .../04-variables/1-hello-variables/task.md | 10 +- .../2-declare-variables/solution.md | 14 +- .../04-variables/2-declare-variables/task.md | 6 +- .../3-uppercast-constant/solution.md | 6 +- .../04-variables/3-uppercast-constant/task.md | 15 +- 1-js/02-first-steps/04-variables/article.md | 250 +++++++++--------- .../04-variables/variable-change.svg | 3 +- 1-js/02-first-steps/04-variables/variable.svg | 2 +- 9 files changed, 158 insertions(+), 151 deletions(-) diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md index 9249e1c84..7c6ed4d23 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md @@ -1,4 +1,4 @@ -In the code below, each line corresponds to the item in the task list. +În codul următor, fiecare linie corespunde cu obiectul din lista de sarcini. ```js run let admin, name; // can declare two variables at once @@ -9,4 +9,5 @@ admin = name; alert( admin ); // "John" ``` +``` diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/task.md b/1-js/02-first-steps/04-variables/1-hello-variables/task.md index 84f009e8c..10f9d8b62 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/task.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/task.md @@ -2,9 +2,9 @@ importance: 2 --- -# Working with variables +# Lucrând cu variabile -1. Declare two variables: `admin` and `name`. -2. Assign the value `"John"` to `name`. -3. Copy the value from `name` to `admin`. -4. Show the value of `admin` using `alert` (must output "John"). +1. Declară două variabile: `admin` și `name`. +2. Atribuie valorii `"John"` valoarea `name`. +3. Copiază valoarea de la `name` la `admin`. +4. Arată valoarea `admin` folosind `alert` (trebuie să rezulte "John"). diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md index 392f4e26f..58ee7ec79 100644 --- a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md +++ b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md @@ -1,21 +1,21 @@ -## The variable for our planet +## Variabilele pentru planeta noastră -That's simple: +Este simplu: ```js let ourPlanetName = "Earth"; ``` -Note, we could use a shorter name `planet`, but it might not be obvious what planet it refers to. It's nice to be more verbose. At least until the variable isNotTooLong. +Ține minte, am putea folosi un nume mai scurt decît `planet`, dar s-ar putea să nu fie evident la ce planetă se referă. E frumos să fim mai verbali. Cel puțin până când variabila nuEstePreaLungă. -## The name of the current visitor +## Numele vizitatorului curent ```js let currentUserName = "John"; ``` -Again, we could shorten that to `userName` if we know for sure that the user is current. +Din nou, am putea scurta acest `userName` dacă știm sigur că acest utilizator este unul curent. -Modern editors and autocomplete make long variable names easy to write. Don't save on them. A name with 3 words in it is fine. +Editoarele moderne și autocompletarea fac numele lungi de variabile ușor de scris. Nu le salva în ele. Un nume care conține trei cuvinte este în regulă. -And if your editor does not have proper autocompletion, get [a new one](/code-editors). +Și dacă editorul tău nu are autocompletare corectă, descarcă [unul nou](/code-editors). diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/task.md b/1-js/02-first-steps/04-variables/2-declare-variables/task.md index f364badf4..b3e696475 100644 --- a/1-js/02-first-steps/04-variables/2-declare-variables/task.md +++ b/1-js/02-first-steps/04-variables/2-declare-variables/task.md @@ -2,7 +2,7 @@ importance: 3 --- -# Giving the right name +# Creează numele corect -1. Create a variable with the name of our planet. How would you name such a variable? -2. Create a variable to store the name of a current visitor to a website. How would you name that variable? +1. Crează o variabilă cu numele planetei noastre. Cum ai numi o astfel de variabilă? +2. Crează o variabilă care să stocheze numele unui vizitator curent al unui website. Cum ai numi o astfel de variabilă? diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md index acd643fde..fb84dab16 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md @@ -1,5 +1,5 @@ -We generally use upper case for constants that are "hard-coded". Or, in other words, when the value is known prior to execution and directly written into the code. +În general folosim majuscule pentru constante care sunt "hard-codate". Sau, în alte cuvinte, când valoarea se știe înainte de execuție și este scrisă direct în cod. -In this code, `birthday` is exactly like that. So we could use the upper case for it. +În acest cod, `birthday` este exact la fel. Deci am putea folosi majuscule pentru el. -In contrast, `age` is evaluated in run-time. Today we have one age, a year after we'll have another one. It is constant in a sense that it does not change through the code execution. But it is a bit "less of a constant" than `birthday`: it is calculated, so we should keep the lower case for it. +În contrast, `age` este evaluat în timpul execuției codului. Astăzi avem o vârstă, după un an vom avea o altă vârstă. Este constantă în sensul că nu se schimbă în timpul execuției codului. Dar este puțin "mai puțin constantă" decât `birthday`: este calculată, deci ar trebui să folosim litere mici pentru aceasta. diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md index 5fd18f90a..46925ae4a 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md @@ -2,9 +2,9 @@ importance: 4 --- -# Uppercase const? +# onst cu majuscule? -Examine the following code: +Examinează următorul cod: ```js const birthday = '18.04.1982'; @@ -12,13 +12,16 @@ const birthday = '18.04.1982'; const age = someCode(birthday); ``` -Here we have a constant `birthday` date and the `age` is calculated from `birthday` with the help of some code (it is not provided for shortness, and because details don't matter here). +Aici avem constanta `birthday` pentru dată, și de asemenea constanta `age`. -Would it be right to use upper case for `birthday`? For `age`? Or even for both? +Constanta `age` este calculată de la `birthday` folosind `someCode()`, care înseamnă chemarea unei funcții pe care nu o explicăm încă (o vom explica curând!), dar detaliile nu contează aici, ideea este că `age` este calculat oarecum bazat pe `birthday`. + +Ar fi corect să folosim majuscule pentru `birthday`? Pentru `age`? Sau chiar pentru amândouă? ```js -const BIRTHDAY = '18.04.1982'; // make uppercase? +const BIRTHDAY = '18.04.1982'; // facem birthday cu majuscule? -const AGE = someCode(BIRTHDAY); // make uppercase? +const AGE = someCode(BIRTHDAY); //facem age cu majuscule? +``` ``` diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 0d5d2f30b..2d84ee7eb 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -1,273 +1,274 @@ -# Variables +# Variabile -Most of the time, a JavaScript application needs to work with information. Here are two examples: -1. An online shop -- the information might include goods being sold and a shopping cart. -2. A chat application -- the information might include users, messages, and much more. +n cea mai mare parte a timpului, o aplicație JavaScript are nevoie să lucreze cu informații. Aici sunt două example: +1. Un magazin online -- informația ar putea include bunurile vândute și un coș de cumpărături. +2. O aplicație de chat -- informația ar pputea include utilizatori, mesaje, și mult mai multe. -Variables are used to store this information. +Variabilele sunt folosite pentru a stoca această informație. -## A variable +## O variabilă -A [variable](https://en.wikipedia.org/wiki/Variable_(computer_science)) is a "named storage" for data. We can use variables to store goodies, visitors, and other data. +O [variabilă](https://en.wikipedia.org/wiki/Variable_(computer_science)) este un "spațiu de stocare numit" pentru date. Putem folosi variabile pentru a stoca bunuri, visitatori, și alte date. -To create a variable in JavaScript, use the `let` keyword. +Pentru a crea o variabilă în JavaScript, folosim termenul`let` . -The statement below creates (in other words: *declares*) a variable with the name "message": +Declarația de mai jos crează (în alte cuvinte: *declară*) o variabilă cu numele "message": ```js let message; ``` -Now, we can put some data into it by using the assignment operator `=`: +Acum, putem pune niște date în ea folosind operatorul de asignare `=`: ```js let message; *!* -message = 'Hello'; // store the string 'Hello' in the variable named message +message = 'Bună'; // stochează stringul 'Bună' în variabila denumită message */!* ``` -The string is now saved into the memory area associated with the variable. We can access it using the variable name: +Stringul este acum salvat în zona de memorie asociată cu variabila. Putem să o accesăm folosind numele variabilei: ```js run let message; -message = 'Hello!'; +message = 'Bună!'; *!* -alert(message); // shows the variable content +alert(message); // arată conținutul variabilei */!* ``` -To be concise, we can combine the variable declaration and assignment into a single line: +Ca să fim conciși, putem să combinăm declarația variabilei și desemnarea ei într-o singură linie: ```js run -let message = 'Hello!'; // define the variable and assign the value +let message = 'Buna!'; // definește variabila și îi asignează valoarea -alert(message); // Hello! +alert(message); // Bună! ``` -We can also declare multiple variables in one line: +De asemenea putem declara multiple variabile într-o singură linie: ```js no-beautify -let user = 'John', age = 25, message = 'Hello'; +let user = 'John', age = 25, message = 'Bună'; ``` -That might seem shorter, but we don't recommend it. For the sake of better readability, please use a single line per variable. +Asta ar putea să apară mai scurt, dar nu recomandăm. De dragul unei lizibilități mai bune, te rugăm să folosești o singură linie de variabilă. -The multiline variant is a bit longer, but easier to read: +Varianta pe mai multe linii este puțin mai lungă, dar mai ușor de citit: ```js let user = 'John'; let age = 25; -let message = 'Hello'; +let message = 'Bună'; ``` -Some people also define multiple variables in this multiline style: +Unele persoane definesc, de asemenea, multiple variabile în acest stil pe mai multe linii: + ```js no-beautify let user = 'John', age = 25, - message = 'Hello'; + message = 'Bună'; ``` -...Or even in the "comma-first" style: +...Sau chiar în "prima-virgulă" ca stil: ```js no-beautify let user = 'John' , age = 25 - , message = 'Hello'; + , message = 'Bună'; ``` -Technically, all these variants do the same thing. So, it's a matter of personal taste and aesthetics. +Technic, toate aceste variante fac același lucru. Deci, este o problemă de preferință personală și de estetică. ````smart header="`var` instead of `let`" -In older scripts, you may also find another keyword: `var` instead of `let`: +În transcrieri mai vechi, ai putea găsi de asemenea un alt termen: `var` în loc de `let`: ```js -*!*var*/!* message = 'Hello'; +*!*var*/!* message = 'Bună'; ``` -The `var` keyword is *almost* the same as `let`. It also declares a variable, but in a slightly different, "old-school" way. +Termenul `var` este *aproape* la fel ca și `let`. Declară de asemenea o variabilă, but într-un mod ușor diferit, de "școală-veche" . -There are subtle differences between `let` and `var`, but they do not matter for us yet. We'll cover them in detail in the chapter . +Există diferențe subtile între `let` și `var`, dar nu contează pentru noi acum. O să le acoperim în detaliu în capitolul . ```` -## A real-life analogy +## O analogie din viața reală -We can easily grasp the concept of a "variable" if we imagine it as a "box" for data, with a uniquely-named sticker on it. +Putem înțelege ușor conceptul de "variabilă" dacă ne-o imaginăm drept o "cutie" pentru date, cu un abțibild cu nume unic pe ea. -For instance, the variable `message` can be imagined as a box labeled `"message"` with the value `"Hello!"` in it: +De exemplu, variabila `message` poate fi imaginată drept o cutie cu eticheta `"mesaj"` cu valoarea `"Bună!"` în ea: ![](variable.svg) -We can put any value in the box. +Putem pune orice valoare în cutie. + +De asemenaea o putem schimba de câte ori vrem: -We can also change it as many times as we want: ```js run let message; -message = 'Hello!'; +message = 'Bună!'; -message = 'World!'; // value changed +message = 'Lume!'; // valoare schimbată alert(message); ``` -When the value is changed, the old data is removed from the variable: +Când valoarea este schimbată, data veche este stearsă din variabilă: ![](variable-change.svg) -We can also declare two variables and copy data from one into the other. +De asemenea putem declara două variabile și copia datele din una în cealaltă. ```js run -let hello = 'Hello world!'; +let hello = 'Buna lume!'; let message; *!* -// copy 'Hello world' from hello into message +// copiază 'Bună lume' din bună în mesaj message = hello; */!* -// now two variables hold the same data -alert(hello); // Hello world! -alert(message); // Hello world! +// acum cele două variabile conțin aceleași date +alert(hello); // Bună lume! +alert(message); // Bună lume! ``` ````warn header="Declaring twice triggers an error" -A variable should be declared only once. +O viariabilă ar trebui declarată o singură dată. -A repeated declaration of the same variable is an error: +O repetare a declarației a aceleași variabile este o eroare: ```js run -let message = "This"; +let message = "acesta"; -// repeated 'let' leads to an error -let message = "That"; // SyntaxError: 'message' has already been declared +// 'let' repetat duce la o eroare +let message = "Acesta"; // SyntaxError: 'message' a fost deja declarat ``` -So, we should declare a variable once and then refer to it without `let`. +Deci, ar trebui să declarăm o variabilă o dată și apoi să ne referim la aceasta fără `let`. ```` ```smart header="Functional languages" -It's interesting to note that there exist [functional](https://en.wikipedia.org/wiki/Functional_programming) programming languages, like [Scala](http://www.scala-lang.org/) or [Erlang](http://www.erlang.org/) that forbid changing variable values. +Este interesant de notat dacă acolo există acele numite [funcțional pure](https://en.wikipedia.org/wiki/Purely_functional_programming) limbaje de programare, cum ar fi [Haskell](https://en.wikipedia.org/wiki/Haskell), care interzic schimbarea valorii variabilelor. -In such languages, once the value is stored "in the box", it's there forever. If we need to store something else, the language forces us to create a new box (declare a new variable). We can't reuse the old one. +În limbaje ca acestea, odată ce valoarea este stocată "în cutie", există acolo pentru totdeauna. Dacă avem nevoie să stocăm altceva, limbajul ne forțează să creăm o nouă cutie (declarăm o nouă variabilă). Nu o putem refolosi pe cea veche. -Though it may seem a little odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits. Studying such a language (even if you're not planning to use it soon) is recommended to broaden the mind. +Deși pare un pic ciudat la prima vedere, aceste limbaje sunt destul de capabile de dezvoltare serioasă. Mai mult decât atât, sunt zone ca de exemplu calcule paralele unde această limitare conferă beneficii sigure. ``` -## Variable naming [#variable-naming] +## Denumirea variabilelor [#variable-naming] -There are two limitations on variable names in JavaScript: +Există două limitări în denumirea variabilelor în JavaScript: -1. The name must contain only letters, digits, or the symbols `$` and `_`. -2. The first character must not be a digit. +1. Numele trebuie să conțină doar litere, numere, sau simboluri `$` și `_`. +2. Primul caracter nu trebuie să fie o cifră. -Examples of valid names: +Exemple de nume valide: ```js let userName; let test123; ``` -When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word except first starting with a capital letter: `myVeryLongName`. +Cînd numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este folosit adesea. Acesta este: cuvintele vin unul după celălalt, fiecare cuvânt exceptând primul care începe cu majusculă: `numeleMeuFoarteLung`. -What's interesting -- the dollar sign `'$'` and the underscore `'_'` can also be used in names. They are regular symbols, just like letters, without any special meaning. +Ceea ce este interesant -- semnul de dolar `'$'` și bară jos `'_'` pot fi de asemenea folosite în nume. Acestea sunt simboluri obișnuite, la fel ca și literele, fără însemnătate specială. -These names are valid: +Aceste nume sunt valide: ```js run untrusted -let $ = 1; // declared a variable with the name "$" -let _ = 2; // and now a variable with the name "_" +let $ = 1; // declarăm o variabilă cu numele "$" +let _ = 2; // și apoi o variabilă cu numele "_" alert($ + _); // 3 ``` -Examples of incorrect variable names: +Example de nume de variabile greșite: ```js no-beautify -let 1a; // cannot start with a digit +let 1a; // nu poate începe cu o cifră -let my-name; // hyphens '-' aren't allowed in the name +let my-name; // cratima '-' nu este permisă în nume ``` ```smart header="Case matters" -Variables named `apple` and `AppLE` are two different variables. +Variabilele numite `apple` și `APPLE` sunt două variabile diferite. ``` ````smart header="Non-Latin letters are allowed, but not recommended" -It is possible to use any language, including cyrillic letters or even hieroglyphs, like this: +Este posibil să folosim orice limbă, inclusiv litere chirilice, caractere chinezești și altele, precum acestea: ```js let имя = '...'; let 我 = '...'; ``` -Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it some time. +Technic, aici nu este nicio greșeală. Astfel de nume sunt permise, dar există o convenție internațională de a folosi limba engleză în denumirile variabilelor. Chiar dacă sunt scrise cu litere mici, pot avea viață lungă. Oamenii din alte țări ar putea avea nevoie să le citescă uneori. ```` ````warn header="Reserved names" -There is a [list of reserved words](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), which cannot be used as variable names because they are used by the language itself. +Există o [listă de cuvinte rezervate](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), care nu poate fi folostă ca nume de variabile pentru că sunt folosite de către limbajul însuși. -For example: `let`, `class`, `return`, and `function` are reserved. +De exemplu: `let`, `class`, `return`, și `function` sunt rezervate. -The code below gives a syntax error: +Codul următor dă eroare de sintaxă: ```js run no-beautify -let let = 5; // can't name a variable "let", error! -let return = 5; // also can't name it "return", error! +let let = 5; // nu putem numi o variabilă "let", eroare! +let return = 5; // de asemenea nu o putem numi "return", eroare! ``` ```` ````warn header="An assignment without `use strict`" -Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value without using `let`. This still works now if we don't put `use strict` in our scripts to maintain compatibility with old scripts. +În mod normal, avem nevoie să definim o variabilă înainte să o folosim. Dar în timpurile vechi, era technic posibil să creezi o variabilă prin simpla asignare a unei valori fără a folosi `let`. Acesta încă funcționează acum dacă nu punem `use strict` în textul nostru pentru a menține compatibilitatea cu textele vechi. ```js run no-strict -// note: no "use strict" in this example +// notă: nu există "use strict" în acest exemplu -num = 5; // the variable "num" is created if it didn't exist +num = 5; // variabila "num" este creată chiar dacă nu există alert(num); // 5 ``` -This is a bad practice and would cause an error in strict mode: +Aceasta este o practică greșită și ar putea produce o eroare în modul strict: ```js "use strict"; *!* -num = 5; // error: num is not defined +num = 5; // eroare: num nu este definit */!* ``` ```` -## Constants +## Constante -To declare a constant (unchanging) variable, use `const` instead of `let`: +Pentru a declara o constantă (care nu se schimbă) variabilă, folosim `const` în loc de `let`: ```js const myBirthday = '18.04.1982'; ``` -Variables declared using `const` are called "constants". They cannot be reassigned. An attempt to do so would cause an error: +Variabilele declarate folosind `const` se numesc "constante". Ele nu pot fi reasignate. O încercare de a face acest lucru va produce o eroare: ```js run const myBirthday = '18.04.1982'; -myBirthday = '01.01.2001'; // error, can't reassign the constant! +myBirthday = '01.01.2001'; // eroare, nu nputem reasigna constanta! ``` -When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and clearly communicate that fact to everyone. +Când un programator este sigur că acea variabilă nu se va schimba niciodată, o poate declara folosind `const` pentru a garanta și a comunica clar acest fapt tuturor. +### Constante cu majuscule -### Uppercase constants +Este o practica răspândită de a folosi constante drept așa-zise valori greu de reținut care sunt cunoscute înainte de execuție. -There is a widespread practice to use constants as aliases for difficult-to-remember values that are known prior to execution. +Aceste constante sunt denumite folosind majuscule și bară jos. -Such constants are named using capital letters and underscores. - -For instance, let's make constants for colors in so-called "web" (hexadecimal) format: +De exemplu, să facem o constantă pentru culori în așa-numitul "web" (hexadecimal) format: ```js run const COLOR_RED = "#F00"; @@ -275,69 +276,70 @@ const COLOR_GREEN = "#0F0"; const COLOR_BLUE = "#00F"; const COLOR_ORANGE = "#FF7F00"; -// ...when we need to pick a color +// ...când avem nevoie să algem o culoare let color = COLOR_ORANGE; alert(color); // #FF7F00 ``` -Benefits: +Beneficii: + +- `COLOR_ORANGE` este mai ușor de reținut decât `"#FF7F00"`. +- Este mai ușor de greșit `"#FF7F00"` decât `COLOR_ORANGE`. +- Când citim codul, `COLOR_ORANGE` are o mai mmare însemnătate decât `#FF7F00`. -- `COLOR_ORANGE` is much easier to remember than `"#FF7F00"`. -- It is much easier to mistype `"#FF7F00"` than `COLOR_ORANGE`. -- When reading the code, `COLOR_ORANGE` is much more meaningful than `#FF7F00`. +Când ar trebui să folosim majuscule pentru o constantă și când ar trebui să o denumim în mod obișnuit? Haideți să clarificăm acest lucru. -When should we use capitals for a constant and when should we name it normally? Let's make that clear. +A fi o "constantă" înseamnă doar a fi o valoare a unei variabile care nu se schimbă. Dar există și constante care sunt cunoscute înainte de execuție (ca de exemplu valoarea hexadecimală pentru roșu) și există constante care sunt *calculate* în timpul execuției, dar nu se schimbă după ce sunt asignate inițial. -Being a "constant" just means that a variable's value never changes. But there are constants that are known prior to execution (like a hexadecimal value for red) and there are constants that are *calculated* in run-time, during the execution, but do not change after their initial assignment. +De exemplu: -For instance: ```js -const pageLoadTime = /* time taken by a webpage to load */; +const pageLoadTime = /* timpul cât durează ca o pagină web să se încarce */; ``` -The value of `pageLoadTime` is not known prior to the page load, so it's named normally. But it's still a constant because it doesn't change after assignment. +Valoarea lui `pageLoadTime` nu este cunoscută înainte ca pagina să se încarce, astfel că este denumită obișnuit. Dar este totuși o constantă pentru că nu se schimbă după ce este asignată. -In other words, capital-named constants are only used as aliases for "hard-coded" values. +În alte cuvinte, constantele cu majuscule sunt folosite doar ca așa-zise valori "hard-codate". -## Name things right +## Denumirea corectă a lucrurilor -Talking about variables, there's one more extremely important thing. +Vorbind despre variabile, există un lucru extrem de important. -A variable name should have a clean, obvious meaning, describing the data that it stores. +Numele unei variabile ar trebui să aibă o denumire clară, o denumire evidentă, care descrie data stocată. -Variable naming is one of the most important and complex skills in programming. A quick glance at variable names can reveal which code was written by a beginner versus an experienced developer. +Denumirea variabilelor este una dintre cele mai importante și complexe abilități în programare. La prima vedere numele unei variabile poate dezvălui dacă codul a fost scris de un începător sau de un programator cu experiență. -In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labeled. Or, in other words, when the variables have good names. +Într-un proiect real, cel mai mult timp este petrecut modificând și extinzând o bază de cod existentă mai mult decât a scrie ceva complet separat de la început. Când ne reîntoarcem la cod după ce am făcut altceva pentru un timp, este mult mai ușor să găsim informația care este bine etichetată. Sau, în alte cuvinte, când variabilele au o denumire bună. -Please spend time thinking about the right name for a variable before declaring it. Doing so will repay you handsomely. +Te rog petrece timp gândindu-te la denumirea corectă pentru o variabilă înainte să o declari. Făcând acest lucru te răsplătești frumos. -Some good-to-follow rules are: +Câteva reguli bune de urmat: -- Use human-readable names like `userName` or `shoppingCart`. -- Stay away from abbreviations or short names like `a`, `b`, `c`, unless you really know what you're doing. -- Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing. -- Agree on terms within your team and in your own mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`. +- Folosește nume uman-reproductibile ca `userName` sau `shoppingCart`. +- Stai departe de abrevieri sau nume scurte ca `a`, `b`, `c`, dacă nu știi exact ceea ce faci. +- Fă numele extrem de descriptiv și concis. Exemple de denumiri proaste sunt `data` și `value`. Aceste denumiri nu reprezintă nimic. Este în regulă să le folosim dacă contextul codului le face excepțional de evidente la care dată sau valoare variabila se referă. +- Pune-te de acord cu echipa și ține minte. Dacă vizitatorul unui site este denumit ca "user" atunci ar trebui ca numele variabilelor legate să fie `currentUser` sau `newUser` în loc de `currentVisitor` sau `newManInTown`. -Sounds simple? Indeed it is, but creating descriptive and concise variable names in practice is not. Go for it. +Sună simplu? Chiar este, dar crearea de variabile descriptive și concise în practică nu este. Încearcă. ```smart header="Reuse or create?" -And the last note. There are some lazy programmers who, instead of declaring new variables, tend to reuse existing ones. +Și ultima notă. Există programatori leneși care, în loc să declare variabile noi, încearcă să le reutilizeze pe cele deja existente. -As a result, their variables are like boxes into which people throw different things without changing their stickers. What's inside the box now? Who knows? We need to come closer and check. +Drept rezultat, variabilele lor sunt ca niște cutii în care oamenii aruncă diferite lucruri fără să schimbe etichetele. Ce este înăuntrul cutiei acum? Cine știe? Trebuie să ne apropiem și să vedem. -Such programmers save a little bit on variable declaration but lose ten times more on debugging. +Astfel de programatori salvează puțin din declararea variabilelor dar pierd de zece ori mai mult să remedieze erorile. -An extra variable is good, not evil. +O variabilă în plus este bună, nu rea. -Modern JavaScript minifiers and browsers optimize code well enough, so it won't create performance issues. Using different variables for different values can even help the engine optimize your code. +Limbajul JavaScript modern micșorează și browserele optimizează codul destul de bine, deci nu vom crea probleme de performanță. Folosind diferite variabile pentru diferite valori putem chiar ajuta ca motorul să îți optimizeze codul. ``` -## Summary +## Sumar -We can declare variables to store data by using the `var`, `let`, or `const` keywords. +Putem declara variabile pentru a stoca date folosind `var`, `let`, sau termenul `const`. -- `let` -- is a modern variable declaration. -- `var` -- is an old-school variable declaration. Normally we don't use it at all, but we'll cover subtle differences from `let` in the chapter , just in case you need them. -- `const` -- is like `let`, but the value of the variable can't be changed. +- `let` -- este o declarație modernă de variabilă. +- `var` -- este o declarație de variabilă de "școală-veche". În mod normal nu o mai folosim deloc, dar o să acoperim diferențele subtile față de `let` în capitolul , în cazul în care ai nevoie de ele. +- `const` -- este la fel ca `let`, doar că valoarea variabilei nu se poate schimba. -Variables should be named in a way that allows us to easily understand what's inside them. +Variabilele ar trebui denumite în așa natură încât să înțelegem ușor ce se află înăuntrul lor. diff --git a/1-js/02-first-steps/04-variables/variable-change.svg b/1-js/02-first-steps/04-variables/variable-change.svg index 1b2679238..603a878d4 100644 --- a/1-js/02-first-steps/04-variables/variable-change.svg +++ b/1-js/02-first-steps/04-variables/variable-change.svg @@ -1 +1,2 @@ -"World!""Hello!"message \ No newline at end of file +"Lume!""Bună +!"mesaj \ No newline at end of file diff --git a/1-js/02-first-steps/04-variables/variable.svg b/1-js/02-first-steps/04-variables/variable.svg index 1c3d8b0cb..b0b29419d 100644 --- a/1-js/02-first-steps/04-variables/variable.svg +++ b/1-js/02-first-steps/04-variables/variable.svg @@ -1 +1 @@ -"Hello!"message \ No newline at end of file +"Bună!"mesaj \ No newline at end of file From 043d333065e4a10770e4034456b57ec56965feb8 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Thu, 1 Dec 2022 21:13:36 +0200 Subject: [PATCH 02/31] fix a typo --- 1-js/02-first-steps/04-variables/3-uppercast-constant/task.md | 4 +--- 1-js/02-first-steps/04-variables/article.md | 3 +-- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md index 46925ae4a..03564cb9e 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md @@ -12,9 +12,7 @@ const birthday = '18.04.1982'; const age = someCode(birthday); ``` -Aici avem constanta `birthday` pentru dată, și de asemenea constanta `age`. - -Constanta `age` este calculată de la `birthday` folosind `someCode()`, care înseamnă chemarea unei funcții pe care nu o explicăm încă (o vom explica curând!), dar detaliile nu contează aici, ideea este că `age` este calculat oarecum bazat pe `birthday`. +Aici avem o constantă `birthday` dată și `age` este calculat din `birthday` cu ajutorul codului (nu este redat aici pentru a scurta, și pentru că detaliile nu contează aici). Ar fi corect să folosim majuscule pentru `birthday`? Pentru `age`? Sau chiar pentru amândouă? diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 2d84ee7eb..d36cc8840 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -1,6 +1,6 @@ # Variabile -n cea mai mare parte a timpului, o aplicație JavaScript are nevoie să lucreze cu informații. Aici sunt două example: +În cea mai mare parte a timpului, o aplicație JavaScript are nevoie să lucreze cu informații. Aici sunt două example: 1. Un magazin online -- informația ar putea include bunurile vândute și un coș de cumpărături. 2. O aplicație de chat -- informația ar pputea include utilizatori, mesaje, și mult mai multe. @@ -64,7 +64,6 @@ let message = 'Bună'; ``` Unele persoane definesc, de asemenea, multiple variabile în acest stil pe mai multe linii: - ```js no-beautify let user = 'John', age = 25, From c42701bb4a88f27a8790dec5a81616c9bb14e0d9 Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Fri, 2 Dec 2022 17:40:41 +0200 Subject: [PATCH 03/31] Apply suggestions from code review --- 1-js/02-first-steps/04-variables/3-uppercast-constant/task.md | 2 +- 1-js/02-first-steps/04-variables/article.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md index 03564cb9e..a2353f0aa 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md @@ -2,7 +2,7 @@ importance: 4 --- -# onst cu majuscule? +# const cu majuscule? Examinează următorul cod: diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index d36cc8840..161c505d3 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -2,7 +2,7 @@ În cea mai mare parte a timpului, o aplicație JavaScript are nevoie să lucreze cu informații. Aici sunt două example: 1. Un magazin online -- informația ar putea include bunurile vândute și un coș de cumpărături. -2. O aplicație de chat -- informația ar pputea include utilizatori, mesaje, și mult mai multe. +2. O aplicație de chat -- informația ar putea include utilizatori, mesaje, și mult mai multe. Variabilele sunt folosite pentru a stoca această informație. From 0b41a45256522758f0c9b1d8278af36dd2f856fb Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 13:09:05 +0200 Subject: [PATCH 04/31] fix-1-solution.md --- .../02-first-steps/04-variables/1-hello-variables/solution.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md index 7c6ed4d23..0961c21a1 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md @@ -1,7 +1,7 @@ În codul următor, fiecare linie corespunde cu obiectul din lista de sarcini. ```js run -let admin, name; // can declare two variables at once +let admin, name; // putem declara două variabile deodată name = "John"; @@ -9,5 +9,5 @@ admin = name; alert( admin ); // "John" ``` -``` + From 46fdd9a8a895b2d3de099965ce52b3cfc1f18645 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 13:11:45 +0200 Subject: [PATCH 05/31] fix 3-task.md --- 1-js/02-first-steps/04-variables/3-uppercast-constant/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md index a2353f0aa..518c6a010 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md @@ -2,7 +2,7 @@ importance: 4 --- -# const cu majuscule? +# Const cu majuscule? Examinează următorul cod: From 070962a2b4757b93ae89a87ec0d76fe28d14a2ba Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 14:37:58 +0200 Subject: [PATCH 06/31] fix article.md --- 1-js/02-first-steps/04-variables/article.md | 53 ++++++++++----------- 1 file changed, 26 insertions(+), 27 deletions(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 161c505d3..c4789a7ad 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -18,17 +18,17 @@ Declarația de mai jos crează (în alte cuvinte: *declară*) o variabilă cu nu let message; ``` -Acum, putem pune niște date în ea folosind operatorul de asignare `=`: +Acum, putem pune niște date în ea folosind operatorul de alocare `=`: ```js let message; *!* -message = 'Bună'; // stochează stringul 'Bună' în variabila denumită message +message = 'Bună'; // stochează șirul 'Hello' în variabila numită mesaj */!* ``` -Stringul este acum salvat în zona de memorie asociată cu variabila. Putem să o accesăm folosind numele variabilei: +Șirul este acum salvat în zona de memorie asociată cu variabila. Putem să o accesăm folosind numele variabilei: ```js run let message; @@ -42,7 +42,7 @@ alert(message); // arată conținutul variabilei Ca să fim conciși, putem să combinăm declarația variabilei și desemnarea ei într-o singură linie: ```js run -let message = 'Buna!'; // definește variabila și îi asignează valoarea +let message = 'Bună!'; // definește variabila și îi asignează valoarea alert(message); // Bună! ``` @@ -78,7 +78,7 @@ let user = 'John' , message = 'Bună'; ``` -Technic, toate aceste variante fac același lucru. Deci, este o problemă de preferință personală și de estetică. +Technic, toate aceste variante fac același lucru. Deci, este o problemă de preferință personală și de estetică.. ````smart header="`var` instead of `let`" În transcrieri mai vechi, ai putea găsi de asemenea un alt termen: `var` în loc de `let`: @@ -87,7 +87,7 @@ Technic, toate aceste variante fac același lucru. Deci, este o problemă de pre *!*var*/!* message = 'Bună'; ``` -Termenul `var` este *aproape* la fel ca și `let`. Declară de asemenea o variabilă, but într-un mod ușor diferit, de "școală-veche" . +Termenul `var` este *aproape* la fel ca și `let`. Declară de asemenea o variabilă, dar într-un mod ușor diferit, de "școală-veche". Există diferențe subtile între `let` și `var`, dar nu contează pentru noi acum. O să le acoperim în detaliu în capitolul . ```` @@ -103,11 +103,10 @@ De exemplu, variabila `message` poate fi imaginată drept o cutie cu eticheta `" Putem pune orice valoare în cutie. De asemenaea o putem schimba de câte ori vrem: - ```js run let message; -message = 'Bună!'; +message = ''Bună!'; message = 'Lume!'; // valoare schimbată @@ -118,10 +117,10 @@ Când valoarea este schimbată, data veche este stearsă din variabilă: ![](variable-change.svg) -De asemenea putem declara două variabile și copia datele din una în cealaltă. +De asemenea putem declara două variabile și copia datele din una în cealaltă.. ```js run -let hello = 'Buna lume!'; +let hello = ''Buna lume!!'; let message; @@ -141,7 +140,7 @@ O viariabilă ar trebui declarată o singură dată. O repetare a declarației a aceleași variabile este o eroare: ```js run -let message = "acesta"; +let message = "Acesta"; // 'let' repetat duce la o eroare let message = "Acesta"; // SyntaxError: 'message' a fost deja declarat @@ -157,7 +156,7 @@ Este interesant de notat dacă acolo există acele numite [funcțional pure](htt Deși pare un pic ciudat la prima vedere, aceste limbaje sunt destul de capabile de dezvoltare serioasă. Mai mult decât atât, sunt zone ca de exemplu calcule paralele unde această limitare conferă beneficii sigure. ``` -## Denumirea variabilelor [#variable-naming] +## Denumirea variabilelor [#variable-naming] Există două limitări în denumirea variabilelor în JavaScript: @@ -171,7 +170,7 @@ let userName; let test123; ``` -Cînd numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este folosit adesea. Acesta este: cuvintele vin unul după celălalt, fiecare cuvânt exceptând primul care începe cu majusculă: `numeleMeuFoarteLung`. +Când numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este folosit adesea. Acesta este: cuvintele vin unul după celălalt, fiecare cuvânt exceptând primul care începe cu majusculă: `numeleMeuFoarteLung`. Ceea ce este interesant -- semnul de dolar `'$'` și bară jos `'_'` pot fi de asemenea folosite în nume. Acestea sunt simboluri obișnuite, la fel ca și literele, fără însemnătate specială. @@ -184,12 +183,12 @@ let _ = 2; // și apoi o variabilă cu numele "_" alert($ + _); // 3 ``` -Example de nume de variabile greșite: +Examples of incorrect variable names: ```js no-beautify let 1a; // nu poate începe cu o cifră -let my-name; // cratima '-' nu este permisă în nume +let my-name; // și apoi o variabilă cu numele "_" ``` ```smart header="Case matters" @@ -210,7 +209,7 @@ Technic, aici nu este nicio greșeală. Astfel de nume sunt permise, dar există ````warn header="Reserved names" Există o [listă de cuvinte rezervate](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), care nu poate fi folostă ca nume de variabile pentru că sunt folosite de către limbajul însuși. -De exemplu: `let`, `class`, `return`, și `function` sunt rezervate. +De exemplu: `let`, `class`, `return`, and `function` sunt rezervate.. Codul următor dă eroare de sintaxă: @@ -222,7 +221,7 @@ let return = 5; // de asemenea nu o putem numi "return", eroare! ````warn header="An assignment without `use strict`" -În mod normal, avem nevoie să definim o variabilă înainte să o folosim. Dar în timpurile vechi, era technic posibil să creezi o variabilă prin simpla asignare a unei valori fără a folosi `let`. Acesta încă funcționează acum dacă nu punem `use strict` în textul nostru pentru a menține compatibilitatea cu textele vechi. +În mod normal, avem nevoie să definim o variabilă înainte să o folosim. Dar în timpurile vechi, era technic posibil să creezi o variabilă prin simpla alocare a unei valori fără a folosi `let`. Acesta încă funcționează acum dacă nu punem `use strict` în textul nostru pentru a menține compatibilitatea cu textele vechi. ```js run no-strict // notă: nu există "use strict" în acest exemplu @@ -251,16 +250,17 @@ Pentru a declara o constantă (care nu se schimbă) variabilă, folosim `const` const myBirthday = '18.04.1982'; ``` -Variabilele declarate folosind `const` se numesc "constante". Ele nu pot fi reasignate. O încercare de a face acest lucru va produce o eroare: +Variabilele declarate folosind `const` se numesc "constante". Ele nu pot fi realocate. O încercare de a face acest lucru va produce o eroare: ```js run const myBirthday = '18.04.1982'; -myBirthday = '01.01.2001'; // eroare, nu nputem reasigna constanta! +myBirthday = '01.01.2001'; // eroare, nu nputem realoca constanta! ``` Când un programator este sigur că acea variabilă nu se va schimba niciodată, o poate declara folosind `const` pentru a garanta și a comunica clar acest fapt tuturor. + ### Constante cu majuscule Este o practica răspândită de a folosi constante drept așa-zise valori greu de reținut care sunt cunoscute înainte de execuție. @@ -275,28 +275,27 @@ const COLOR_GREEN = "#0F0"; const COLOR_BLUE = "#00F"; const COLOR_ORANGE = "#FF7F00"; -// ...când avem nevoie să algem o culoare +// ...când avem nevoie să alegem o culoare let color = COLOR_ORANGE; alert(color); // #FF7F00 ``` Beneficii: -- `COLOR_ORANGE` este mai ușor de reținut decât `"#FF7F00"`. -- Este mai ușor de greșit `"#FF7F00"` decât `COLOR_ORANGE`. -- Când citim codul, `COLOR_ORANGE` are o mai mmare însemnătate decât `#FF7F00`. +- `COLOR_ORANGE` este mai ușor de reținut decât `"#FF7F00"`. +- Este mai ușor de greșit `"#FF7F00"` decât `COLOR_ORANGE`. +- Când citim codul, `COLOR_ORANGE` are o mai mmare însemnătate `#FF7F00`. Când ar trebui să folosim majuscule pentru o constantă și când ar trebui să o denumim în mod obișnuit? Haideți să clarificăm acest lucru. -A fi o "constantă" înseamnă doar a fi o valoare a unei variabile care nu se schimbă. Dar există și constante care sunt cunoscute înainte de execuție (ca de exemplu valoarea hexadecimală pentru roșu) și există constante care sunt *calculate* în timpul execuției, dar nu se schimbă după ce sunt asignate inițial. +A fi o "constantă" înseamnă doar a fi o valoare a unei variabile care nu se schimbă. Dar există și constante care sunt cunoscute înainte de execuție (ca de exemplu valoarea hexadecimală pentru roșu) și există constante care sunt *calculate* în timpul execuției, dar nu se schimbă după ce sunt alocate inițial. De exemplu: - ```js -const pageLoadTime = /* timpul cât durează ca o pagină web să se încarce */; +const pageLoadTime = /* timpul cât durează ca o pagină web să se încarce */; ``` -Valoarea lui `pageLoadTime` nu este cunoscută înainte ca pagina să se încarce, astfel că este denumită obișnuit. Dar este totuși o constantă pentru că nu se schimbă după ce este asignată. +Valoarea lui `pageLoadTime` nu este cunoscută înainte ca pagina să se încarce, astfel că este denumită obișnuit. Dar este totuși o constantă pentru că nu se schimbă după ce este alocată. În alte cuvinte, constantele cu majuscule sunt folosite doar ca așa-zise valori "hard-codate". From 5a7f0a009c80b438884719922861afa4f1c358c5 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 19:14:12 +0200 Subject: [PATCH 07/31] fix 3-task.md --- 1-js/02-first-steps/04-variables/3-uppercast-constant/task.md | 1 - 1 file changed, 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md index 518c6a010..db3e478a2 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md @@ -21,5 +21,4 @@ const BIRTHDAY = '18.04.1982'; // facem birthday cu majuscule? const AGE = someCode(BIRTHDAY); //facem age cu majuscule? ``` -``` From f41283ae4613d9732865dd8fee1e30e8a74421a0 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 19:54:35 +0200 Subject: [PATCH 08/31] variables --- 1-js/02-first-steps/04-variables/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index c4789a7ad..e6900f79d 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -1,4 +1,4 @@ -# Variabile +`# Variabile În cea mai mare parte a timpului, o aplicație JavaScript are nevoie să lucreze cu informații. Aici sunt două example: 1. Un magazin online -- informația ar putea include bunurile vândute și un coș de cumpărături. From a1b16e31a0138902056f20c3ce1794a581db36ea Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 20:07:13 +0200 Subject: [PATCH 09/31] 1-solution.md --- 1-js/02-first-steps/04-variables/1-hello-variables/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md index 0961c21a1..36cdecae0 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md @@ -1,7 +1,7 @@ În codul următor, fiecare linie corespunde cu obiectul din lista de sarcini. ```js run -let admin, name; // putem declara două variabile deodată +let admin, name; // putem să declarăm două variabile deodată name = "John"; From d8f9162f646786797d8d9966b53d9fc2a035cff8 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 20:10:04 +0200 Subject: [PATCH 10/31] update 1-solution.md per last request --- 1-js/02-first-steps/04-variables/1-hello-variables/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md index 36cdecae0..41690576b 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md @@ -1,4 +1,4 @@ -În codul următor, fiecare linie corespunde cu obiectul din lista de sarcini. +În codul de mai jos, fiecare linie corespunde cu obiectul din lista de sarcini. ```js run let admin, name; // putem să declarăm două variabile deodată From e37acbc14f2abfe14b795bd16e4dc29f8a1d12ed Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 20:11:54 +0200 Subject: [PATCH 11/31] update article.md --- 1-js/02-first-steps/04-variables/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index e6900f79d..f586d23e7 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -18,7 +18,7 @@ Declarația de mai jos crează (în alte cuvinte: *declară*) o variabilă cu nu let message; ``` -Acum, putem pune niște date în ea folosind operatorul de alocare `=`: +Acum, putem pune niște date în aceasta folosind operatorul de alocare `=`: ```js let message; From 425a827766335786241484364a5eaee49a28f537 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 20:17:21 +0200 Subject: [PATCH 12/31] fix line in article.md --- 1-js/02-first-steps/04-variables/article.md | 1 + 1 file changed, 1 insertion(+) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index f586d23e7..d42931f9f 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -70,6 +70,7 @@ let user = 'John', message = 'Bună'; ``` + ...Sau chiar în "prima-virgulă" ca stil: ```js no-beautify From 3ad99765c499d8e576adde5fe783fe73304ebb74 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 20:21:15 +0200 Subject: [PATCH 13/31] fix some lines and typos on article.md --- 1-js/02-first-steps/04-variables/article.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index d42931f9f..91ecd8c28 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -104,6 +104,7 @@ De exemplu, variabila `message` poate fi imaginată drept o cutie cu eticheta `" Putem pune orice valoare în cutie. De asemenaea o putem schimba de câte ori vrem: + ```js run let message; @@ -136,7 +137,7 @@ alert(message); // Bună lume! ``` ````warn header="Declaring twice triggers an error" -O viariabilă ar trebui declarată o singură dată. +O variabilă ar trebui declarată o singură dată. O repetare a declarației a aceleași variabile este o eroare: From 0e335587f3c66950f252db5a2e6adc67af284841 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 20:25:15 +0200 Subject: [PATCH 14/31] fix lines in article.md --- 1-js/02-first-steps/04-variables/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 91ecd8c28..d1bdae757 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -262,7 +262,6 @@ myBirthday = '01.01.2001'; // eroare, nu nputem realoca constanta! Când un programator este sigur că acea variabilă nu se va schimba niciodată, o poate declara folosind `const` pentru a garanta și a comunica clar acest fapt tuturor. - ### Constante cu majuscule Este o practica răspândită de a folosi constante drept așa-zise valori greu de reținut care sunt cunoscute înainte de execuție. @@ -293,6 +292,7 @@ Când ar trebui să folosim majuscule pentru o constantă și când ar trebui s A fi o "constantă" înseamnă doar a fi o valoare a unei variabile care nu se schimbă. Dar există și constante care sunt cunoscute înainte de execuție (ca de exemplu valoarea hexadecimală pentru roșu) și există constante care sunt *calculate* în timpul execuției, dar nu se schimbă după ce sunt alocate inițial. De exemplu: + ```js const pageLoadTime = /* timpul cât durează ca o pagină web să se încarce */; ``` From 7dc624170847c02a6bfd1367f29086fdf3a613b5 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Fri, 2 Dec 2022 21:43:59 +0200 Subject: [PATCH 15/31] fix line in article.md --- 1-js/02-first-steps/04-variables/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index d1bdae757..f4922b3d5 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -64,13 +64,13 @@ let message = 'Bună'; ``` Unele persoane definesc, de asemenea, multiple variabile în acest stil pe mai multe linii: + ```js no-beautify let user = 'John', age = 25, message = 'Bună'; ``` - ...Sau chiar în "prima-virgulă" ca stil: ```js no-beautify @@ -103,7 +103,7 @@ De exemplu, variabila `message` poate fi imaginată drept o cutie cu eticheta `" Putem pune orice valoare în cutie. -De asemenaea o putem schimba de câte ori vrem: +De asemenea o putem schimba de câte ori vrem: ```js run let message; From e44643dca6675d3f70924fc57016ec92000fabe0 Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Sat, 3 Dec 2022 15:53:38 +0200 Subject: [PATCH 16/31] updated --- .../02-first-steps/04-variables/1-hello-variables/solution.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md index 41690576b..9c0166829 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md @@ -1,7 +1,7 @@ -În codul de mai jos, fiecare linie corespunde cu obiectul din lista de sarcini. +În codul de mai jos, fiecare linie corespunde cu articolul din lista de sarcini. ```js run -let admin, name; // putem să declarăm două variabile deodată +let admin, name; // putem declara două variabile deodată name = "John"; From 8af28790b4fe4147365706ecc813a2dbae9938fe Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Sat, 3 Dec 2022 15:56:19 +0200 Subject: [PATCH 17/31] update --- 1-js/02-first-steps/04-variables/1-hello-variables/task.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/task.md b/1-js/02-first-steps/04-variables/1-hello-variables/task.md index 10f9d8b62..cee04415d 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/task.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/task.md @@ -5,6 +5,6 @@ importance: 2 # Lucrând cu variabile 1. Declară două variabile: `admin` și `name`. -2. Atribuie valorii `"John"` valoarea `name`. +2. Atribuie valoarea `"John"` la `name`. 3. Copiază valoarea de la `name` la `admin`. -4. Arată valoarea `admin` folosind `alert` (trebuie să rezulte "John"). +4. Arată valoarea lui `admin` folosind `alert` (trebuie să rezulte "John"). From 206cfbbe361dde17f8920b411fa9ab1d09202e99 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Sat, 3 Dec 2022 20:47:28 +0200 Subject: [PATCH 18/31] declare variables --- .../04-variables/2-declare-variables/solution.md | 6 +++--- .../02-first-steps/04-variables/2-declare-variables/task.md | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md index 58ee7ec79..bbf6739f0 100644 --- a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md +++ b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md @@ -6,7 +6,7 @@ Este simplu: let ourPlanetName = "Earth"; ``` -Ține minte, am putea folosi un nume mai scurt decît `planet`, dar s-ar putea să nu fie evident la ce planetă se referă. E frumos să fim mai verbali. Cel puțin până când variabila nuEstePreaLungă. +Notează, am putea folosi un nume mai scurt decât `planet`, dar s-ar putea să nu fie evident la ce planetă se referă. E frumos să fim mai verbali. Cel puțin până când variabila nuEstePreaLungă. ## Numele vizitatorului curent @@ -16,6 +16,6 @@ let currentUserName = "John"; Din nou, am putea scurta acest `userName` dacă știm sigur că acest utilizator este unul curent. -Editoarele moderne și autocompletarea fac numele lungi de variabile ușor de scris. Nu le salva în ele. Un nume care conține trei cuvinte este în regulă. +Editoarele moderne și autocompletarea fac numele lungi de variabile ușor de scris. Nu economisi la ele. Un nume care conține trei cuvinte este în regulă. -Și dacă editorul tău nu are autocompletare corectă, descarcă [unul nou](/code-editors). +Și dacă editorul tău nu are autocompletare corectă, ia [unul nou](/code-editors). diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/task.md b/1-js/02-first-steps/04-variables/2-declare-variables/task.md index b3e696475..4c718e5e9 100644 --- a/1-js/02-first-steps/04-variables/2-declare-variables/task.md +++ b/1-js/02-first-steps/04-variables/2-declare-variables/task.md @@ -2,7 +2,7 @@ importance: 3 --- -# Creează numele corect +# Dând numele corect 1. Crează o variabilă cu numele planetei noastre. Cum ai numi o astfel de variabilă? 2. Crează o variabilă care să stocheze numele unui vizitator curent al unui website. Cum ai numi o astfel de variabilă? From 947b6d3764bae2dd1872f74b6abd08951ce94fe8 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Sat, 3 Dec 2022 20:58:57 +0200 Subject: [PATCH 19/31] uppercast-constant --- .../04-variables/3-uppercast-constant/solution.md | 4 ++-- 1-js/02-first-steps/04-variables/3-uppercast-constant/task.md | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md index fb84dab16..747e86482 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md @@ -1,5 +1,5 @@ -În general folosim majuscule pentru constante care sunt "hard-codate". Sau, în alte cuvinte, când valoarea se știe înainte de execuție și este scrisă direct în cod. +În general folosim majuscule pentru constante care sunt "hard-coded". Sau, în alte cuvinte, când valoarea este știută înainte de execuție și este scrisă direct în cod. În acest cod, `birthday` este exact la fel. Deci am putea folosi majuscule pentru el. -În contrast, `age` este evaluat în timpul execuției codului. Astăzi avem o vârstă, după un an vom avea o altă vârstă. Este constantă în sensul că nu se schimbă în timpul execuției codului. Dar este puțin "mai puțin constantă" decât `birthday`: este calculată, deci ar trebui să folosim litere mici pentru aceasta. +În contrast, `age` este evaluat la run time. Astăzi avem o vârstă, peste un an vom avea alta. Este constantă în sensul că nu se schimbă pe parcursul execuției codului. Dar este un pic "mai puțin constantă" decât `birthday`: este calculată, deci ar trebui să păstrăm litere mici pentru aceasta. diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md index db3e478a2..2d224570e 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md @@ -17,8 +17,8 @@ Aici avem o constantă `birthday` dată și `age` este calculat din `birthday` Ar fi corect să folosim majuscule pentru `birthday`? Pentru `age`? Sau chiar pentru amândouă? ```js -const BIRTHDAY = '18.04.1982'; // facem birthday cu majuscule? +const BIRTHDAY = '18.04.1982'; // facem cu majuscule? -const AGE = someCode(BIRTHDAY); //facem age cu majuscule? +const AGE = someCode(BIRTHDAY); //facem cu majuscule? ``` From cea67dfd99b89e477be25f5515b6b3bb7fa5f893 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Sat, 3 Dec 2022 21:09:04 +0200 Subject: [PATCH 20/31] article.md --- 1-js/02-first-steps/04-variables/article.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index f4922b3d5..3251432b4 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -1,4 +1,4 @@ -`# Variabile +# Variabile În cea mai mare parte a timpului, o aplicație JavaScript are nevoie să lucreze cu informații. Aici sunt două example: 1. Un magazin online -- informația ar putea include bunurile vândute și un coș de cumpărături. @@ -53,7 +53,7 @@ De asemenea putem declara multiple variabile într-o singură linie: let user = 'John', age = 25, message = 'Bună'; ``` -Asta ar putea să apară mai scurt, dar nu recomandăm. De dragul unei lizibilități mai bune, te rugăm să folosești o singură linie de variabilă. +Asta ar putea să pară mai scurt, dar nu recomandăm. De dragul unei lizibilități mai bune, te rugăm să folosești o singură linie per variabilă. Varianta pe mai multe linii este puțin mai lungă, dar mai ușor de citit: @@ -122,7 +122,7 @@ Când valoarea este schimbată, data veche este stearsă din variabilă: De asemenea putem declara două variabile și copia datele din una în cealaltă.. ```js run -let hello = ''Buna lume!!'; +let hello = ''Bună lume!!'; let message; @@ -174,23 +174,23 @@ let test123; Când numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este folosit adesea. Acesta este: cuvintele vin unul după celălalt, fiecare cuvânt exceptând primul care începe cu majusculă: `numeleMeuFoarteLung`. -Ceea ce este interesant -- semnul de dolar `'$'` și bară jos `'_'` pot fi de asemenea folosite în nume. Acestea sunt simboluri obișnuite, la fel ca și literele, fără însemnătate specială. +Ceea ce este interesant -- semnul de dolar `'$'` și bara jos `'_'` pot fi de asemenea folosite în nume. Acestea sunt simboluri obișnuite, la fel ca și literele, fără însemnătate specială. Aceste nume sunt valide: ```js run untrusted -let $ = 1; // declarăm o variabilă cu numele "$" +let $ = 1; // a declarat o variabilă cu numele "$" let _ = 2; // și apoi o variabilă cu numele "_" alert($ + _); // 3 ``` -Examples of incorrect variable names: +Example de nume de variabile greșite: ```js no-beautify let 1a; // nu poate începe cu o cifră -let my-name; // și apoi o variabilă cu numele "_" +let my-name; // liniuțele '-' nu sunt permise în nume ``` ```smart header="Case matters" @@ -294,7 +294,7 @@ A fi o "constantă" înseamnă doar a fi o valoare a unei variabile care nu se s De exemplu: ```js -const pageLoadTime = /* timpul cât durează ca o pagină web să se încarce */; +const pageLoadTime = /* durata timpului de încărcare a unei pagini web */; ``` Valoarea lui `pageLoadTime` nu este cunoscută înainte ca pagina să se încarce, astfel că este denumită obișnuit. Dar este totuși o constantă pentru că nu se schimbă după ce este alocată. @@ -325,13 +325,13 @@ Sună simplu? Chiar este, dar crearea de variabile descriptive și concise în p ```smart header="Reuse or create?" Și ultima notă. Există programatori leneși care, în loc să declare variabile noi, încearcă să le reutilizeze pe cele deja existente. -Drept rezultat, variabilele lor sunt ca niște cutii în care oamenii aruncă diferite lucruri fără să schimbe etichetele. Ce este înăuntrul cutiei acum? Cine știe? Trebuie să ne apropiem și să vedem. +Drept rezultat, variabilele lor sunt ca niște cutii în care oamenii aruncă diferite lucruri fără să schimbe etichetele. Ce este înăuntrul cutiei acum? Cine știe? Trebuie să ne apropiem și să verificăm. Astfel de programatori salvează puțin din declararea variabilelor dar pierd de zece ori mai mult să remedieze erorile. O variabilă în plus este bună, nu rea. -Limbajul JavaScript modern micșorează și browserele optimizează codul destul de bine, deci nu vom crea probleme de performanță. Folosind diferite variabile pentru diferite valori putem chiar ajuta ca motorul să îți optimizeze codul. +Minificatoarele și browserele moderne de JavaScript optimizează codul suficient de bine, astfel încât să nu creeze probleme de performanță. Folosirea unor variabile diferite pentru valori diferite poate chiar ajuta motorul să vă optimizeze codul. ``` ## Sumar From 80bea6d8e763b03111343735a1f70b0f91435503 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Sat, 3 Dec 2022 21:12:51 +0200 Subject: [PATCH 21/31] article.md --- 1-js/02-first-steps/04-variables/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 3251432b4..a6500aca4 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -133,7 +133,7 @@ message = hello; // acum cele două variabile conțin aceleași date alert(hello); // Bună lume! -alert(message); // Bună lume! +alert(message); // Bună ziua lume! ``` ````warn header="Declaring twice triggers an error" @@ -145,7 +145,7 @@ O repetare a declarației a aceleași variabile este o eroare: let message = "Acesta"; // 'let' repetat duce la o eroare -let message = "Acesta"; // SyntaxError: 'message' a fost deja declarat +let message = "Acesta"; // SyntaxError: 'message' has already been declared ``` Deci, ar trebui să declarăm o variabilă o dată și apoi să ne referim la aceasta fără `let`. ```` From 7fe85d0d90f3cd1bf1bef1304d448cc46ce2bc71 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Sat, 3 Dec 2022 21:33:32 +0200 Subject: [PATCH 22/31] article.md --- 1-js/02-first-steps/04-variables/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index a6500aca4..938278d2b 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -132,7 +132,7 @@ message = hello; */!* // acum cele două variabile conțin aceleași date -alert(hello); // Bună lume! +alert(hello); // Bună ziua lume! alert(message); // Bună ziua lume! ``` From 215e676efb71511ac6ea1e017659d6e4f589a0d8 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Mon, 5 Dec 2022 22:06:59 +0200 Subject: [PATCH 23/31] article.md --- 1-js/02-first-steps/04-variables/article.md | 54 ++++++++++----------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 938278d2b..136718f0f 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -63,7 +63,7 @@ let age = 25; let message = 'Bună'; ``` -Unele persoane definesc, de asemenea, multiple variabile în acest stil pe mai multe linii: +Unele persoane definesc de asemenea multiple variabile în acest stil pe mai multe linii: ```js no-beautify let user = 'John', @@ -71,7 +71,7 @@ let user = 'John', message = 'Bună'; ``` -...Sau chiar în "prima-virgulă" ca stil: +...Sau chiar în stilul "virgulă-înainte": ```js no-beautify let user = 'John' @@ -82,15 +82,15 @@ let user = 'John' Technic, toate aceste variante fac același lucru. Deci, este o problemă de preferință personală și de estetică.. ````smart header="`var` instead of `let`" -În transcrieri mai vechi, ai putea găsi de asemenea un alt termen: `var` în loc de `let`: +În scripturi mai vechi, ai putea găsi de asemenea un alt cuvânt cheie: `var` în loc de `let`: ```js *!*var*/!* message = 'Bună'; ``` -Termenul `var` este *aproape* la fel ca și `let`. Declară de asemenea o variabilă, dar într-un mod ușor diferit, de "școală-veche". +Termenul `var` este *aproape* la fel ca și `let`. El declară de asemenea o variabilă, dar într-un mod ușor diferit, de "școală-veche". -Există diferențe subtile între `let` și `var`, dar nu contează pentru noi acum. O să le acoperim în detaliu în capitolul . +Există diferențe subtile între `let` și `var`, dar nu contează pentru noi încă. O să le acoperim în detaliu în capitolul . ```` ## O analogie din viața reală @@ -127,11 +127,11 @@ let hello = ''Bună lume!!'; let message; *!* -// copiază 'Bună lume' din bună în mesaj +// copiază 'Bună lume' din bună în message message = hello; */!* -// acum cele două variabile conțin aceleași date +// acum două variabile conțin aceleași date alert(hello); // Bună ziua lume! alert(message); // Bună ziua lume! ``` @@ -139,7 +139,7 @@ alert(message); // Bună ziua lume! ````warn header="Declaring twice triggers an error" O variabilă ar trebui declarată o singură dată. -O repetare a declarației a aceleași variabile este o eroare: +O declarație repetată a aceleiași variabile este o eroare: ```js run let message = "Acesta"; @@ -151,7 +151,7 @@ Deci, ar trebui să declarăm o variabilă o dată și apoi să ne referim la ac ```` ```smart header="Functional languages" -Este interesant de notat dacă acolo există acele numite [funcțional pure](https://en.wikipedia.org/wiki/Purely_functional_programming) limbaje de programare, cum ar fi [Haskell](https://en.wikipedia.org/wiki/Haskell), care interzic schimbarea valorii variabilelor. +Este interesant de notat dacă acolo există așa-numitele [funcțional pure](https://en.wikipedia.org/wiki/Purely_functional_programming) limbaje de programare, cum ar fi [Haskell](https://en.wikipedia.org/wiki/Haskell), care interzic schimbarea valorii variabilelor. În limbaje ca acestea, odată ce valoarea este stocată "în cutie", există acolo pentru totdeauna. Dacă avem nevoie să stocăm altceva, limbajul ne forțează să creăm o nouă cutie (declarăm o nouă variabilă). Nu o putem refolosi pe cea veche. @@ -180,7 +180,7 @@ Aceste nume sunt valide: ```js run untrusted let $ = 1; // a declarat o variabilă cu numele "$" -let _ = 2; // și apoi o variabilă cu numele "_" +let _ = 2; // și acum o variabilă cu numele "_" alert($ + _); // 3 ``` @@ -205,7 +205,7 @@ let имя = '...'; let 我 = '...'; ``` -Technic, aici nu este nicio greșeală. Astfel de nume sunt permise, dar există o convenție internațională de a folosi limba engleză în denumirile variabilelor. Chiar dacă sunt scrise cu litere mici, pot avea viață lungă. Oamenii din alte țări ar putea avea nevoie să le citescă uneori. +Technic, aici nu este nicio eroare. Astfel de nume sunt permise, dar există o convenție internațională de a folosi limba engleză în denumirile variabilelor. Chiar dacă scriem un script mic, poate avea viață lungă. Oamenii din alte țări ar putea avea nevoie să le citescă uneori. ```` ````warn header="Reserved names" @@ -223,7 +223,7 @@ let return = 5; // de asemenea nu o putem numi "return", eroare! ````warn header="An assignment without `use strict`" -În mod normal, avem nevoie să definim o variabilă înainte să o folosim. Dar în timpurile vechi, era technic posibil să creezi o variabilă prin simpla alocare a unei valori fără a folosi `let`. Acesta încă funcționează acum dacă nu punem `use strict` în textul nostru pentru a menține compatibilitatea cu textele vechi. +În mod normal, avem nevoie să definim o variabilă înainte să o folosim. Dar în timpurile vechi, era technic posibil să creezi o variabilă prin simpla alocare a unei valori fără a folosi `let`. Acesta încă funcționează acum dacă nu punem `use strict` în scriptul nostru pentru a menține compatibilitatea cu scripturile vechi. ```js run no-strict // notă: nu există "use strict" în acest exemplu @@ -257,7 +257,7 @@ Variabilele declarate folosind `const` se numesc "constante". Ele nu pot fi real ```js run const myBirthday = '18.04.1982'; -myBirthday = '01.01.2001'; // eroare, nu nputem realoca constanta! +myBirthday = '01.01.2001'; // eroare, nu putem realoca constanta! ``` Când un programator este sigur că acea variabilă nu se va schimba niciodată, o poate declara folosind `const` pentru a garanta și a comunica clar acest fapt tuturor. @@ -284,8 +284,8 @@ alert(color); // #FF7F00 Beneficii: - `COLOR_ORANGE` este mai ușor de reținut decât `"#FF7F00"`. -- Este mai ușor de greșit `"#FF7F00"` decât `COLOR_ORANGE`. -- Când citim codul, `COLOR_ORANGE` are o mai mmare însemnătate `#FF7F00`. +- Este mai ușor de scris greșit `"#FF7F00"` decât `COLOR_ORANGE`. +- Când citim codul, `COLOR_ORANGE` are o însemnătate mai mare decât `#FF7F00`. Când ar trebui să folosim majuscule pentru o constantă și când ar trebui să o denumim în mod obișnuit? Haideți să clarificăm acest lucru. @@ -299,47 +299,47 @@ const pageLoadTime = /* durata timpului de încărcare a unei pagini web */; Valoarea lui `pageLoadTime` nu este cunoscută înainte ca pagina să se încarce, astfel că este denumită obișnuit. Dar este totuși o constantă pentru că nu se schimbă după ce este alocată. -În alte cuvinte, constantele cu majuscule sunt folosite doar ca așa-zise valori "hard-codate". +În alte cuvinte, constantele cu majuscule sunt folosite doar ca așa-zise valori "hard-coded". ## Denumirea corectă a lucrurilor -Vorbind despre variabile, există un lucru extrem de important. +Vorbind despre variabile, mai este un lucru extrem de important. -Numele unei variabile ar trebui să aibă o denumire clară, o denumire evidentă, care descrie data stocată. +Numele unei variabile trebuie să aibă o semnificație clară, evidentă, care să descrie datele pe care le stochează. -Denumirea variabilelor este una dintre cele mai importante și complexe abilități în programare. La prima vedere numele unei variabile poate dezvălui dacă codul a fost scris de un începător sau de un programator cu experiență. +Numirea variabilelor este una dintre cele mai importante și mai complexe abilități în programare. O privire rapidă asupra numelor variabilelor poate dezvălui ce cod a fost scris de un începător față de un programator experimentat. -Într-un proiect real, cel mai mult timp este petrecut modificând și extinzând o bază de cod existentă mai mult decât a scrie ceva complet separat de la început. Când ne reîntoarcem la cod după ce am făcut altceva pentru un timp, este mult mai ușor să găsim informația care este bine etichetată. Sau, în alte cuvinte, când variabilele au o denumire bună. +Într-un proiect real, cea mai mare parte a timpului se petrece modificând și extinzând o bază de cod existentă, mai degrabă decât scriind ceva complet separat de la zero. Atunci când ne întoarcem la un cod după ce am făcut altceva pentru o vreme, este mult mai ușor să găsim informații care sunt bine etichetate. Sau, cu alte cuvinte, când variabilele au nume bune. Te rog petrece timp gândindu-te la denumirea corectă pentru o variabilă înainte să o declari. Făcând acest lucru te răsplătești frumos. -Câteva reguli bune de urmat: +Câteva reguli bune de urmat sunt: - Folosește nume uman-reproductibile ca `userName` sau `shoppingCart`. -- Stai departe de abrevieri sau nume scurte ca `a`, `b`, `c`, dacă nu știi exact ceea ce faci. -- Fă numele extrem de descriptiv și concis. Exemple de denumiri proaste sunt `data` și `value`. Aceste denumiri nu reprezintă nimic. Este în regulă să le folosim dacă contextul codului le face excepțional de evidente la care dată sau valoare variabila se referă. +- Stai departe de abrevieri sau nume scurte ca `a`, `b`, `c`, decât dacă știi cu adevărat ceea ce faci. +- Fă Fă ca numele să fie cât mai descriptiv și concis. Exemple de nume proaste sunt `data` și `value`. Astfel de nume nu spun nimic. Este în regulă să le folosiți doar dacă contextul codului face extrem de evident la ce date sau valoare face referire variabila. - Pune-te de acord cu echipa și ține minte. Dacă vizitatorul unui site este denumit ca "user" atunci ar trebui ca numele variabilelor legate să fie `currentUser` sau `newUser` în loc de `currentVisitor` sau `newManInTown`. Sună simplu? Chiar este, dar crearea de variabile descriptive și concise în practică nu este. Încearcă. ```smart header="Reuse or create?" -Și ultima notă. Există programatori leneși care, în loc să declare variabile noi, încearcă să le reutilizeze pe cele deja existente. +Și ultima notă. Există programatori leneși care, în loc să declare variabile noi, tind să le reutilizeze pe cele deja existente. Drept rezultat, variabilele lor sunt ca niște cutii în care oamenii aruncă diferite lucruri fără să schimbe etichetele. Ce este înăuntrul cutiei acum? Cine știe? Trebuie să ne apropiem și să verificăm. Astfel de programatori salvează puțin din declararea variabilelor dar pierd de zece ori mai mult să remedieze erorile. -O variabilă în plus este bună, nu rea. +O variabilă extra este bună, nu rea. Minificatoarele și browserele moderne de JavaScript optimizează codul suficient de bine, astfel încât să nu creeze probleme de performanță. Folosirea unor variabile diferite pentru valori diferite poate chiar ajuta motorul să vă optimizeze codul. ``` ## Sumar -Putem declara variabile pentru a stoca date folosind `var`, `let`, sau termenul `const`. +Putem declara variabile pentru a stoca date folosind `var`, `let`, sau cuvântul cheie `const`. - `let` -- este o declarație modernă de variabilă. - `var` -- este o declarație de variabilă de "școală-veche". În mod normal nu o mai folosim deloc, dar o să acoperim diferențele subtile față de `let` în capitolul , în cazul în care ai nevoie de ele. - `const` -- este la fel ca `let`, doar că valoarea variabilei nu se poate schimba. -Variabilele ar trebui denumite în așa natură încât să înțelegem ușor ce se află înăuntrul lor. +Variabilele ar trebui să fie denumite într-un mod care să ne permită să înțelegem cu ușurință ce se află în ele. From 6d5f95606e11eb83164e35a4d18fe907d1ed0992 Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Mon, 5 Dec 2022 22:12:58 +0200 Subject: [PATCH 24/31] article.md --- 1-js/02-first-steps/04-variables/article.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 136718f0f..98954cb36 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -8,9 +8,9 @@ Variabilele sunt folosite pentru a stoca această informație. ## O variabilă -O [variabilă](https://en.wikipedia.org/wiki/Variable_(computer_science)) este un "spațiu de stocare numit" pentru date. Putem folosi variabile pentru a stoca bunuri, visitatori, și alte date. +O [variabilă](https://en.wikipedia.org/wiki/Variable_(computer_science)) este un "spațiu de stocare numit" pentru date. Putem folosi variabile pentru a stoca bunuri, vizitatori, și alte date. -Pentru a crea o variabilă în JavaScript, folosim termenul`let` . +Pentru a crea o variabilă în JavaScript, folosim cuvântul cheie `let` . Declarația de mai jos crează (în alte cuvinte: *declară*) o variabilă cu numele "message": @@ -42,7 +42,7 @@ alert(message); // arată conținutul variabilei Ca să fim conciși, putem să combinăm declarația variabilei și desemnarea ei într-o singură linie: ```js run -let message = 'Bună!'; // definește variabila și îi asignează valoarea +let message = 'Bună!'; // definește variabila și îi atribuie valoarea alert(message); // Bună! ``` @@ -122,7 +122,7 @@ Când valoarea este schimbată, data veche este stearsă din variabilă: De asemenea putem declara două variabile și copia datele din una în cealaltă.. ```js run -let hello = ''Bună lume!!'; +let hello = 'Bună lume!'; let message; From e60bf8f361227840cbef4b720d5e2b78447005fb Mon Sep 17 00:00:00 2001 From: Alexandra2888 Date: Mon, 5 Dec 2022 22:14:36 +0200 Subject: [PATCH 25/31] svg --- 1-js/02-first-steps/04-variables/variable-change.svg | 2 +- 1-js/02-first-steps/04-variables/variable.svg | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/variable-change.svg b/1-js/02-first-steps/04-variables/variable-change.svg index 603a878d4..d5f208427 100644 --- a/1-js/02-first-steps/04-variables/variable-change.svg +++ b/1-js/02-first-steps/04-variables/variable-change.svg @@ -1,2 +1,2 @@ "Lume!""Bună -!"mesaj \ No newline at end of file +!"message \ No newline at end of file diff --git a/1-js/02-first-steps/04-variables/variable.svg b/1-js/02-first-steps/04-variables/variable.svg index b0b29419d..5dcfaf8c4 100644 --- a/1-js/02-first-steps/04-variables/variable.svg +++ b/1-js/02-first-steps/04-variables/variable.svg @@ -1 +1 @@ -"Bună!"mesaj \ No newline at end of file +"Bună!"message \ No newline at end of file From 36095550c24c9ed968473c32438e3b8a52a1c410 Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Tue, 6 Dec 2022 10:11:34 +0200 Subject: [PATCH 26/31] final polish Translated smart headers and other minor improvements. --- 1-js/02-first-steps/04-variables/article.md | 50 ++++++++++----------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md index 98954cb36..765886de6 100644 --- a/1-js/02-first-steps/04-variables/article.md +++ b/1-js/02-first-steps/04-variables/article.md @@ -53,7 +53,7 @@ De asemenea putem declara multiple variabile într-o singură linie: let user = 'John', age = 25, message = 'Bună'; ``` -Asta ar putea să pară mai scurt, dar nu recomandăm. De dragul unei lizibilități mai bune, te rugăm să folosești o singură linie per variabilă. +Asta ar putea să pară mai scurt, dar nu o recomandăm. De dragul unei lizibilități mai bune, te rugăm să folosești o singură linie per variabilă. Varianta pe mai multe linii este puțin mai lungă, dar mai ușor de citit: @@ -63,7 +63,7 @@ let age = 25; let message = 'Bună'; ``` -Unele persoane definesc de asemenea multiple variabile în acest stil pe mai multe linii: +Unele persoane definesc de asemenea multiple variabile în acest stil multiliniar: ```js no-beautify let user = 'John', @@ -81,7 +81,7 @@ let user = 'John' Technic, toate aceste variante fac același lucru. Deci, este o problemă de preferință personală și de estetică.. -````smart header="`var` instead of `let`" +````smart header="`var` în loc de `let`" În scripturi mai vechi, ai putea găsi de asemenea un alt cuvânt cheie: `var` în loc de `let`: ```js @@ -132,14 +132,14 @@ message = hello; */!* // acum două variabile conțin aceleași date -alert(hello); // Bună ziua lume! -alert(message); // Bună ziua lume! +alert(hello); // Bună lume!! +alert(message); // Bună lume! ``` -````warn header="Declaring twice triggers an error" +````warn header="Declararea de două ori declanșează o eroare" O variabilă ar trebui declarată o singură dată. -O declarație repetată a aceleiași variabile este o eroare: +O declarație repetată a aceleiași variabile este o eroare: ```js run let message = "Acesta"; @@ -150,15 +150,15 @@ let message = "Acesta"; // SyntaxError: 'message' has already been declared Deci, ar trebui să declarăm o variabilă o dată și apoi să ne referim la aceasta fără `let`. ```` -```smart header="Functional languages" -Este interesant de notat dacă acolo există așa-numitele [funcțional pure](https://en.wikipedia.org/wiki/Purely_functional_programming) limbaje de programare, cum ar fi [Haskell](https://en.wikipedia.org/wiki/Haskell), care interzic schimbarea valorii variabilelor. +```smart header="Limbaje funcționale" +Este interesant de notat că există așa-numitele limbaje de programare [pur funcționale](https://en.wikipedia.org/wiki/Purely_functional_programming), cum ar fi [Haskell](https://en.wikipedia.org/wiki/Haskell), care interzic schimbarea valorii variabilelor. În limbaje ca acestea, odată ce valoarea este stocată "în cutie", există acolo pentru totdeauna. Dacă avem nevoie să stocăm altceva, limbajul ne forțează să creăm o nouă cutie (declarăm o nouă variabilă). Nu o putem refolosi pe cea veche. Deși pare un pic ciudat la prima vedere, aceste limbaje sunt destul de capabile de dezvoltare serioasă. Mai mult decât atât, sunt zone ca de exemplu calcule paralele unde această limitare conferă beneficii sigure. ``` -## Denumirea variabilelor [#variable-naming] +## Denumirea variabilelor [#variable-naming] Există două limitări în denumirea variabilelor în JavaScript: @@ -172,7 +172,7 @@ let userName; let test123; ``` -Când numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este folosit adesea. Acesta este: cuvintele vin unul după celălalt, fiecare cuvânt exceptând primul care începe cu majusculă: `numeleMeuFoarteLung`. +Când numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este adesea folosit. Adică: cuvintele vin unul după celălalt, fiecare cuvânt cu excepția celui dintâi începe cu majusculă: `numeleMeuFoarteLung`. Ceea ce este interesant -- semnul de dolar `'$'` și bara jos `'_'` pot fi de asemenea folosite în nume. Acestea sunt simboluri obișnuite, la fel ca și literele, fără însemnătate specială. @@ -185,7 +185,7 @@ let _ = 2; // și acum o variabilă cu numele "_" alert($ + _); // 3 ``` -Example de nume de variabile greșite: +Example de nume de variabile incorecte: ```js no-beautify let 1a; // nu poate începe cu o cifră @@ -193,12 +193,12 @@ let 1a; // nu poate începe cu o cifră let my-name; // liniuțele '-' nu sunt permise în nume ``` -```smart header="Case matters" +```smart header="Uscula contează" Variabilele numite `apple` și `APPLE` sunt două variabile diferite. ``` -````smart header="Non-Latin letters are allowed, but not recommended" -Este posibil să folosim orice limbă, inclusiv litere chirilice, caractere chinezești și altele, precum acestea: +````smart header="Literele non-latine sunt permise, dar nu sunt recomandate" +Este posibil să folosim orice limbă, inclusiv litere chirilice, caractere chinezești și așa mai departe, precum acestea: ```js let имя = '...'; @@ -208,10 +208,10 @@ let 我 = '...'; Technic, aici nu este nicio eroare. Astfel de nume sunt permise, dar există o convenție internațională de a folosi limba engleză în denumirile variabilelor. Chiar dacă scriem un script mic, poate avea viață lungă. Oamenii din alte țări ar putea avea nevoie să le citescă uneori. ```` -````warn header="Reserved names" +````warn header="Nume rezervate" Există o [listă de cuvinte rezervate](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), care nu poate fi folostă ca nume de variabile pentru că sunt folosite de către limbajul însuși. -De exemplu: `let`, `class`, `return`, and `function` sunt rezervate.. +De exemplu: `let`, `class`, `return`, și `function` sunt rezervate.. Codul următor dă eroare de sintaxă: @@ -221,12 +221,12 @@ let return = 5; // de asemenea nu o putem numi "return", eroare! ``` ```` -````warn header="An assignment without `use strict`" +````warn header="O atribuire fără `use strict`" În mod normal, avem nevoie să definim o variabilă înainte să o folosim. Dar în timpurile vechi, era technic posibil să creezi o variabilă prin simpla alocare a unei valori fără a folosi `let`. Acesta încă funcționează acum dacă nu punem `use strict` în scriptul nostru pentru a menține compatibilitatea cu scripturile vechi. ```js run no-strict -// notă: nu există "use strict" în acest exemplu +// notă: fără "use strict" în acest exemplu num = 5; // variabila "num" este creată chiar dacă nu există @@ -283,18 +283,18 @@ alert(color); // #FF7F00 Beneficii: -- `COLOR_ORANGE` este mai ușor de reținut decât `"#FF7F00"`. -- Este mai ușor de scris greșit `"#FF7F00"` decât `COLOR_ORANGE`. +- `COLOR_ORANGE` este mai ușor de reținut decât `"#FF7F00"`. +- Este mult mai ușor de scris greșit `"#FF7F00"` decât `COLOR_ORANGE`. - Când citim codul, `COLOR_ORANGE` are o însemnătate mai mare decât `#FF7F00`. -Când ar trebui să folosim majuscule pentru o constantă și când ar trebui să o denumim în mod obișnuit? Haideți să clarificăm acest lucru. +Când ar trebui să folosim majuscule pentru o constantă și când ar trebui să o denumim în mod obișnuit? Haideți să clarificăm asta. A fi o "constantă" înseamnă doar a fi o valoare a unei variabile care nu se schimbă. Dar există și constante care sunt cunoscute înainte de execuție (ca de exemplu valoarea hexadecimală pentru roșu) și există constante care sunt *calculate* în timpul execuției, dar nu se schimbă după ce sunt alocate inițial. De exemplu: ```js -const pageLoadTime = /* durata timpului de încărcare a unei pagini web */; +const pageLoadTime = /* durata timpului de încărcare a unei pagini web */; ``` Valoarea lui `pageLoadTime` nu este cunoscută înainte ca pagina să se încarce, astfel că este denumită obișnuit. Dar este totuși o constantă pentru că nu se schimbă după ce este alocată. @@ -322,7 +322,7 @@ Câteva reguli bune de urmat sunt: Sună simplu? Chiar este, dar crearea de variabile descriptive și concise în practică nu este. Încearcă. -```smart header="Reuse or create?" +```smart header="Reutilizare sau creare?" Și ultima notă. Există programatori leneși care, în loc să declare variabile noi, tind să le reutilizeze pe cele deja existente. Drept rezultat, variabilele lor sunt ca niște cutii în care oamenii aruncă diferite lucruri fără să schimbe etichetele. Ce este înăuntrul cutiei acum? Cine știe? Trebuie să ne apropiem și să verificăm. @@ -339,7 +339,7 @@ Minificatoarele și browserele moderne de JavaScript optimizează codul suficien Putem declara variabile pentru a stoca date folosind `var`, `let`, sau cuvântul cheie `const`. - `let` -- este o declarație modernă de variabilă. -- `var` -- este o declarație de variabilă de "școală-veche". În mod normal nu o mai folosim deloc, dar o să acoperim diferențele subtile față de `let` în capitolul , în cazul în care ai nevoie de ele. +- `var` -- este o declarație de variabilă de "școală-veche". În mod normal nu o mai folosim deloc, dar o să acoperim diferențele subtile față de `let` în capitolul , doar în cazul în care ai nevoie de ele. - `const` -- este la fel ca `let`, doar că valoarea variabilei nu se poate schimba. Variabilele ar trebui să fie denumite într-un mod care să ne permită să înțelegem cu ușurință ce se află în ele. From 0832fdf2ed8794b5dfeb7ebb87c65f3446528509 Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Tue, 6 Dec 2022 10:12:27 +0200 Subject: [PATCH 27/31] minor fix --- 1-js/02-first-steps/04-variables/variable-change.svg | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/variable-change.svg b/1-js/02-first-steps/04-variables/variable-change.svg index d5f208427..ed9d1062e 100644 --- a/1-js/02-first-steps/04-variables/variable-change.svg +++ b/1-js/02-first-steps/04-variables/variable-change.svg @@ -1,2 +1 @@ -"Lume!""Bună -!"message \ No newline at end of file +"Lume!""Bună!"message From 13da2ca88379954bacf92cb74d3059f017c0021d Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Tue, 6 Dec 2022 10:18:14 +0200 Subject: [PATCH 28/31] sync main synced with main repo and translated --- .../04-variables/3-uppercast-constant/task.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md index 2d224570e..66281b555 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md @@ -12,13 +12,15 @@ const birthday = '18.04.1982'; const age = someCode(birthday); ``` -Aici avem o constantă `birthday` dată și `age` este calculat din `birthday` cu ajutorul codului (nu este redat aici pentru a scurta, și pentru că detaliile nu contează aici). +Aici avem o constantă `birthday` pentru dată, și de asemenea constanta `age`. -Ar fi corect să folosim majuscule pentru `birthday`? Pentru `age`? Sau chiar pentru amândouă? +`age` este calculată din `birthday` folosind `someCode()`, ceea ce înseamnă un apel de funcție pe care nu l-am explicat încă (o vom face în curând!), dar detaliile nu contează aici, ideea este că `age` este calculată cumva pe baza `birthday`. + +Ar fi corect să folosim majuscule pentru `birthday`? Pentru `age`? Sau chiar pentru ambele? ```js -const BIRTHDAY = '18.04.1982'; // facem cu majuscule? +const BIRTHDAY = '18.04.1982'; // facem BIRTHDAY cu majuscule? -const AGE = someCode(BIRTHDAY); //facem cu majuscule? +const AGE = someCode(BIRTHDAY); // facem AGE cu majuscule? ``` From e9dcaf333af90f1b9a0ee300964c171655ac1867 Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Tue, 6 Dec 2022 10:20:40 +0200 Subject: [PATCH 29/31] minor improvement --- 1-js/02-first-steps/04-variables/1-hello-variables/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/task.md b/1-js/02-first-steps/04-variables/1-hello-variables/task.md index cee04415d..b17adfead 100644 --- a/1-js/02-first-steps/04-variables/1-hello-variables/task.md +++ b/1-js/02-first-steps/04-variables/1-hello-variables/task.md @@ -7,4 +7,4 @@ importance: 2 1. Declară două variabile: `admin` și `name`. 2. Atribuie valoarea `"John"` la `name`. 3. Copiază valoarea de la `name` la `admin`. -4. Arată valoarea lui `admin` folosind `alert` (trebuie să rezulte "John"). +4. Arată valoarea lui `admin` folosind `alert` (trebuie să iasă "John"). From 873c53fb1caffa24b2fbe6fab96780e160ec3e98 Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Tue, 6 Dec 2022 10:23:05 +0200 Subject: [PATCH 30/31] minor update --- .../04-variables/2-declare-variables/solution.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md index bbf6739f0..3b22bdbe3 100644 --- a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md +++ b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md @@ -1,9 +1,9 @@ -## Variabilele pentru planeta noastră +## Variabila pentru planeta noastră Este simplu: ```js -let ourPlanetName = "Earth"; +let ourPlanetName = "Pământ"; ``` Notează, am putea folosi un nume mai scurt decât `planet`, dar s-ar putea să nu fie evident la ce planetă se referă. E frumos să fim mai verbali. Cel puțin până când variabila nuEstePreaLungă. From 14c9aa45ff789c76c6d85a9b69f93374227d6c9b Mon Sep 17 00:00:00 2001 From: Bogdan Bacosca Date: Tue, 6 Dec 2022 10:25:53 +0200 Subject: [PATCH 31/31] minor update --- .../04-variables/3-uppercast-constant/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md index 747e86482..973a049ec 100644 --- a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md +++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md @@ -2,4 +2,4 @@ În acest cod, `birthday` este exact la fel. Deci am putea folosi majuscule pentru el. -În contrast, `age` este evaluat la run time. Astăzi avem o vârstă, peste un an vom avea alta. Este constantă în sensul că nu se schimbă pe parcursul execuției codului. Dar este un pic "mai puțin constantă" decât `birthday`: este calculată, deci ar trebui să păstrăm litere mici pentru aceasta. +În contrast, `age` evaluat în timpul execuției. Astăzi avem o vârstă, peste un an vom avea alta. Este constantă în sensul că nu se schimbă pe parcursul execuției codului. Dar este un pic "mai puțin constantă" decât `birthday`: este calculată, deci ar trebui să păstrăm minuscule pentru aceasta.