git-manpages-l 10n - en to ro translation catalogue (372 entries)

note: type: Title -
en: DATE FORMATS
ro: FORMATE DE DATE

note: type: Plain text
en: The `GIT_AUTHOR_DATE` and `GIT_COMMITTER_DATE` environment variables support the following date formats:
ro: Variabilele de mediu `GIT_AUTHOR_DATE` și `GIT_COMMITTER_DATE` acceptă următoarele formate de date:

note: type: Labeled list
en: Git internal format
ro: Formatul intern Git

note: type: Plain text
en: It is `<unix timestamp> <time zone offset>`, where `<unix timestamp>` is the number of seconds since the UNIX epoch.  `<time zone offset>` is a positive or negative offset from UTC.  For example CET (which is 1 hour ahead of UTC) is `+0100`.
ro: Este `<<unix timestamp> <depășirea zonei de timp>`, unde `<unix timestamp>` este numărul de secunde de la epoca UNIX.  `<depășirea zonei de timp>` este o decalare pozitivă sau negativă față de UTC.  De exemplu, CET (care este cu o oră înainte de UTC) este `+0100`.

note: type: Plain text
en: The standard email format as described by RFC 2822, for example `Thu, 07 Apr 2005 22:13:13 +0200`.
ro: Formatul standard de e-mail descris în RFC 2822, de exemplu `Thu, 07 Apr 2005 22:13:13:13 +0200`.

note: type: Plain text
en: Time and date specified by the ISO 8601 standard, for example `2005-04-07T22:13:13`. The parser accepts a space instead of the `T` character as well. Fractional parts of a second will be ignored, for example `2005-04-07T22:13:13.019` will be treated as `2005-04-07T22:13:13`.
ro: Ora și data specificate de standardul ISO 8601, de exemplu `2005-04-07T22:13:13`. Analizatorul acceptă, de asemenea, un spațiu în locul caracterului `T`. Părțile fracționare de secundă vor fi ignorate, de exemplu `2005-04-07T22:13:13:13.019` va fi tratat ca `2005-04-07T22:13:13:13`.

note: type: Plain text
en: In addition, the date part is accepted in the following formats: `YYYY.MM.DD`, `MM/DD/YYYY` and `DD.MM.YYYY`.
ro: În plus, partea referitoare la dată este acceptată în următoarele formate: `YYYY.MM.DD`, `MM/DD/YYYYYY` și `DD.MM.YYYY`.

note: type: Plain text
en: In addition to recognizing all date formats above, the `--date` option will also try to make sense of other, more human-centric date formats, such as relative dates like "yesterday" or "last Friday at noon".
ro: În plus față de recunoașterea tuturor formatelor de date de mai sus, opțiunea `--date` va încerca, de asemenea, să înțeleagă și alte formate de date, mai centrate pe om, cum ar fi datele relative precum "ieri" sau "vinerea trecută la prânz".

note: type: Title -
en: Raw output format
ro: Format de ieșire brut

note: type: Plain text
en: The raw output format from "git-diff-index", "git-diff-tree", "git-diff-files" and "git diff --raw" are very similar.
ro: Formatul de ieșire brut de la "git-diff-index", "git-diff-tree", "git-diff-files" și "git diff --raw" sunt foarte asemănătoare.

note: type: Plain text
en: These commands all compare two sets of things; what is compared differs:
ro: Toate aceste comenzi compară două seturi de lucruri; ceea ce este comparat diferă:

note: type: Plain text
en: compares the <tree-ish> and the files on the filesystem.
ro: compară <tree-ish> și fișierele din sistemul de fișiere.

note: type: Plain text
en: compares the <tree-ish> and the index.
ro: compară <arborele> și indexul.

note: type: Labeled list
en: git-diff-tree [-r] <tree-ish-1> <tree-ish-2> [<pattern>...]
ro: git-diff-tree [-r] <tree-ish-1> <tree-ish-2> [<model>...]

note: type: Plain text
en: compares the trees named by the two arguments.
ro: compară arborii numiți de cele două argumente.

note: type: Labeled list
en: git-diff-files [<pattern>...]
ro: git-diff-files [<model>...]

note: type: Plain text
en: compares the index and the files on the filesystem.
ro: compară indexul și fișierele din sistemul de fișiere.

note: type: Plain text
en: The "git-diff-tree" command begins its output by printing the hash of what is being compared. After that, all the commands print one output line per changed file.
ro: Comanda "git-diff-tree" își începe ieșirea prin tipărirea hash-ului a ceea ce se compară. După aceea, toate comenzile tipăresc câte o linie de ieșire pentru fiecare fișier modificat.

note: type: Plain text
en: An output line is formatted this way:
ro: O linie de ieșire este formatată în felul următor:

note: type: Plain text
en: That is, from the left to the right:
ro: Adică, de la stânga la dreapta:

note: type: Plain text
en: a colon.
ro: un colon.

note: type: Plain text
en: mode for "src"; 000000 if creation or unmerged.
ro: modul pentru "src"; 000000 dacă este vorba de creație sau de nefuziune.

note: type: Plain text
en: a space.
ro: un spațiu.

note: type: Plain text
en: mode for "dst"; 000000 if deletion or unmerged.
ro: modul pentru "dst"; 000000 dacă este vorba de ștergere sau de nefuziune.

note: type: Plain text
en: sha1 for "src"; 0\{40\} if creation or unmerged.
ro: sha1 pentru "src"; 0\{40\} în cazul în care este vorba de o creație sau nu a fost fuzionată.

note: type: Plain text
en: sha1 for "dst"; 0\{40\} if creation, unmerged or "look at work tree".
ro: sha1 pentru "dst"; 0\{40\} în cazul în care este vorba de creație, fără fuziune sau " uita-te la configurația de lucru".

note: type: Plain text
en: status, followed by optional "score" number.
ro: statutul, urmat de numărul opțional "scor".

note: type: Plain text
en: a tab or a NUL when `-z` option is used.
ro: o tabulație sau un NUL atunci când se utilizează opțiunea `-z`.

note: type: Plain text
en: path for "src"
ro: calea pentru "src"

note: type: Plain text
en: a tab or a NUL when `-z` option is used; only exists for C or R.
ro: o tabulație sau un NUL atunci când se utilizează opțiunea `-z`; există numai pentru C sau R.

note: type: Plain text
en: path for "dst"; only exists for C or R.
ro: calea pentru "dst"; există numai pentru C sau R.

note: type: Plain text
en: an LF or a NUL when `-z` option is used, to terminate the record.
ro: un LF sau un NUL atunci când se utilizează opțiunea `-z`, pentru a încheia înregistrarea.

note: type: Plain text
en: Possible status letters are:
ro: Scrisorile de stare posibile sunt:

note: type: Plain text
en: A: addition of a file
ro: A: adăugarea unui fișier

note: type: Plain text
en: C: copy of a file into a new one
ro: C: copierea unui fișier într-unul nou

note: type: Plain text
en: D: deletion of a file
ro: D: ștergerea unui fișier

note: type: Plain text
en: M: modification of the contents or mode of a file
ro: M: modificarea conținutului sau a modului unui fișier

note: type: Plain text
en: R: renaming of a file
ro: R: redenumirea unui fișier

note: type: Plain text
en: U: file is unmerged (you must complete the merge before it can be committed)
ro: U: fișierul nu este fuzionat (trebuie să finalizați fuziunea înainte de a putea fi confirmat)

note: type: Plain text
en: X: "unknown" change type (most probably a bug, please report it)
ro: X: tip de modificare "necunoscut" (cel mai probabil o eroare, vă rugăm să o raportați)

note: type: Plain text
en: Status letters C and R are always followed by a score (denoting the percentage of similarity between the source and target of the move or copy).  Status letter M may be followed by a score (denoting the percentage of dissimilarity) for file rewrites.
ro: Literele de stare C și R sunt întotdeauna urmate de un scor (care indică procentul de similitudine dintre sursa și ținta mutării sau a copiei).  Litera de stare M poate fi urmată de un scor (care indică procentul de disimilaritate) pentru rescrierea fișierelor.

note: type: Plain text
en: <sha1> is shown as all 0's if a file is new on the filesystem and it is out of sync with the index.
ro: <sha1> este afișat cu toate 0 dacă un fișier este nou în sistemul de fișiere și nu este sincronizat cu indexul.

note: type: Labeled list
en: Example:
ro: Exemplu:

note: type: Plain text
en: Without the `-z` option, pathnames with "unusual" characters are quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]).  Using `-z` the filename is output verbatim and the line is terminated by a NUL byte.
ro: Fără opțiunea `-z`, numele de cale cu caractere "neobișnuite" sunt citate așa cum se explică pentru variabila de configurare `core.quotePath` (vezi linkgit:git-config[1]).  Folosind `-z` numele fișierului este redat textual, iar linia este terminată cu un byte NUL.

note: type: Title -
en: diff format for merges
ro: format diff pentru fuziuni

note: type: Plain text
en: "git-diff-tree", "git-diff-files" and "git-diff --raw" can take `-c` or `--cc` option to generate diff output also for merge commits.  The output differs from the format described above in the following way:
ro: "git-diff-tree", "git-diff-files" și "git-diff --raw" pot primi opțiunile `-c` sau `--cc` pentru a genera o ieșire diff și pentru comenzi de fuziune.  Ieșirea diferă de formatul descris mai sus în felul următor:

note: type: Plain text
en: there is a colon for each parent
ro: există o coloană pentru fiecare părinte

note: type: Plain text
en: there are more "src" modes and "src" sha1
ro: există mai multe moduri "src" și "src" sha1

note: type: Plain text
en: status is concatenated status characters for each parent
ro: status reprezintă caracterele de status concaternate pentru fiecare ascendent

note: type: Plain text
en: no optional "score" number
ro: niciun număr opțional de "scor"

note: type: Plain text
en: tab-separated pathname(s) of the file
ro: numele traseului (traseele) fișierului, separate prin tabulare

note: type: Plain text
en: For `-c` and `--cc`, only the destination or final path is shown even if the file was renamed on any side of history.  With `--combined-all-paths`, the name of the path in each parent is shown followed by the name of the path in the merge commit.
ro: Pentru `-c` și `--cc`, este afișată numai calea de destinație sau finală, chiar dacă fișierul a fost redenumit în orice parte a istoricului.  Cu `--combined-all-paths`, se afișează numele căii de acces din fiecare sursă , urmat de numele căii de acces din comisionul de fuziune.

note: type: Plain text
en: Examples for `-c` and `--cc` without `--combined-all-paths`:
ro: Exemple pentru `-c` și `--cc` fără `--combined-all-paths`:

note: type: Plain text
en: Examples when `--combined-all-paths` added to either `-c` or `--cc`:
ro: Exemple atunci când se adaugă `--combined-all-paths` la `-c` sau `--cc`:

note: type: Plain text
en: Note that 'combined diff' lists only files which were modified from all parents.
ro: Rețineți că "combined diff" listează numai fișierele care au fost modificate de la fiecare sursă.

note: type: Title -
en: other diff formats
ro: alte formate diff

note: type: Plain text
en: The `--summary` option describes newly added, deleted, renamed and copied files.  The `--stat` option adds diffstat(1) graph to the output.  These options can be combined with other options, such as `-p`, and are meant for human consumption.
ro: Opțiunea `--summary` descrie fișierele nou adăugate, șterse, redenumite și copiate.  Opțiunea `--stat` adaugă graficul diffstat(1) la ieșire.  Aceste opțiuni pot fi combinate cu alte opțiuni, cum ar fi `-p`, și sunt destinate consumului uman.

note: type: Plain text
en: When showing a change that involves a rename or a copy, `--stat` output formats the pathnames compactly by combining common prefix and suffix of the pathnames.  For example, a change that moves `arch/i386/Makefile` to `arch/x86/Makefile` while modifying 4 lines will be shown like this:
ro: Atunci când se afișează o modificare care implică o redenumire sau o copiere, ieșirea `--stat` formatează compact numele căilor de acces prin combinarea prefixului și sufixului comun al numelor de acces.  De exemplu, o modificare care mută `arch/i386/Makefile` în `arch/x86/Makefile`, modificând 4 linii, va fi afișată în felul următor:

note: type: Plain text
en: The `--numstat` option gives the diffstat(1) information but is designed for easier machine consumption.  An entry in `--numstat` output looks like this:
ro: Opțiunea `--numstat` oferă informațiile din diffstat(1), dar este concepută pentru un consum mai ușor al mașinii.  O intrare în ieșirea `--numstat` arată astfel:

note: type: Plain text
en: That is, from left to right:
ro: Adică, de la stânga la dreapta:

note: type: Plain text
en: the number of added lines;
ro: numărul de linii adăugate;

note: type: Plain text
en: a tab;
ro: o filă;

note: type: Plain text
en: the number of deleted lines;
ro: numărul de linii șterse;

note: type: Plain text
en: pathname (possibly with rename/copy information);
ro: pathname (eventual cu informații de redenumire/copiere);

note: type: Plain text
en: a newline.
ro: o linie nouă.

note: type: Plain text
en: When `-z` output option is in effect, the output is formatted this way:
ro: Atunci când opțiunea de ieșire `-z` este în vigoare, ieșirea este formatată în acest mod:

note: type: Plain text
en: That is:
ro: Asta este:

note: type: Plain text
en: a NUL (only exists if renamed/copied);
ro: un NUL (există numai dacă este redenumit/copiat);

note: type: Plain text
en: pathname in preimage;
ro: pathname în preimagine;

note: type: Plain text
en: pathname in postimage (only exists if renamed/copied);
ro: pathname în postimage (există doar dacă este redenumit/copiat);

note: type: Plain text
en: a NUL.
ro: un NUL.

note: type: Plain text
en: The extra `NUL` before the preimage path in renamed case is to allow scripts that read the output to tell if the current record being read is a single-path record or a rename/copy record without reading ahead.  After reading added and deleted lines, reading up to `NUL` would yield the pathname, but if that is `NUL`, the record will show two paths.
ro: Introducerea unui `NUL` suplimentar înaintea căii de preimagine în cazul redenumirii este pentru a permite scripturilor care citesc ieșirea să afle dacă înregistrarea curentă citită este o înregistrare cu o singură cale sau o înregistrare de redenumire/copiere fără a citi înainte.  După citirea liniilor adăugate și șterse, citirea până la `NUL` ar produce numele căii de acces, dar dacă acesta este `NUL`, înregistrarea va afișa două căi de acces.

note: type: Title -
en: Generating patch text with -p
ro: Generarea textului patch-ului cu -p

note: type: Plain text
en: Running linkgit:git-diff[1], linkgit:git-log[1], linkgit:git-show[1], linkgit:git-diff-index[1], linkgit:git-diff-tree[1], or linkgit:git-diff-files[1] with the `-p` option produces patch text.  You can customize the creation of patch text via the `GIT_EXTERNAL_DIFF` and the `GIT_DIFF_OPTS` environment variables (see linkgit:git[1]), and the `diff` attribute (see linkgit:gitattributes[5]).
ro: Rularea linkgit:git-diff[1], linkgit:git-log[1], linkgit:git-show[1], linkgit:git-diff-index[1], linkgit:git-diff-tree[1], sau linkgit:git-diff-files[1] cu opțiunea `-p` produce un text de patch.  Puteți personaliza crearea textului de patch-uri prin intermediul variabilelor de mediu `GIT_EXTERNAL_DIFF` și `GIT_DIFF_OPTS` (a se vedea linkgit:git[1]), precum și prin atributul `diff` (a se vedea linkgit:gitattributes[5]).

