diff options
39 files changed, 1531 insertions, 127 deletions
diff --git a/ansible.html.markdown b/ansible.html.markdown index 30dfba13..839aed24 100644 --- a/ansible.html.markdown +++ b/ansible.html.markdown @@ -753,3 +753,4 @@ the `register` command. * [A system administrator's guide to getting started with Ansible - FAST!](https://www.redhat.com/en/blog/system-administrators-guide-getting-started-ansible-fast) * [Ansible Tower](https://www.ansible.com/products/tower) - Ansible Tower provides a web UI, dashboard and rest interface to ansible. * [Ansible AWX](https://github.com/ansible/awx) - The Open Source version of Ansible Tower. +* [Ansible Tutorial for Beginners: Ultimate Playbook & Examples](https://spacelift.io/blog/ansible-tutorial) diff --git a/awk.html.markdown b/awk.html.markdown index b8b6271a..34013251 100644 --- a/awk.html.markdown +++ b/awk.html.markdown @@ -178,26 +178,26 @@ function arithmetic_functions(a, b, c, d) { # Now, to demonstrate the arithmetic functions # Most AWK implementations have some standard trig functions - localvar = sin(a); - localvar = cos(a); - localvar = atan2(b, a); # arc tangent of b / a + d = sin(a); + d = cos(a); + d = atan2(b, a); # arc tangent of b / a # And logarithmic stuff - localvar = exp(a); - localvar = log(a); + d = exp(a); + d = log(a); # Square root - localvar = sqrt(a); + d = sqrt(a); # Truncate floating point to integer - localvar = int(5.34); # localvar => 5 + d = int(5.34); # d => 5 # Random numbers srand(); # Supply a seed as an argument. By default, it uses the time of day - localvar = rand(); # Random number between 0 and 1. + d = rand(); # Random number between 0 and 1. # Here's how to return a value - return localvar; + return d; } function string_functions( localvar, arr) { diff --git a/bf.html.markdown b/bf.html.markdown index 1e415a4d..5ede0546 100644 --- a/bf.html.markdown +++ b/bf.html.markdown @@ -9,7 +9,7 @@ contributors: Brainfuck (not capitalized except at the start of a sentence) is an extremely minimal Turing-complete programming language with just 8 commands. -You can try brainfuck on your browser with [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/). +You can try brainfuck on your browser with [brainfuck-visualizer](https://brainfuck-visualizer.herokuapp.com). ```bf Any character not "><+-.,[]" (excluding quotation marks) is ignored. diff --git a/c.html.markdown b/c.html.markdown index 90b5ed2d..a898f052 100644 --- a/c.html.markdown +++ b/c.html.markdown @@ -1,5 +1,5 @@ --- -language: c +language: C filename: learnc.c contributors: - ["Adam Bard", "http://adambard.com/"] diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown index 87e75ad6..cca54c30 100644 --- a/de-de/c++-de.html.markdown +++ b/de-de/c++-de.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ filename: learncpp-de.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index f9090518..3a726b83 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -1,5 +1,5 @@ --- -language: c +language: C filename: learnc-de.c contributors: - ["caminsha", "https://github.com/caminsha"] diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown index 78bb0a6b..18a23017 100644 --- a/de-de/csharp-de.html.markdown +++ b/de-de/csharp-de.html.markdown @@ -1,5 +1,5 @@ ---
-language: c#
+language: C#
contributors:
- ["Irfan Charania", "https://github.com/irfancharania"]
- ["Max Yankov", "https://github.com/golergka"]
diff --git a/de-de/qt-de.html.markdown b/de-de/qt-de.html.markdown index 480030fe..7d287cab 100644 --- a/de-de/qt-de.html.markdown +++ b/de-de/qt-de.html.markdown @@ -1,7 +1,7 @@ --- category: tool tool: Qt Framework -language: c++ +language: C++ filename: learnqt-de.cpp contributors: - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown index 9db2c802..f624d3c7 100644 --- a/es-es/c++-es.html.markdown +++ b/es-es/c++-es.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ filename: learncpp-es.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown index cae4349e..ae357d91 100644 --- a/es-es/c-es.html.markdown +++ b/es-es/c-es.html.markdown @@ -1,5 +1,5 @@ --- -language: c +language: C filename: learnc-es.c contributors: - ["Adam Bard", "http://adambard.com/"] diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown index c8603756..b96d0ad0 100644 --- a/fr-fr/c++-fr.html.markdown +++ b/fr-fr/c++-fr.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ filename: learncpp-fr.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown index 58b3f386..b3bf9c3b 100644 --- a/fr-fr/csharp-fr.html.markdown +++ b/fr-fr/csharp-fr.html.markdown @@ -1,5 +1,5 @@ --- -language: c# +language: C# contributors: - ["Irfan Charania", "https://github.com/irfancharania"] - ["Max Yankov", "https://github.com/golergka"] diff --git a/gdscript.html.markdown b/gdscript.html.markdown index 25af0974..0bfac26a 100644 --- a/gdscript.html.markdown +++ b/gdscript.html.markdown @@ -95,7 +95,7 @@ func doing_math(): func control_flow(): x = 8 y = 2 # y was originally a float, - # but we can change it's type to int + # but we can change its type to int # using the power of dynamic typing! if x < y: @@ -114,6 +114,9 @@ func control_flow(): for i in range(20): # GDScript's range is similar to Python's print(i) # so this will print numbers from 0 to 19 + for i in 20: # unlike Python, you can loop over an int directly + print(i) # so this will also print numbers from 0 to 19 + for i in ["two", 3, 1.0]: # iterating over an array print(i) @@ -319,4 +322,4 @@ signal example(arg: int) # ERROR! Signals can't take typed arguments! * [NodePath](https://docs.godotengine.org/en/stable/classes/class_nodepath.html) * [Signals](https://docs.godotengine.org/en/stable/getting_started/step_by_step/signals.html) * [GDQuest](https://www.gdquest.com/) -* [GDScript.com](https://gdscript.com/)
\ No newline at end of file +* [GDScript.com](https://gdscript.com/) diff --git a/git.html.markdown b/git.html.markdown index 474ee25d..b587e624 100644 --- a/git.html.markdown +++ b/git.html.markdown @@ -124,9 +124,12 @@ To configure settings. Whether it be for the repository, the system itself, or global configurations ( global config file is `~/.gitconfig` ). ```bash -# Print & Set Some Basic Config Variables (Global) +# Set & Print Some Basic Config Variables (Global) $ git config --global user.email "MyEmail@Zoho.com" $ git config --global user.name "My Name" + +$ git config --global user.email +$ git config --global user.name ``` [Learn More About git config.](http://git-scm.com/docs/git-config) @@ -579,6 +582,18 @@ $ git rm HelloWorld.c $ git rm /pather/to/the/file/HelloWorld.c ``` +### blame +Examine specific parts of the code's history and find out who was the last author to modify that line +```bash +# find the authors on the latest modified lines +$ git blame google_python_style.vim +b88c6a1b (Google Python team 2019-12-30 13:45:23 -0800 12) " See the License for the specific language governing permissions and +b88c6a1b (Google Python team 2019-12-30 13:45:23 -0800 13) " limitations under the License. +b88c6a1b (Google Python team 2019-12-30 13:45:23 -0800 14) +222e6da8 (mshields@google.com 2010-11-29 20:32:06 +0000 15) " Indent Python in the Google way. +222e6da8 (mshields@google.com 2010-11-29 20:32:06 +0000 16) +222e6da8 (mshields@google.com 2010-11-29 20:32:06 +0000 17) setlocal indentexpr=GetGooglePythonIndent(v:lnum) +``` ## Further Information * [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) diff --git a/hack.html.markdown b/hack.html.markdown index 1ab958b5..24055503 100644 --- a/hack.html.markdown +++ b/hack.html.markdown @@ -11,7 +11,7 @@ filename: learnhack.hh To run Hack code, [install HHVM](https://docs.hhvm.com/hhvm/installation/introduction), the open-source virtual machine. -```Hack +```php /* ================================== * READ THE DOCS! * ================================== diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown index 449aebfb..a8e0c7b5 100644 --- a/it-it/c++-it.html.markdown +++ b/it-it/c++-it.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ filename: learncpp-it.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] diff --git a/it-it/qt-it.html.markdown b/it-it/qt-it.html.markdown index d7469f67..ef829493 100644 --- a/it-it/qt-it.html.markdown +++ b/it-it/qt-it.html.markdown @@ -1,7 +1,7 @@ --- category: tool tool: Qt Framework -language: c++ +language: C++ filename: learnqt-it.cpp contributors: - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown new file mode 100644 index 00000000..be747e68 --- /dev/null +++ b/it-it/solidity.html.markdown @@ -0,0 +1,1069 @@ +--- +language: Solidity +filename: learnSolidity-it.sol +contributors: + - ["Nemil Dalal", "https://www.nemil.com"] + - ["Joseph Chow", ""] + - ["Bhoomtawath Plinsut", "https://github.com/varshard"] + - ["Shooter", "https://github.com/liushooter"] + - ["Patrick Collins", "https://gist.github.com/PatrickAlphaC"] +translators: + - ["Al", "http://github.com/al-ias"] +lang: it-it +--- + +Solidity permette di programmare su [Ethereum](https://www.ethereum.org/), una +macchina virtuale basata sulla blockchain che consente la creazione e +l'esecuzione degli smart contract senza che sia richiesta centralizzazione o +fiducia negli attori coinvolti. + +Solidity è un linguaggio di programmazione di contratti tipizzato staticamente e +ha molte cose in comune con Javascript e C. Come per gli oggetti nella +programmazione ad oggetti, ogni contratto contiene variabili di stato, funzioni +e tipi di dato semplici. Tra le funzionalità specifiche dei contratti troviamo +le clausole (guardie) dei modifier, gli event notifier per i listener, e le +variabili globali custom. + +Come esempi di contratti su Ethereum troviamo sistemi di crowdfunding, voto, +[finanza decentralizzata](https://defipulse.com/) e aste al buio. + +Compiere errori nel codice Solidity può portare a rischi e costi alti, quindi +bisogna fare attenzione a testare e rilasciare le modifiche lentamente. A +CAUSA DEI CONTINUI CAMBIAMENTI DI ETHEREUM È IMPROBABILE CHE QUESTO DOCUMENTO +RESTI AGGIORNATO, QUINDI COSNIGLIAMO DI SEGUIRE LA CHAT ROOM DI SOLIDITY E IL +BLOG DI ETHEREUM PER TENERSI AGGIORNATI. TUTTO IL CODICE QUI PRESENTE E' FORNITO +COSÌ COM'È, CON ANNESSI RISCHI SOSTANZIALI DI ERRORI O PATTERN DI PROGRAMMAZIONE +DEPRECATI. + +A differenza di altri linguaggi, potresti aver bisogno di usare pattern di +pausing, deprecation e throttling usage per ridurre il rischio. Questo documento +tratta principalmene la sintassi e quindi esclude molti design pattern in voga. + +Visto che Solidity e Ethereum sono in continuo sviluppo, le funzionalità +sperimentali o beta sono evidenziate e soggette a cambiamenti. Ogni Pull Request +è ben accetta. + + +# Lavorare con Remix e Metamask + +Uno dei modi più semplici di scrivere, distribuire e testare il codice Solidity +è usare : + +1. [L'ambiente di sviluppo online Remix](https://remix.ethereum.org/) +2. [Il wallet Metamask](https://metamask.io/). + +Per cominciare, [scarichiamo l'estesione per browser di Metamask](https://metamask.io/). + +Una volta installata, potremo iniziare ad usare Remix. Il codice seguente è +pre-inizializzato, ma prima di addentrarci, diamo un'occhiata a qualche +trucchetto per iniziare ad usare Remix. Carica tutto il necessario [clickando su questo link](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=f490c0d51141dd0515244db40bbd0c17&runs=200). + +1. Scegli il compilatore per Solidity + +![Solidity-in-remix](../images/solidity/remix-solidity.png) + +2. Apri il file che si caricherà su quel link + +![Solidity-choose-file](../images/solidity/remix-choose-file.png) + +3. Compila il file + +![Solidity-compile](../images/solidity/remix-compile.png) + +4. Fai il deploy + +![Solidity-deploy](../images/solidity/remix-deploy.png) + +5. Smanetta con i contratti + +![Solidity-deploy](../images/solidity/remix-interact.png) + +Hai distribuito il tuo primo contratto! Congratulazioni! + +Potrai testarlo e smanettare con le funzioni già definite. Dai un'occhiata ai +commenti per scoprire cosa fanno. + + +## Lavorare su una testnet + +Distribuire e testare su una testnet è il modo più accurato per mettere alla +prova i tuoi smart contract in Solidity. Per farlo procuriamoci prima degli ETH +di test dalla testnet Kovan. + +[Entra in questo Gitter Channel](https://gitter.im/kovan-testnet/faucet) e +scrivici l'indirizzo del tuo wallet Metamask. + +Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`. + +![Solidity-in-remix](../images/solidity/metamask-kovan.png) + +Riceverai degli Ethereum di test gratuiti. Abbiamo bisogno di Ethereum per +distribuire degli smart contract su una testnet. + +Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito +su un ambiente virtuale fittizio. Quando si lavora su una testnet, possiamo +davvero monitorare e interagire con i nostri contratti in maniera persistente. + +Per distribuire su una testnet, allo step `#4 Fai il deploy`, cambia +l'`environment` selezionato in `injected web3`. In questo modo verrà usato +come network su cui fare il deploy qualsiasi network selezionato sul tuo +Metamask. + +![Solidity-in-remix](../images/solidity/remix-testnet.png) + +Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di +cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che +ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso +di tempo, ti apparirà la stessa interfaccia per il contratto nella parte +inferiore dello schermo. + + +```javascript +// Iniziamo con un semplice contratto su una Banca +// Permette di depositare, prelevare e fare l'estratto conto + +// simple_bank.sol (nota l'estensione .sol) +/* **** INIZIO DELL'ESEMPIO **** */ + +// Dichiara la versione del compilatore per il file sorgente +pragma solidity ^0.6.6; + +// Inizia con il commento Natspec (i tre slash) +// viene usato per la documentazione - e per i dati descrittivi per gli elementi +// dell'interfaccia utente / azioni + +/// @title SimpleBank +/// @author nemild + +/* 'contract' somiglia a 'class' in altri linguaggi (ha variabili di classe, +ereditarietà, etc.) */ +contract SimpleBank { // CapWords + // Dichiariamo le variabili di stato fuori dalle funzioni, persisteranno + // durante tutta la vita del contratto + + // i dizionari mappano gli indirizzi con i saldi + // fai sempre attenzione agli overflow attack che sfruttano i numeri + mapping (address => uint) private balances; + + // "private" significa che che altri contratti non possono leggere i + // saldi ma le informazioni restano visibili ad altri attori sulla blockchain + + address public owner; + // 'public' lo rende leggibile dall'esterno (ma non modificabile) dagli + // utenti e dai contratti + + // Gli 'event' pubblicano le azioni in modo che siano ascoltabili da + // listener esterni + event LogDepositMade(address accountAddress, uint amount); + + // I 'constructor' possono ricevere uno o più parametri; Si può + // dichiarare un solo costruttore + constructor() public { + // 'msg' fornisce i dettagli sul messaggio che è stato mandato al contratto + // 'msg.sender' è chi invoca il contratto (l'indirizzo di chi lo crea) + owner = msg.sender; + } + + /// @notice Deposita ether nella banca + /// @return Il saldo dell'utente dopo che è stato effettualto il deposito + function deposit() public payable returns (uint) { + // Usiamo 'require' per testare gli input dell'utente, 'assert' per gli + // invarianti interni. Qui ci assicuriamo di non avere a che fare con + // un overflow + require((balances[msg.sender] + msg.value) >= balances[msg.sender]); + + balances[msg.sender] += msg.value; + // Non servono "this." o "self." con le variabili di stato + // Tutti i valori iniziali delle variabili sono impostati automaticamente + // al valore di default per quel tipo di dato + + emit LogDepositMade(msg.sender, msg.value); // Fa scattare l'evento + + return balances[msg.sender]; + } + + /// @notice Preleva ether dalla banca + /// @dev Non restituisce gli ether inviati in eccesso + /// @param withdrawAmount L'importo che si vuole ritirare + /// @return remainingBal + function withdraw(uint withdrawAmount) public returns (uint remainingBal) { + require(withdrawAmount <= balances[msg.sender]); + + // Notiamo come per prima cosa scaliamo i soldi dal saldo, prima di + // invarli. Ogni .transfer/.send in questo contratto può chiamare una + // funzione esterna. Questa cosa potrebbe permettere a chi invoca la + // funzione di richiedere un importo maggiore del suo saldo usando + // una chiamata ricorsiva. Miriamo ad aggiornare lo stato prima che sia + // chiamata una funzione esterna, incluse .transfer/.send + balances[msg.sender] -= withdrawAmount; + + // Qui lancia automaticamente un errore se fallisce, il che implica + // che il saldo (non più aggiornato) viene ripristinato a prima della + // transazione + msg.sender.transfer(withdrawAmount); + + return balances[msg.sender]; + } + + /// @notice Recupera il saldo + /// @return Il saldo dell'utente + // 'view' (ex: constant) impedisce alle funzioni di modificare lo stato + // delle variabili; consente alle le funzioni di essere disponibili in + // locale/fuori dalla blockchain + function balance() view public returns (uint) { + return balances[msg.sender]; + } +} +// ** FINE DELL'ESEMPIO ** + + +// Passiamo alle basi di Solidity + +// 1. TIPI DI DATO E I LORO METODI +// uint viene usato per gli importi in valuta (non ci sono double o float) +// e per le date (in unix time) +uint x; + +// int di 256 bit, non possono essere modificati dopo l'istanziazione +int constant a = 8; +int256 constant a = 8; // stesso effetto della riga prima, qui viene +// dichiarato esplicitamente che è di 256 bit +uint constant VERSION_ID = 0x123A1; // Una costante esadecimale +// con 'constant', il compilatore rimpiazza ogni occorrenza con il valore + +// Tutte le variabili di stato (quelle fuori da una funzione) +// sono 'interne' di default e accessibili SOLO dall'interno del contratto +// e da tutti contratti che le ereditano +// Bisogna usare esplicitamente 'public' per consentire l'accesso dai contratti +// esterni +int256 public a = 8; + +// Per int e uint possiamo esplicitamente assegnare una dimensione tra 8 e 256 +// es. int8, int16, int24 +uint8 b; +int64 c; +uint248 e; + +// Attenzione a non andare in overflow e a proteggersi dagli attacchi che lo fanno +// Ad esempio per quanto rigrada l'addizione, conviene fare: +uint256 c = a + b; +assert(c >= a); // 'assert' testa gli invarianti interni; require viene usato +// per gli input +// Per altri esempi di problemi comuni con le operazioni aritmentiche, dai una +// occhiata alla Zeppelin's SafeMath library +// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol + + +// Non ci sono funzioni random built-in, puoi ottenere un numero pseudo-casuale +// hashando l'ultimo blockhash, o ottenere un numero realmente casuale usando +// qualcosa come Chainlink VRF. +// https://docs.chain.link/docs/get-a-random-number + +// Conversione di tipo +int x = int(b); + +bool b = true; // oppure 'var b = true;' per l'inferenza di tipo + +// Indirizzi - contengono indirizzi Ethereum di 20 byte/160 bit +// Non sono consentite operazioni aritmetiche +address public owner; + +// Tipi di account: +// Contract account: l'indirizzo viene impostato quando lo si crea (funzione con +// l'indirzzo di chi lo crea, il numero della transazione inviata) +// External Account: (persona/enitità esterna): l'indirizzo viene creato dalla +// chiave pubblica + +// Aggiungi il campo 'public' per indicare che è pubblico/accessibile dall'esterno +// un getter viene creato automaticamente, ma NON un setter + +// Si possono mandare ether a tutti gli indirizzi +owner.transfer(SOME_BALANCE); // fallisce e, in tal caso, ripristina +// lo stato precedente + +// Possiamo anche usare la funzione di livello più basso .send, che restituisce +// false se fallisce +if (owner.send) {} // RICORDA: metti la send in un 'if' dato che gli indirizzi +// usati nei contratti hanno delle funzioni, che vengono eseguite quando viene +// fatta una send, che possono fallire. +// Inoltre fai attenzione a scalare i saldi PRIMA di provare a fare una send, +// dato il rischio di chiamate riscorsive che potrebbero prosciugare il contratto + +// Possiamo controllare il saldo +owner.balance; // il saldo del propietario (utente o contratto) + + +// I Byte sono disposibili in dimensioni da 1 a 32 +byte a; // 'byte' è la stessa cosa di 'bytes1' +bytes2 b; +bytes32 c; + +// Byte con dimensione dinamica +bytes m; // Un array particolare, la stessa cosa dell'array 'byte[]' (ma scritto stringato) +// È più dispendioso di byte1-byte32, che di solito sono preferibili + +// come bytes, ma non permette di accedere alla lunghezza o all'indice (per ora) +string n = "hello"; // salvato in UTF8, nota i doppi apici, non singoli +// le utility function per le stringhe saranno aggiunte in futuro +// sono preferibili bytes32/bytes, dato che UTF8 occupa più memoria + +// Inferenza di tipo +// 'var' fa inferenza di tipo a seconda del primo assegnamento, +// non può essere usata tra i parametri di una funzione +var a = true; +// da usare con cautela, può inferire un tipo errato +// es. un int8 quando un contatore dev'essere un int16 + +// var può essere usata per assegnare una funzione ad una variabile +function a(uint x) returns (uint) { + return x * 2; +} +var f = a; +f(22); // chiamata + +// di default, tutte le variabili sono impostate a 0 durante l'istanziazione + + +// Delete può essere chiamato sulla maggior parte dei valori +// (NON distrugge il valore, ma lo setta a 0, il valore did default) +uint x = 5; + + +// Destructuring/Tuple +(x, y) = (2, 7); // assegna/scambia più valori + + +// 2. STRUTTURE DATI +// Array +bytes32[5] nicknames; // array statico +bytes32[] names; // array dinamico +uint newLength = names.push("John"); // aggiungere un elemento restituisce +// la nuova dimensione dell'array +// Dimesione +names.length; // ottenere la dimensione +names.length = 1; // la dimensione può essere assegnata (solo per gli array nello storage) + +// array multidimensionali +uint[][5] x; // array con 5 array dinamici (ordine opposto rispetto ad +// altri linguaggi) + +// Dizionari (da un tipo qualsiasi a un tipo qualsiasi) +mapping (string => uint) public balances; +balances["charles"] = 1; +// il risultato balances["ada"] è 0, tutte le chiavi non settate +// restituiscono zero +// 'public' permette che si possa fare questo da un altro contratto: +contractName.balances("charles"); // restituisce 1 +// 'public' ha creato getter (ma non un setter), come il seguente: +function balances(string _account) returns (uint balance) { + return balances[_account]; +} + +// Mapping annidati +mapping (address => mapping (address => uint)) public custodians; + +// Fare una delete +delete balances["John"]; +delete balances; // assegna 0 a tutti gli elementi + +// Diversamente da altri linguaggi NON si può iterare tra gli elementi di un +// mapping senza conoscere le chiavi - ma si può costruire una struttura dati a monte +// che lo faccia + +// Strutture dati +struct Bank { + address owner; + uint balance; +} +Bank b = Bank({ + owner: msg.sender, + balance: 5 +}); +// oppure +Bank c = Bank(msg.sender, 5); + +c.balance = 5; // imposta ad un nuovo valore +delete b; +// reimposta, imposta tutte le variabili della struttura a 0, tranne i mapping + +// Enumerazioni +enum State { Created, Locked, Inactive }; // di solito si usano per gli automi a stati finiti +State public state; // Dichiara una variabile da un enum +state = State.Created; +// Le enum possono essere convertite esplicitamente in int +uint createdState = uint(State.Created); // 0 + +// Data location: Memory vs. storage vs. calldata - tutti i tipi complessi +// (array, struct) hanno una data location +// 'memory' non è persistente, 'storage' sì +// Il default è 'storage' per varibili locali e di stato; +// 'memory' per i parametri delle funzioni +// Lo stack può contenere poche varaibili locali + +// Per la maggior parte dei tipi, si può impostare esplicitamente +// quale data location usare + + +// 3. Operatori semplici +// Ci sono operatori logici, a bit e aritmetici +// Potenza: ** +// Or esclusivo: ^ +// Negazione bitwise: ~ + + +// 4. Variabili globali degne di nota +// ** this ** +this; // indirizzo del contratto +// di solito si usa per trasferire altrove il saldo rimanente +// al termine della vita del contratto +this.balance; +this.someFunction(); // invoca una funzione esterna tramite chiamata, +// non attraverso un salto interno + +// ** msg - Il messaggio corrente ricevuto dal contratto ** +msg.sender; // indirizzo di chi ha inviato msg +msg.value; // l'importo di ether forniti a questo contratto espresso in "wei", +// la funzione dovrebbe essere marcata come "payable" +msg.data; // in bytes, tutti gli argomenti del messaggio +msg.gas; // 'gas' restante + +// ** tx - Questa transazione ** +tx.origin; // l'indirizzo di chi ha avviato questa transazione +tx.gasprice; // il prezzo del "gas" per la transazione + +// ** block - Informazioni sul blocco attuale ** +now; // ora corrente (approssimatamente), alias di block.timestamp (in Unix time) +// Da notare come può essere manipolata dai miner, quindi da usare con cautela + +block.number; // numero del blocco attuale +block.difficulty; // difficulty del blocco attuale +block.blockhash(1); // restituisce un bytes32, funziona solo per i 256 blocchi +// più recenti +block.gasLimit(); + +// ** storage - Memoria persistente (in hash) ** +storage['abc'] = 'def'; // mappa da parole di 256 bit a parole di 256 bit + + +// 4. FUNZIONI E ALTRO +// A. Funzioni +// Una semplice funzione +function increment(uint x) returns (uint) { + x += 1; + return x; +} + +// Le funzioni possono restituire molti valori, +// e visto che i valori di ritorno vengono dichiarati prima +// non è richiesta un'instruzione return esplicita +function increment(uint x, uint y) returns (uint x, uint y) { + x += 1; + y += 1; +} +// Chiama la funzione di cui sopra +uint (a,b) = increment(1,1); + +// 'view' (un alias di 'constant') +// indica che la funzione non cambia / non può cambiare le variabili persistenti +// Le funzioni definite con view vengono eseguite localmente, non sulla blockchain +// N.B. la keyword constant sarà presto deprecata +uint y = 1; + +function increment(uint x) view returns (uint x) { + x += 1; + y += 1; // questa riga fallirebbe + // y è una variabile di stato, e non può essere cambiata in una funzione di view +} + +// 'pure' è più restrittivo di 'view' o 'constant', e non +// permette nemmeno di leggere le varaibili di stato +// In realtà è più complicato, per approfondire su +// view/pure: +// http://solidity.readthedocs.io/en/develop/contracts.html#view-functions + +// Modificatori di visibilità per le funzioni +// Possono essere messi vicino a 'view' e includono: +// public - visibile esternamente e internamente (di default per function) +// external - visible solo esternamente (comprese le chiamate fatte con this.) +// private - visibile solo dal contratto attuale +// internal - visibile solo dal contratto attuale, e da quelli che ne derivano + +// Di solito è una buona idea marcare esplicitamente ogni funzione + +// Le funzioni sono hoisted e si può assegnare una funzione ad una variabile +function a() { + var z = b; + b(); +} + +function b() { + +} + +// Tutte le funzioni che ricevono ether devono essere dichiarate come 'payable' +function depositEther() public payable { + balances[msg.sender] += msg.value; +} + + +// I cicli sono da preferire alla ricorsione +// (la profondità massima dello stack è 1024) +// Inoltre, non impostare dei loop senza limiti, +// perchè potresti raggiungere il limite per il gas + +// B. Eventi +// Gli eventi notificano a terze parti; è facile ispezionare e +// accedere agli eventi al di fuori della blockchain (con client leggeri); +// Tipicamente si dichiarano dopo i parametri del contratto + +// Tipicamente, sono capitalized - si usa Log come prefisso per esplicitarli +// meglio ed evitare che si confondano con una chiamata a funzione + +// Dichiarazione +event LogSent(address indexed from, address indexed to, uint amount); +// Da notare le prime lettere maiuscole + +// Chiamata +LogSent(from, to, amount); + +/** + +Una terza parte esterna (entità o contratto), può osservare usando +la libreria Javascript Web3: + +// Quel che se segue è codice Javascript, non Solidity +Coin.LogSent().watch({}, '', function(error, result) { + if (!error) { + console.log("Trasferimento valuta: " + result.args.amount + + " la valuta è stata mandata da " + result.args.from + + " a " + result.args.to + "."); + console.log("I saldi ora sono:\n" + + "Mittente: " + Coin.balances.call(result.args.from) + + "Destinatario: " + Coin.balances.call(result.args.to)); + } +} +**/ + +// È prassi che un contratto dipenda da un altro (es. che dipenda +// dai tassi di cambio forniti da un altro contratto) + +// C. Modifier +// I modifier validano gli input per conto dele funzioni verificando ad esempio +// il saldo minimo o l'autenticazione dell'utente; +// sono simili alle calusole di guardia di altri linguaggi + +// '_' (underscore) viene spesso posizionato nell'ultima riga del body, e indica +// che la funzione chiamata dev'essere posizionata lì +modifier onlyAfter(uint _time) { require (now >= _time); _; } +modifier onlyOwner { require(msg.sender == owner) _; } +// usate comunemente negli automi a stati finiti +modifier onlyIfStateA (State currState) { require(currState == State.A) _; } + +// Si dichiarano appena dopo la definizione di una funzione +function changeOwner(newOwner) +onlyAfter(someTime) +onlyOwner() +onlyIfState(State.A) +{ + owner = newOwner; +} + +// L'underscore può essere messo prima della fine del body, +// ma un'istruzione di ritorno esplicita lo salterebbe, +// quindi è da usare con cautela +modifier checkValue(uint amount) { + _; + if (msg.value > amount) { + uint amountToRefund = amount - msg.value; + msg.sender.transfer(amountToRefund); + } +} + + +// 6. ISTRUZIONI CONDIZIONALI E CICLI + +// Troviamo tutte le istruzioni condizionali di base - incluse if/else, for, +// while, break, continue e return - ma non c'è lo switch + +// La sintassi è la stessa di javascript, ma non esiste la conversione di tipo +// in booleano dai non booleani (bisogna usare gli operatori logici per +// ottenere il valore boolean) + +// Bisogna stare attenti i loop che iterano in base al comportamento +// dell'utente, dato che i contratti hanno un tetto massimo di gas +// per blocco di codice e falliranno se lo superano +// Ad esempio: +for(uint x = 0; x < refundAddressList.length; x++) { + refundAddressList[x].transfer(SOME_AMOUNT); +} + +// Ci sono due errori nel codice precedente: +// 1. Un fallimento su una transfer impedisce al loop di completare tutti +// i cicli, bloccando dei soldi; +// 2. Questo loop potrebbe essere arbitrariamente lungo (si basa sul numero +// degli utenti che hanno diritto al rimborso), quindi potrebbe fallire sempre +// se supera il tetto massimo di gas per blocco; +// Come soluzione, si permette agli utenti di prelevare +// individualmente dal loro subaccount e segnare il rimborso come riscosso +// Ad es. preferire pull payments ai push payment + + +// 7. OGGETTI/CONTRATTI + +// A. Invocare un contratto esterno +contract InfoFeed { + function info() payable returns (uint ret) { return 42; } +} + +contract Consumer { + InfoFeed feed; // punta ad un contratto sulla blockchain + + // Imposta il feed sull'istanza del contratto esistente + function setFeed(address addr) { + // fare attenzione alla conversione di tipo automatica; + // il costruttore non viene invocato + feed = InfoFeed(addr); + } + + // Imposta il feed ad una nuova istanza del contratto + function createNewFeed() { + feed = new InfoFeed(); // viene creata una nuova istanza; + // viene invocato il costruttore + } + + function callFeed() { + // le parentesi finali invocano il contratto, opzionalmente si può + // specificare un importo custom di ether o di gas + feed.info.value(10).gas(800)(); + } +} + +// B. ereditarietà + +// Conta l'ordine, l'ultimo contratto ereditato (es. 'def') può andare +// in overriding su parti dei contratti precedentemente ereditati +contract MyContract is abc, def("a custom argument to def") { + +// Funzione in overriding + function z() { + if (msg.sender == owner) { + def.z(); // invoca la funzione overridden da def + super.z(); // chiama la funzione overridden del padre + } + } +} + +// Funzioni astratte +function someAbstractFunction(uint x); +// non possono essere compilate, vengono usate nei contratti base/astratti +// e poi verranno implementate + +// C. Import + +import "filename"; +import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol"; + + +// 8. ALTRE KEYWORD + +// A. Selfdestruct +// autodistrugge il contratto corrente, inviando i fondi ad un indirizzo +// (di solito il creatore) +selfdestruct(SOME_ADDRESS); + +// rimuove il codice e quanto in memoria dal blocco corrente e da tutti i blocchi futuri +// aiuta ad alleggerire i client, ma le informazioni precedenti continueranno +// a persistere sulla blockchain + +// È un pattern comune, permette al proprietario di terminare il contratto +// e ricevere i fondi rimasti +function remove() { + if(msg.sender == creator) { // Solo il creatore del contratto può farlo + selfdestruct(creator); // Cessa l'attività del contratto, trasferisce i fondi + } +} + +// Si potrebbe voler disattivare il contratto manualmente, anzichè usare una +// selfdestruct (gli ether inviati ad un contratto dopo una selfdestruct +// vengono persi) + + +// 9. NOTE SUL DESIGN DEI CONTRATTI + +// A. Offruscamento +// Tutte le variabili sono pubblicamente visibili sulla blockchain, quindi +// qualsiasi informazione privata ha bisogno di essere offruscata (es. hash con una +// chiave segreta) + +// Passi: 1. Impegnarsi pagare una certa cifra, 2. Rivelare l'impegno preso +keccak256("una_puntata_d_asta", "un segreto"); // impegno + +// in futuro, l'invocazione della funzione rivelatrice del contratto +// mostrerà la puntata con il segreto che produce lo SHA3 +reveal(100, "ilMioSegreto"); + +// B. Ottimizzazione della memoria (storage) +// Scrivere dati sulla blockchain può essere costoso visto che vengono +// conservati per sempre; siamo incoraggati ad usare la memoria in maniera +// scaltra (un giorno la compilazione migliorerà, ma per ora è vantaggioso +// pianificare le strutture dati da usare - e conservarne il minimo possibile +// sulla blockchain) + +// I costi per conservare cose come array multidimensionali sono spesso alti +// (costa conservare dati - non dichiarare variabili parzialmente vuote) + +// C. Accesso ai dati sulla blockchain +// Non si può impedire alle persone o ai computer di leggere il contenuto +// o lo stato delle transazioni + +// Anche se 'private' non permette agli altri *contratti* di leggere alcune +// informazioni direttamente, qualsiasi altro attore può leggerle +// sulla blockchain + +// Tutti i dati, dall'inizio, vegono conservati sulla blockchain e +// tutti possono accedere alle informazioni passate e ai cambiamenti futuri + +// D. Oracle e dati esterni +// Gli oracle consentono di interagire con i tuoi smart contract +// al di fuori della blockchain. +// Vengono usati per ricevere informazioni dal mondo reale, mandare +// richieste post al mondo reale o vice versa. + +// Anche le implementazioni che sfruttano l'ora vengono fatte attraverso +// gli oracle, visto che i contratti devono essere chiamati direttamente e +// non possono fare una "subscribe" a un certo orario. +// Data la decentralizzazione degli smart contract, vorrai ricevere informazioni +// in maniera decentralizzata, altrimenti rischi di ricreare l'accentramento +// che la progettazione degli smart contract si prefigge di prevenire. + +// Il modo migliore di ottenere e usare dati decentralizzati già pronti +// è attraverso i Chainlink Data Feeds +// https://docs.chain.link/docs/get-the-latest-price +// Possiamo fare riferimento a certe informazioni della blockchain +// che sono già state aggregate da più fonti e ridistribuite on-chain, +// usandole come "banche dati" di fonti di informazione. + +// Puoi vedere altri esempi che effettuano chiamate alle API qui: +// https://docs.chain.link/docs/make-a-http-get-request + +// E ovviamente puoi costruire la tua rete di orace, ma assicurati di sapere +// quant'è accentrata o decentralizzata la tua applicazione. + +// Mettere su una rete di oracle per conto tuo + +// E. Cron Job +// I contratti devono essere chiamati manualmente per gestire lo scheduling +// in base all'orario; si può creare un codice esterno che li pinghi reglarmente +// oppure fornire degli incentivi (ether) a qualcun'altro che lo faccia + +// F. Pattern Observer +// Un pattern observer permette di iscriversi come osservatore e +// registrare una funzione che verrà chiamata dall'oracle +// (N.B. l'oracolo paga perchè sia eseguita quest'azione) +// Ci sono alcune somoglianze nella registrazione con Pub/sub + +// Questo è un contratto astratto che importano sia il client che il server +// Il client dovrebbe implementarlo +contract SomeOracleCallback { + function oracleCallback(int _value, uint _time, bytes32 info) external; +} + +contract SomeOracle { + SomeOracleCallback[] callbacks; // array di tutti gli osservatori iscritti + + // Osservatori iscritti + function addSubscriber(SomeOracleCallback a) { + callbacks.push(a); + } + + function notify(value, time, info) private { + for(uint i = 0;i < callbacks.length; i++) { + // tutti gli osservatori iscritti dovranno implementare la oracleCallback + callbacks[i].oracleCallback(value, time, info); + } + } + + function doSomething() public { + // Codice che fa qualcosa + + // Notifica a tutti gli iscritti + notify(_value, _time, _info); + } +} + +// Il contratto client può aggiungersi agli iscritti (con addSubscriber) +// del contratto SomeOracle, importando SomeOracleCallback + +// G. Automi a stati finiti +// vedi l'esempio sotto che usa enum per lo stato e il modifier inState +``` + +Prova l'esempio completo qui sotto [usando remix e la `Javascript VM`](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=3d12cd503dcedfcdd715ef61f786be0b&runs=200) + +```javascript +// *** ESEMPIO: Un esempio di crowdfunding (molto simile a Kickstarter) *** +// ** START EXAMPLE ** + +// CrowdFunder.sol +pragma solidity ^0.6.6; + +/// @title CrowdFunder +/// @author nemild +contract CrowdFunder { + // Variabili impostate alla creazione dal creatore + address public creator; + address payable public fundRecipient; // il creatore può essere diverso + // da chi riceve i fondi, che dev'essere payable + uint public minimumToRaise; // è richiesto per chiedere il finanziamento, + // altrimenti tutti ricevono un rimborso + string campaignUrl; + byte version = "1"; + + // Strutture dati + enum State { + Fundraising, + ExpiredRefund, + Successful + } + struct Contribution { + uint amount; + address payable contributor; + } + + // Variabili di stato + State public state = State.Fundraising; // inizializzato alla creazione + uint public totalRaised; + uint public raiseBy; + uint public completeAt; + Contribution[] contributions; + + event LogFundingReceived(address addr, uint amount, uint currentTotal); + event LogWinnerPaid(address winnerAddress); + + modifier inState(State _state) { + require(state == _state); + _; + } + + modifier isCreator() { + require(msg.sender == creator); + _; + } + + // Aspetta 24 settimane dopo l'ultimo cambio di stato prima di consentire + // che in contratto venga distrutto + modifier atEndOfLifecycle() { + require(((state == State.ExpiredRefund || state == State.Successful) && + completeAt + 24 weeks < now)); + _; + } + + function crowdFund( + uint timeInHoursForFundraising, + string memory _campaignUrl, + address payable _fundRecipient, + uint _minimumToRaise) + public + { + creator = msg.sender; + fundRecipient = _fundRecipient; + campaignUrl = _campaignUrl; + minimumToRaise = _minimumToRaise; + raiseBy = now + (timeInHoursForFundraising * 1 hours); + } + + function contribute() + public + payable + inState(State.Fundraising) + returns(uint256 id) + { + contributions.push( + Contribution({ + amount: msg.value, + contributor: msg.sender + }) // usiamo un array per iterare + ); + totalRaised += msg.value; + + emit LogFundingReceived(msg.sender, msg.value, totalRaised); + + checkIfFundingCompleteOrExpired(); + return contributions.length - 1; // restituisce l'id + } + + function checkIfFundingCompleteOrExpired() + public + { + if (totalRaised > minimumToRaise) { + state = State.Successful; + payOut(); + + // qui si può incentivare chi ha provocato il cambiamento di stato + } else if ( now > raiseBy ) { + state = State.ExpiredRefund; // ora i finanziatori possono avere + // il rimborso chiamando getRefund(id) + } + completeAt = now; + } + + function payOut() + public + inState(State.Successful) + { + fundRecipient.transfer(address(this).balance); + LogWinnerPaid(fundRecipient); + } + + function getRefund(uint256 id) + inState(State.ExpiredRefund) + public + returns(bool) + { + require(contributions.length > id && id >= 0 && contributions[id].amount != 0 ); + + uint256 amountToRefund = contributions[id].amount; + contributions[id].amount = 0; + + contributions[id].contributor.transfer(amountToRefund); + + return true; + } + + function removeContract() + public + isCreator() + atEndOfLifecycle() + { + selfdestruct(msg.sender); + // il creatore riceve tutti i fondi che non sono stati riscossi + } +} +// ** END EXAMPLE ** + +``` + +Qualche altra funzionalità. + +```javascript +// 10. ATRE FUNZIONALITA' NATIVE + +// Unità di valuta +// La valuta viene definita partendo dai wei, l'unità più piccola di Ether +uint minAmount = 1 wei; +uint a = 1 finney; // 1 ether == 1000 finney +// Per altre unità, vedi: http://ether.fund/tool/converter + +// Unità temporali +1 == 1 second +1 minutes == 60 seconds + +// Le unità temporali si possono moltiplicare, visto che non vegono salvate +// nelle variabili +uint x = 5; +(x * 1 days); // 5 giorni + +// Attenzione ad usare l'operatore di uguaglianza con i secondi/anni bisestili +// (sono da preferire maggiore/minore di) + +// Crittografia +// Tutte le stringhe che vengono passate vengono concatenate prima di +// calcolare l'hash +sha3("ab", "cd"); +ripemd160("abc"); +sha256("def"); + + +// 11.SICUREZZA + +// I bug possono essere disastrosi per i contratti Ethereum e anche +// i pattern comuni di Solidity potrebbero riverlarsi degli antipattern + +// Dai un'occhiata ai link sulla sicurezza alla fine di questo documento + + +// 12. FUNZIONI DI BASSO LIVELLO +// call - è di basso livello, non viene usata spesso, perchè non è type safe +successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2'); + +// callcode - Il codice all'indirizzo target viene eseguito *contestualmente* +// alla chiamata del contratto +// fornisce le stesse funzionalità di una libreria +someContractAddress.callcode('function_name'); + + +// 13. NOTE SULLO STILE +// Basate sulla guida allo stile PEP8 di Python +// Guida completa allo stile: http://solidity.readthedocs.io/en/develop/style-guide.html + +// Riassunto veloce: +// 4 spazi per l'indentazione +// Due righe per separare la dichiarazione dei contratti +// (e altre dichirazioni top level) +// Evitare spazi ai lati interni delle parentesi tonde +// Si possono omettere le parentesi graffe per statement monolinea (if, for, etc) +// L'else dovrebbe essere posizionato su una riga a se + +// 14. COMMENTI NATSPEC +// usati per la documentazione, commenti e UI esterne + +// Natspec dei contratti - sempre sopra la definizione del contratto +/// @title Titolo del contratto +/// @author Nome dell'autore + +// Natspec delle funzioni +/// @notice informazioni su quel che fa la funzione; mostrate quando la funzione viene eseguita +/// @dev Documentazione della funzione per sviluppatori + +// Natspec dei parametri/valori di ritorno delle funzioni +/// @param someParam Una descrizione di quel che fa il parametro +/// @return Descrizione del valore di ritorno +``` + +## Risorse Aggiuntive +- [Documentazione di Solidity](https://solidity.readthedocs.org/en/latest/) +- [Tutorial Chainlink per Principianti](https://docs.chain.link/docs/beginners-tutorial) +- [Best Practice per Smart Contract](https://github.com/ConsenSys/smart-contract-best-practices) +- [Superblocks Lab - Ambiente di sviluppo su browser per Solidity](https://lab.superblocks.com/) +- [EthFiddle - Il JsFiddle di Solidity](https://ethfiddle.com/) +- [Solidity Editor su Browser](https://remix.ethereum.org/) +- [Chat Room Gitter su Solidity](https://gitter.im/ethereum/solidity) +- [Stategie di Progettazione Modulare per Contratti Ethereum](https://docs.erisindustries.com/tutorials/solidity/) +- [Documentazione Chainlink](https://docs.chain.link/docs/getting-started) + +## Framework di Sviluppo per Smart Contract +- [Hardhat](https://hardhat.org/) +- [Brownie](https://github.com/eth-brownie/brownie) +- [Truffle](https://www.trufflesuite.com/) + +## Librerie importanti +- [Zeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts): Librerie che offrono pattern comuni (crowdfuding, safemath, ecc) +- [Chainlink](https://github.com/smartcontractkit/chainlink): Codice che permette di interagire con dati esterni + +## Contratti di esempio +- [Dapp Bin](https://github.com/ethereum/dapp-bin) +- [Esempi Defi](https://github.com/PatrickAlphaC/chainlink_defi) +- [Solidity per Contratti a Piccoli Passi](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts) +- [Contratti ConsenSys](https://github.com/ConsenSys/dapp-store-contracts) +- [Lo stato delle Dapp](http://dapps.ethercasts.com/) + +## Sicurezza +- [Pensando Alla Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/) +- [Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/10/smart-contract-security/) +- [Blog Distribuito di Hacking](http://hackingdistributed.com/) + +## Stile +- [Guida allo Stile di Solidity](http://solidity.readthedocs.io/en/latest/style-guide.html): La guida allo stile di Ethereum deriva in gran parte dalla guida allo stile [PEP 8](https://www.python.org/dev/peps/pep-0008/) di Python. + +## Editor +- [Remix](https://remix.ethereum.org/) +- [Emacs Modalità Solidity](https://github.com/ethereum/emacs-solidity) +- [Vim Solidity](https://github.com/tomlion/vim-solidity) +- Snippet per gli Editor ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc)) + +## Cose da fare in futuro +- Nuove keyword: protected, inheritable +- Lista dei design pattern comuni (throttling, RNG, upgrade di versione) +-Anti patterns comuni sulla sicurezza + +Sentiti libero di mandare una pull request con qualsiasi modifica - o scrivi una mail a nemild -/at-/ gmail diff --git a/lua.html.markdown b/lua.html.markdown index ac7883b2..de71ccd4 100644 --- a/lua.html.markdown +++ b/lua.html.markdown @@ -58,7 +58,7 @@ foo = anUnknownVariable -- Now foo = nil. aBoolValue = false -- Only nil and false are falsy; 0 and '' are true! -if not aBoolValue then print('twas false') end +if not aBoolValue then print('it was false') end -- 'or' and 'and' are short-circuited. -- This is similar to the a?b:c operator in C/js: @@ -193,7 +193,7 @@ end -- A table can have a metatable that gives the table -- operator-overloadish behavior. Later we'll see --- how metatables support js-prototypey behavior. +-- how metatables support js-prototype behavior. f1 = {a = 1, b = 2} -- Represents the fraction a/b. f2 = {a = 2, b = 3} @@ -364,7 +364,7 @@ end)() -- locals inside mod.lua are invisible outside it. -- This works because mod here = M in mod.lua: -mod.sayHello() -- Says hello to Hrunkner. +mod.sayHello() -- Prints: Why hello there Hrunkner -- This is wrong; sayMyName only exists in mod.lua: mod.sayMyName() -- error @@ -406,7 +406,7 @@ I started with <a href="https://ebens.me/post/lua-for-programmers-part-1/">Black Next I read the official <a href="http://www.lua.org/pil/contents.html">Programming in Lua</a> book. That's the how. -It might be helpful to check out the <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Lua short +It might be helpful to check out the <a href="http://lua-users.org/wiki/LuaShortReference">Lua short reference</a> on lua-users.org. The main topics not covered are standard libraries: diff --git a/openscad.html.markdown b/openscad.html.markdown new file mode 100644 index 00000000..e09b5109 --- /dev/null +++ b/openscad.html.markdown @@ -0,0 +1,117 @@ +--- +language: openscad +filename: learnopenscad.scad +contributors: + - ["Tom Preston", "https://github.com/tompreston/"] +--- + +Draw 3D models with code using [OpenSCAD](https://openscad.org/). + +```openscad +// Comments look like this + +// 3D Primitives +cube(10); +cube([5, 10, 20]); +sphere(10); + +// Transformations +translate([20, 0, 0]) cube(10); +rotate([0, 20, 30]) cube(10); + +translate([20, 0, 0]) rotate([0, 20, 30]) cube(10); +rotate([0, 20, 30]) translate([20, 0, 0]) cube(10); + +// Modifiers +// +// * disable +// ! show only +// # highlight / debug +// % transparent / background +// +// For example, show only the rotated cube at the origin, before we translate it. +translate([20, 0, 0]) !rotate([0, 20, 30]) cube(10); + +// Formatting +// The following models are the same. The official docs prefer the second. +rotate([0, 20, 30]) translate([20, 0, 0]) cube(10); + +rotate([0, 20, 30]) + translate([20, 0, 0]) + cube(10); + +rotate([0, 20, 30]) { + translate([20, 0, 0]) { + cube(10); + } +} + +// Loops +num_cubes = 5; +r = 20; +cube_len = 5; + +for (i = [0:num_cubes]) { + echo(str("Plot cube ", i)); + rotate([0, i * 360 / num_cubes, 0]) + translate([r, 0, 0]) + cube(cube_len, center=true); +} + +// Boolean operations +// +// union() - the sum of both shapes +// difference() - the first shape, minus the second shape +// intersection() - only parts of both shapes which intersect +// +cube_l = 20; +cube_w = 10; +cube_h = 10; + +hole_pos_l = 10; +hole_pos_h = 5; +hole_r = 3; + +difference() { + cube([cube_l, cube_w, cube_h]); + translate([hole_pos_l, 0, hole_pos_h]) + rotate([-90, 0, 0]) + cylinder(cube_w, r=hole_r); +} + +// Functions calculate values +function inch2mm(i) = i * 25.4; + +cube(inch2mm(2)); + +// Modules create objects you want to use later +module house(roof="flat", paint=[1,0,0]) { + color(paint) + if (roof=="flat") { + translate([0,-1,0]) cube(); + } else if (roof=="pitched") { + rotate([90,0,0]) + linear_extrude(height=1) + polygon(points=[[0,0],[0,1],[0.5,1.5],[1,1],[1,0]]); + } + else if (roof=="domical") { + translate([0,-1,0]) { + translate([0.5,0.5,1]) + sphere(r=0.5,$fn=20); + cube(); + } + } +} + +house("pitched"); +translate([2, 0, 0]) house("domical"); + +// Import modules and function from other files +include <filename> // Import the content of the file as if they were written in this file +use <filename> // Import modules and functions, but do not execute any commands +``` + +## Further Reading +* Official docs https://openscad.org/documentation.html +* Cheat sheet https://openscad.org/cheatsheet/index.html +* Vim bindings https://github.com/sirtaj/vim-openscad diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown index 42a29991..7d8b75f1 100644 --- a/pt-br/c++-pt.html.markdown +++ b/pt-br/c++-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ filename: learncpp-pt.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown index 6885c41a..c3f62bc6 100644 --- a/pt-br/c-pt.html.markdown +++ b/pt-br/c-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: c +language: C filename: learnc-pt.c contributors: - ["Adam Bard", "http://adambard.com/"] diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown index 384ca325..475c0568 100644 --- a/pt-br/csharp-pt.html.markdown +++ b/pt-br/csharp-pt.html.markdown @@ -1,5 +1,5 @@ --- -language: c# +language: C# filename: csharp-pt.cs contributors: - ["Robson Alves", "http://robsonalves.net/"] diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown index c2e85ab2..2cc1c337 100644 --- a/pt-br/git-pt.html.markdown +++ b/pt-br/git-pt.html.markdown @@ -11,6 +11,7 @@ contributors: translators: - ["Suzane Sant Ana", "http://github.com/suuuzi"] - ["Bruno Volcov", "http://github.com/volcov"] + - ["Marcel Ribeiro-Dantas", "http://github.com/mribeirodantas"] --- Git é um sistema distribuido de gestão para código fonte e controle de versões. @@ -67,7 +68,8 @@ referências e outros. ### *Working Tree* (componente do repositório) -A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto. +A *Working Tree* é basicamente a listagem dos diretórios e arquivos do +repositório. É chamada também de diretório do projeto. ### *Index* (componente do diretório .git) @@ -77,28 +79,37 @@ maior controle sobre o que é registado no repositório git. ### *Commit* -Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto. -Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações -serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado -para outros repositórios ou não! +Um *commit** de git é um registo de um conjunto de alterações ou manipulações +nos arquivos do projeto. Por exemplo, ao adicionar cinco arquivos e remover +outros 2, estas alterações serão gravadas em um *commit* (ou registro). Este +*commit* pode então ser enviado para outros repositórios, caso você queira. ### *Branch* -Um *branch* é essencialmente uma referência que aponta para o último *commit* +Uma *branch* é essencialmente uma referência que aponta para o último *commit* efetuado. Na medida que são feitos novos commits, esta referência é atualizada automaticamente e passa a apontar para o commit mais recente. ### *Tag* Uma tag é uma marcação em um ponto específico da história. Geralmente as -pessoas usam esta funcionalidade para marcar pontos de release (v2.0, e por aí vai) +pessoas usam esta funcionalidade para marcar pontos de release (v2.0, e por aí +vai) ### *HEAD* e *head* (componentes do diretório .git) -*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem -uma *HEAD* activa. -*head* é uma referência que aponta para qualquer *commit*. Um repositório pode -ter um número indefinido de *heads* +*HEAD* é a referência que aponta para a *branch* em uso. Um repositório só tem +uma *HEAD* activa. *head* é uma referência que aponta para qualquer *commit*. Um +repositório pode ter um número indefinido de *heads*. + +### Estados no Git + +* Modificado (Modified): Ocorreram mudanças em ao menos um arquivo mas essas +mudanças ainda não foram registradas na base de dados do Git +* Preparado (Staged): Marca o arquivo como preparado para ser adicionado ao +próximo commit +* Consolidado (Committed): As mudanças foram registradas na base de dados do +Git ### Recursos conceituais (EN) @@ -109,8 +120,8 @@ ter um número indefinido de *heads* ### *init* -Cria um repositório Git vazio. As definições, informação guardada e outros do -repositório git são guardados em uma pasta chamada ".git". +Cria um repositório Git vazio. As configurações do repositório, e outras +informações são guardadas em uma pasta dentro do repositório com o nome ".git". ```bash $ git init @@ -118,23 +129,24 @@ $ git init ### *config* -Permite configurar as definições, sejam as definições do repositório, sistema -ou configurações globais. +Permite configurar o git, seja com respeito a definições deste repositório, +do sistema ou configurações globais para todos os repositórios. ```bash -# Imprime e define algumas variáveis de configuração básicas (global) -$ git config --global user.email -$ git config --global user.name - +# Define e imprime algumas variáveis de configuração básicas (global) $ git config --global user.email "MyEmail@Zoho.com" $ git config --global user.name "My Name" + +$ git config --global user.email +$ git config --global user.name ``` [Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config) ### help -Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica. +Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da +semântica. ```bash # Ver rapidamente os comandos disponiveis @@ -148,16 +160,32 @@ $ git help -a $ git help add $ git help commit $ git help init +# ou git <comando_aqui> --help +$ git add --help +$ git commit --help +$ git init --help +``` + +### Ignorando arquivos + +É possível intencionalmente ignorar arquivos e pastas. Costuma-se utilizar o +arquivo .gitignore para fazer o git ignorar a existência de arquivos e pastas +geralmente utilizados para arquivos privados ou temporários que, de outro modo, +seriam compartilhados com todos que tem acesso ao repositório. + +```bash +$ echo "temp/" >> .gitignore +$ echo "chave_privada" >> .gitignore ``` ### status -Apresenta as diferenças entre o arquivo *index* (a versão corrente -do repositório) e o *commit* da *HEAD* atual. +Apresenta as diferenças entre o arquivo *index* (a versão corrente do +repositório) e o *commit* da *HEAD* atual. ```bash -# Apresenta o *branch*, arquivos não monitorados, alterações e outras +# Apresenta a *branch*, arquivos não monitorados, alterações e outras # diferenças $ git status @@ -173,35 +201,42 @@ incluidos nos commits! ```bash # adiciona um arquivo no diretório do projeto atual -$ git add HelloWorld.java +$ git add OlaMundo.java -# adiciona um arquivo num sub-diretório -$ git add /path/to/file/HelloWorld.c +# adiciona um arquivo em um sub-diretório +$ git add /caminho/para/arquivo/OlaMundo.java # permite usar expressões regulares! $ git add ./*.java + +# Você também pode adicionar tudo no seu diretório de trabalho como alterações +prontas para o próximo commit. +$ git add -A ``` +Esse comando apenas adiciona os arquivos no estado de preparados para o próximo +commit, mas não realiza o commit de fato. + ### branch -Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este +Gerencia as *branches*. É possível ver, editar, criar e apagar branches com este comando. ```bash # listar *branches* existentes e remotos $ git branch -a -# criar um novo *branch* +# criar uma nova *branch* $ git branch myNewBranch -# apagar um *branch* +# apagar uma *branch* $ git branch -d myBranch -# alterar o nome de um *branch* +# alterar o nome de uma *branch* # git branch -m <oldname> <newname> $ git branch -m myBranchName myNewBranchName -# editar a descrição de um *branch* +# editar a descrição de uma *branch* $ git branch myBranchName --edit-description ``` @@ -212,18 +247,22 @@ Gerencia as *tags* ```bash # Listar tags $ git tag + # Criar uma tag anotada. # O parâmetro -m define uma mensagem, que é armazenada com a tag. # Se você não especificar uma mensagem para uma tag anotada, # o Git vai rodar seu editor de texto para você digitar alguma coisa. $ git tag -a v2.0 -m 'minha versão 2.0' + # Mostrar informações sobre a tag # O comando mostra a informação da pessoa que criou a tag, # a data de quando o commit foi taggeado, # e a mensagem antes de mostrar a informação do commit. $ git show v2.0 + # Enviar uma tag para o repositório remoto $ git push origin v2.0 + # Enviar várias tags para o repositório remoto $ git push origin --tags ``` @@ -231,14 +270,16 @@ $ git push origin --tags ### checkout Atualiza todos os arquivos no diretório do projeto para que fiquem iguais -à versão do index ou do *branch* especificado. +à versão do index ou da *branch* especificado. ```bash -# Checkout de um repositório - por padrão para o branch master +# Checkout de um repositório - por padrão para a branch master $ git checkout -# Checkout de um branch especifico + +# Checkout de uma branch especifica $ git checkout branchName -# Cria um novo branch e faz checkout para ele. + +# Cria uma nova branch e faz checkout para ela. # Equivalente a: "git branch <name>; git checkout <name>" $ git checkout -b newBranch ``` @@ -246,22 +287,41 @@ $ git checkout -b newBranch ### clone Clona ou copia um repositório existente para um novo diretório. Também -adiciona *branches* de monitoramento remoto para cada *branch* no repositório -clonado o que permite enviar alterações para um *branch* remoto. +adiciona *branches* no repositório clonado para cada *branch* no repositório +remoto o que permite enviar alterações para uma *branch* no repositório remoto. ```bash # Clona learnxinyminutes-docs $ git clone https://github.com/adambard/learnxinyminutes-docs.git + +# Clone superficial - É mais rápido, mas puxa apenas o último commit +$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git + +# Clona apenas uma branch em específica +$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch ``` ### commit -Guarda o conteudo atual do index num novo *commit*. Este *commit* contém +Guarda o conteúdo atual do index em um novo *commit*. Este *commit* contém as alterações feitas e a mensagem criada pelo usuário. ```bash -# commit com uma mensagem -$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" +# Realiza um commit com uma mensagem +$ git commit -m "Adicione a função multipliqueNumeros() em OlaMundo.c" + +# Assine um commit com sua chave GPG. Antes disso, você precisa ter +# configurado a opção user.signkey do git com o comando: +# git config --global user.signinkey ID_CHAVE_AQUI +$ git commit -S -m "mensagem do commit aqui" + +# Automaticamente adicione como preparados arquivos modificados ou apagados e +# então realize um commit: +$ git commit -a -m "Modified foo.php and removed bar.php" + +# Altere o último commit (Esse comando cria um novo commit com o conteúdo do +# commit anterior mais suas novas alterações e sobrescreve o último commit) +$ git commit --amend -m "Correct message" ``` ### diff @@ -282,7 +342,7 @@ $ git diff HEAD ### grep -Permite procurar facilmente num repositório +Permite procurar facilmente em um repositório. Configurações opcionais: @@ -313,74 +373,158 @@ Apresenta commits do repositório. # Apresenta todos os commits $ git log -# Apresenta X commits -$ git log -n 10 +# Apresenta apenas mensagem do commit e referência +$ git log --oneline # Apresenta apenas commits de merge $ git log --merges + +# Apresenta todos os commits representados por um gráfico em ASCII +$ git log --graph ``` ### merge -"Merge" junta as alterações de commits externos com o *branch* atual. +"Merge" junta as alterações de commits externos com a *branch* atual. ```bash -# Junta o branch especificado com o atual +# Junta a branch especificada com o atual $ git merge branchName -# Para gerar sempre um commit ao juntar os branches +# Para gerar sempre um commit ao juntar as branches $ git merge --no-ff branchName ``` ### mv -Alterar o nome ou mover um arquivo. +Altera o nome ou move um arquivo. ```bash # Alterar o nome de um arquivo -$ git mv HelloWorld.c HelloNewWorld.c +$ git mv OlaMundo.c OlaNovoMundo.c # Mover um arquivo -$ git mv HelloWorld.c ./new/path/HelloWorld.c +$ git mv OlaMundo.c ./novo/caminho/OlaMundo.c -# Forçar a alteração de nome ou mudança local -# "existingFile" já existe no directório, será sobrescrito. +# Forçar a alteração de nome ou mudança de local +# Se o arquivo já existir no diretório, será sobrescrito. $ git mv -f myFile existingFile ``` ### pull -Puxa alterações de um repositório e as junta com outro branch +Puxa alterações de um repositório e as junta com outra branch ```bash # Atualiza o repositório local, juntando as novas alterações # do repositório remoto 'origin' e branch 'master' # git pull <remote> <branch> -# git pull => aplica a predefinição => git pull origin master $ git pull origin master -# Juntar alterações do branch remote e fazer rebase commits do branch +# Por padrão, o git irá realizar o pull na branch atual fazendo um merge +# com as alterações novas na branch remota +$ git pull + +# Juntar alterações da branch remote e fazer rebase commits da branch # no repositório local, como: "git pull <remote> <branch>, git rebase <branch>" $ git pull origin master --rebase ``` ### push -Enviar e juntar alterações de um branch para o seu branch correspondente -num repositório remoto. +Enviar e juntar alterações de uma branch para a sua branch correspondente +em um repositório remoto. ```bash # Envia e junta as alterações de um repositório local -# para um remoto denominado "origin" no branch "master". +# para um remoto denominado "origin" na branch "master". # git push <remote> <branch> -# git push => aplica a predefinição => git push origin master $ git push origin master + +# Por padrão, o git push irá enviar e realizar merge das mudanças da sua branch +# local com a branch remota +$ git push + +# Para associar a branch local com uma branch específica remota, adicione a +# flag -u +$ git push -u origin master + +# Agora, sempre que você realizar um push daquela branch local, use o atalho: +$ git push +``` + +### stash + +O objetivo desse comando do git é pegar o estado "sujo" do seu diretório de +trabalho, que não está pronto (staged), e salvá-lo em um outro lugar para que +você possa trabalhar no seu repositório do zero, mas sem perder as mudanças que +fez. Em qualquer outro momento que você quiser, você pode trazer de volta as +alterações que você tirou dali com o comando stash. + +Digamos que você tem feito algumas alterações no seu repositório, mas agora +você quer realizar um pull do repositório remoto. Como você tem alterações não +commitadas no seu diretório (ele está "sujo"), você não irá conseguir realizar +o `git pull` com sucesso. Mas você pode executar o `git stash` para salvar +essas alterações e conseguir realizar o pull. Depois, você traz de volta. + +```bash +$ git stash +Saved working directory and index state \ + "WIP on master: 049d078 added the index file" + HEAD is now at 049d078 added the index file + (To restore them type "git stash apply") +``` + +Agora você irá conseguir realizar o pull! + +```bash +git pull +``` +`...changes apply...` + +Verifique se está tudo OK com o `git status` + +```bash +$ git status +# On branch master +nothing to commit, working directory clean +``` + +É possível verificar as alterações que você guardou com cada uso do comando +`git stash` com o `git stash list`. Como os usos desse comando são guardados +como em uma pilha, os usos mais recentes estarão no topo. + +```bash +$ git stash list +stash@{0}: WIP on master: 049d078 added the index file +stash@{1}: WIP on master: c264051 Revert "added file_size" +stash@{2}: WIP on master: 21d80a5 added number to log +``` + +Agora vamos trazer o que havíamos salvado com o `git stash` de volta para o +diretório de trabalho. + +```bash +$ git stash pop +# On branch master +# Changes not staged for commit: +# (use "git add <file>..." to update what will be committed) +# +# modified: index.html +# modified: lib/simplegit.rb +# ``` +`git stash apply` faz a mesma coisa + +Agora podemos voltar a trabalhar no que havíamos deixado de lado! + +[Additional Reading.](http://git-scm.com/book/en/v1/Git-Tools-Stashing) + ### rebase (cautela!) -Pega em todas as alterações que foram registadas num branch e volta a -aplicá-las em outro branch. +Pega em todas as alterações que foram registadas em uma branch e volta a +aplicá-las em outra branch. *Não deve ser feito rebase de commits que foram enviados para um repositório público* @@ -407,31 +551,79 @@ $ git reset # sobrescreve o projeto atual $ git reset --hard -# Move a head do branch atual para o commit especificado, sem alterar o projeto. +# Move a head da branch atual para o commit especificado, sem alterar o projeto. # todas as alterações ainda existem no projeto $ git reset 31f2bb1 -# Inverte a head do branch atual para o commit especificado +# Inverte a head da branch atual para o commit especificado # fazendo com que este esteja em sintonia com o diretório do projeto -# Remove alterações não registadas e todos os commits após o commit especificado +# Remove alterações não registradas e todos os commits após o commit +# especificado $ git reset --hard 31f2bb1 ``` +### reflog (cuidado!) + +O reflog irá listar a maior parte dos comandos que você realizou no git em um +determinado intervalo de tempo. O intervalo padrão é de 90 dias. + +Isso te dá a oportunidade de reverter qualquer comando que você realizou no git +e que tenha tido consequências indesejadas (por exemplo, se um rebase quebrou +sua aplicação). + +Você pode fazer assim: + +1. `git reflog` para listar todos os comandos utilizados no git para o rebase + +``` +38b323f HEAD@{0}: rebase -i (finish): returning to refs/heads/feature/add_git_reflog +38b323f HEAD@{1}: rebase -i (pick): Clarify inc/dec operators +4fff859 HEAD@{2}: rebase -i (pick): Update java.html.markdown +34ed963 HEAD@{3}: rebase -i (pick): [yaml/en] Add more resources (#1666) +ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748) +2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d +``` +2. Selecione para onde você quer resetar. No nosso exemplo, seria o commit +`2e6c386`, ou `HEAD@{5}` +3. 'git reset --hard HEAD@{5}' esse comando irá resetar o seu repositório para +aquele ponto (5 commits atrás). +4. Agora você pode recomeçar o rebase ou apenas deixar como está. + +[Leitura complementar](https://git-scm.com/docs/git-reflog) + +### revert + +O comando revert pode ser utilizado para desfazer um commit. Não deve ser +confundido com o comando reset que restabelece o estado do repositório para um +momento anterior. O revert irá criar um novo commit com alterações inversas a +de um outro commit especificado, portanto revertendo aquelas alterações. + +```bash +# Revertendo um commit específico +$ git revert <commit> +``` + ### rm -O oposto de git add, git rm remove arquivos do branch atual. +O oposto de git add, git rm remove arquivos da branch atual. ```bash -# remove HelloWorld.c -$ git rm HelloWorld.c +# remove OlaMundo.c +$ git rm OlaMundo.c -# Remove um arquivo de um sub-directório -$ git rm /pather/to/the/file/HelloWorld.c +# Remove um arquivo de um sub-diretório +$ git rm /caminho/para/o/arquivo/OlaMundo.c ``` -## Informação complementar (EN) +## Leitura complementar + +* [Configurar o Git (GitHub Docs)](https://docs.github.com/pt/get-started/quickstart/set-up-git) + +* [Learn Git Branching - the most visual and interactive way to learn Git on the web](http://learngitbranching.js.org/) + +* [Udemy Git Tutorial: A Comprehensive Guide](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/) -* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) +* [Git Immersion - A Guided tour that walks through the fundamentals of git](http://gitimmersion.com/) * [git-scm - Video Tutorials](http://git-scm.com/videos) @@ -440,3 +632,11 @@ $ git rm /pather/to/the/file/HelloWorld.c * [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/) * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html) + +* [Pro Git (em Português)](https://www.git-scm.com/book/pt-br/v2) + +* [An introduction to Git and GitHub for Beginners (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners) + +* [The New Boston tutorial to Git covering basic commands and workflow](https://www.youtube.com/playlist?list=PL6gx4Cwl9DGAKWClAD_iKpNC0bGHxGhcx) diff --git a/pt-br/qt-pt.html.markdown b/pt-br/qt-pt.html.markdown index 99579c35..f4211e09 100644 --- a/pt-br/qt-pt.html.markdown +++ b/pt-br/qt-pt.html.markdown @@ -1,7 +1,7 @@ --- category: tool tool: Qt Framework -language: c++ +language: C++ filename: learnqt-pt.cpp contributors: - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] diff --git a/python.html.markdown b/python.html.markdown index 0bd16a80..e8c7110a 100644 --- a/python.html.markdown +++ b/python.html.markdown @@ -153,13 +153,14 @@ None # => None "etc" is None # => False None is None # => True -# None, 0, and empty strings/lists/dicts/tuples all evaluate to False. +# None, 0, and empty strings/lists/dicts/tuples/sets all evaluate to False. # All other values are True -bool(0) # => False -bool("") # => False -bool([]) # => False -bool({}) # => False -bool(()) # => False +bool(0) # => False +bool("") # => False +bool([]) # => False +bool({}) # => False +bool(()) # => False +bool(set()) # => False #################################################### ## 2. Variables and Collections diff --git a/ru-ru/c++-ru.html.markdown b/ru-ru/c++-ru.html.markdown index 3acfafa3..fad1b434 100644 --- a/ru-ru/c++-ru.html.markdown +++ b/ru-ru/c++-ru.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ filename: learncpp-ru.cpp contributors: - ["Steven Basart", "http://github.com/xksteven"] diff --git a/ru-ru/c-ru.html.markdown b/ru-ru/c-ru.html.markdown index cc68d620..eb5de011 100644 --- a/ru-ru/c-ru.html.markdown +++ b/ru-ru/c-ru.html.markdown @@ -1,5 +1,5 @@ --- -language: c +language: C filename: learnc-ru.c contributors: - ["Adam Bard", "http://adambard.com/"] diff --git a/ru-ru/qt-ru.html.markdown b/ru-ru/qt-ru.html.markdown index d0a70c9d..5fbcc3b4 100644 --- a/ru-ru/qt-ru.html.markdown +++ b/ru-ru/qt-ru.html.markdown @@ -1,7 +1,7 @@ --- category: tool tool: Qt Framework -language: c++ +language: C++ filename: learnqt-ru.cpp contributors: - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] diff --git a/tr-tr/c++-tr.html.markdown b/tr-tr/c++-tr.html.markdown index 9d65cf9c..c944f245 100644 --- a/tr-tr/c++-tr.html.markdown +++ b/tr-tr/c++-tr.html.markdown @@ -1,5 +1,5 @@ --- -language: c++ +language: C++ lang: tr-tr filename: learncpp-tr.cpp contributors: diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown index 4ef12527..05531d64 100644 --- a/tr-tr/c-tr.html.markdown +++ b/tr-tr/c-tr.html.markdown @@ -1,7 +1,7 @@ --- -name: c +name: C category: language -language: c +language: C filename: learnc-tr.c contributors: - ["Adam Bard", "http://adambard.com/"] diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown index 91c7c269..9834be20 100644 --- a/tr-tr/csharp-tr.html.markdown +++ b/tr-tr/csharp-tr.html.markdown @@ -1,5 +1,5 @@ --- -language: c# +language: C# contributors: - ["Irfan Charania", "https://github.com/irfancharania"] - ["Max Yankov", "https://github.com/golergka"] diff --git a/typescript.html.markdown b/typescript.html.markdown index 74cd15c6..3fe707a0 100644 --- a/typescript.html.markdown +++ b/typescript.html.markdown @@ -291,7 +291,5 @@ foo.baz = 'hello world' ## Further Reading * [TypeScript Official website] (http://www.typescriptlang.org/) - * [TypeScript language specifications] (https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md) - * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript) + * [TypeScript language specifications] (https://github.com/microsoft/TypeScript/blob/main/doc/spec-ARCHIVED.md) * [Source Code on GitHub] (https://github.com/Microsoft/TypeScript) - * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/) diff --git a/uk-ua/c-ua.html.markdown b/uk-ua/c-ua.html.markdown index c4dac75f..56a2b2ad 100644 --- a/uk-ua/c-ua.html.markdown +++ b/uk-ua/c-ua.html.markdown @@ -1,5 +1,5 @@ --- -language: c +language: C filename: learnc-ua.c contributors: - ["Adam Bard", "http://adambard.com/"] diff --git a/zh-cn/c++-cn.html.markdown b/zh-cn/c++-cn.html.markdown index e0d6b6fe..a6a61949 100644 --- a/zh-cn/c++-cn.html.markdown +++ b/zh-cn/c++-cn.html.markdown @@ -1,5 +1,5 @@ ---
-language: c++
+language: C++
filename: learncpp-cn.cpp
contributors:
- ["Steven Basart", "http://github.com/xksteven"]
diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown index dbad5030..dd4445f7 100644 --- a/zh-cn/c-cn.html.markdown +++ b/zh-cn/c-cn.html.markdown @@ -1,5 +1,5 @@ --- -language: c +language: C filename: learnc-cn.c contributors: - ["Adam Bard", "http://adambard.com/"] diff --git a/zh-cn/csharp-cn.html.markdown b/zh-cn/csharp-cn.html.markdown index 971c1be9..0bad34ce 100644 --- a/zh-cn/csharp-cn.html.markdown +++ b/zh-cn/csharp-cn.html.markdown @@ -1,5 +1,5 @@ --- -language: c# +language: C# contributors: - ["Irfan Charania", "https://github.com/irfancharania"] - ["Max Yankov", "https://github.com/golergka"] diff --git a/zh-cn/python-cn.html.markdown b/zh-cn/python-cn.html.markdown index a4e53c1b..127f7ad5 100644 --- a/zh-cn/python-cn.html.markdown +++ b/zh-cn/python-cn.html.markdown @@ -552,7 +552,7 @@ next(our_iterator) # => "three" # 当迭代器所有元素都取出后,会抛出 StopIteration next(our_iterator) # 抛出 StopIteration -# 我们可以通过遍历还访问所有的值,实际上,for 内部实现了迭代 +# 我们还可以通过遍历访问所有的值,实际上,for 内部实现了迭代 our_iterator = iter(our_iterable) for i in our_iterator: print(i) # 依次打印 one, two, three @@ -697,7 +697,7 @@ import math dir(math) # 当你的脚本文件所在的文件夹也包含了一个名为 math.py 的 Python 文件 -# 这个 math.p 文件会被代替引入,而不是引入 Python 內建模块中的 math +# 这个 math.py 文件会被代替引入,而不是引入 Python 內建模块中的 math # 出现这个情况的原因是本地文件夹的引入优先级要比 Python 內建库引入优先级要高 @@ -760,7 +760,7 @@ class Human: del self._age # 当 Python 解释器在读取源文件的时候,就会执行文件中所有的代码 -# 对 __name__ 的检查可以保证这块代码只会在执行这个模块是住程序情况下被运行(而不是在引用时运行) +# 对 __name__ 的检查可以保证这块代码只会在这个模块是主程序的情况下被运行(而不是在引用时运行) if __name__ == '__main__': # i = Human(name="Ian") diff --git a/zh-cn/qt-cn.html.markdown b/zh-cn/qt-cn.html.markdown index 8681c85b..1d24f200 100644 --- a/zh-cn/qt-cn.html.markdown +++ b/zh-cn/qt-cn.html.markdown @@ -1,7 +1,7 @@ --- category: tool tool: Qt Framework -language: c++ +language: C++ filename: learnqt-cn.cpp contributors: - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"] |