note: type: Plain text
en: What the -p option produces is slightly different from the traditional diff format:
ro: Ceea ce produce opțiunea -p este ușor diferit de formatul diff tradițional:

note: type: Plain text
en: It is preceded with a "git diff" header that looks like this:
ro: Acesta este precedat de un antet "git diff" care arată astfel:

note: type: Plain text
en: diff --git a/file1 b/file2
ro: diff --git un/fișier1 b/fișier2

note: type: Plain text
en: The `a/` and `b/` filenames are the same unless rename/copy is involved.  Especially, even for a creation or a deletion, `/dev/null` is _not_ used in place of the `a/` or `b/` filenames.
ro: Numele fișierelor `a/` și `b/` sunt identice, cu excepția cazului în care este vorba de redenumire/copiere.  În special, chiar și pentru o creare sau o ștergere, `/dev/null` este _nu_ utilizat în locul numelor de fișiere `a/` sau `b/`.

note: type: Plain text
en: When rename/copy is involved, `file1` and `file2` show the name of the source file of the rename/copy and the name of the file that rename/copy produces, respectively.
ro: Atunci când este vorba de redenumire/copiere, `fișier1` și `fișier2` arată numele fișierului sursă al redenumirii/copierii și, respectiv, numele fișierului pe care îl produce redenumirea/copierea.

note: type: Plain text
en: It is followed by one or more extended header lines:
ro: Acesta este urmat de una sau mai multe linii de antet extinse:

note: type: Plain text
en: old mode <mode>
    new mode <mode>
    deleted file mode <mode>
    new file mode <mode>
    copy from <path>
    copy to <path>
    rename from <path>
    rename to <path>
    similarity index <number>
    dissimilarity index <number>
    index <hash>..<hash> <mode>
ro: modul vechi <modul>
    modul nou <modul>
    mod fișier șters <mode>
    noul mod de fișier <mode>
    copie din <path>
    copie din <path>
    redenumire din <path>
    redenumește în <path>
    indice de similaritate <număr>
    indice de disimilaritate <număr>
    index <hash>..<hash> <mode>

note: type: Plain text
en: File modes are printed as 6-digit octal numbers including the file type and file permission bits.
ro: Modurile de fișier sunt tipărite ca numere octale din 6 cifre, inclusiv tipul de fișier și biții de permisiune ai fișierului.

note: type: Plain text
en: Path names in extended headers do not include the `a/` and `b/` prefixes.
ro: Numele căilor de acces din antetele extinse nu includ prefixele `a/` și `b/`.

note: type: Plain text
en: The similarity index is the percentage of unchanged lines, and the dissimilarity index is the percentage of changed lines.  It is a rounded down integer, followed by a percent sign.  The similarity index value of 100% is thus reserved for two equal files, while 100% dissimilarity means that no line from the old file made it into the new one.
ro: Indicele de similaritate reprezintă procentul de linii neschimbate, iar indicele de disimilaritate reprezintă procentul de linii modificate.  Este un număr întreg rotunjit în jos, urmat de un semn de procent.  Astfel, indicele de similitudine de 100% este rezervat pentru două fișiere egale, în timp ce o valoare de disimilaritate de 100% înseamnă că nicio linie din vechiul fișier nu a fost inclusă în cel nou.

note: type: Plain text
en: The index line includes the blob object names before and after the change.  The <mode> is included if the file mode does not change; otherwise, separate lines indicate the old and the new mode.
ro: Linia indexului include numele obiectelor blob înainte și după modificare.  <mode> este inclus dacă modul de fișier nu se schimbă; în caz contrar, linii separate indică vechiul și noul mod.

note: type: Plain text
en: Pathnames with "unusual" characters are quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]).
ro: Numele de drum cu caractere "neobișnuite" sunt citate așa cum se explică pentru variabila de configurare `core.quotePath` (vezi linkgit:git-config[1]).

note: type: Plain text
en: All the `file1` files in the output refer to files before the commit, and all the `file2` files refer to files after the commit.  It is incorrect to apply each change to each file sequentially.  For example, this patch will swap a and b:
ro: Toate fișierele `file1` din ieșire se referă la fișierele dinainte de confirmare, iar toate fișierele `file2` se referă la fișierele de după confirmare.  Nu este corect să se aplice fiecare modificare fiecărui fișier în mod secvențial.  De exemplu, acest patch va schimba a și b:

note: type: Plain text
en: diff --git a/a b/b
    rename from a
    rename to b
    diff --git a/b b/a
    rename from b
    rename to a
ro: diff --git a/a b/b
    redenumiți din a
    redenumește în b
    diff --git a/b b/a
    redenumire din b
    redenumire în a

note: type: Plain text
en: Hunk headers mention the name of the function to which the hunk applies.  See "Defining a custom hunk-header" in linkgit:gitattributes[5] for details of how to tailor to this to specific languages.
ro: În antetul hunk-ului se menționează numele funcției la care se aplică hunk-ul.  Consultați "Definirea unui hunk-header personalizat" în linkgit:gitattributes[5] pentru detalii despre cum să adaptați acest lucru la anumite limbaje.

note: type: Title -
en: Combined diff format
ro: Formatul dif combinat

note: type: Plain text
en: Any diff-generating command can take the `-c` or `--cc` option to produce a 'combined diff' when showing a merge. This is the default format when showing merges with linkgit:git-diff[1] or linkgit:git-show[1]. Note also that you can give suitable `--diff-merges` option to any of these commands to force generation of diffs in specific format.
ro: Orice comandă care generează diferențe poate folosi opțiunea `-c` sau `--cc` pentru a produce o "diferență combinată" atunci când arată o fuziune. Acesta este formatul implicit atunci când se afișează fuziunile cu linkgit:git-diff[1] sau linkgit:git-show[1]. Rețineți, de asemenea, că puteți da opțiunea `--diff-merges` adecvată oricăreia dintre aceste comenzi pentru a forța generarea de diferențe într-un format specific.

note: type: Plain text
en: A "combined diff" format looks like this:
ro: Un format "combined diff" arată în felul următor:

note: type: Plain text
en: It is preceded with a "git diff" header, that looks like this (when the `-c` option is used):
ro: Acesta este precedat de un antet "git diff", care arată astfel (atunci când este utilizată opțiunea `-c`):

note: type: Plain text
en: diff --combined file
ro: diff --fișier combinat

note: type: Plain text
en: or like this (when the `--cc` option is used):
ro: sau în felul următor (atunci când se utilizează opțiunea `--cc`):

note: type: Plain text
en:        diff --cc file
ro:        diff --cc fișier

note: type: Plain text
en: It is followed by one or more extended header lines (this example shows a merge with two parents):
ro: Acesta este urmat de una sau mai multe linii de antet extinse (acest exemplu arată o fuziune cu doi ascendenți):

note: type: Plain text
en: index <hash>,<hash>..<hash>
    mode <mode>,<mode>..<mode>
    new file mode <mode>
    deleted file mode <mode>,<mode>
ro: index <hash>,<hash>..<hash>
    mode <mode>,<mode>..<mode>
    noul mod de fișier <mode>
    mod fișier șters <mode>,<mode>,<mode>

note: type: Plain text
en: The `mode <mode>,<mode>..<mode>` line appears only if at least one of the <mode> is different from the rest. Extended headers with information about detected contents movement (renames and copying detection) are designed to work with diff of two <tree-ish> and are not used by combined diff format.
ro: Linia `mode <mode>,<mode>..<mode>` apare numai dacă cel puțin unul dintre <mode> este diferit de restul. Antetele extinse cu informații despre mișcările de conținut detectate (redenumiri și detectarea copierii) sunt concepute pentru a funcționa cu diff de două <tree-ish> și nu sunt utilizate de formatul diff combinat.

note: type: Plain text
en: It is followed by two-line from-file/to-file header
ro: Acesta este urmat de un antet de două rânduri de la fișier/la fișier

note: type: Plain text
en: a/file
ro: a/fișier

note: type: Plain text
en: b/file
ro: b/fișier

note: type: Plain text
en: Similar to two-line header for traditional 'unified' diff format, `/dev/null` is used to signal created or deleted files.
ro: Similar cu antetul de două linii pentru formatul tradițional "unificat" diff, `/dev/null` este utilizat pentru a semnala fișierele create sau șterse.

note: type: Plain text
en: However, if the --combined-all-paths option is provided, instead of a two-line from-file/to-file you get a N+1 line from-file/to-file header, where N is the number of parents in the merge commit
ro: Cu toate acestea, dacă este furnizată opțiunea --combined-all-paths, în loc de un antet de două linii from-file/to-file veți obține un antet de N+1 linii from-file/to-file, unde N este numărul de surse din comisionul de fuziune

note: type: Plain text
en: This extended format can be useful if rename or copy detection is active, to allow you to see the original name of the file in different parents.
ro: Acest format extins poate fi util în cazul în care detectarea redenumirii sau a copierii este activă, pentru a vă permite să vedeți numele original al fișierului în diferiți ascendenți.

note: type: Plain text
en: Chunk header format is modified to prevent people from accidentally feeding it to `patch -p1`. Combined diff format was created for review of merge commit changes, and was not meant to be applied. The change is similar to the change in the extended 'index' header:
ro: Formatul antetului Chunk este modificat pentru a preveni ca oamenii să nu-l introducă accidental în `patch -p1`. Formatul Combined diff a fost creat pentru revizuirea modificărilor de comisionare a fuziunii și nu a fost conceput pentru a fi aplicat. Modificarea este similară cu cea din antetul extins "index":

note: type: Plain text
en: @@@ <from-file-range> <from-file-range> <to-file-range> @@@
ro: @@@ <de la-fila-range> <de la-fila-range> <de la-fila-range> @@@

note: type: Plain text
en: There are (number of parents + 1) `@` characters in the chunk header for combined diff format.
ro: Există (numărul de autori + 1) caractere `@` în antetul chunk pentru formatul de diferență combinat.

note: type: Plain text
en: Unlike the traditional 'unified' diff format, which shows two files A and B with a single column that has `-` (minus -- appears in A but removed in B), `+` (plus -- missing in A but added to B), or `" "` (space -- unchanged) prefix, this format compares two or more files file1, file2,... with one file X, and shows how X differs from each of fileN.  One column for each of fileN is prepended to the output line to note how X's line is different from it.
ro: Spre deosebire de formatul tradițional "unificat" diff, care prezintă două fișiere A și B cu o singură coloană care are prefixul `-` (minus -- apare în A, dar este eliminat în B), `+` (plus -- lipsește în A, dar este adăugat în B) sau `""` (spațiu -- neschimbat), acest format compară două sau mai multe fișiere file1, file2,... cu un singur fișier X și arată în ce fel diferă X de fiecare din fileN.  O coloană pentru fiecare dintre fișiereleN este adăugată la linia de ieșire pentru a nota modul în care linia lui X este diferită de aceasta.

note: type: Plain text
en: A `-` character in the column N means that the line appears in fileN but it does not appear in the result.  A `+` character in the column N means that the line appears in the result, and fileN does not have that line (in other words, the line was added, from the point of view of that parent).
ro: Un caracter `-` în coloana N înseamnă că linia apare în fișierulN, dar nu apare în rezultat.  Un caracter `+` în coloana N înseamnă că linia apare în rezultat, iar fișierulN nu are acea linie (cu alte cuvinte, linia a fost adăugată, din punctul de vedere al ascendentului respectiv).

note: type: Plain text
en: In the above example output, the function signature was changed from both files (hence two `-` removals from both file1 and file2, plus `++` to mean one line that was added does not appear in either file1 or file2).  Also eight other lines are the same from file1 but do not appear in file2 (hence prefixed with `+`).
ro: În exemplul de ieșire de mai sus, semnătura funcției a fost modificată în ambele fișiere (de aici două eliminări `-` atât din fișierul1, cât și din fișierul2, plus `++` pentru a însemna că o linie care a fost adăugată nu apare nici în fișierul1, nici în fișierul2).  De asemenea, alte opt linii sunt aceleași din fișierul1, dar nu apar în fișierul2 (de unde și prefixarea cu `+`).

note: type: Plain text
en: When shown by `git diff-tree -c`, it compares the parents of a merge commit with the merge result (i.e. file1..fileN are the parents).  When shown by `git diff-files -c`, it compares the two unresolved merge parents with the working tree file (i.e. file1 is stage 2 aka "our version", file2 is stage 3 aka "their version").
ro: Atunci când este afișat de `git diff-tree -c`, acesta compară părinții unei comenzi de fuziune cu rezultatul fuziunii (de exemplu, fișierul1..fișierulN sunt părinții).  Atunci când este afișat de `git diff-files -c`, acesta compară cei doi părinți nerezolvați ai fuziunii cu fișierul din arborele de lucru (de exemplu, fișierul1 este stadiul 2, adică "versiunea noastră", iar fișierul2 este stadiul 3, adică "versiunea lor").

note: type: Plain text
en: Generate plain patches without any diffstats.
ro: Generează patch-uri simple fără statistici diff.

note: type: Plain text
en: Generate patch (see section on generating patches).
ro: Generate patch (a se vedea secțiunea privind generarea de patch-uri).

note: type: Plain text
en: 	This is the default.
ro: 	Aceasta este valoarea implicită.

note: type: Plain text
en: Suppress diff output. Useful for commands like `git show` that show the patch by default, or to cancel the effect of `--patch`.
ro: Suprimarea ieșirii dif. Utile pentru comenzi precum `git show`, care afișează implicit patch-ul, sau pentru a anula efectul lui `--patch`.

note: type: Plain text
en: Specify diff format to be used for merge commits. Default is {diff-merges-default} unless `--first-parent` is in use, in which case `first-parent` is the default.
ro: Specificați formatul diff care urmează să fie utilizat pentru comenzi de fuziune. Valoarea implicită este {diff-merges-default}, cu excepția cazului în care se utilizează `--first-parent`, caz în care `first-parent` este valoarea implicită.

note: type: Plain text
en: Disable output of diffs for merge commits. Useful to override implied value.
ro: Dezactivați afișarea diferențelor pentru comenzi de fuziune. Util pentru a înlocui valoarea implicită.

note: type: Plain text
en: This option makes merge commits show the full diff with respect to the first parent only.
ro: Această opțiune face ca modificările de fuziune să afișeze diferența completă numai în raport cu primul ascendent.

note: type: Plain text
en: With this option, diff output for a merge commit shows the differences from each of the parents to the merge result simultaneously instead of showing pairwise diff between a parent and the result one at a time. Furthermore, it lists only files which were modified from all parents. `-c` implies `-p`.
ro: Cu această opțiune, ieșirea diff pentru un angajament de fuziune afișează simultan diferențele dintre fiecare dintre ascendenți și rezultatul fuziunii, în loc să afișeze diferențele pe perechi dintre un ascendent și rezultat, pe rând. În plus, sunt listate numai fișierele care au fost modificate din toate fișierele sursă. `-c` implică `-p`.

note: type: Plain text
en: With this option the output produced by `--diff-merges=combined` is further compressed by omitting uninteresting hunks whose contents in the parents have only two variants and the merge result picks one of them without modification.  `--cc` implies `-p`.
ro: Cu această opțiune, rezultatul produs de `--diff-merges=combined` este comprimat și mai mult prin omiterea grupurilor neinteresante ale căror conținuturi în ascendenți au doar două variante, iar rezultatul fuziunii alege una dintre ele fără modificări.  `--cc` implică `-p`.

note: type: Plain text
en: This flag causes combined diffs (used for merge commits) to list the name of the file from all parents.  It thus only has effect when `--diff-merges=[dense-]combined` is in use, and is likely only useful if filename changes are detected (i.e.  when either rename or copy detection have been requested).
ro: Acest indicator determină ca diferențele combinate (utilizate pentru comenzi de fuziune) să listeze numele fișierului din toate fișierele părinte.  Prin urmare, are efect numai atunci când se utilizează `--diff-merges=[dense-]combined` și este probabil util numai dacă sunt detectate modificări ale numelui de fișier (adică atunci când a fost solicitată fie redenumirea, fie detectarea copierii).

note: type: Plain text
en: Generate diffs with <n> lines of context instead of the usual three.
ro: Generați diferențe cu <n> linii de context în loc de trei, ca de obicei.

note: type: Plain text
en: 	Implies `--patch`.
ro: 	Implică `--patch`.

note: type: Plain text
en: Output to a specific file instead of stdout.
ro: Ieșire către un fișier specific în loc de stdout.

note: type: Plain text
en: Specify the character used to indicate new, old or context lines in the generated patch. Normally they are '+', '-' and ' ' respectively.
ro: Specificați caracterul utilizat pentru a indica liniile noi, vechi sau de context în patch-ul generat. În mod normal, acestea sunt "+", "-" și, respectiv, " ' ".

note: type: Plain text
en: 	Generate the diff in raw format.
ro: 	Generează diferența în format brut.

note: type: Plain text
en: 	For each commit, show a summary of changes using the raw diff
    	format. See the "RAW OUTPUT FORMAT" section of
    	linkgit:git-diff[1]. This is different from showing the log
    	itself in raw format, which you can achieve with
    	`--format=raw`.
ro: 	Pentru fiecare confirmare, afișați un rezumat al modificărilor folosind diff brut
    	format. Consultați secțiunea "FORMAT DE IeșIRE RAW" din
    	linkgit:git-diff[1]. Acest lucru este diferit de afișarea jurnalului
    	în sine în format brut, ceea ce se poate realiza cu
    	`--format=raw`.

note: type: Plain text
en: Synonym for `-p --raw`.
ro: Sinonim pentru `-p --raw`.

note: type: Plain text
en: Show the tree objects in the diff output.
ro: Afișează obiectele structurii de tip arbore în fișierul de diferență.

note: type: Plain text
en: Enable the heuristic that shifts diff hunk boundaries to make patches easier to read. This is the default.
ro: Activați euristica care deplasează limitele dif hunk pentru a face patch-urile mai ușor de citit. Aceasta este opțiunea implicită.

note: type: Plain text
en: Disable the indent heuristic.
ro: Dezactivează euristica de indentare.

note: type: Plain text
en: Spend extra time to make sure the smallest possible diff is produced.
ro: Petreceți timp suplimentar pentru a vă asigura că este produsă cea mai mică diferență posibilă.

note: type: Plain text
en: Generate a diff using the "patience diff" algorithm.
ro: Generați o diferență folosind algoritmul "patience diff".

note: type: Plain text
en: Generate a diff using the "histogram diff" algorithm.
ro: Generați o diferență utilizând algoritmul "histogramă diff".

note: type: Plain text
en: Generate a diff using the "anchored diff" algorithm.
ro: Generați o diferență folosind algoritmul "anchored diff".

note: type: Plain text
en: This option may be specified more than once.
ro: Această opțiune poate fi specificată de mai multe ori.

note: type: Plain text
en: If a line exists in both the source and destination, exists only once, and starts with this text, this algorithm attempts to prevent it from appearing as a deletion or addition in the output. It uses the "patience diff" algorithm internally.
ro: În cazul în care o linie există atât în sursă, cât și în destinație, există doar o singură dată și începe cu acest text, acest algoritm încearcă să împiedice ca aceasta să apară ca o ștergere sau adăugare în rezultat. Acesta utilizează în mod intern algoritmul "patience diff".

note: type: Plain text
en: Choose a diff algorithm. The variants are as follows:
ro: Alegeți un algoritm de diferențiere. Variantele sunt următoarele:

note: type: Plain text
en: The basic greedy diff algorithm. Currently, this is the default.
ro: Algoritmul de bază al diferenței avide. În prezent, acesta este algoritmul implicit.

note: type: Plain text
en: Use "patience diff" algorithm when generating patches.
ro: Utilizați algoritmul "patience diff" atunci când generați patch-uri.

note: type: Plain text
en: This algorithm extends the patience algorithm to "support low-occurrence common elements".
ro: Acest algoritm extinde algoritmul de răbdare pentru a "sprijini elementele comune cu frecvență redusă".

note: type: Plain text
en: For instance, if you configured the `diff.algorithm` variable to a non-default value and want to use the default one, then you have to use `--diff-algorithm=default` option.
ro: De exemplu, dacă ați configurat variabila `diff.algorithm` la o valoare diferită de cea implicită și doriți să o utilizați pe cea implicită, atunci trebuie să utilizați opțiunea `--diff-algorithm=default`.

note: type: Plain text
en: Generate a diffstat. By default, as much space as necessary will be used for the filename part, and the rest for the graph part. Maximum width defaults to terminal width, or 80 columns if not connected to a terminal, and can be overridden by `<width>`. The width of the filename part can be limited by giving another width `<name-width>` after a comma. The width of the graph part can be limited by using `--stat-graph-width=<width>` (affects all commands generating a stat graph) or by setting `diff.statGraphWidth=<width>` (does not affect `git format-patch`).  By giving a third parameter `<count>`, you can limit the output to the first `<count>` lines, followed by `...` if there are more.
ro: Generarea unei statistici diff. În mod implicit, se va utiliza atât spațiu cât este necesar pentru partea cu numele fișierului, iar restul pentru partea cu graficul. Lățimea maximă este, în mod implicit, cea a terminalului sau 80 de coloane dacă nu este conectat la un terminal și poate fi înlocuită cu `<width>`. Lățimea părții de nume de fișier poate fi limitată prin atribuirea unei alte lățimi `<name-width>` după o virgulă. Lățimea părții de grafic poate fi limitată prin utilizarea `--stat-graph-width=<width>` (afectează toate comenzile care generează un grafic stat) sau prin setarea `diff.statGraphWidth=<width>` (nu afectează `git format-patch`).  Dând un al treilea parametru `<count>`, puteți limita ieșirea la primele `<count>` linii, urmate de `...` dacă sunt mai multe.

note: type: Plain text
en: These parameters can also be set individually with `--stat-width=<width>`, `--stat-name-width=<name-width>` and `--stat-count=<count>`.
ro: Acești parametri pot fi, de asemenea, setați individual cu `--stat-width=<width>`, `--stat-name-width=<name-width>` și `--stat-count=<count>`.

note: type: Plain text
en: Output a condensed summary of extended header information such as file creations or deletions ("new" or "gone", optionally "+l" if it's a symlink) and mode changes ("+x" or "-x" for adding or removing executable bit respectively) in diffstat. The information is put between the filename part and the graph part. Implies `--stat`.
ro: Emite un rezumat condensat al informațiilor extinse din antet, cum ar fi crearea sau ștergerea de fișiere ("new" sau "gone", opțional "+l" dacă este vorba de o legătură simbolică) și schimbările de mod ("+x" sau "-x" pentru adăugarea sau eliminarea bitului executabil) în diffstat. Informațiile sunt plasate între partea de nume de fișier și partea de grafic. Implică `--stat`.

note: type: Plain text
en: Similar to `--stat`, but shows number of added and deleted lines in decimal notation and pathname without abbreviation, to make it more machine friendly.  For binary files, outputs two `-` instead of saying `0 0`.
ro: Similar cu `--stat`, dar afișează numărul de linii adăugate și șterse în notație zecimală și numele căii de acces fără abrevieri, pentru a fi mai ușor de utilizat.  În cazul fișierelor binare, afișează două `-` în loc să spună `0 0 0`.

note: type: Plain text
en: Output only the last line of the `--stat` format containing total number of modified files, as well as number of added and deleted lines.
ro: Emite numai ultima linie din formatul `--stat` care conține numărul total de fișiere modificate, precum și numărul de linii adăugate și șterse.

note: type: Plain text
en: Output the distribution of relative amount of changes for each sub-directory. The behavior of `--dirstat` can be customized by passing it a comma separated list of parameters.  The defaults are controlled by the `diff.dirstat` configuration variable (see linkgit:git-config[1]).  The following parameters are available:
ro: Afișează distribuția cantității relative de modificări pentru fiecare subdirector. Comportamentul lui `--dirstat` poate fi personalizat prin transmiterea unei liste de parametri separați prin virgulă.  Valorile implicite sunt controlate de variabila de configurare `diff.dirstat` (a se vedea linkgit:git-config[1]).  Sunt disponibili următorii parametri:

note: type: Plain text
en: Compute the dirstat numbers by counting the lines that have been removed from the source, or added to the destination. This ignores the amount of pure code movements within a file.  In other words, rearranging lines in a file is not counted as much as other changes.  This is the default behavior when no parameter is given.
ro: Calculați numerele dirstat prin numărarea liniilor care au fost eliminate de la sursă sau adăugate la destinație. În acest mod nu se ține seama de cantitatea de mișcări de cod pur în cadrul unui fișier.  Cu alte cuvinte, rearanjarea liniilor într-un fișier nu este contabilizată la fel de mult ca alte modificări.  Acesta este comportamentul implicit în cazul în care nu se furnizează niciun parametru.

note: type: Plain text
en: Compute the dirstat numbers by doing the regular line-based diff analysis, and summing the removed/added line counts. (For binary files, count 64-byte chunks instead, since binary files have no natural concept of lines). This is a more expensive `--dirstat` behavior than the `changes` behavior, but it does count rearranged lines within a file as much as other changes. The resulting output is consistent with what you get from the other `--*stat` options.
ro: Calculați cifrele dirstat prin efectuarea analizei obișnuite a diferențelor bazate pe linii și prin însumarea numărului de linii eliminate/adăugate. (În cazul fișierelor binare, numărați în schimb bucăți de 64 de octeți, deoarece fișierele binare nu au un concept natural de linii). Acesta este un comportament `--dirstat` mai costisitor decât comportamentul `changes`, dar numără liniile rearanjate în cadrul unui fișier la fel de mult ca și alte modificări. Rezultatul este în concordanță cu ceea ce se obține cu celelalte opțiuni `--*stat`.

note: type: Plain text
en: Compute the dirstat numbers by counting the number of files changed.  Each changed file counts equally in the dirstat analysis. This is the computationally cheapest `--dirstat` behavior, since it does not have to look at the file contents at all.
ro: Calculați numerele dirstat prin numărarea numărului de fișiere modificate.  Fiecare fișier modificat contează în mod egal în analiza dirstat. Acesta este comportamentul `--dirstat` cel mai ieftin din punct de vedere computațional, deoarece nu trebuie să se uite deloc la conținutul fișierelor.

note: type: Plain text
en: Count changes in a child directory for the parent directory as well.  Note that when using `cumulative`, the sum of the percentages reported may exceed 100%. The default (non-cumulative) behavior can be specified with the `noncumulative` parameter.
ro: Numără modificările dintr-un director copil și pentru directorul de origine.  Rețineți că atunci când se utilizează `cumulative`, suma procentelor raportate poate depăși 100%. Comportamentul implicit (non-cumulativ) poate fi specificat cu ajutorul parametrului `noncumulative`.

note: type: Labeled list
en: <limit>
ro: <limită>

note: type: Plain text
en: An integer parameter specifies a cut-off percent (3% by default).  Directories contributing less than this percentage of the changes are not shown in the output.
ro: Un parametru întreg specifică un procent de tăiere (3% în mod implicit).  Directoarele care contribuie cu mai puțin de acest procent la modificări nu sunt afișate în rezultat.

note: type: Plain text
en: Example: The following will count changed files, while ignoring directories with less than 10% of the total amount of changed files, and accumulating child directory counts in the parent directories: `--dirstat=files,10,cumulative`.
ro: Exemplu: Următorul va număra fișierele modificate, ignorând în același timp directoarele cu mai puțin de 10% din numărul total de fișiere modificate și acumulând numărul de directoare secundare în directoarele principale: `--dirstat=files,10,cumulative`.

note: type: Plain text
en: Synonym for --dirstat=cumulative
ro: Sinonim pentru --dirstat=cumulativ

note: type: Plain text
en: Synonym for --dirstat=files,param1,param2...
ro: Sinonim pentru --dirstat=files,param1,param2....

note: type: Plain text
en: Output a condensed summary of extended header information such as creations, renames and mode changes.
ro: Emite un rezumat condensat al informațiilor din antetul extins, cum ar fi creări, redenumiri și schimbări de mod.

note: type: Plain text
en: Synonym for `-p --stat`.
ro: Sinonim pentru `-p --stat`.

note: type: Plain text
en: 	Separate the commits with NULs instead of with new newlines.
ro: 	Separați comenzile cu NUL-uri în loc de linii noi.

note: type: Plain text
en: Also, when `--raw` or `--numstat` has been given, do not munge pathnames and use NULs as output field terminators.
ro: De asemenea, în cazul în care a fost dat `--raw` sau `--numstat`, nu se folosesc nume de căi de acces și se folosesc NUL-uri ca terminatori ai câmpurilor de ieșire.

note: type: Plain text
en: 	When `--raw`, `--numstat`, `--name-only` or `--name-status` has been
    	given, do not munge pathnames and use NULs as output field terminators.
ro: 	Atunci când `--raw`, `--numstat`, `--name-only` sau `--name-status` a fost
    	nu se utilizează nume de căi de acces și se folosesc NUL-uri ca terminatori ai câmpurilor de ieșire.

note: type: Plain text
en: Without this option, pathnames with "unusual" characters are quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]).
ro: Fără această opțiune, numele căilor de acces cu caractere "neobișnuite" sunt citate așa cum se explică pentru variabila de configurare `core.quotePath` (vezi linkgit:git-config[1]).

note: type: Plain text
en: Show only names of changed files. The file names are often encoded in UTF-8.  For more information see the discussion about encoding in the linkgit:git-log[1] manual page.
ro: Afișează numai numele fișierelor modificate. Numele fișierelor sunt adesea codificate în UTF-8.  Pentru mai multe informații, consultați discuția despre codificare în pagina de manual linkgit:git-log[1].

note: type: Plain text
en: Show only names and status of changed files. See the description of the `--diff-filter` option on what the status letters mean.  Just like `--name-only` the file names are often encoded in UTF-8.
ro: Afișează numai numele și starea fișierelor modificate. Consultați descrierea opțiunii `--diff-filter` pentru a afla ce înseamnă literele de stare.  La fel ca în cazul lui `--name-only`, numele fișierelor sunt adesea codificate în UTF-8.

note: type: Labeled list
en: --submodule[=<format>]
ro: --submodule[=<formatul>]

note: type: Plain text
en: Specify how differences in submodules are shown.  When specifying `--submodule=short` the 'short' format is used.  This format just shows the names of the commits at the beginning and end of the range.  When `--submodule` or `--submodule=log` is specified, the 'log' format is used.  This format lists the commits in the range like linkgit:git-submodule[1] `summary` does.  When `--submodule=diff` is specified, the 'diff' format is used.  This format shows an inline diff of the changes in the submodule contents between the commit range.  Defaults to `diff.submodule` or the 'short' format if the config option is unset.
ro: Specificați modul în care sunt afișate diferențele dintre submodule.  Atunci când se specifică `--submodule=short` se utilizează formatul "short".  Acest format afișează doar denumirile comenzilor de la începutul și sfârșitul intervalului.  Atunci când se specifică `--submodule` sau `--submodule=log`, se utilizează formatul "log".  Acest format enumeră comenzile din interval, la fel cum face linkgit:git-submodule[1] `summary`.  Atunci când se specifică `--submodule=diff`, se utilizează formatul "diff".  Acest format afișează o diferență în linie a modificărilor din conținutul submodulelor între intervalul de confirmări.  Se utilizează în mod implicit `diff.submodule` sau formatul "short" dacă opțiunea de configurare nu este setată.

note: type: Labeled list
en: --color[=<when>]
ro: --color[=<când>]

note: type: Plain text
en: Show colored diff.  `--color` (i.e. without '=<when>') is the same as `--color=always`.  '<when>' can be one of `always`, `never`, or `auto`.
ro: Afișați diferențele de culoare.  `--color` (adică fără '=<when>') este același lucru cu `--color=always`.  '<when>' poate fi unul dintre `always`, `never` sau `auto`.

note: type: Labeled list
en: --shallow-since=<date>
ro: --shallow-since=<data>

note: type: Labeled list
en: --shallow-exclude=<revision>
ro: --shallow-exclude=<revizie>

note: type: Labeled list
en: --upload-pack <upload-pack>
ro: --upload-pack <pachet de încărcare>

note: type: Plain text
en: Be verbose.
ro: Poți să fii vorbăreț.

note: type: Plain text
en: Transmit the given string to the server when communicating using protocol version 2.  The given string must not contain a NUL or LF character.  The server's handling of server options, including unknown ones, is server-specific.  When multiple `--server-option=<option>` are given, they are all sent to the other side in the order listed on the command line.
ro: Transmite serverului șirul de caractere dat atunci când se comunică folosind versiunea 2 a protocolului.  Șirul dat nu trebuie să conțină un caracter NUL sau LF.  Gestionarea de către server a opțiunilor serverului, inclusiv a celor necunoscute, este specifică serverului.  Atunci când sunt date mai multe `--server-option=<option>`, toate sunt trimise celeilalte părți în ordinea listată pe linia de comandă.

note: type: Title -
en: NAME
ro: NUME

note: type: Plain text
en: git-add - Add file contents to the index
ro: git-add - Adaugă conținutul fișierului la index

note: type: Title -
en: SYNOPSIS
ro: REZUMAT

note: type: Title -
en: DESCRIPTION
ro: DESCRIERE

note: type: Plain text
en: This command updates the index using the current content found in the working tree, to prepare the content staged for the next commit.  It typically adds the current content of existing paths as a whole, but with some options it can also be used to add content with only part of the changes made to the working tree files applied, or remove paths that do not exist in the working tree anymore.
ro: Această comandă actualizează indexul folosind conținutul curent găsit în arborele de lucru, pentru a pregăti conținutul pregătit pentru următoarea confirmare.  De obicei, adaugă conținutul actual al căilor de acces existente ca întreg, dar, cu ajutorul unor opțiuni, poate fi utilizată și pentru a adăuga conținut cu aplicarea doar a unei părți din modificările aduse fișierelor din arborele de lucru sau pentru a elimina căile de acces care nu mai există în arborele de lucru.

note: type: Plain text
en: The "index" holds a snapshot of the content of the working tree, and it is this snapshot that is taken as the contents of the next commit.  Thus after making any changes to the working tree, and before running the commit command, you must use the `add` command to add any new or modified files to the index.
ro: "Index" conține un instantaneu al conținutului configurației de lucru, iar acest instantaneu este luat ca fiind conținutul următoarei comenzi.  Prin urmare, după ce ați efectuat orice modificare în configurația de lucru și înainte de a rula comanda commit, trebuie să utilizați comanda `add` pentru a adăuga orice fișier nou sau modificat la index.

note: type: Plain text
en: This command can be performed multiple times before a commit.  It only adds the content of the specified file(s) at the time the add command is run; if you want subsequent changes included in the next commit, then you must run `git add` again to add the new content to the index.
ro: Această comandă poate fi executată de mai multe ori înainte de o confirmare.  Aceasta adaugă doar conținutul fișierului (fișierelor) specificat(e) în momentul în care comanda add este executată; dacă doriți ca modificările ulterioare să fie incluse în următoarea confirmare, trebuie să executați din nou `git add` pentru a adăuga noul conținut la index.

note: type: Plain text
en: The `git status` command can be used to obtain a summary of which files have changes that are staged for the next commit.
ro: Comanda `git status` poate fi utilizată pentru a obține un rezumat al fișierelor care au modificări care sunt pregătite pentru următoarea confirmare.

note: type: Plain text
en: The `git add` command will not add ignored files by default.  If any ignored files were explicitly specified on the command line, `git add` will fail with a list of ignored files.  Ignored files reached by directory recursion or filename globbing performed by Git (quote your globs before the shell) will be silently ignored.  The 'git add' command can be used to add ignored files with the `-f` (force) option.
ro: Comanda `git add` nu va adăuga în mod implicit fișiere ignorate.  Dacă în linia de comandă au fost specificate în mod explicit fișiere ignorate, `git add` va eșua cu o listă de fișiere ignorate.  Fișierele ignorate la care se ajunge prin recursivitatea directoarelor sau prin globarea numelor de fișiere efectuată de Git (citați glob-urile înainte de shell) vor fi ignorate în mod silențios.  Comanda "git add" poate fi utilizată pentru a adăuga fișiere ignorate cu opțiunea `-f` (force).

note: type: Plain text
en: Please see linkgit:git-commit[1] for alternative ways to add content to a commit.
ro: Vă rugăm să consultați linkgit:git-commit[1] pentru modalități alternative de a adăuga conținut la un commit.

note: type: Title -
en: OPTIONS
ro: OPȚIUNI

note: type: Plain text
en: Files to add content from.  Fileglobs (e.g. `*.c`) can be given to add all matching files.  Also a leading directory name (e.g. `dir` to add `dir/file1` and `dir/file2`) can be given to update the index to match the current state of the directory as a whole (e.g.  specifying `dir` will record not just a file `dir/file1` modified in the working tree, a file `dir/file2` added to the working tree, but also a file `dir/file3` removed from the working tree). Note that older versions of Git used to ignore removed files; use `--no-all` option if you want to add modified or new files but ignore removed ones.
ro: Fișiere din care se adaugă conținut.  Se pot introduce blocuri de fișiere (de exemplu, `*.c`) pentru a adăuga toate fișierele corespunzătoare.  De asemenea, se poate introduce un nume de director (de exemplu, `dir` pentru a adăuga `dir/file1` și `dir/file2`) pentru a actualiza indexul pentru a se potrivi cu starea curentă a directorului ca întreg (de exemplu, dacă se specifică `dir` se va înregistra nu numai un fișier `dir/file1` modificat în configurația de lucru, un fișier `dir/file2` adăugat în configurația de lucru, ci și un fișier `dir/file3` eliminat din acesta). Rețineți că versiunile mai vechi ale Git obișnuiau să ignore fișierele eliminate; utilizați opțiunea `--no-all` dacă doriți să adăugați fișiere modificate sau noi, dar să le ignorați pe cele eliminate.

note: type: Plain text
en: For more details about the <pathspec> syntax, see the 'pathspec' entry in linkgit:gitglossary[7].
ro: Pentru mai multe detalii despre sintaxa <pathspec>, consultați intrarea "pathspec" din linkgit:gitglossary[7].

note: type: Plain text
en: Don't actually add the file(s), just show if they exist and/or will be ignored.
ro: Nu adăugați de fapt fișierul (fișierele), doar arătați dacă acestea există și/sau vor fi ignorate.

note: type: Plain text
en: Allow adding otherwise ignored files.
ro: Permite adăugarea de fișiere altfel ignorate.

note: type: Plain text
en: Add modified contents in the working tree interactively to the index. Optional path arguments may be supplied to limit operation to a subset of the working tree. See ``Interactive mode'' for details.
ro: Adăugați în mod interactiv la index conținutul modificat în configurația de lucru. Se pot furniza argumente opționale privind calea de acces pentru a limita operațiunea la un subset al structurii de lucru. A se vedea "Mod interactiv" pentru detalii.

note: type: Plain text
en: Interactively choose hunks of patch between the index and the work tree and add them to the index. This gives the user a chance to review the difference before adding modified contents to the index.
ro: Alegeți în mod interactiv bucăți de patch-uri între index și arborele de lucru și adăugați-le la index. Astfel, utilizatorul are posibilitatea de a examina diferența înainte de a adăuga conținutul modificat la index.

note: type: Plain text
en: This effectively runs `add --interactive`, but bypasses the initial command menu and directly jumps to the `patch` subcommand.  See ``Interactive mode'' for details.
ro: Acest lucru rulează efectiv `add --interactive`, dar ocolește meniul inițial de comenzi și trece direct la subcomanda `patch`.  Pentru detalii, consultați ``Modul interactiv''.

note: type: Plain text
en: Open the diff vs. the index in an editor and let the user edit it.  After the editor was closed, adjust the hunk headers and apply the patch to the index.
ro: Deschideți fișierul diferență față de index într-un editor și lăsați utilizatorul să îl editeze.  După ce editorul a fost închis, ajustați anteturile hunk și aplicați patch-ul la index.

note: type: Plain text
en: The intent of this option is to pick and choose lines of the patch to apply, or even to modify the contents of lines to be staged. This can be quicker and more flexible than using the interactive hunk selector.  However, it is easy to confuse oneself and create a patch that does not apply to the index. See EDITING PATCHES below.
ro: Scopul acestei opțiuni este de a selecta și de a alege liniile din patch-ul care urmează să fie aplicat sau chiar de a modifica conținutul liniilor care urmează să fie etapizate. Această opțiune poate fi mai rapidă și mai flexibilă decât utilizarea selectorului interactiv de hunk-uri.  Cu toate acestea, este ușor să te confunzi și să creezi un patch care nu se aplică la index. Consultați EDITING PATCHES (Editarea patch-urilor) de mai jos.

note: type: Plain text
en: Update the index just where it already has an entry matching <pathspec>.  This removes as well as modifies index entries to match the working tree, but adds no new files.
ro: Actualizează indexul doar acolo unde există deja o intrare care corespunde cu <pathspec>.  Acest lucru elimină și modifică intrările din index pentru a se potrivi cu arborele de lucru, dar nu adaugă fișiere noi.

note: type: Plain text
en: If no <pathspec> is given when `-u` option is used, all tracked files in the entire working tree are updated (old versions of Git used to limit the update to the current directory and its subdirectories).
ro: Dacă nu se dă nici o <pathspec> atunci când se utilizează opțiunea `-u`, sunt actualizate toate fișierele urmărite din întregul configurație de lucru (vechile versiuni ale Git obișnuiau să limiteze actualizarea la directorul curent și la subdirectoarele sale).

note: type: Plain text
en: Update the index not only where the working tree has a file matching <pathspec> but also where the index already has an entry. This adds, modifies, and removes index entries to match the working tree.
ro: Actualizează indexul nu numai în cazul în care în arborele de lucru există un fișier care se potrivește cu <pathspec>, ci și în cazul în care indexul are deja o intrare. Această operațiune adaugă, modifică și elimină intrări din index pentru a se potrivi cu structura de lucru.

note: type: Plain text
en: If no <pathspec> is given when `-A` option is used, all files in the entire working tree are updated (old versions of Git used to limit the update to the current directory and its subdirectories).
ro: Dacă nu se indică nicio <pathspec> atunci când se utilizează opțiunea `-A`, sunt actualizate toate fișierele din întregul configurator de lucru (vechile versiuni ale Git obișnuiau să limiteze actualizarea la directorul curent și la subdirectoarele sale).

note: type: Plain text
en: Update the index by adding new files that are unknown to the index and files modified in the working tree, but ignore files that have been removed from the working tree.  This option is a no-op when no <pathspec> is used.
ro: Actualizarea indexului prin adăugarea de fișiere noi necunoscute indexului și a fișierelor modificate în configurația de lucru, dar ignoră fișierele care au fost eliminate din configurația de lucru.  Această opțiune nu este opțională atunci când nu se utilizează <pathspec>.

note: type: Plain text
en: This option is primarily to help users who are used to older versions of Git, whose "git add <pathspec>..." was a synonym for "git add --no-all <pathspec>...", i.e. ignored removed files.
ro: Această opțiune este în primul rând pentru a ajuta utilizatorii care sunt obișnuiți cu versiunile mai vechi de Git, în care "git add <pathspec>..." era un sinonim pentru "git add --no-all <pathspec>...", adică ignora fișierele eliminate.

note: type: Plain text
en: Record only the fact that the path will be added later. An entry for the path is placed in the index with no content. This is useful for, among other things, showing the unstaged content of such files with `git diff` and committing them with `git commit -a`.
ro: Înregistrați doar faptul că traseul va fi adăugat ulterior. O intrare pentru calea de acces este plasată în index fără conținut. Acest lucru este util, printre altele, pentru a arăta conținutul neetajat al unor astfel de fișiere cu `git diff` și pentru a le confirma cu `git commit -a`.

note: type: Plain text
en: Don't add the file(s), but only refresh their stat()  information in the index.
ro: Nu adăugați fișierul (sau fișierele), ci doar reîmprospătați informațiile stat() ale acestora în index.

note: type: Plain text
en: If some files could not be added because of errors indexing them, do not abort the operation, but continue adding the others. The command shall still exit with non-zero status.  The configuration variable `add.ignoreErrors` can be set to true to make this the default behaviour.
ro: În cazul în care unele fișiere nu au putut fi adăugate din cauza unor erori de indexare, nu întrerupeți operațiunea, ci continuați să le adăugați pe celelalte. Comanda va ieși în continuare cu un status diferit de zero.  Variabila de configurare `add.ignoreErrors` poate fi setată la true pentru ca acesta să fie comportamentul implicit.

note: type: Plain text
en: This option can only be used together with --dry-run. By using this option the user can check if any of the given files would be ignored, no matter if they are already present in the work tree or not.
ro: Această opțiune poate fi utilizată numai împreună cu --dry-run. Utilizând această opțiune, utilizatorul poate verifica dacă vreunul dintre fișierele date va fi ignorat, indiferent dacă acestea sunt deja prezente sau nu în configurația de lucru.

note: type: Plain text
en: By default, `git add` will warn when adding an embedded repository to the index without using `git submodule add` to create an entry in `.gitmodules`. This option will suppress the warning (e.g., if you are manually performing operations on submodules).
ro: În mod implicit, `git add` va avertiza atunci când se adaugă un depozit încorporat în index fără a folosi `git submodule add` pentru a crea o intrare în `.gitmodules`. Această opțiune va suprima avertismentul (de exemplu, dacă efectuați manual operațiuni asupra submodulelor).

note: type: Plain text
en: Apply the "clean" process freshly to all tracked files to forcibly add them again to the index.  This is useful after changing `core.autocrlf` configuration or the `text` attribute in order to correct files added with wrong CRLF/LF line endings.  This option implies `-u`.
ro: Aplicați proaspăt procesul "clean" la toate fișierele urmărite pentru a le adăuga din nou cu forța la index.  Acest lucru este util după modificarea configurației `core.autocrlf` sau a atributului `text` pentru a corecta fișierele adăugate cu terminații de linie CRLF/LF greșite.  Această opțiune implică `-u`.

note: type: Plain text
en: Override the executable bit of the added files.  The executable bit is only changed in the index, the files on disk are left unchanged.
ro: Suprascrieți bitul executabil al fișierelor adăugate.  Bitul executabil este modificat doar în index, fișierele de pe disc rămân neschimbate.

note: type: Labeled list
en: --pathspec-from-file=<file>
ro: --pathspec-from-file=<fișier>

note: type: Plain text
en: Pathspec is passed in `<file>` instead of commandline args. If `<file>` is exactly `-` then standard input is used. Pathspec elements are separated by LF or CR/LF. Pathspec elements can be quoted as explained for the configuration variable `core.quotePath` (see linkgit:git-config[1]). See also `--pathspec-file-nul` and global `--literal-pathspecs`.
ro: Pathspec este transmis în `<file>` în loc de argetele din linia de comandă. Dacă `<file>` este exact `-`, se utilizează intrarea standard. Elementele Pathspec sunt separate prin LF sau CR/LF. Elementele Pathspec pot fi citate așa cum se explică pentru variabila de configurare `core.quotePath` (a se vedea linkgit:git-config[1]). A se vedea și `--pathspec-file-nul` și `--literal-pathspecs` global.

note: type: Plain text
en: Only meaningful with `--pathspec-from-file`. Pathspec elements are separated with NUL character and all other characters are taken literally (including newlines and quotes).
ro: Are sens numai cu `--pathspec-from-file`. Elementele Pathspec sunt separate prin caracterul NUL, iar toate celelalte caractere sunt luate în considerare în mod literal (inclusiv liniile de început și ghilimelele).

note: type: Plain text
en: This option can be used to separate command-line options from the list of files, (useful when filenames might be mistaken for command-line options).
ro: Această opțiune poate fi utilizată pentru a separa opțiunile liniei de comandă de lista de fișiere (util atunci când numele fișierelor pot fi confundate cu opțiunile liniei de comandă).

note: type: Title -
en: EXAMPLES
ro: EXEMPLE

note: type: Plain text
en: Adds content from all `*.txt` files under `Documentation` directory and its subdirectories:
ro: Adaugă conținutul din toate fișierele `*.txt` din directorul `Documentation` și din subdirectoarele sale:

note: type: Plain text
en: Note that the asterisk `*` is quoted from the shell in this example; this lets the command include the files from subdirectories of `Documentation/` directory.
ro: Observați că asteriscul `*` este citat din shell în acest exemplu; acest lucru permite comenzii să includă fișierele din subdirectoarele din directorul `Documentation/`.

note: type: Plain text
en: Considers adding content from all git-*.sh scripts:
ro: Are în vedere adăugarea conținutului din toate scripturile git-*.sh:

note: type: Plain text
en: Because this example lets the shell expand the asterisk (i.e. you are listing the files explicitly), it does not consider `subdir/git-foo.sh`.
ro: Deoarece acest exemplu permite shell-ului să extindă asteriscul (adică listați fișierele în mod explicit), nu ia în considerare `subdir/git-foo.sh`.

note: type: Title -
en: INTERACTIVE MODE
ro: MODUL INTERACTIV

note: type: Plain text
en: When the command enters the interactive mode, it shows the output of the 'status' subcommand, and then goes into its interactive command loop.
ro: Atunci când comanda intră în modul interactiv, aceasta afișează rezultatul subcomandei "status" și apoi intră în bucla de comandă interactivă.

note: type: Plain text
en: The command loop shows the list of subcommands available, and gives a prompt "What now> ".  In general, when the prompt ends with a single '>', you can pick only one of the choices given and type return, like this:
ro: Bucla de comenzi afișează lista de subcomandă disponibile și oferă o solicitare "What now> ".  În general, atunci când promptul se termină cu un singur ">", puteți alege doar una dintre opțiunile oferite și tasta return, astfel:

note: type: delimited block -
en:     *** Commands ***
          1: status       2: update       3: revert       4: add untracked
          5: patch        6: diff         7: quit         8: help
        What now> 1
ro:     *** Comenzi ***
          1: status 2: update 3: revert 4: add untracked
          5: patch 6: diff 7: quit 8: help
        Ce se întâmplă acum> 1
    patch        6: diff         7: quit         8: help
        What now> 1

note: type: Plain text
en: You also could say `s` or `sta` or `status` above as long as the choice is unique.
ro: De asemenea, puteți spune `s` sau `sta` sau `status` mai sus, atâta timp cât alegerea este unică.

note: type: Plain text
en: The main command loop has 6 subcommands (plus help and quit).
ro: Bucla comenzii principale are 6 subcomandă (plus help și quit).

note: type: Plain text
en: This shows the change between HEAD and index (i.e. what will be committed if you say `git commit`), and between index and working tree files (i.e. what you could stage further before `git commit` using `git add`) for each path.  A sample output looks like this:
ro: Aceasta arată modificarea între HEAD și index (adică ceea ce va fi trimis dacă spui `git commit`) și între index și fișierele din configurația  de lucru (adică ceea ce ai putea modifica înainte de `git commit` folosind `git add`) pentru fiecare cale.  Un exemplu de ieșire arată astfel:

note: type: delimited block -
en:               staged     unstaged path
         1:       binary      nothing foo.png
         2:     +403/-35        +1/-1 git-add--interactive.perl
ro:               traseu etapizat      neetapizat
         1: binary       nothing foo.png
         2: +403/-35 +1/-1 git-add--interactive.perl

note: type: Plain text
en: It shows that foo.png has differences from HEAD (but that is binary so line count cannot be shown) and there is no difference between indexed copy and the working tree version (if the working tree version were also different, 'binary' would have been shown in place of 'nothing').  The other file, git-add{litdd}interactive.perl, has 403 lines added and 35 lines deleted if you commit what is in the index, but working tree file has further modifications (one addition and one deletion).
ro: Se arată că foo.png are diferențe față de HEAD (dar acesta este binar, astfel încât nu poate fi afișat numărul de linii) și nu există nicio diferență între copia indexată și versiunea structurii de lucru (dacă versiunea structurii de lucru ar fi fost, de asemenea, diferită, ar fi fost afișat "binar" în loc de "nimic").  Celălalt fișier, git-add{litdd}interactive.perl, are 403 linii adăugate și 35 de linii șterse dacă se confirmă ceea ce este în index, dar fișierul din configurația arborelui de lucru are alte modificări (o adăugare și o ștergere).

note: type: Plain text
en: This shows the status information and issues an "Update>>" prompt.  When the prompt ends with double '>>', you can make more than one selection, concatenated with whitespace or comma.  Also you can say ranges.  E.g. "2-5 7,9" to choose 2,3,4,5,7,9 from the list.  If the second number in a range is omitted, all remaining patches are taken.  E.g. "7-" to choose 7,8,9 from the list.  You can say '*' to choose everything.
ro: Aceasta afișează informațiile de stare și emite o solicitare "Update>>".  Atunci când promptul se termină cu dublu ">>", puteți face mai multe selecții, concatenate cu spații albe sau virgule.  De asemenea, puteți spune intervale.  De exemplu, "2-5 7,9" pentru a alege 2,3,4,5,7,9 din listă.  Dacă al doilea număr dintr-un interval este omis, sunt luate toate patch-urile rămase.  De exemplu, "7-" pentru a alege 7,8,9 din listă.  Puteți spune "*" pentru a alege totul.

note: type: Plain text
en: What you chose are then highlighted with '*', like this:
ro: Cele pe care le-ați ales sunt apoi evidențiate cu "*", astfel:

note: type: Plain text
en: To remove selection, prefix the input with `-` like this:
ro: Pentru a elimina selecția, prefixați intrarea cu `-`, astfel:

note: type: Plain text
en: After making the selection, answer with an empty line to stage the contents of working tree files for selected paths in the index.
ro: După efectuarea selecției, răspundeți cu o linie goală pentru a pune în scenă conținutul fișierelor din configurația de lucru pentru căile selectate în index.

note: type: Labeled list
en: revert
ro: reveniți la

note: type: Plain text
en: This has a very similar UI to 'update', and the staged information for selected paths are reverted to that of the HEAD version.  Reverting new paths makes them untracked.
ro: Aceasta are o interfață de utilizare foarte asemănătoare cu "update", iar informațiile etapizate pentru căile selectate sunt readuse la cele din versiunea HEAD.  Anularea căilor de acces noi le face să nu mai fie urmărite.

note: type: Labeled list
en: add untracked
ro: adăugați untracked

note: type: Plain text
en: This has a very similar UI to 'update' and 'revert', and lets you add untracked paths to the index.
ro: Aceasta are o interfață de utilizare foarte asemănătoare cu 'update' și 'revert' și vă permite să adăugați la index căi de acces netrasate.

note: type: Plain text
en: This lets you choose one path out of a 'status' like selection.  After choosing the path, it presents the diff between the index and the working tree file and asks you if you want to stage the change of each hunk.  You can select one of the following options and type return:
ro: Acest lucru vă permite să alegeți o cale dintr-o selecție de tip "status".  După alegerea căii, vă prezintă diferența dintre fișierul index și fișierul de lucru și vă întreabă dacă doriți să etapizați modificarea fiecărei bucăți.  Puteți selecta una dintre următoarele opțiuni și tasta return:

note: type: Plain text
en: y - stage this hunk
    n - do not stage this hunk
    q - quit; do not stage this hunk or any of the remaining ones
    a - stage this hunk and all later hunks in the file
    d - do not stage this hunk or any of the later hunks in the file
    g - select a hunk to go to
    / - search for a hunk matching the given regex
    j - leave this hunk undecided, see next undecided hunk
    J - leave this hunk undecided, see next hunk
    k - leave this hunk undecided, see previous undecided hunk
    K - leave this hunk undecided, see previous hunk
    s - split the current hunk into smaller hunks
    e - manually edit the current hunk
    ? - print help
ro: y - pune în scenă această bucată
    n - nu puneți în scenă această bucată
    q - renunță; nu pune în scenă această bucată sau oricare dintre cele rămase
    a - pune în scenă această bucată și toate bucățile ulterioare din fișier
    d - nu pune în scenă această bucată și nici una dintre bucățile ulterioare din fișier
    g - selectează o bucată la care să treacă
    / - caută o bucată care se potrivește cu regex-ul dat
    j - lasă această bucată nehotărâtă, vezi următoarea bucată nehotărâtă
    J - lasă acest hunk nehotărât, vezi următorul hunk
    k - lasă această bucată nehotărâtă, vezi bucată nehotărâtă anterioară
    K - lasă această bucată nehotărâtă, vezi bucată anterioară
    s - împarte bucata curentă în bucăți mai mici
    e - editează manual hunk-ul curent
    ? - tipărește ajutorul

note: type: Plain text
en: After deciding the fate for all hunks, if there is any hunk that was chosen, the index is updated with the selected hunks.
ro: După ce se hotărăște ce se întâmplă cu toate părțile, în cazul în care există o parte care a fost aleasă, indexul este actualizat cu părțile selectate.

note: type: Plain text
en: You can omit having to type return here, by setting the configuration variable `interactive.singleKey` to `true`.
ro: Puteți omite să tastați return aici, prin setarea variabilei de configurare `interactive.singleKey` la `true`.

note: type: Plain text
en: This lets you review what will be committed (i.e. between HEAD and index).
ro: Acest lucru vă permite să verificați ce va fi confirmat (adică între HEAD și index).

note: type: Title -
en: EDITING PATCHES
ro: EDITAREA PATCH-URILOR

note: type: Plain text
en: Invoking `git add -e` or selecting `e` from the interactive hunk selector will open a patch in your editor; after the editor exits, the result is applied to the index. You are free to make arbitrary changes to the patch, but note that some changes may have confusing results, or even result in a patch that cannot be applied.  If you want to abort the operation entirely (i.e., stage nothing new in the index), simply delete all lines of the patch. The list below describes some common things you may see in a patch, and which editing operations make sense on them.
ro: Invocând `git add -e` sau selectând `e` din selectorul interactiv hunk va deschide un patch în editorul dumneavoastră; după ce editorul iese, rezultatul este aplicat la index. Sunteți liber să faceți modificări arbitrare la patch, dar rețineți că unele modificări pot avea rezultate confuze sau chiar pot duce la un patch care nu poate fi aplicat.  Dacă doriți să abandonați complet operațiunea (adică să nu mai puneți nimic nou în index), ștergeți pur și simplu toate liniile din patch. Lista de mai jos descrie unele lucruri comune pe care le puteți vedea într-un patch și ce operații de editare au sens asupra lor.

note: type: Labeled list
en: added content
ro: conținut adăugat

note: type: Plain text
en: Added content is represented by lines beginning with "{plus}". You can prevent staging any addition lines by deleting them.
ro: Conținutul adăugat este reprezentat de liniile care încep cu "{plus}". Puteți împiedica punerea în scenă a liniilor de adăugare prin ștergerea acestora.

note: type: Labeled list
en: removed content
ro: conținut eliminat

note: type: Plain text
en: Removed content is represented by lines beginning with "-". You can prevent staging their removal by converting the "-" to a " " (space).
ro: Conținutul eliminat este reprezentat de liniile care încep cu "-". Puteți preveni eliminarea lor prin transformarea lui "-" într-un " " (spațiu).

note: type: Labeled list
en: modified content
ro: conținut modificat

note: type: Plain text
en: Modified content is represented by "-" lines (removing the old content)  followed by "{plus}" lines (adding the replacement content). You can prevent staging the modification by converting "-" lines to " ", and removing "{plus}" lines. Beware that modifying only half of the pair is likely to introduce confusing changes to the index.
ro: Conținutul modificat este reprezentat prin linii "-" (eliminarea conținutului vechi) urmate de linii "{plus}" (adăugarea conținutului de înlocuire). Puteți preveni etapizarea modificării prin transformarea liniilor "-" în " " și prin eliminarea liniilor "{plus}". Aveți grijă că modificarea doar a jumătate din pereche este posibil să introducă modificări confuze în index.

note: type: Plain text
en: There are also more complex operations that can be performed. But beware that because the patch is applied only to the index and not the working tree, the working tree will appear to "undo" the change in the index.  For example, introducing a new line into the index that is in neither the HEAD nor the working tree will stage the new line for commit, but the line will appear to be reverted in the working tree.
ro: Există, de asemenea, operații mai complexe care pot fi efectuate. Atenție însă, deoarece patch-ul este aplicat numai la index și nu la configurația de lucru, arborele de lucru va părea că "anulează" modificarea din index.  De exemplu, introducerea unei linii noi în index care nu se află nici în HEAD, nici în configurația de lucru va pune în scenă noua linie pentru confirmare, dar linia va părea că a fost anulată în acesta.

note: type: Plain text
en: Avoid using these constructs, or do so with extreme caution.
ro: Evitați să utilizați aceste construcții sau faceți acest lucru cu mare precauție.

note: type: Labeled list
en: removing untouched content
ro: eliminarea conținutului neatins

note: type: Plain text
en: Content which does not differ between the index and working tree may be shown on context lines, beginning with a " " (space).  You can stage context lines for removal by converting the space to a "-". The resulting working tree file will appear to re-add the content.
ro: Conținutul care nu diferă între index și structura de lucru poate fi afișat pe linii de context, începând cu un " " (spațiu).  Puteți etapiza liniile de context pentru a fi eliminate prin transformarea spațiului în "-". Fișierul configurat în structura de lucru va apărea pentru a reintroduce conținutul.

note: type: Labeled list
en: modifying existing content
ro: modificarea conținutului existent

note: type: Plain text
en: One can also modify context lines by staging them for removal (by converting " " to "-") and adding a "{plus}" line with the new content.  Similarly, one can modify "{plus}" lines for existing additions or modifications. In all cases, the new modification will appear reverted in the working tree.
ro: Se pot modifica, de asemenea, liniile de context, prin pregătirea lor pentru eliminare (prin transformarea " " în "-") și adăugarea unei linii "{plus}" cu noul conținut.  În mod similar, se pot modifica liniile "{plus}" pentru adăugirile sau modificările existente. În toate cazurile, noua modificare va apărea inversată în configurația de lucru.

note: type: Labeled list
en: new content
ro: conținut nou

note: type: Plain text
en: You may also add new content that does not exist in the patch; simply add new lines, each starting with "{plus}". The addition will appear reverted in the working tree.
ro: De asemenea, puteți adăuga conținut nou care nu există în patch; pur și simplu adăugați linii noi, fiecare începând cu "{plus}". Adăugarea va apărea inversată în configurația de lucru.

note: type: Plain text
en: There are also several operations which should be avoided entirely, as they will make the patch impossible to apply:
ro: Există, de asemenea, câteva operațiuni care ar trebui evitate în totalitate, deoarece acestea vor face imposibilă aplicarea patch-ului:

note: type: Plain text
en: adding context (" ") or removal ("-") lines
ro: adăugarea de linii de context (" ") sau de eliminare ("-")

note: type: Plain text
en: deleting context or removal lines
ro: ștergerea liniilor de context sau de eliminare

note: type: Plain text
en: modifying the contents of context or removal lines
ro: modificarea conținutului liniilor de context sau de eliminare

note: type: Title -
en: SEE ALSO
ro: VEZI ȘI

note: type: Plain text
en: Part of the linkgit:git[1] suite
ro: Parte a suitei linkgit:git[1]

note: type: Plain text
en: git-clone - Clone a repository into a new directory
ro: git-clone - Clonează un depozit într-un nou director

note: type: Plain text
en: 'git clone' [--template=<template_directory>]
    	  [-l] [-s] [--no-hardlinks] [-q] [-n] [--bare] [--mirror]
    	  [-o <name>] [-b <name>] [-u <upload-pack>] [--reference <repository>]
    	  [--dissociate] [--separate-git-dir <git dir>]
    	  [--depth <depth>] [--[no-]single-branch] [--no-tags]
    	  [--recurse-submodules[=<pathspec>]] [--[no-]shallow-submodules]
    	  [--[no-]remote-submodules] [--jobs <n>] [--sparse] [--[no-]reject-shallow]
    	  [--filter=<filter>] [--] <repository>
    	  [<directory>]
ro: 'git clone' [--template=<template_director>]
    	  [-l] [-s] [--no-hardlinks] [-q] [-n] [--bare] [--mirror]
    	  [-o <name>] [-b <name>] [-u <upload-pack>] [--reference <depozit>]
    	  [--dissociate] [--separate-git-dir <git dir>]
    	  [--depth <depth>] [--[no-]single-branch] [--no-tags]
    	  [--recurse-submodules[=<pathspec>]] [--[no-]shallow-submodules]
    	  [--[no-]remote-submodules] [--jobs <n>] [--sparse] [--[no-]reject-shallow]
    	  [--filter=<filter>] [--] <depozit>
    	  [<director>]

note: type: Plain text
en: Clones a repository into a newly created directory, creates remote-tracking branches for each branch in the cloned repository (visible using `git branch --remotes`), and creates and checks out an initial branch that is forked from the cloned repository's currently active branch.
ro: Clonează un depozit într-un director nou creat, creează branșe de urmărire la distanță pentru fiecare branșă din depozitul clonat (vizibile folosind `git branch --remotes`) și creează și extrage o branșă inițială care este bifurcată din branșa activă a depozitului clonat.

note: type: Plain text
en: After the clone, a plain `git fetch` without arguments will update all the remote-tracking branches, and a `git pull` without arguments will in addition merge the remote master branch into the current master branch, if any (this is untrue when "--single-branch" is given; see below).
ro: După clonare, un simplu `git fetch` fără argumente va actualiza toate branșele de urmărire de la distanță, iar un `git pull` fără argumente va unifica în plus branșa master de la distanță în branșa master curentă, dacă există (acest lucru nu este adevărat atunci când se dă "--single-branch"; vezi mai jos).

note: type: Plain text
en: This default configuration is achieved by creating references to the remote branch heads under `refs/remotes/origin` and by initializing `remote.origin.url` and `remote.origin.fetch` configuration variables.
ro: Această configurație implicită este realizată prin crearea de referințe la capetele de branșă la distanță în `refs/remotes/origin` și prin inițializarea variabilelor de configurare `remote.origin.url` și `remote.origin.fetch`.

note: type: Plain text
en: When the repository to clone from is on a local machine, this flag bypasses the normal "Git aware" transport mechanism and clones the repository by making a copy of HEAD and everything under objects and refs directories.  The files under `.git/objects/` directory are hardlinked to save space when possible.
ro: Atunci când depozitul din care se clonează se află pe o mașină locală, acest indicator ocolește mecanismul normal de transport "Git aware" și clonează depozitul prin copierea lui HEAD și a tot ceea ce se află în directoarele objects și refs.  Fișierele din directorul `.git/objects/` sunt legate prin hardlinking pentru a economisi spațiu atunci când este posibil.

note: type: Plain text
en: If the repository is specified as a local path (e.g., `/path/to/repo`), this is the default, and --local is essentially a no-op.  If the repository is specified as a URL, then this flag is ignored (and we never use the local optimizations).  Specifying `--no-local` will override the default when `/path/to/repo` is given, using the regular Git transport instead.
ro: Dacă depozitul este specificat ca fiind o cale locală (de exemplu, `/path/to/repo`), aceasta este calea implicită, iar --local este în esență o opțiune fără efect.  Dacă depozitul este specificat ca o adresă URL, atunci acest indicator este ignorat (și nu vom folosi niciodată optimizările locale).  Dacă se specifică `--no-local`, se va anula valoarea implicită atunci când se indică `/path/to/repo`, utilizând în schimb transportul Git obișnuit.

note: type: Plain text
en: *NOTE*: this operation can race with concurrent modification to the
    source repository, similar to running `cp -r src dst` while modifying
    `src`.
ro: *NOTA*: această operațiune se poate întrece cu modificarea concurentă a fișierului
    depozitului sursă, similar cu rularea `cp -r src dst` în timp ce se modifică
    `src`.

note: type: Plain text
en: Force the cloning process from a repository on a local filesystem to copy the files under the `.git/objects` directory instead of using hardlinks. This may be desirable if you are trying to make a back-up of your repository.
ro: Forțează procesul de clonare de la un depozit pe un sistem de fișiere local să copieze fișierele din directorul `.git/objects` în loc să folosească hardlink-uri. Acest lucru poate fi de dorit dacă încercați să faceți o copie de siguranță a depozitului dumneavoastră.

note: type: Plain text
en: When the repository to clone is on the local machine, instead of using hard links, automatically setup `.git/objects/info/alternates` to share the objects with the source repository.  The resulting repository starts out without any object of its own.
ro: Atunci când depozitul de clonat se află pe calculatorul local, în loc să folosiți legături dure, configurați automat `.git/objects/info/alternates` pentru a partaja obiectele cu depozitul sursă.  Depozitul rezultat pornește fără niciun obiect propriu.

note: type: Plain text
en: *NOTE*: this is a possibly dangerous operation; do *not* use
    it unless you understand what it does. If you clone your
    repository using this option and then delete branches (or use any
    other Git command that makes any existing commit unreferenced) in the
    source repository, some objects may become unreferenced (or dangling).
    These objects may be removed by normal Git operations (such as `git commit`)
    which automatically call `git maintenance run --auto`. (See
    linkgit:git-maintenance[1].) If these objects are removed and were referenced
    by the cloned repository, then the cloned repository will become corrupt.
ro: *NOTA*: aceasta este o operațiune care poate fi periculoasă; *nu* folosiți
    dacă nu înțelegeți ce face. Dacă vă clonați
    depozitul folosind această opțiune și apoi ștergeți ramuri (sau folosiți orice
    altă comandă Git care face ca orice comitere existentă să nu mai aibă referință) în
    depozit sursă, este posibil ca unele obiecte să nu mai aibă referințe (sau să fie suspendate).
    Aceste obiecte pot fi eliminate prin operațiuni Git normale (cum ar fi `git commit`)
    care apelează automat `git maintenance run --auto`. (A se vedea
    linkgit:git-maintenance[1].) În cazul în care aceste obiecte sunt eliminate și au fost menționate
    de către depozitul clonat, atunci depozitul clonat va deveni corupt.

note: type: Plain text
en: Note that running `git repack` without the `--local` option in a repository cloned with `--shared` will copy objects from the source repository into a pack in the cloned repository, removing the disk space savings of `clone --shared`.  It is safe, however, to run `git gc`, which uses the `--local` option by default.
ro: Rețineți că rularea `git repack` fără opțiunea `--local` într-un depozit clonat cu `--shared` va copia obiectele din depozitul sursă într-un pachet din depozitul clonat, eliminând economiile de spațiu pe disc realizate de `clone --shared`.  Cu toate acestea, este sigur să rulați `git gc`, care utilizează opțiunea `--local` în mod implicit.

note: type: Plain text
en: If you want to break the dependency of a repository cloned with `--shared` on its source repository, you can simply run `git repack -a` to copy all objects from the source repository into a pack in the cloned repository.
ro: Dacă doriți să întrerupeți dependența unui depozit clonat cu `--shared` de depozitul sursă, puteți rula pur și simplu `git repack -a` pentru a copia toate obiectele din depozitul sursă într-un pachet din depozitul clonat.

note: type: Labeled list
en: --reference[-if-able] <repository>
ro: --reference[-if-able] <depozit>

note: type: Plain text
en: If the reference repository is on the local machine, automatically setup `.git/objects/info/alternates` to obtain objects from the reference repository.  Using an already existing repository as an alternate will require fewer objects to be copied from the repository being cloned, reducing network and local storage costs.  When using the `--reference-if-able`, a non existing directory is skipped with a warning instead of aborting the clone.
ro: În cazul în care depozitul de referință se află pe calculatorul local, configurați automat `.git/objects/info/alternates` pentru a obține obiecte din depozitul de referință.  Utilizarea unui depozit deja existent ca alternativă va necesita mai puține obiecte care să fie copiate din depozitul clonat, reducând costurile de rețea și de stocare locală.  Atunci când se utilizează `--reference-if-able`, un director inexistent este sărit cu un avertisment în loc să se anuleze clonarea.

note: type: Plain text
en: *NOTE*: see the NOTE for the `--shared` option, and also the
    `--dissociate` option.
ro: *NOTA*: a se vedea NOTA pentru opțiunea `--shared` și, de asemenea, opțiunea
    `--dissociate`.

note: type: Plain text
en: Borrow the objects from reference repositories specified with the `--reference` options only to reduce network transfer, and stop borrowing from them after a clone is made by making necessary local copies of borrowed objects.  This option can also be used when cloning locally from a repository that already borrows objects from another repository--the new repository will borrow objects from the same repository, and this option can be used to stop the borrowing.
ro: Împrumutați obiectele din depozitele de referință specificate cu opțiunile `--reference` numai pentru a reduce transferul de rețea și încetați să mai împrumutați din acestea după ce se face o clonă, făcând copiile locale necesare ale obiectelor împrumutate.  Această opțiune poate fi utilizată și atunci când se clonează local dintr-un depozit care împrumută deja obiecte de la un alt depozit - noul depozit va împrumuta obiecte din același depozit, iar această opțiune poate fi utilizată pentru a opri împrumutul.

note: type: Plain text
en: Operate quietly.  Progress is not reported to the standard error stream.
ro: Funcționează în liniște.  Progresul nu este raportat la fluxul de eroare standard.

note: type: Plain text
en: Run verbosely. Does not affect the reporting of progress status to the standard error stream.
ro: Se execută la nivel verbal. Nu afectează raportarea stării de progres către fluxul de eroare standard.

note: type: Plain text
en: Progress status is reported on the standard error stream by default when it is attached to a terminal, unless `--quiet` is specified. This flag forces progress status even if the standard error stream is not directed to a terminal.
ro: Starea de progres este raportată în mod implicit pe fluxul de eroare standard atunci când este atașat la un terminal, cu excepția cazului în care se specifică `--quiet`. Acest indicator forțează starea de progres chiar dacă fluxul de eroare standard nu este direcționat către un terminal.

note: type: Plain text
en: No checkout of HEAD is performed after the clone is complete.
ro: După finalizarea clonei, nu se efectuează nicio verificare a lui HEAD.

note: type: Plain text
en: Fail if the source repository is a shallow repository.  The 'clone.rejectShallow' configuration variable can be used to specify the default.
ro: Eșuează dacă depozitul sursă este un depozit superficial.  Variabila de configurare "clone.rejectShallow" poate fi utilizată pentru a specifica valoarea implicită.

note: type: Plain text
en: Make a 'bare' Git repository.  That is, instead of creating `<directory>` and placing the administrative files in `<directory>/.git`, make the `<directory>` itself the `$GIT_DIR`. This obviously implies the `--no-checkout` because there is nowhere to check out the working tree.  Also the branch heads at the remote are copied directly to corresponding local branch heads, without mapping them to `refs/remotes/origin/`.  When this option is used, neither remote-tracking branches nor the related configuration variables are created.
ro: Creați un depozit Git "gol".  Adică, în loc să creați `<directory>` și să plasați fișierele administrative în `<directory>/.git`, faceți din `<directory>` însuși `<directory>` `$GIT_DIR`. Acest lucru implică în mod evident `--no-checkout`, deoarece nu există niciun loc unde să se verifice structura de lucru.  De asemenea, capetele de branșă de la distanță sunt copiate direct în capetele de branșă locale corespunzătoare, fără a le cartografia în `refs/remotes/origin/`.  Când se utilizează această opțiune, nu se creează nici branșele de urmărire la distanță, nici variabilele de configurare aferente.

note: type: Plain text
en: Initialize the sparse-checkout file so the working directory starts with only the files in the root of the repository. The sparse-checkout file can be modified to grow the working directory as needed.
ro: Inițializați fișierul sparse-checkout astfel încât directorul de lucru să înceapă doar cu fișierele din root-ul depozitului. Fișierul sparse-checkout poate fi modificat pentru a mări directorul de lucru, după cum este necesar.

note: type: Plain text
en: Use the partial clone feature and request that the server sends a subset of reachable objects according to a given object filter.  When using `--filter`, the supplied `<filter-spec>` is used for the partial clone filter. For example, `--filter=blob:none` will filter out all blobs (file contents) until needed by Git. Also, `--filter=blob:limit=<size>` will filter out all blobs of size at least `<size>`. For more details on filter specifications, see the `--filter` option in linkgit:git-rev-list[1].
ro: Utilizați funcția de clonare parțială și solicitați ca serverul să trimită un subset de obiecte accesibile în funcție de un anumit filtru de obiecte.  Atunci când se utilizează `--filter`, se utilizează `<filter-spec>` furnizat pentru filtrul de clonare parțială. De exemplu, `--filter=blob:none` va filtra toate blob-urile (conținutul fișierelor) până când Git va avea nevoie de ele. De asemenea, `--filter=blob:limit=<size>` va filtra toate blob-urile cu o dimensiune de cel puțin `<size>`. Pentru mai multe detalii despre specificațiile filtrelor, consultați opțiunea `--filter` din linkgit:git-rev-list[1].

note: type: Plain text
en: Set up a mirror of the source repository.  This implies `--bare`.  Compared to `--bare`, `--mirror` not only maps local branches of the source to local branches of the target, it maps all refs (including remote-tracking branches, notes etc.) and sets up a refspec configuration such that all these refs are overwritten by a `git remote update` in the target repository.
ro: Configurați o oglindă a depozitului sursă.  Acest lucru implică `--bare`.  În comparație cu `--bare`, `--mirror` nu numai că mapează branșele locale ale sursei în branșele locale ale țintei, ci mapează toate referințele (inclusiv branșele de urmărire la distanță, notele etc.) și stabilește o configurație refspec astfel încât toate aceste referințe să fie suprascrise de o `git remote update` în depozitul țintă.

note: type: Labeled list
en: --origin <name>
ro: --origin <nume>

note: type: Plain text
en: Instead of using the remote name `origin` to keep track of the upstream repository, use `<name>`.  Overrides `clone.defaultRemoteName` from the config.
ro: În loc să folosiți numele de la distanță `origin` pentru a ține evidența depozitului din upstream, folosiți `<name>`.  Suprascrie `clone.defaultRemoteName` din configurare.

note: type: Plain text
en: Instead of pointing the newly created HEAD to the branch pointed to by the cloned repository's HEAD, point to `<name>` branch instead. In a non-bare repository, this is the branch that will be checked out.  `--branch` can also take tags and detaches the HEAD at that commit in the resulting repository.
ro: În loc să direcționați HEAD nou creat către branșa indicată de HEAD-ul depozitului clonat, direcționați-l către ramura `<name>`. Într-un depozit non-bare, aceasta este branșa care va fi verificată.  `--branch` poate, de asemenea, să primească etichete și detașează HEAD la acea confirmare în depozitul rezultat.

note: type: Plain text
en: When given, and the repository to clone from is accessed via ssh, this specifies a non-default path for the command run on the other end.
ro: Atunci când este dată, iar depozitul din care se clonează este accesat prin ssh, aceasta specifică o cale diferită de cea implicită pentru comanda executată la celălalt capăt.

note: type: Plain text
en: Specify the directory from which templates will be used; (See the "TEMPLATE DIRECTORY" section of linkgit:git-init[1].)
ro: Specificați directorul din care vor fi utilizate șabloanele; (Consultați secțiunea "TEMPLATE DIRECTORY" din linkgit:git-init[1])

note: type: Labeled list
en: --config <key>=<value>
ro: --config <key>=<valoare>

note: type: Plain text
en: Set a configuration variable in the newly-created repository; this takes effect immediately after the repository is initialized, but before the remote history is fetched or any files checked out.  The key is in the same format as expected by linkgit:git-config[1] (e.g., `core.eol=true`). If multiple values are given for the same key, each value will be written to the config file. This makes it safe, for example, to add additional fetch refspecs to the origin remote.
ro: Setați o variabilă de configurare în depozitul nou-creat; aceasta intră în vigoare imediat după ce depozitul este inițializat, dar înainte ca istoricul de la distanță să fie preluat sau ca orice fișier să fie verificat.  Cheia este în același format ca cel așteptat de linkgit:git-config[1] (de exemplu, `core.eol=true`). Dacă sunt date mai multe valori pentru aceeași cheie, fiecare valoare va fi scrisă în fișierul de configurare. Acest lucru face ca, de exemplu, să fie sigură adăugarea unor refspecs suplimentare de preluare la remote origin.

note: type: Plain text
en: Due to limitations of the current implementation, some configuration variables do not take effect until after the initial fetch and checkout.  Configuration variables known to not take effect are: `remote.<name>.mirror` and `remote.<name>.tagOpt`.  Use the corresponding `--mirror` and `--no-tags` options instead.
ro: Din cauza limitărilor implementării actuale, unele variabile de configurare nu intră în vigoare decât după preluarea și verificarea inițială.  Se știe că variabilele de configurare care nu își fac efectul sunt: `remote.<name>.mirror` și `remote.<name>.tagOpt`.  Utilizați în schimb opțiunile corespunzătoare `--mirror` și `--no-tags`.

note: type: Labeled list
en: --depth <depth>
ro: --depth <adâncime>

note: type: Plain text
en: Create a 'shallow' clone with a history truncated to the specified number of commits. Implies `--single-branch` unless `--no-single-branch` is given to fetch the histories near the tips of all branches. If you want to clone submodules shallowly, also pass `--shallow-submodules`.
ro: Creează o clonă "superficială" cu un istoric trunchiat la numărul specificat de comenzi. Implică `--single-branch`, cu excepția cazului în care se specifică `--no-single-branch` pentru a prelua istoricul din apropierea vârfurilor tuturor ramurilor. Dacă doriți să clonați submodulele superficial, treceți și `--shallow-submodules`.

note: type: Plain text
en: Create a shallow clone with a history after the specified time.
ro: Creează o clonă superficială cu un istoric după timpul specificat.

note: type: Plain text
en: Create a shallow clone with a history, excluding commits reachable from a specified remote branch or tag.  This option can be specified multiple times.
ro: Creează o clonă superficială cu un istoric, excluzând comenzile care pot fi accesate de la o branșă sau etichetă la distanță specificată.  Această opțiune poate fi specificată de mai multe ori.

note: type: Plain text
en: Clone only the history leading to the tip of a single branch, either specified by the `--branch` option or the primary branch remote's `HEAD` points at.  Further fetches into the resulting repository will only update the remote-tracking branch for the branch this option was used for the initial cloning.  If the HEAD at the remote did not point at any branch when `--single-branch` clone was made, no remote-tracking branch is created.
ro: Clonează numai istoricul care duce la vârful unei singure branșe, fie că este specificat de opțiunea `--branch`, fie că este vorba de ramura principală la care indică `HEAD` de la distanță.  Preluările ulterioare în depozitul rezultat vor actualiza numai branșa de urmărire de la distanță pentru branșa pentru care această opțiune a fost utilizată pentru clonarea inițială.  În cazul în care HEAD de la distanță nu a indicat nicio branșă atunci când s-a efectuat clonarea `--single-branch`, nu se creează nicio branșă de urmărire la distanță.

note: type: Plain text
en: Don't clone any tags, and set `remote.<remote>.tagOpt=--no-tags` in the config, ensuring that future `git pull` and `git fetch` operations won't follow any tags. Subsequent explicit tag fetches will still work, (see linkgit:git-fetch[1]).
ro: Nu clonați niciun tag și setați `remote.<remote>.tagOpt=--no-tags` în configurație, asigurându-vă că viitoarele operațiuni `git pull` și `git fetch` nu vor urmări niciun tag. Recuperările ulterioare explicite de etichete vor funcționa în continuare (a se vedea linkgit:git-fetch[1]).

note: type: Plain text
en: Can be used in conjunction with `--single-branch` to clone and maintain a branch with no references other than a single cloned branch. This is useful e.g. to maintain minimal clones of the default branch of some repository for search indexing.
ro: Poate fi utilizat împreună cu `--single-branch` pentru a clona și a menține o branșă fără alte referințe decât o singură branșă clonată. Acest lucru este util, de exemplu, pentru a menține un număr minim de clone ale branșei implicite a unui depozit pentru indexarea căutărilor.

note: type: Labeled list
en: --recurse-submodules[=<pathspec>]
ro: --recurse-submodules[=<path-specificații>]

note: type: Plain text
en: After the clone is created, initialize and clone submodules within based on the provided pathspec.  If no pathspec is provided, all submodules are initialized and cloned.  This option can be given multiple times for pathspecs consisting of multiple entries.  The resulting clone has `submodule.active` set to the provided pathspec, or "." (meaning all submodules) if no pathspec is provided.
ro: După ce clona este creată, inițializați și clonați submodulele din cadrul acesteia pe baza specificației de traseu furnizate.  Dacă nu este furnizată nicio specificație de traseu, toate submodulele sunt inițializate și clonate.  Această opțiune poate fi furnizată de mai multe ori pentru specificațiile de traseu compuse din mai multe intrări.  Clona rezultată are `submodule.active` setat la specificația de traseu furnizată sau "." (însemnând toate submodulele) dacă nu este furnizată nicio specificație de traseu.

note: type: Plain text
en: Submodules are initialized and cloned using their default settings. This is equivalent to running `git submodule update --init --recursive <pathspec>` immediately after the clone is finished. This option is ignored if the cloned repository does not have a worktree/checkout (i.e. if any of `--no-checkout`/`-n`, `--bare`, or `--mirror` is given)
ro: Submodulele sunt inițializate și clonate folosind setările lor implicite. Acest lucru este echivalent cu rularea `git submodule update --init --recursive <pathspec>` imediat după ce clona este terminată. Această opțiune este ignorată dacă depozitul clonat nu are un registru de lucru/checkout (de exemplu, dacă se dă oricare dintre `--no-checkout`/`-n`, `--bare` sau `--mirror`)

note: type: Plain text
en: All submodules which are cloned will be shallow with a depth of 1.
ro: Toate submodulele care sunt clonate vor fi superficiale, cu o adâncime de 1.

note: type: Plain text
en: All submodules which are cloned will use the status of the submodule's remote-tracking branch to update the submodule, rather than the superproject's recorded SHA-1. Equivalent to passing `--remote` to `git submodule update`.
ro: Toate submodulele care sunt clonate vor utiliza starea branșei de urmărire la distanță a submodulelor pentru a actualiza submodulele, mai degrabă decât SHA-1 înregistrat de superproiect. Echivalent cu trecerea `--remote` la `git submodule update`.

note: type: Labeled list
en: --separate-git-dir=<git dir>
ro: --separate-git-dir=<git director>

note: type: Plain text
en: Instead of placing the cloned repository where it is supposed to be, place the cloned repository at the specified directory, then make a filesystem-agnostic Git symbolic link to there.  The result is Git repository can be separated from working tree.
ro: În loc să plasați depozitul clonat acolo unde ar trebui să fie, plasați depozitul clonat în directorul specificat, apoi creați o legătură simbolică Git agnostică pentru sistemul de fișiere.  Rezultatul este că depozitul Git poate fi separat de structura de lucru.

note: type: Plain text
en: The number of submodules fetched at the same time.  Defaults to the `submodule.fetchJobs` option.
ro: Numărul de submodule preluate în același timp.  Valoarea implicită este cea a opțiunii `submodule.fetchJobs`.

note: type: Plain text
en: The (possibly remote) repository to clone from.  See the <<URLS,GIT URLS>> section below for more information on specifying repositories.
ro: Depozitul (eventual la distanță) din care se clonează.  Consultați secțiunea <<URLS,GIT URLS>> de mai jos pentru mai multe informații despre specificarea depozitelor.

note: type: Plain text
en: The name of a new directory to clone into.  The "humanish" part of the source repository is used if no directory is explicitly given (`repo` for `/path/to/repo.git` and `foo` for `host.xz:foo/.git`).  Cloning into an existing directory is only allowed if the directory is empty.
ro: Numele unui nou director în care se clonează.  Partea "humanish" a depozitului sursă este utilizată dacă nu se indică în mod explicit un director (`repo` pentru `/path/to/repo.git` și `foo` pentru `host.xz:foo/.git`).  Clonarea într-un director existent este permisă numai dacă directorul este gol.

note: type: Plain text
en: Clone from upstream:
ro: Clonă din upstream:

note: type: Plain text
en: Make a local clone that borrows from the current directory, without checking things out:
ro: Realizează o clonă locală care împrumută din directorul curent, fără a verifica lucrurile:

note: type: Plain text
en: Clone from upstream while borrowing from an existing local directory:
ro: Clonarea din upstream în timp ce împrumutați dintr-un director local existent:

note: type: Plain text
en: Create a bare repository to publish your changes to the public:
ro: Creați un depozit gol pentru a vă publica modificările în mod public:

note: type: Plain text
en: git-init - Create an empty Git repository or reinitialize an existing one
ro: git-init - Creează un depozit Git gol sau reinitializează unul existent

note: type: Plain text
en: 'git init' [-q | --quiet] [--bare] [--template=<template_directory>]
    	  [--separate-git-dir <git dir>] [--object-format=<format>]
    	  [-b <branch-name> | --initial-branch=<branch-name>]
    	  [--shared[=<permissions>]] [directory]
ro: 'git init' [-q | --quiet] [--bare] [--template=<directorul_șablon>]]
    	  [--separate-git-dir <git dir>] [--object-format=<format>]
    	  [-b <branch-name> | --initial-branch=<branch-name>]
    	  [--shared[=<permissions>]]] [director]

note: type: Plain text
en: This command creates an empty Git repository - basically a `.git` directory with subdirectories for `objects`, `refs/heads`, `refs/tags`, and template files.  An initial branch without any commits will be created (see the `--initial-branch` option below for its name).
ro: Această comandă creează un depozit Git gol - practic un director `.git` cu subdirectoare pentru `objects`, `refs/heads`, `refs/tags` și fișiere șablon.  Va fi creată o branșă inițială fără nici un angajament (a se vedea opțiunea `--initial-branch` de mai jos pentru numele acesteia).

note: type: Plain text
en: If the `$GIT_DIR` environment variable is set then it specifies a path to use instead of `./.git` for the base of the repository.
ro: Dacă variabila de mediu `$GIT_DIR` este setată, atunci aceasta specifică o cale care să fie utilizată în locul lui `./.git` pentru baza depozitului.

note: type: Plain text
en: If the object storage directory is specified via the `$GIT_OBJECT_DIRECTORY` environment variable then the sha1 directories are created underneath - otherwise the default `$GIT_DIR/objects` directory is used.
ro: Dacă directorul de stocare a obiectelor este specificat prin intermediul variabilei de mediu `$GIT_OBJECT_DIRECTORY`, atunci directoarele sha1 sunt create dedesubt - în caz contrar, se utilizează directorul implicit `$GIT_DIR/objects`.

note: type: Plain text
en: Running 'git init' in an existing repository is safe. It will not overwrite things that are already there. The primary reason for rerunning 'git init' is to pick up newly added templates (or to move the repository to another place if --separate-git-dir is given).
ro: Rularea 'git init' într-un depozit existent este sigură. Nu va suprascrie lucruri care există deja. Motivul principal pentru care se reia "git init" este pentru a prelua șabloanele nou adăugate (sau pentru a muta depozitul în alt loc dacă se indică --separate-git-dir).

note: type: Plain text
en: Only print error and warning messages; all other output will be suppressed.
ro: Imprimă numai mesajele de eroare și de avertizare; toate celelalte mesaje de ieșire vor fi suprimate.

note: type: Plain text
en: Create a bare repository. If `GIT_DIR` environment is not set, it is set to the current working directory.
ro: Creați un depozit gol. Dacă mediul `GIT_DIR` nu este setat, acesta este setat la directorul de lucru curent.

note: type: Plain text
en: Specify the given object format (hash algorithm) for the repository.  The valid values are 'sha1' and (if enabled) 'sha256'.  'sha1' is the default.
ro: Specifică formatul obiectului dat (algoritmul hash) pentru depozit.  Valorile valide sunt "sha1" și (dacă este activat) "sha256".  'sha1' este valoarea implicită.

note: type: Plain text
en: Specify the directory from which templates will be used.  (See the "TEMPLATE DIRECTORY" section below.)
ro: Specificați directorul din care vor fi utilizate șabloanele.  (A se vedea secțiunea "REPERTORIUL DE MODELE" de mai jos)

note: type: Plain text
en: Instead of initializing the repository as a directory to either `$GIT_DIR` or `./.git/`, create a text file there containing the path to the actual repository.  This file acts as filesystem-agnostic Git symbolic link to the repository.
ro: În loc să inițializați depozitul ca un director în `$GIT_DIR` sau `./.git/`, creați un fișier text care să conțină calea către depozitul real.  Acest fișier acționează ca o legătură simbolică Git agnostică pentru sistemul de fișiere către depozit.

note: type: Plain text
en: If this is reinitialization, the repository will be moved to the specified path.
ro: Dacă este vorba de o reinitializare, depozitul va fi mutat în calea specificată.

note: type: Plain text
en: Use the specified name for the initial branch in the newly created repository.  If not specified, fall back to the default name (currently `master`, but this is subject to change in the future; the name can be customized via the `init.defaultBranch` configuration variable).
ro: Utilizați numele specificat pentru branșa inițială din depozitul nou creat.  Dacă nu este specificat, se revine la numele implicit (în prezent `master`, dar acesta poate fi modificat în viitor; numele poate fi personalizat prin intermediul variabilei de configurare `init.defaultBranch`).

note: type: Plain text
en: Specify that the Git repository is to be shared amongst several users.  This allows users belonging to the same group to push into that repository.  When specified, the config variable "core.sharedRepository" is set so that files and directories under `$GIT_DIR` are created with the requested permissions.  When not specified, Git will use permissions reported by umask(2).
ro: Specificați că depozitul Git trebuie partajat între mai mulți utilizatori.  Acest lucru permite utilizatorilor care aparțin aceluiași grup să facă push în acest depozit.  Atunci când este specificată, variabila de configurare "core.sharedRepository" este setată astfel încât fișierele și directoarele din `$GIT_DIR` să fie create cu permisiunile solicitate.  Atunci când nu este specificată, Git va utiliza permisiunile raportate de umask(2).

note: type: Plain text
en: The option can have the following values, defaulting to 'group' if no value is given:
ro: Opțiunea poate avea următoarele valori, valoarea implicită fiind "group" în cazul în care nu se dă nicio valoare:

note: type: Plain text
en: Use permissions reported by umask(2). The default, when `--shared` is not specified.
ro: Utilizați permisiunile raportate de umask(2). Valoarea implicită, atunci când nu este specificat `--shared`.

note: type: Plain text
en: Make the repository group-writable, (and g+sx, since the git group may be not the primary group of all users). This is used to loosen the permissions of an otherwise safe umask(2) value. Note that the umask still applies to the other permission bits (e.g. if umask is '0022', using 'group' will not remove read privileges from other (non-group) users). See '0xxx' for how to exactly specify the repository permissions.
ro: Faceți ca depozitul să poată fi scris în grup (și g+sx, deoarece este posibil ca grupul git să nu fie grupul principal al tuturor utilizatorilor). Acest lucru este utilizat pentru a slăbi permisiunile unei valori umask(2), care altfel ar fi sigură. Rețineți că umask-ul se aplică în continuare celorlalți bits de permisiune (de exemplu, dacă umask este "0022", utilizarea "group" nu va elimina privilegiile de citire pentru alți utilizatori (care nu fac parte din grup)). Consultați "0xxx" pentru a afla cum să specificați cu exactitate permisiunile depozitului.

note: type: Plain text
en: Same as 'group', but make the repository readable by all users.
ro: La fel ca "group", dar face ca depozitul să poată fi citit de toți utilizatorii.

note: type: Plain text
en: '0xxx' is an octal number and each file will have mode '0xxx'. '0xxx' will override users' umask(2) value (and not only loosen permissions as 'group' and 'all' does). '0640' will create a repository which is group-readable, but not group-writable or accessible to others. '0660' will create a repo that is readable and writable to the current user and group, but inaccessible to others.
ro: "0xxx" este un număr octal și fiecare fișier va avea modul "0xxx". '0xxx' va anula valoarea umask(2) a utilizatorilor (și nu doar va slăbi permisiunile, așa cum fac 'group' și 'all'). '0640' va crea un depozit care poate fi citit de grup, dar nu poate fi scris de grup sau accesibil altora. '0660' va crea un depozit care poate fi citit și scris de către utilizatorul și grupul curent, dar care este inaccesibil altora.

note: type: Plain text
en: By default, the configuration flag `receive.denyNonFastForwards` is enabled in shared repositories, so that you cannot force a non fast-forwarding push into it.
ro: În mod implicit, marcajul de configurație `receive.denyNonFastForwards` este activat în depozitele partajate, astfel încât să nu puteți forța un push care nu este de tip fast-forwarding în acestea.

note: type: Plain text
en: If you provide a 'directory', the command is run inside it. If this directory does not exist, it will be created.
ro: Dacă furnizați un "director", comanda este executată în interiorul acestuia. Dacă acest director nu există, va fi creat.

note: type: Title -
en: TEMPLATE DIRECTORY
ro: DIRECTOR DE ȘABLOANE

note: type: Plain text
en: Files and directories in the template directory whose name do not start with a dot will be copied to the `$GIT_DIR` after it is created.
ro: Fișierele și directoarele din directorul șablon al căror nume nu începe cu un punct vor fi copiate în `$GIT_DIR` după ce acesta este creat.

note: type: Plain text
en: The template directory will be one of the following (in order):
ro: Directorul șablonului va fi unul dintre următoarele (în ordine):

note: type: Plain text
en: the argument given with the `--template` option;
ro: argumentul dat cu opțiunea `--template`;

note: type: Plain text
en: the contents of the `$GIT_TEMPLATE_DIR` environment variable;
ro: conținutul variabilei de mediu `$GIT_TEMPLATE_DIR`;

note: type: Plain text
en: the `init.templateDir` configuration variable; or
ro: variabila de configurare `init.templateDir`; sau

note: type: Plain text
en: the default template directory: `/usr/share/git-core/templates`.
ro: directorul de șabloane implicit: `/usr/share/git-core/templates`.

note: type: Plain text
en: The default template directory includes some directory structure, suggested "exclude patterns" (see linkgit:gitignore[5]), and sample hook files.
ro: Directorul șablon implicit include o anumită structură de directoare, "modele de excludere" sugerate (a se vedea linkgit:gitignore[5]) și exemple de fișiere hook.

note: type: Plain text
en: The sample hooks are all disabled by default. To enable one of the sample hooks rename it by removing its `.sample` suffix.
ro: Probele de tip hook sunt toate dezactivate în mod implicit. Pentru a activa unul dintre cârligele de probă, redenumiți-l prin eliminarea sufixului `.sample`.

note: type: Plain text
en: See linkgit:githooks[5] for more general info on hook execution.
ro: Consultați linkgit:githooks[5] pentru mai multe informații generale despre executarea Consultați linkgit:githooks[5] pentru mai multe informații generale despre executarea hook-urilor..

note: type: Labeled list
en: Start a new Git repository for an existing code base
ro: Începeți un nou depozit Git pentru o bază de cod existentă

note: type: Plain text
en: Create a /path/to/my/codebase/.git directory.
ro: Creați un director /path/to/my/codebase/.git.

note: type: Plain text
en: Add all existing files to the index.
ro: Adăugați toate fișierele existente la index.

note: type: Plain text
en: Record the pristine state as the first commit in the history.
ro: Înregistrează starea inițială ca prima confirmare în cursul depozitului.

note: type: Plain text
en: THIS OPTION IS EXPERIMENTAL! SHA-256 support is experimental and still in an early stage.  A SHA-256 repository will in general not be able to share work with "regular" SHA-1 repositories.  It should be assumed that, e.g., Git internal file formats in relation to SHA-256 repositories may change in backwards-incompatible ways.  Only use `--object-format=sha256` for testing purposes.
ro: ACEASTĂ OPȚIUNE ESTE EXPERIMENTALĂ! Suportul pentru SHA-256 este experimental și se află încă într-un stadiu incipient.  Un depozit SHA-256 nu va putea, în general, să partajeze munca cu depozitele SHA-1 "obișnuite".  Trebuie să se presupună că, de exemplu, formatele de fișiere interne Git în legătură cu depozitele SHA-256 se pot schimba în moduri incompatibile cu trecutul.  Utilizați `--object-format=sha256` numai în scopuri de testare.

note: type: Plain text
en: In general, URLs contain information about the transport protocol, the address of the remote server, and the path to the repository.  Depending on the transport protocol, some of this information may be absent.
ro: În general, URL-urile conțin informații despre protocolul de transport, adresa serverului la distanță și calea către depozit.  În funcție de protocolul de transport, unele dintre aceste informații pot lipsi.

note: type: Plain text
en: Git supports ssh, git, http, and https protocols (in addition, ftp, and ftps can be used for fetching, but this is inefficient and deprecated; do not use it).
ro: Git acceptă protocoalele ssh, git, http și https (în plus, ftp și ftps pot fi utilizate pentru preluare, dar acest lucru este ineficient și depreciat; nu-l utilizați).

note: type: Plain text
en: The native transport (i.e. git:// URL) does no authentication and should be used with caution on unsecured networks.
ro: Transportul nativ (adică git:// URL) nu face autentificare și ar trebui utilizat cu precauție în rețelele nesecurizate.

note: type: Plain text
en: The following syntaxes may be used with them:
ro: Următoarele sintaxe pot fi utilizate cu acestea:

note: type: Plain text
en: An alternative scp-like syntax may also be used with the ssh protocol:
ro: O sintaxă alternativă de tip scp poate fi utilizată, de asemenea, cu protocolul ssh:

note: type: Plain text
en: This syntax is only recognized if there are no slashes before the first colon. This helps differentiate a local path that contains a colon. For example the local path `foo:bar` could be specified as an absolute path or `./foo:bar` to avoid being misinterpreted as an ssh url.
ro: Această sintaxă este recunoscută numai dacă nu există bariere înaintea primelor două puncte. Acest lucru ajută la diferențierea unei căi locale care conține două puncte. De exemplu, calea locală `foo:bar` ar putea fi specificată ca o cale absolută sau `./foo:bar` pentru a evita să fie interpretată greșit ca o adresă url ssh.

note: type: Plain text
en: The ssh and git protocols additionally support ~username expansion:
ro: Protocoalele ssh și git acceptă, în plus, extinderea ~username:

note: type: Plain text
en: ssh://{startsb}user@{endsb}host.xz{startsb}:port{endsb}/~{startsb}user{endsb}/path/to/repo.git/
ro: ssh://{startsb}utilizator@{endsb}host.xz{startsb}:port{endsb}/~{startsb}user{endsb}/path/to/repo.git/

note: type: Plain text
en: {startsb}user@{endsb}host.xz:/~{startsb}user{endsb}/path/to/repo.git/
ro: {startsb}utilizator@{endsb}host.xz:/~{startsb}user{endsb}/path/to/repo.git/

note: type: Plain text
en: For local repositories, also supported by Git natively, the following syntaxes may be used:
ro: Pentru depozitele locale, de asemenea suportate nativ de Git, se pot folosi următoarele sintaxe:

note: type: Plain text
en: These two syntaxes are mostly equivalent, except when cloning, when the former implies --local option. See linkgit:git-clone[1] for details.
ro: Aceste două sintaxe sunt în mare parte echivalente, cu excepția clonării, când prima implică opțiunea --local. Consultați linkgit:git-clone[1] pentru detalii.

note: type: Plain text
en: These two syntaxes are mostly equivalent, except the former implies --local option.
ro: Aceste două sintaxe sunt în mare parte echivalente, cu excepția faptului că prima implică opțiunea --local.

note: type: Plain text
en: 'git clone', 'git fetch' and 'git pull', but not 'git push', will also accept a suitable bundle file. See linkgit:git-bundle[1].
ro: 'git clone', 'git fetch' și 'git pull', dar nu și 'git push', vor accepta, de asemenea, un fișier bundle adecvat. A se vedea linkgit:git-bundle[1].

note: type: Plain text
en: When Git doesn't know how to handle a certain transport protocol, it attempts to use the 'remote-<transport>' remote helper, if one exists. To explicitly request a remote helper, the following syntax may be used:
ro: Atunci când Git nu știe cum să gestioneze un anumit protocol de transport, încearcă să utilizeze ajutorul de la distanță "remote-<transport>", dacă există unul. Pentru a solicita în mod explicit un ajutor la distanță, se poate utiliza următoarea sintaxă:

note: type: Plain text
en: where <address> may be a path, a server and path, or an arbitrary URL-like string recognized by the specific remote helper being invoked. See linkgit:gitremote-helpers[7] for details.
ro: unde <address> poate fi o cale, un server și o cale sau un șir arbitrar de tip URL recunoscut de ajutorul specific de la distanță care este invocat. Pentru detalii, consultați linkgit:gitremote-helpers[7].

note: type: Plain text
en: If there are a large number of similarly-named remote repositories and you want to use a different format for them (such that the URLs you use will be rewritten into URLs that work), you can create a configuration section of the form:
ro: Dacă există un număr mare de depozite la distanță cu nume similare și doriți să utilizați un format diferit pentru acestea (astfel încât URL-urile pe care le utilizați să fie rescrise în URL-uri care funcționează), puteți crea o secțiune de configurare a formularului:

note: type: Plain text
en: For example, with this:
ro: De exemplu, cu aceasta:

note: type: Plain text
en: a URL like "work:repo.git" or like "host.xz:/path/to/repo.git" will be rewritten in any context that takes a URL to be "git://git.host.xz/repo.git".
ro: o adresă URL de tipul "work:repo.git" sau "host.xz:/path/to/repo.git" va fi rescrisă în orice context care consideră că o adresă URL este "git://git.host.xz/repo.git".

note: type: Plain text
en: If you want to rewrite URLs for push only, you can create a configuration section of the form:
ro: Dacă doriți să rescrieți URL-urile doar pentru push, puteți crea o secțiune de configurare a formularului:

note: type: Plain text
en: a URL like "git://example.org/path/to/repo.git" will be rewritten to "ssh://example.org/path/to/repo.git" for pushes, but pulls will still use the original URL.
ro: o adresă URL de tipul "git://example.org/path/to/repo.git" va fi rescrisă în "ssh://example.org/path/to/repo.git" pentru împingeri, dar pentru extrageri se va utiliza în continuare adresa URL originală.
