mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 07:12:31 +03:00
Merge remote-tracking branch 'upstream/master'
pull latest
This commit is contained in:
commit
a4e381d756
@ -8,6 +8,7 @@ contributors:
|
||||
- ["Denis Arh", "https://github.com/darh"]
|
||||
- ["akirahirose", "https://twitter.com/akirahirose"]
|
||||
- ["Anton Strömkvist", "http://lutic.org/"]
|
||||
- ["Rahil Momin", "https://github.com/iamrahil"]
|
||||
filename: LearnBash.sh
|
||||
---
|
||||
|
||||
@ -140,6 +141,12 @@ do
|
||||
echo "$VARIABLE"
|
||||
done
|
||||
|
||||
# Or write it the "traditional for loop" way:
|
||||
for ((a=1; a <= 3; a++))
|
||||
do
|
||||
echo $a
|
||||
done
|
||||
|
||||
# They can also be used to act on files..
|
||||
# This will run the command 'cat' on file1 and file2
|
||||
for VARIABLE in file1 file2
|
||||
|
@ -4,6 +4,7 @@ filename: learnc.c
|
||||
contributors:
|
||||
- ["Adam Bard", "http://adambard.com/"]
|
||||
- ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
|
||||
- ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
|
||||
|
||||
---
|
||||
|
||||
@ -175,6 +176,9 @@ int main() {
|
||||
i2 * i1; // => 2
|
||||
i1 / i2; // => 0 (0.5, but truncated towards 0)
|
||||
|
||||
// You need to cast at least one integer to float to get a floating-point result
|
||||
(float)i1 / i2 // => 0.5f
|
||||
i1 / (double)i2 // => 0.5 // Same with double
|
||||
f1 / f2; // => 0.5, plus or minus epsilon
|
||||
// Floating-point numbers and calculations are not exact
|
||||
|
||||
@ -194,9 +198,11 @@ int main() {
|
||||
2 >= 2; // => 1
|
||||
|
||||
// C is not Python - comparisons don't chain.
|
||||
// WRONG:
|
||||
//int between_0_and_2 = 0 < a < 2;
|
||||
// Correct:
|
||||
// Warning: The line below will compile, but it means `(0 < a) < 2`.
|
||||
// This expression is always true, because (0 < a) could be either 1 or 0.
|
||||
// In this case it's 1, because (0 < 1).
|
||||
int between_0_and_2 = 0 < a < 2;
|
||||
// Instead use:
|
||||
int between_0_and_2 = 0 < a && a < 2;
|
||||
|
||||
// Logic works on ints
|
||||
@ -573,7 +579,7 @@ typedef void (*my_fnp_type)(char *);
|
||||
'\''; // single quote
|
||||
'\"'; // double quote
|
||||
'\xhh'; // hexadecimal number. Example: '\xb' = vertical tab character
|
||||
'\ooo'; // octal number. Example: '\013' = vertical tab character
|
||||
'\0oo'; // octal number. Example: '\013' = vertical tab character
|
||||
|
||||
//print formatting:
|
||||
"%d"; // integer
|
||||
|
@ -11,7 +11,7 @@ As one of the succeeders of JavaScript, CoffeeScript tries its best to output re
|
||||
|
||||
See also [the CoffeeScript website](http://coffeescript.org/), which has a complete tutorial on CoffeeScript.
|
||||
|
||||
``` coffeescript
|
||||
```coffeescript
|
||||
# CoffeeScript is a hipster language.
|
||||
# It goes with the trends of many modern languages.
|
||||
# So comments are like Ruby and Python, they use number symbols.
|
||||
|
@ -17,7 +17,7 @@ Another popular and recent book is
|
||||
|
||||
|
||||
|
||||
```scheme
|
||||
```common_lisp
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;; 0. Syntax
|
||||
|
237
compojure.html.markdown
Normal file
237
compojure.html.markdown
Normal file
@ -0,0 +1,237 @@
|
||||
---
|
||||
category: tool
|
||||
tool: compojure
|
||||
contributors:
|
||||
- ["Adam Bard", "http://adambard.com/"]
|
||||
filename: learncompojure.clj
|
||||
---
|
||||
|
||||
## Getting Started with Compojure
|
||||
|
||||
Compojure is a DSL for *quickly* creating *performant* web applications
|
||||
in Clojure with minimal effort:
|
||||
|
||||
```clojure
|
||||
(ns myapp.core
|
||||
(:require [compojure.core :refer :all]
|
||||
[org.httpkit.server :refer [run-server]])) ; httpkit is a server
|
||||
|
||||
(defroutes myapp
|
||||
(GET "/" [] "Hello World"))
|
||||
|
||||
(defn -main []
|
||||
(run-server myapp {:port 5000}))
|
||||
```
|
||||
|
||||
**Step 1:** Create a project with [Leiningen](http://leiningen.org/):
|
||||
|
||||
```
|
||||
lein new myapp
|
||||
```
|
||||
|
||||
**Step 2:** Put the above code in `src/myapp/core.clj`
|
||||
|
||||
**Step 3:** Add some dependencies to `project.clj`:
|
||||
|
||||
```
|
||||
[compojure "1.1.8"]
|
||||
[http-kit "2.1.16"]
|
||||
```
|
||||
|
||||
**Step 4:** Run:
|
||||
|
||||
```
|
||||
lein run -m myapp.core
|
||||
```
|
||||
|
||||
View at: <http://localhost:5000/>
|
||||
|
||||
Compojure apps will run on any ring-compatible server, but we recommend
|
||||
[http-kit](http://http-kit.org/) for its performance and
|
||||
[massive concurrency](http://http-kit.org/600k-concurrent-connection-http-kit.html).
|
||||
|
||||
### Routes
|
||||
|
||||
In compojure, each route is an HTTP method paired with a URL-matching pattern,
|
||||
an argument list, and a body.
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(GET "/" [] "Show something")
|
||||
(POST "/" [] "Create something")
|
||||
(PUT "/" [] "Replace something")
|
||||
(PATCH "/" [] "Modify Something")
|
||||
(DELETE "/" [] "Annihilate something")
|
||||
(OPTIONS "/" [] "Appease something")
|
||||
(HEAD "/" [] "Preview something"))
|
||||
```
|
||||
|
||||
Compojure route definitions are just functions which
|
||||
[accept request maps and return response maps](https://github.com/mmcgrana/ring/blob/master/SPEC):
|
||||
|
||||
```clojure
|
||||
(myapp {:uri "/" :request-method :post})
|
||||
; => {:status 200
|
||||
; :headers {"Content-Type" "text/html; charset=utf-8}
|
||||
; :body "Create Something"}
|
||||
```
|
||||
|
||||
The body may be a function, which must accept the request as a parameter:
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(GET "/" [] (fn [req] "Do something with req")))
|
||||
```
|
||||
|
||||
Or, you can just use the request directly:
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(GET "/" req "Do something with req"))
|
||||
```
|
||||
|
||||
Route patterns may include named parameters:
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(GET "/hello/:name" [name] (str "Hello " name)))
|
||||
```
|
||||
|
||||
You can adjust what each parameter matches by supplying a regex:
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(GET ["/file/:name.:ext" :name #".*", :ext #".*"] [name ext]
|
||||
(str "File: " name ext))
|
||||
```
|
||||
|
||||
Handlers may utilize query parameters:
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(GET "/posts" []
|
||||
(fn [req]
|
||||
(let [title (get (:params req) "title")
|
||||
author (get (:params req) "title")]
|
||||
" Do something with title and author"))))
|
||||
```
|
||||
|
||||
Or, for POST and PUT requests, form parameters
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(POST "/posts" []
|
||||
(fn [req]
|
||||
(let [title (get (:params req) "title")
|
||||
author (get (:params req) "title")]
|
||||
"Do something with title and author"))))
|
||||
```
|
||||
|
||||
|
||||
### Return values
|
||||
|
||||
The return value of a route block determines at least the response body
|
||||
passed on to the HTTP client, or at least the next middleware in the
|
||||
ring stack. Most commonly, this is a string, as in the above examples.
|
||||
But, you may also return a [response map](https://github.com/mmcgrana/ring/blob/master/SPEC):
|
||||
|
||||
```clojure
|
||||
(defroutes myapp
|
||||
(GET "/" []
|
||||
{:status 200 :body "Hello World"})
|
||||
(GET "/is-403" []
|
||||
{:status 403 :body ""})
|
||||
(GET "/is-json" []
|
||||
{:status 200 :headers {"Content-Type" "application/json"} :body "{}"}))
|
||||
```
|
||||
|
||||
### Static Files
|
||||
|
||||
To serve up static files, use `compojure.route.resources`.
|
||||
Resources will be served from your project's `resources/` folder.
|
||||
|
||||
```clojure
|
||||
(require '[compojure.route :as route])
|
||||
|
||||
(defroutes myapp
|
||||
(GET "/")
|
||||
(route/resources "/")) ; Serve static resources at the root path
|
||||
|
||||
(myapp {:uri "/js/script.js" :request-method :get})
|
||||
; => Contents of resources/public/js/script.js
|
||||
```
|
||||
|
||||
### Views / Templates
|
||||
|
||||
To use templating with Compojure, you'll need a template library. Here are a few:
|
||||
|
||||
#### [Stencil](https://github.com/davidsantiago/stencil)
|
||||
|
||||
[Stencil](https://github.com/davidsantiago/stencil) is a [Mustache](http://mustache.github.com/) template library:
|
||||
|
||||
```clojure
|
||||
(require '[stencil.core :refer [render-string]])
|
||||
|
||||
(defroutes myapp
|
||||
(GET "/hello/:name" [name]
|
||||
(render-string "Hello {{name}}" {:name name})))
|
||||
```
|
||||
|
||||
You can easily read in templates from your resources directory. Here's a helper function
|
||||
|
||||
```clojure
|
||||
(require 'clojure.java.io)
|
||||
|
||||
(defn read-template [filename]
|
||||
(slurp (clojure.java.io/resource filename)))
|
||||
|
||||
(defroutes myapp
|
||||
(GET "/hello/:name" [name]
|
||||
(render-string (read-template "templates/hello.html") {:name name})))
|
||||
```
|
||||
|
||||
#### [Selmer](https://github.com/yogthos/Selmer)
|
||||
|
||||
[Selmer](https://github.com/yogthos/Selmer) is a Django and Jinja2-inspired templating language:
|
||||
|
||||
```clojure
|
||||
(require '[selmer.parser :refer [render-file]])
|
||||
|
||||
(defroutes myapp
|
||||
(GET "/hello/:name" [name]
|
||||
(render-file "templates/hello.html" {:name name})))
|
||||
```
|
||||
|
||||
#### [Hiccup](https://github.com/weavejester/hiccup)
|
||||
|
||||
[Hiccup](https://github.com/weavejester/hiccup) is a library for representing HTML as Clojure code
|
||||
|
||||
```clojure
|
||||
(require '[hiccup.core :as hiccup])
|
||||
|
||||
(defroutes myapp
|
||||
(GET "/hello/:name" [name]
|
||||
(hiccup/html
|
||||
[:html
|
||||
[:body
|
||||
[:h1 {:class "title"}
|
||||
(str "Hello " name)]]])))
|
||||
```
|
||||
|
||||
#### [Markdown](https://github.com/yogthos/markdown-clj)
|
||||
|
||||
[Markdown-clj](https://github.com/yogthos/markdown-clj) is a Markdown implementation.
|
||||
|
||||
```clojure
|
||||
(require '[markdown.core :refer [md-to-html-string]])
|
||||
|
||||
(defroutes myapp
|
||||
(GET "/hello/:name" [name]
|
||||
(md-to-html-string "## Hello, world")))
|
||||
```
|
||||
|
||||
Further reading:
|
||||
|
||||
* [Official Compojure Documentation](https://github.com/weavejester/compojure/wiki)
|
||||
|
||||
* [Clojure for the Brave and True](http://www.braveclojure.com/)
|
@ -14,7 +14,7 @@ fácilmente a HTML (y, actualmente, otros formatos también).
|
||||
¡Denme todo la retroalimentación que quieran! / ¡Sientanse en la libertad de hacer forks o pull requests!
|
||||
|
||||
|
||||
```
|
||||
```markdown
|
||||
<!-- Markdown está basado en HTML, así que cualquier archivo HTML es Markdown
|
||||
válido, eso significa que podemos usar elementos HTML en Markdown como, por
|
||||
ejemplo, el comentario y no serán afectados por un parseador Markdown. Aún
|
||||
|
525
fr-fr/javascript-fr.html.markdown
Normal file
525
fr-fr/javascript-fr.html.markdown
Normal file
@ -0,0 +1,525 @@
|
||||
---
|
||||
language: javascript
|
||||
contributors:
|
||||
- ['Adam Brenecki', 'http://adam.brenecki.id.au']
|
||||
- ['Ariel Krakowski', 'http://www.learneroo.com']
|
||||
filename: javascript-fr.js
|
||||
translators:
|
||||
- ['@nbrugneaux', 'https://nicolasbrugneaux.me']
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
JavaScript a été créé par Brendan Eich, travaillant alors a Netscape, en 1995.
|
||||
Le langage avait à l'origine pour but d'être un langage de scripting simple
|
||||
pour les sites web, complétant le Java (à ne pas confondre avec JavaScript)
|
||||
pour des applications web complexes. Mais son intégration très proche et
|
||||
simple des pages web, ainsi que le support natif des navigateurs a rendu
|
||||
le JavaScript incontournable aujourd'hui tant bien dans le front-end que
|
||||
dans le back-end.
|
||||
|
||||
En effet, le JavaScript n'est plus uniquement limité aux navigateurs, grâce à
|
||||
Node.JS, un projet qui offre un environnement indépendant dans lequel un
|
||||
interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome,
|
||||
peut être utilisé directement côté serveur pour exécuter des programmes écrits
|
||||
en JavaScript.
|
||||
|
||||
```js
|
||||
// Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs,
|
||||
/* et les commentaires sur plusieurs lignes commencent avec slash-étoile
|
||||
et finissent avec étoile-slash */
|
||||
|
||||
// Toutes les expressions peuvent finir par ;
|
||||
doStuff();
|
||||
|
||||
// ... mais n'en n'ont pas forcément besoin, les point-virgules sont ajoutés
|
||||
// lors de l’interprétation aux sauts de ligne, sauf exceptions
|
||||
doStuff()
|
||||
|
||||
// Parce que ces cas peuvent produire des effets inattendus, nous utiliserons
|
||||
// des point-virgules dans ce guide.
|
||||
|
||||
|
||||
///////////////////////////////////
|
||||
// 1. Nombres, Chaines de caractères et Opérateurs
|
||||
|
||||
// JavaScript a un seul type de nombre (qui est un 64-bit IEEE 754 double (décimaux))
|
||||
// Comme avec le Lua, ne paniquez pas à cause du manque d'int (entiers) : les
|
||||
// doubles ont un mantisse de 52 bits, ce qui est assez pour stocker des int jusqu'à
|
||||
// 9 x 10¹⁵ exactement.
|
||||
3; // = 3
|
||||
1.5; // = 1.5
|
||||
|
||||
// L'arithmétique de base fonctionne comme vous vous y attendriez
|
||||
1 + 1; // = 2
|
||||
8 - 1; // = 7
|
||||
10 * 2; // = 20
|
||||
35 / 5; // = 7
|
||||
|
||||
// Ainsi que les divisions non-entières
|
||||
5 / 2; // = 2.5
|
||||
|
||||
// Les opérations bits à bits fonctionnent aussi, quand vous effectuez une opération
|
||||
// bits à bits, votre nombre décimal est converti en entier *jusqu'à* 32 bits.
|
||||
1 << 2; // = 4
|
||||
|
||||
// Comme en mathématiques, la priorité est donnée aux parenthèses.
|
||||
(1 + 3) * 2; // = 8
|
||||
|
||||
// Il existe 3 valeurs spéciales pour les nombres:
|
||||
Infinity; // le résultat de 1/0 par exemple
|
||||
-Infinity; // le résultat de -1/0 par exemple
|
||||
NaN; // le résultat de 0/0 par exemple
|
||||
|
||||
// Il existe également le type booléen.
|
||||
true; // vrai
|
||||
false; // faux
|
||||
|
||||
// Les chaines de caractères (strings) sont créees avec " ou ' indifféremment, la seule
|
||||
// raison de choisir l'un ou l'autre est la cohérence dans votre code.
|
||||
"abc";
|
||||
'Hello, world';
|
||||
|
||||
// La négation utilise le symbole !
|
||||
!true; // = false
|
||||
!false; // = true
|
||||
|
||||
// L'égalité est === ou ==
|
||||
// === compare la valeur exacte 2 === '2' // = false
|
||||
// == convertit la valeur pour comparer 2 === '2' // = true
|
||||
// En général, il vaut mieux utiliser === pour ne pas faire d'erreur.
|
||||
1 === 1; // = true
|
||||
2 === 1; // = false
|
||||
|
||||
// L'inégalité est !== ou !=, basé sur le même principe qu'avant.
|
||||
1 !== 1; // = false
|
||||
2 !== 1; // = true
|
||||
|
||||
// Plus de comparaisons :
|
||||
1 < 10; // = true
|
||||
1 > 10; // = false
|
||||
2 <= 2; // = true
|
||||
2 >= 2; // = true
|
||||
|
||||
// Les chaines de caractères se concatènent avec +
|
||||
'Hello ' + 'world!'; // = 'Hello world!'
|
||||
|
||||
// et peuvent être comparées alphabétiquement avec < et >
|
||||
'a' < 'b'; // = true
|
||||
|
||||
// Vous pouvez accéder les caractères dans une string avec charAt
|
||||
'This is a string'.charAt(0); // = 'T'
|
||||
|
||||
// ... ou utiliser substring pour avoir un plus gros morceau
|
||||
'Hello world'.substring(0, 5); // = 'Hello'
|
||||
|
||||
// la longueur, length, est une propriété, donc n'utilisez pas de ()
|
||||
'Hello'.length; // = 5
|
||||
|
||||
// Il y a également null et undefined
|
||||
null; // utilisé pour une non-valeur
|
||||
undefined; // utilisé pour une valeur actuellement non présente (cependant,
|
||||
// undefined est aussi une valeur valide)
|
||||
|
||||
// false, null, undefined, NaN, 0 and '' sont 'presque-faux' (falsy), tout le reste
|
||||
// est 'presque-vrai' (truthy)
|
||||
// Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0')
|
||||
|
||||
|
||||
///////////////////////////////////
|
||||
// 2. Variables, Tableaux et Objets
|
||||
|
||||
// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est
|
||||
// dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =.
|
||||
var someVar = 5;
|
||||
|
||||
// si vous oubliez le mot clé var, vous n'aurez pas d'erreur (sauf en mode strict)
|
||||
someOtherVar = 10;
|
||||
|
||||
// ... mais la variable aura une portée globale (plus communément trouvé en tant
|
||||
// que "global scope" en anglais), et non pas une portée limitée à la fonction
|
||||
// dans laquelle vous l'aviez définie.
|
||||
|
||||
// Les variables déclarées et non assignées sont undefined par défaut
|
||||
var someThirdVar;
|
||||
var someThirdVar = undefined;
|
||||
|
||||
// ... sont deux déclarations identiques.
|
||||
|
||||
// Il y a des raccourcis pour les opérations mathématiques:
|
||||
someVar += 5; // équivalent pour someVar = someVar + 5;
|
||||
someVar *= 10; // de même, someVar = someVar * 100;
|
||||
someVar++; // = someVar += 1;
|
||||
someVar--; // = someVar -= 1;
|
||||
|
||||
// Les tableaux (Arrays) sont des listes ordonnées de valeurs, de tous types.
|
||||
var myArray = ['Hello', 45, true];
|
||||
|
||||
// Leurs membres peuvent être accédés en utilisant les crochets
|
||||
// Les indices commencent à 0.
|
||||
myArray[1]; // = 45
|
||||
|
||||
// Les tableaux sont modifiables, ainsi que leurs longueurs
|
||||
myArray.push( 'World' );
|
||||
myArray.length; // = 4
|
||||
|
||||
// Ajout/Modification à un index spécifique
|
||||
myArray[3] = 'Hello';
|
||||
|
||||
// Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres
|
||||
// langages : ils sont une liste non-ordonnée de paires clé-valeur.
|
||||
var myObj = {key1: 'Hello', key2: 'World'};
|
||||
|
||||
// Les clés sont des strings, mais les ' ou " sont optionels si elles sont des
|
||||
// noms valides en JavaScript. Les valeurs peuvent être de n'importe quel type.
|
||||
var myObj = {myKey: 'myValue', 'my other key': 4};
|
||||
|
||||
// Les attributs d'objets peuvent être accédés avec les crochets
|
||||
myObj['my other key']; // = 4
|
||||
|
||||
// .. ou avec un point si la clé est un identifiant valide.
|
||||
myObj.myKey; // = 'myValue'
|
||||
|
||||
// Les objets sont eux aussi modifiables.
|
||||
myObj.myThirdKey = true;
|
||||
|
||||
// Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined
|
||||
myObj.myFourthKey; // = undefined
|
||||
|
||||
|
||||
///////////////////////////////////
|
||||
// 3. Logique et structures de contrôle
|
||||
|
||||
// Les si (if) fonctionnent comme vous vous y attendez.
|
||||
var count = 1;
|
||||
if (count === 3) {
|
||||
// seulement quand count est 3
|
||||
}
|
||||
else if (count === 4) {
|
||||
// uniquement quand count est 4
|
||||
}
|
||||
else {
|
||||
// le reste du temps, si ni 3, ni 4.
|
||||
}
|
||||
|
||||
// De même pour while.
|
||||
while (true) {
|
||||
// Une boucle infinie !
|
||||
}
|
||||
|
||||
// Les boucles do-while sont pareilles, mais sont exécutées au moins une fois.
|
||||
var input
|
||||
do {
|
||||
input = getInput();
|
||||
} while (!isValid(input))
|
||||
|
||||
// La boucle for est la même qu'en C ou en Java:
|
||||
// initialisation; condition pour continuer; itération
|
||||
for (var i = 0; i < 5; i++){
|
||||
// sera exécutée 5 fois
|
||||
}
|
||||
|
||||
// && est le "et" logique, || est le "ou" logique
|
||||
if (house.size === 'big' && house.colour === 'blue'){
|
||||
house.contains = 'bear';
|
||||
}
|
||||
if (colour === 'red' || colour === 'blue'){
|
||||
// colour est soit 'red' soit 'blue'
|
||||
}
|
||||
|
||||
// Les raccourcis && et || sont pratiques pour instancier des valeurs par defaut.
|
||||
var name = otherName || 'default';
|
||||
|
||||
// Ceci est l'équivalent de
|
||||
var name = otherName;
|
||||
if (!name){
|
||||
name = 'default';
|
||||
}
|
||||
|
||||
// Le switch vérifie les égalités avec ===
|
||||
// utilisez un "break" à la fin de chaque cas
|
||||
// ou les cas suivants seront eux aussi exécutés
|
||||
grade = 'B';
|
||||
switch (grade) {
|
||||
case 'A':
|
||||
console.log('Great job');
|
||||
break;
|
||||
case 'B':
|
||||
console.log('OK job');
|
||||
break;
|
||||
case 'C':
|
||||
console.log('You can do better');
|
||||
break;
|
||||
default:
|
||||
console.log('Oy vey');
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////
|
||||
// 4. Fonctions, Scope (Environnement) et Closures
|
||||
|
||||
// Les fonctions sont déclarées avec le mot clé function
|
||||
function myFunction(thing){
|
||||
return thing.toUpperCase();
|
||||
}
|
||||
myFunction('foo'); // = 'FOO'
|
||||
|
||||
// Les fonctions JavaScript sont des objets de première classe, donc peuvent
|
||||
// être réassignées à d'autres variables et passées en tant que paramètres pour
|
||||
// d'autres fonctions
|
||||
function myFunction(){
|
||||
// ce code s'exécutera dans 5 secondes
|
||||
}
|
||||
setTimeout(myFunction, 5000);
|
||||
// Note: setTimeout ne fait pas parti du langage, mais les navigateurs ainsi
|
||||
// que Node.js le rendent disponible
|
||||
|
||||
// Les fonctions n'ont pas nécessairement besoin d'un nom, elles peuvent être
|
||||
// anonymes
|
||||
setTimeout(function(){
|
||||
// ce code s'exécutera dans 5 secondes
|
||||
}, 5000);
|
||||
|
||||
// Le Javascript crée uniquement un scope, une portée d'action limitée, pour
|
||||
// les fonctions, et pas dans les autres blocs.
|
||||
if (true){
|
||||
var i = 5;
|
||||
}
|
||||
i; // = 5 - et non undefined comme vous pourriez vous y attendre
|
||||
|
||||
// Cela a mené à un style commun de fonctions anonymes immédiatement exécutée;
|
||||
// ou "immediately-executing anonymous functions"
|
||||
(function(){
|
||||
var temporary = 5;
|
||||
// Nous pouvons accéder au scope global en assignant à l'objet global,
|
||||
// qui dans les navigateurs est "window". Il est différent dans Node.js,
|
||||
// le scope global sera en fait local au module dans lequel vous
|
||||
// vous trouvez. http://nodejs.org/api/globals.html
|
||||
window.permanent = 10;
|
||||
})();
|
||||
// Cela permet de ne pas avoir de fuites de variables qui polluent
|
||||
// l’environnement global.
|
||||
temporary; // raises ReferenceError
|
||||
permanent; // = 10
|
||||
|
||||
// Une des fonctionnalités les plus puissantes de Javascript est le système de
|
||||
// closures. Si une fonction est définie dans une autre fonction, alors la
|
||||
// fonction interne aura accès aux variables de la fonction parente, même si
|
||||
// celle-ci a déjà finie son exécution.
|
||||
function sayHelloInFiveSeconds(name){
|
||||
var prompt = 'Hello, ' + name + '!';
|
||||
// Fonction interne
|
||||
function inner(){
|
||||
alert(prompt);
|
||||
}
|
||||
setTimeout(inner, 5000);
|
||||
// setTimeout is asynchrone, donc la fonction sayHelloInFiveSeconds quittera
|
||||
// immédiatement, et setTimeout appelera inner après.
|
||||
}
|
||||
sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec
|
||||
|
||||
|
||||
///////////////////////////////////
|
||||
// 5. Encore plus à propos des Objets; Constructeurs and Prototypes
|
||||
|
||||
// Les objets peuvent contenir des fonctions.
|
||||
var myObj = {
|
||||
myFunc: function(){
|
||||
return 'Hello world!';
|
||||
}
|
||||
};
|
||||
myObj.myFunc(); // = 'Hello world!'
|
||||
|
||||
// Lorsqu'une fonction attachée à un objet est appelée, elle peut accéder à
|
||||
// l'objet avec le mot clé this.
|
||||
myObj = {
|
||||
myString: 'Hello world!',
|
||||
myFunc: function(){
|
||||
return this.myString;
|
||||
}
|
||||
};
|
||||
myObj.myFunc(); // = 'Hello world!'
|
||||
|
||||
// La valeur de "this" change de par l'endroit où la fonction est appelée, et
|
||||
// non de l'endroit où elle est définie. Donc elle ne fonctionnera pas si elle
|
||||
// est appelée hors du contexte l'objet.
|
||||
var myFunc = myObj.myFunc;
|
||||
myFunc(); // = undefined
|
||||
|
||||
// A l'inverse, une fonction peut être attachée à un objet et y gagner l'accès
|
||||
// au travers de "this"
|
||||
var myOtherFunc = function(){
|
||||
return this.myString.toUpperCase();
|
||||
}
|
||||
|
||||
myObj.myOtherFunc = myOtherFunc;
|
||||
myObj.myOtherFunc(); // = 'HELLO WORLD!'
|
||||
|
||||
// Le contexte correspond à la valeur de "this".
|
||||
// Nous pouvons aussi spécifier un contexte, forcer la valeur de "this,
|
||||
// pour une fonction quand elle est appelée grâce à "call" ou "apply".
|
||||
var anotherFunc = function(s){
|
||||
return this.myString + s;
|
||||
}
|
||||
anotherFunc.call(myObj, ' And Hello Moon!'); // = 'Hello World! And Hello Moon!'
|
||||
|
||||
// 'apply' est presque identique, mais prend un tableau comme liste d’arguments.
|
||||
|
||||
anotherFunc.apply(myObj, [' And Hello Sun!']); // = 'Hello World! And Hello Sun!'
|
||||
|
||||
Math.min(42, 6, 27); // = 6
|
||||
Math.min([42, 6, 27]); // = NaN (uh-oh!)
|
||||
Math.min.apply(Math, [42, 6, 27]); // = 6
|
||||
|
||||
// Mais, "call" and "apply" fonctionnenent uniquement au moment de l'appel de la
|
||||
// fonction. Pour lier le contexte de façon permanente, nous pouvons utiliser
|
||||
// "bind" pour garder une référence à la fonction avec ce "this".
|
||||
var boundFunc = anotherFunc.bind(myObj);
|
||||
boundFunc(' And Hello Saturn!'); // = 'Hello World! And Hello Saturn!'
|
||||
|
||||
// "bind" peut aussi être utilisé pour créer une application partielle de la
|
||||
// fonction (curry)
|
||||
var product = function(a, b){ return a * b; }
|
||||
var doubler = product.bind(this, 2);
|
||||
doubler(8); // = 16
|
||||
|
||||
// Lorsque vous appelez une fonction avec le mot clé "new", un nouvel objet est
|
||||
// crée et mis à disposition de la fonction via "this". Ces fonctions sont
|
||||
// communément appelées constructeurs.
|
||||
var MyConstructor = function(){
|
||||
this.myNumber = 5;
|
||||
}
|
||||
myNewObj = new MyConstructor(); // = {myNumber: 5}
|
||||
myNewObj.myNumber; // = 5
|
||||
|
||||
// Chaque objet en Javascript a un "prototype". Quand vous essayez d'accéder à
|
||||
// une propriété que l'objet n'a pas, l'interpréteur va regarder son prototype.
|
||||
|
||||
// Quelques implémentations de JS vous laissent accéder au prototype avec la
|
||||
// propriété "magique" __proto__. Ceci peut être utile, mais n'est pas standard
|
||||
// et ne fonctionne pas dans certains des navigateurs actuels.
|
||||
var myObj = {
|
||||
myString: 'Hello world!'
|
||||
};
|
||||
var myPrototype = {
|
||||
meaningOfLife: 42,
|
||||
myFunc: function(){
|
||||
return this.myString.toLowerCase()
|
||||
}
|
||||
};
|
||||
|
||||
myObj.__proto__ = myPrototype;
|
||||
myObj.meaningOfLife; // = 42
|
||||
myObj.myFunc(); // = 'hello world!'
|
||||
|
||||
myPrototype.__proto__ = {
|
||||
myBoolean: true
|
||||
};
|
||||
myObj.myBoolean; // = true
|
||||
|
||||
|
||||
// Pour obtenir le prototype il existe également Object.getPrototypeOf
|
||||
Object.getPrototypeOf( myObj ) // = {meaningOfLife: 42, myFunc: function}
|
||||
|
||||
// Il n'y a pas de copie ici. Chacun des objets stocke une référence à son
|
||||
// prototype. Cela veut dire que l'on peut le modifier et cela se répercutera
|
||||
// partout.
|
||||
myPrototype.meaningOfLife = 43;
|
||||
myObj.meaningOfLife; // = 43
|
||||
|
||||
// L'inverse n'est cependant pas vrai. Changer la propriété d'un objet ne change
|
||||
// pas la chaine prototypale.
|
||||
myObj.meaningOfLife = 42;
|
||||
myPrototype.meaningOfLife; // = 43
|
||||
|
||||
// Comme précédemment dit, __proto__ n'est pas standard et ne devrait pas être
|
||||
// utilisé. Il y a deux autres moyen de créer un nouvel objet avec un prototype
|
||||
// donné.
|
||||
|
||||
// Le premier est Object.create, mais c'est assez récent et risque de ne pas
|
||||
// fonctionner dans tous les navigateurs.
|
||||
var myObj = Object.create(myPrototype);
|
||||
myObj.meaningOfLife; // = 43
|
||||
|
||||
// Le deuxième moyen, qui marche partout, fonctionne avec les constructeurs.
|
||||
// Les constructeurs ont un propriété appelée prototype. Ce n'est *pas* le
|
||||
// prototype du constructeur de la fonction elle-même, c'est le prototype que
|
||||
// les nouveaux objets crées grâce à ce constructeur avec "new" auront.
|
||||
MyConstructor.prototype = {
|
||||
myNumber: 5,
|
||||
getMyNumber: function(){
|
||||
return this.myNumber;
|
||||
}
|
||||
};
|
||||
var myNewObj2 = new MyConstructor();
|
||||
myNewObj2.getMyNumber(); // = 5
|
||||
myNewObj2.myNumber = 6
|
||||
myNewObj2.getMyNumber(); // = 6
|
||||
|
||||
// Les types pré-définis tels que les strings ou nombres ont aussi des
|
||||
// constructeurs
|
||||
var myNumber = 12;
|
||||
var myNumberObj = new Number(12);
|
||||
myNumber == myNumberObj; // = true
|
||||
|
||||
// ... mais ils ne sont pas exactement équivalent.
|
||||
typeof myNumber; // = 'number'
|
||||
typeof myNumberObj; // = 'object'
|
||||
myNumber === myNumberObj; // = false
|
||||
if (0){
|
||||
// 0 est falsy, le code ne fonctionnera pas.
|
||||
}
|
||||
if (Number(0)){
|
||||
// Parce que Number(0) est truthy, le code fonctionnera
|
||||
}
|
||||
|
||||
// Cependant, vous pouvez ajouter des fonctionnalités aux types de bases grâce à
|
||||
// cette particularité.
|
||||
String.prototype.firstCharacter = function(){
|
||||
return this.charAt(0);
|
||||
}
|
||||
'abc'.firstCharacter(); // = 'a'
|
||||
|
||||
// C'est très souvent utilisé pour le "polyfilling", qui implémente des nouvelles
|
||||
// fonctionnalités de JavaScript dans de plus anciens environnements, tels que
|
||||
// les vieux navigateurs.
|
||||
|
||||
//Par exemple, Object.create est assez récent, mais peut être implémenté grâce à
|
||||
// ce polyfill
|
||||
if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe déjà
|
||||
Object.create = function(proto){
|
||||
// on crée un constructeur temporaire avec le bon prototype
|
||||
var Constructor = function(){};
|
||||
Constructor.prototype = proto;
|
||||
// puis on utilise "new" pour créer un object avec ce même prototype
|
||||
return new Constructor();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Pour aller plus loin (en anglais)
|
||||
|
||||
The [Mozilla Developer
|
||||
Network](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript) expose une
|
||||
excellente documentation pour le Javascript dans les navigateurs. Et contient
|
||||
également un wiki pour s'entraider.
|
||||
|
||||
MDN's [A re-introduction to
|
||||
JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
|
||||
recouvre les principaux sujets vus ici. Le guide est délibérément uniquement
|
||||
à propos du JavaScript, et ne parle pas des navigateurs; pour cela, dirigez vous
|
||||
plutôt ici :
|
||||
[Document Object
|
||||
Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
|
||||
|
||||
[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) quelques challenges.
|
||||
|
||||
[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
|
||||
un guide pour vous éviter les faux-amis dans le JavaScript.
|
||||
|
||||
[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) un classique. A lire.
|
||||
|
||||
En addition aux contributeurs de cet article, du contenu provient du
|
||||
"Python tutorial" de Louie Dinh, et de [JS
|
||||
Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
|
||||
sur le réseau Mozilla.
|
@ -14,7 +14,7 @@ lang: fr-fr
|
||||
|
||||
L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
|
||||
|
||||
```cpp
|
||||
```objective_c
|
||||
// Les commentaires sur une seule ligne commencent par //
|
||||
|
||||
/*
|
||||
|
@ -12,7 +12,7 @@ contributors:
|
||||
- ["Alexej Friesen", "https://github.com/heyalexej"]
|
||||
---
|
||||
|
||||
Go was created out of the need to get work done. It's not the latest trend
|
||||
Go was created out of the need to get work done. It's not the latest trend
|
||||
in computer science, but it is the newest fastest way to solve real-world
|
||||
problems.
|
||||
|
||||
@ -26,7 +26,7 @@ Go comes with a great standard library and an enthusiastic community.
|
||||
```go
|
||||
// Single line comment
|
||||
/* Multi-
|
||||
line comment */
|
||||
line comment */
|
||||
|
||||
// A package clause starts every source file.
|
||||
// Main is a special name declaring an executable rather than a library.
|
||||
@ -41,8 +41,8 @@ import (
|
||||
"strconv" // String conversions.
|
||||
)
|
||||
|
||||
// A function definition. Main is special. It is the entry point for the
|
||||
// executable program. Love it or hate it, Go uses brace brackets.
|
||||
// A function definition. Main is special. It is the entry point for the
|
||||
// executable program. Love it or hate it, Go uses brace brackets.
|
||||
func main() {
|
||||
// Println outputs a line to stdout.
|
||||
// Qualify it with the package name, fmt.
|
||||
@ -77,7 +77,7 @@ func learnTypes() {
|
||||
s2 := `A "raw" string literal
|
||||
can include line breaks.` // Same string type.
|
||||
|
||||
// Non-ASCII literal. Go source is UTF-8.
|
||||
// Non-ASCII literal. Go source is UTF-8.
|
||||
g := 'Σ' // rune type, an alias for int32, holds a unicode code point.
|
||||
|
||||
f := 3.14195 // float64, an IEEE-754 64-bit floating point number.
|
||||
@ -92,11 +92,12 @@ can include line breaks.` // Same string type.
|
||||
|
||||
// Arrays have size fixed at compile time.
|
||||
var a4 [4]int // An array of 4 ints, initialized to all 0.
|
||||
a3 := [...]int{3, 1, 5} // An array of 3 ints, initialized as shown.
|
||||
a3 := [...]int{3, 1, 5} // An array initialized with a fixed size of three
|
||||
// elements, with values 3, 1, and 5.
|
||||
|
||||
// Slices have dynamic size. Arrays and slices each have advantages
|
||||
// Slices have dynamic size. Arrays and slices each have advantages
|
||||
// but use cases for slices are much more common.
|
||||
s3 := []int{4, 5, 9} // Compare to a3. No ellipsis here.
|
||||
s3 := []int{4, 5, 9} // Compare to a3. No ellipsis here.
|
||||
s4 := make([]int, 4) // Allocates slice of 4 ints, initialized to all 0.
|
||||
var d2 [][]float64 // Declaration only, nothing allocated here.
|
||||
bs := []byte("a slice") // Type conversion syntax.
|
||||
@ -116,7 +117,7 @@ can include line breaks.` // Same string type.
|
||||
fmt.Println(s) // Updated slice is now [1 2 3 4 5 6 7 8 9]
|
||||
|
||||
p, q := learnMemory() // Declares p, q to be type pointer to int.
|
||||
fmt.Println(*p, *q) // * follows a pointer. This prints two ints.
|
||||
fmt.Println(*p, *q) // * follows a pointer. This prints two ints.
|
||||
|
||||
// Maps are a dynamically growable associative array type, like the
|
||||
// hash or dictionary types of some other languages.
|
||||
@ -142,7 +143,7 @@ func learnNamedReturns(x, y int) (z int) {
|
||||
return // z is implicit here, because we named it earlier.
|
||||
}
|
||||
|
||||
// Go is fully garbage collected. It has pointers but no pointer arithmetic.
|
||||
// Go is fully garbage collected. It has pointers but no pointer arithmetic.
|
||||
// You can make a mistake with a nil pointer, but not by incrementing a pointer.
|
||||
func learnMemory() (p, q *int) {
|
||||
// Named return values p and q have type pointer to int.
|
||||
@ -220,7 +221,7 @@ func learnFlowControl() {
|
||||
func(a, b int) int {
|
||||
return (a + b) * 2
|
||||
}(10, 2)) // Called with args 10 and 2
|
||||
// => Add + double two numbers: 24
|
||||
// => Add + double two numbers: 24
|
||||
|
||||
// When you need it, you'll love it.
|
||||
goto love
|
||||
@ -267,7 +268,7 @@ type pair struct {
|
||||
x, y int
|
||||
}
|
||||
|
||||
// Define a method on type pair. Pair now implements Stringer.
|
||||
// Define a method on type pair. Pair now implements Stringer.
|
||||
func (p pair) String() string { // p is called the "receiver"
|
||||
// Sprintf is another public function in package fmt.
|
||||
// Dot syntax references fields of p.
|
||||
@ -275,13 +276,13 @@ func (p pair) String() string { // p is called the "receiver"
|
||||
}
|
||||
|
||||
func learnInterfaces() {
|
||||
// Brace syntax is a "struct literal." It evaluates to an initialized
|
||||
// struct. The := syntax declares and initializes p to this struct.
|
||||
// Brace syntax is a "struct literal". It evaluates to an initialized
|
||||
// struct. The := syntax declares and initializes p to this struct.
|
||||
p := pair{3, 4}
|
||||
fmt.Println(p.String()) // Call String method of p, of type pair.
|
||||
var i Stringer // Declare i of interface type Stringer.
|
||||
i = p // Valid because pair implements Stringer
|
||||
// Call String method of i, of type Stringer. Output same as above.
|
||||
// Call String method of i, of type Stringer. Output same as above.
|
||||
fmt.Println(i.String())
|
||||
|
||||
// Functions in the fmt package call the String method to ask an object
|
||||
@ -319,7 +320,7 @@ func learnErrorHandling() {
|
||||
// prints 'strconv.ParseInt: parsing "non-int": invalid syntax'
|
||||
fmt.Println(err)
|
||||
}
|
||||
// We'll revisit interfaces a little later. Meanwhile,
|
||||
// We'll revisit interfaces a little later. Meanwhile,
|
||||
learnConcurrency()
|
||||
}
|
||||
|
||||
@ -330,12 +331,12 @@ func inc(i int, c chan int) {
|
||||
|
||||
// We'll use inc to increment some numbers concurrently.
|
||||
func learnConcurrency() {
|
||||
// Same make function used earlier to make a slice. Make allocates and
|
||||
// Same make function used earlier to make a slice. Make allocates and
|
||||
// initializes slices, maps, and channels.
|
||||
c := make(chan int)
|
||||
// Start three concurrent goroutines. Numbers will be incremented
|
||||
// Start three concurrent goroutines. Numbers will be incremented
|
||||
// concurrently, perhaps in parallel if the machine is capable and
|
||||
// properly configured. All three send to the same channel.
|
||||
// properly configured. All three send to the same channel.
|
||||
go inc(0, c) // go is a statement that starts a new goroutine.
|
||||
go inc(10, c)
|
||||
go inc(-805, c)
|
||||
@ -348,7 +349,7 @@ func learnConcurrency() {
|
||||
go func() { c <- 84 }() // Start a new goroutine just to send a value.
|
||||
go func() { cs <- "wordy" }() // Again, for cs this time.
|
||||
// Select has syntax like a switch statement but each case involves
|
||||
// a channel operation. It selects a case at random out of the cases
|
||||
// a channel operation. It selects a case at random out of the cases
|
||||
// that are ready to communicate.
|
||||
select {
|
||||
case i := <-c: // The value received can be assigned to a variable,
|
||||
@ -358,7 +359,7 @@ func learnConcurrency() {
|
||||
case <-ccs: // Empty channel, not ready for communication.
|
||||
fmt.Println("didn't happen.")
|
||||
}
|
||||
// At this point a value was taken from either c or cs. One of the two
|
||||
// At this point a value was taken from either c or cs. One of the two
|
||||
// goroutines started above has completed, the other will remain blocked.
|
||||
|
||||
learnWebProgramming() // Go does it. You want to do it too.
|
||||
@ -397,15 +398,15 @@ func requestServer() {
|
||||
The root of all things Go is the [official Go web site](http://golang.org/).
|
||||
There you can follow the tutorial, play interactively, and read lots.
|
||||
|
||||
The language definition itself is highly recommended. It's easy to read
|
||||
The language definition itself is highly recommended. It's easy to read
|
||||
and amazingly short (as language definitions go these days.)
|
||||
|
||||
You can play around with the code on [Go playground](https://play.golang.org/p/tnWMjr16Mm). Try to change it and run it from your browser! Note that you can use [https://play.golang.org](https://play.golang.org) as a [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) to test things and code in your browser, without even installing Go.
|
||||
|
||||
On the reading list for students of Go is the [source code to the standard
|
||||
library](http://golang.org/src/pkg/). Comprehensively documented, it
|
||||
library](http://golang.org/src/pkg/). Comprehensively documented, it
|
||||
demonstrates the best of readable and understandable Go, Go style, and Go
|
||||
idioms. Or you can click on a function name in [the
|
||||
idioms. Or you can click on a function name in [the
|
||||
documentation](http://golang.org/pkg/) and the source code comes up!
|
||||
|
||||
Another great resource to learn Go is [Go by example](https://gobyexample.com/).
|
||||
|
@ -14,7 +14,7 @@ R は統計計算用の言語です。
|
||||
データの取得やクリーニング、統計処理やグラフ作成をするために便利な、たくさんのライブラリがあります。また、LaTeX文書からRコマンドを呼び出すこともできます
|
||||
|
||||
|
||||
```python
|
||||
```r
|
||||
# コメント行は、#で開始します
|
||||
|
||||
|
||||
@ -772,4 +772,4 @@ pp + geom_point()
|
||||
|
||||
|
||||
* RとR GUIはこちら [http://www.r-project.org/](http://www.r-project.org/)
|
||||
* [RStudio](http://www.rstudio.com/ide/) 別のGUI
|
||||
* [RStudio](http://www.rstudio.com/ide/) 別のGUI
|
||||
|
@ -10,7 +10,7 @@ Markdown was created by John Gruber in 2004. It's meant to be an easy to read an
|
||||
Give me as much feedback as you want! / Feel free to fork and pull request!
|
||||
|
||||
|
||||
```
|
||||
```markdown
|
||||
<!-- Markdown is a superset of HTML, so any HTML file is valid Markdown, that
|
||||
means we can use HTML elements in Markdown, such as the comment element, and
|
||||
they won't be affected by a markdown parser. However, if you create an HTML
|
||||
|
@ -85,7 +85,7 @@ load myFile.mat y % no parentheses, and spaces instead of commas
|
||||
% Logicals can be applied to matrices:
|
||||
A > 5
|
||||
% for each element, if condition is true, that element is 1 in returned matrix
|
||||
A[ A > 5 ]
|
||||
A( A > 5 )
|
||||
% returns a vector containing the elements in A for which condition is true
|
||||
|
||||
% Strings
|
||||
|
@ -12,7 +12,7 @@ filename: LearnObjectiveC.m
|
||||
Objective-C is the main programming language used by Apple for the OS X and iOS operating systems and their respective frameworks, Cocoa and Cocoa Touch.
|
||||
It is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language.
|
||||
|
||||
```cpp
|
||||
```objective_c
|
||||
// Single-line comments start with //
|
||||
|
||||
/*
|
||||
|
@ -14,7 +14,7 @@ escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos
|
||||
Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e
|
||||
puxar o projeto (pull request)
|
||||
|
||||
```
|
||||
```markdown
|
||||
<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é
|
||||
um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML
|
||||
em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
|
||||
|
@ -8,7 +8,7 @@ filename: learnr.r
|
||||
|
||||
R is a statistical computing language. It has lots of libraries for uploading and cleaning data sets, running statistical procedures, and making graphs. You can also run `R` commands within a LaTeX document.
|
||||
|
||||
```python
|
||||
```r
|
||||
|
||||
# Comments start with number symbols.
|
||||
|
||||
|
@ -13,11 +13,11 @@ lang: ru-ru
|
||||
---
|
||||
|
||||
Go - это язык общего назначения, целью которого является удобство, простота,
|
||||
конкуррентность. Это не тренд в компьютерных науках, а новейший и быстрый
|
||||
конкурентность. Это не тренд в компьютерных науках, а новейший и быстрый
|
||||
способ решать насущные проблемы.
|
||||
|
||||
Концепции Go схожи с другими императивными статически типизированными языками.
|
||||
Быстро компилируется и быстро исполняется, имеет легкие в понимании конструкции
|
||||
Быстро компилируется и быстро исполняется, имеет лёгкие в понимании конструкции
|
||||
для создания масштабируемых и многопоточных программ.
|
||||
|
||||
Может похвастаться отличной стандартной библиотекой и большим комьюнити, полным
|
||||
@ -57,7 +57,7 @@ func main() {
|
||||
func beyondHello() {
|
||||
var x int // Переменные должны быть объявлены до их использования.
|
||||
x = 3 // Присвоение значения переменной.
|
||||
// Краткое определение := позволяет объявить перменную с автоматической
|
||||
// Краткое определение := позволяет объявить переменную с автоматической
|
||||
// подстановкой типа из значения.
|
||||
y := 4
|
||||
sum, prod := learnMultiple(x, y) // Функция возвращает два значения.
|
||||
@ -70,7 +70,7 @@ func learnMultiple(x, y int) (sum, prod int) {
|
||||
return x + y, x * y // Возврат двух значений.
|
||||
}
|
||||
|
||||
// Некотрые встроенные типы и литералы.
|
||||
// Некоторые встроенные типы и литералы.
|
||||
func learnTypes() {
|
||||
// Краткое определение переменной говорит само за себя.
|
||||
s := "Learn Go!" // Тип string.
|
||||
@ -97,7 +97,7 @@ func learnTypes() {
|
||||
|
||||
// Слайсы (slices) имеют динамическую длину. И массивы, и слайсы имеют свои
|
||||
// преимущества, но слайсы используются гораздо чаще.
|
||||
s3 := []int{4, 5, 9} // Сравните с a3. Тут нет троеточия.
|
||||
s3 := []int{4, 5, 9} // Сравните с a3, тут нет троеточия.
|
||||
s4 := make([]int, 4) // Выделение памяти для слайса из 4-х int (нули).
|
||||
var d2 [][]float64 // Только объявление, память не выделяется.
|
||||
bs := []byte("a slice") // Синтаксис приведения типов.
|
||||
@ -113,7 +113,7 @@ func learnTypes() {
|
||||
delete(m, "three") // Встроенная функция, удаляет элемент из map-а.
|
||||
|
||||
// Неиспользуемые переменные в Go являются ошибкой.
|
||||
// Нижнее подчеркивание позволяет игнорировать такие переменные.
|
||||
// Нижнее подчёркивание позволяет игнорировать такие переменные.
|
||||
_, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
|
||||
// Вывод считается использованием переменной.
|
||||
fmt.Println(s, c, a4, s3, d2, m)
|
||||
@ -121,16 +121,16 @@ func learnTypes() {
|
||||
learnFlowControl() // Идем дальше.
|
||||
}
|
||||
|
||||
// У Go есть полноценный сборщик мусора. В нем есть указатели но нет арифметики
|
||||
// У Go есть полноценный сборщик мусора. В нем есть указатели, но нет арифметики
|
||||
// указателей. Вы можете допустить ошибку с указателем на nil, но не с
|
||||
// инкрементацией указателя.
|
||||
func learnMemory() (p, q *int) {
|
||||
// Именованные возвращаемые значения p и q являются указателями на int.
|
||||
p = new(int) // Встроенная функция new выделяет память.
|
||||
// Выделенный int проинициализирован нулем, p больше не содержит nil.
|
||||
// Выделенный int проинициализирован нулём, p больше не содержит nil.
|
||||
s := make([]int, 20) // Выделение единого блока памяти под 20 int-ов.
|
||||
s[3] = 7 // Присвоить значение одному из них.
|
||||
r := -2 // Определить еще одну локальную переменную.
|
||||
r := -2 // Определить ещё одну локальную переменную.
|
||||
return &s[3], &r // Амперсанд(&) обозначает получение адреса переменной.
|
||||
}
|
||||
|
||||
@ -139,7 +139,7 @@ func expensiveComputation() float64 {
|
||||
}
|
||||
|
||||
func learnFlowControl() {
|
||||
// If-ы всегда требуют наличине фигурных скобок, но не круглых.
|
||||
// If-ы всегда требуют наличие фигурных скобок, но не круглых.
|
||||
if true {
|
||||
fmt.Println("told ya")
|
||||
}
|
||||
@ -178,7 +178,7 @@ func learnFlowControl() {
|
||||
}
|
||||
// Функции являются замыканиями.
|
||||
xBig := func() bool {
|
||||
return x > 10000 // Ссылается на x, объявленый выше switch.
|
||||
return x > 10000 // Ссылается на x, объявленный выше switch.
|
||||
}
|
||||
fmt.Println("xBig:", xBig()) // true (т.к. мы присвоили x = e^10).
|
||||
x = 1.3e3 // Тут х == 1300
|
||||
@ -189,7 +189,7 @@ func learnFlowControl() {
|
||||
love:
|
||||
|
||||
learnDefer() // Быстрый обзор важного ключевого слова.
|
||||
learnInterfaces() // О! Интерфейсы, идем далее.
|
||||
learnInterfaces() // О! Интерфейсы, идём далее.
|
||||
}
|
||||
|
||||
func learnDefer() (ok bool) {
|
||||
@ -214,7 +214,7 @@ type pair struct {
|
||||
|
||||
// Объявление метода для типа pair. Теперь pair реализует интерфейс Stringer.
|
||||
func (p pair) String() string { // p в данном случае называют receiver-ом.
|
||||
// Sprintf – еще одна функция из пакета fmt.
|
||||
// Sprintf – ещё одна функция из пакета fmt.
|
||||
// Обращение к полям p через точку.
|
||||
return fmt.Sprintf("(%d, %d)", p.x, p.y)
|
||||
}
|
||||
@ -234,7 +234,7 @@ func learnInterfaces() {
|
||||
fmt.Println(p) // Вывод такой же, что и выше. Println вызывает метод String.
|
||||
fmt.Println(i) // Вывод такой же, что и выше.
|
||||
|
||||
learnVariadicParams("Учиться", "учиться", "и еще раз учиться!")
|
||||
learnVariadicParams("Учиться", "учиться", "и ещё раз учиться!")
|
||||
}
|
||||
|
||||
// Функции могут иметь варьируемое количество параметров.
|
||||
@ -263,22 +263,22 @@ func learnErrorHandling() {
|
||||
// выведет "strconv.ParseInt: parsing "non-int": invalid syntax"
|
||||
fmt.Println(err)
|
||||
}
|
||||
// Мы еще обратимся к интерфейсам чуть позже, а пока...
|
||||
// Мы ещё обратимся к интерфейсам чуть позже, а пока...
|
||||
learnConcurrency()
|
||||
}
|
||||
|
||||
// c – это тип данных channel (канал), объект для конкуррентного взаимодействия.
|
||||
// c – это тип данных channel (канал), объект для конкурентного взаимодействия.
|
||||
func inc(i int, c chan int) {
|
||||
c <- i + 1 // когда channel слева, <- являтся оператором "отправки".
|
||||
}
|
||||
|
||||
// Будем использовать функцию inc для конкуррентной инкрементации чисел.
|
||||
// Будем использовать функцию inc для конкурентной инкрементации чисел.
|
||||
func learnConcurrency() {
|
||||
// Тот же make, что и в случае со slice. Он предназначен для выделения
|
||||
// памяти и инициализации типов slice, map и channel.
|
||||
c := make(chan int)
|
||||
// Старт трех конкуррентных goroutine. Числа будут инкрементированы
|
||||
// конкуррентно и, может быть параллельно, если машина правильно
|
||||
// Старт трех конкурентных goroutine. Числа будут инкрементированы
|
||||
// конкурентно и, может быть параллельно, если машина правильно
|
||||
// сконфигурирована и позволяет это делать. Все они будут отправлены в один
|
||||
// и тот же канал.
|
||||
go inc(0, c) // go начинает новую горутину.
|
||||
@ -291,7 +291,7 @@ func learnConcurrency() {
|
||||
cs := make(chan string) // другой канал, содержит строки.
|
||||
cc := make(chan chan string) // канал каналов со строками.
|
||||
go func() { c <- 84 }() // пуск новой горутины для отправки значения
|
||||
go func() { cs <- "wordy" }() // еще раз, теперь для cs
|
||||
go func() { cs <- "wordy" }() // ещё раз, теперь для cs
|
||||
// Select тоже что и switch, но работает с каналами. Он случайно выбирает
|
||||
// готовый для взаимодействия канал.
|
||||
select {
|
||||
@ -327,7 +327,7 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
Основа всех основ в Go это [официальный веб сайт](http://golang.org/).
|
||||
Там можно пройти туториал, поиграться с интерактивной средой Go и почитать
|
||||
объемную документацию.
|
||||
объёмную документацию.
|
||||
|
||||
Для живого ознакомления рекомендуется почитать исходные коды [стандартной
|
||||
библиотеки Go](http://golang.org/src/pkg/). Отлично задокументированная, она
|
||||
|
@ -13,7 +13,7 @@ Objective-C — компилируемый объектно-ориентиров
|
||||
построенный на основе языка Си и парадигм Smalltalk.
|
||||
В частности, объектная модель построена в стиле Smalltalk — то есть объектам посылаются сообщения.
|
||||
|
||||
```cpp
|
||||
```objective_c
|
||||
// Однострочный комментарий
|
||||
|
||||
/*
|
||||
|
@ -5,25 +5,29 @@ contributors:
|
||||
- ["Louie Dinh", "http://ldinh.ca"]
|
||||
translators:
|
||||
- ["Yury Timofeev", "http://twitter.com/gagar1n"]
|
||||
- ["Andre Polykanine", "https://github.com/Oire"]
|
||||
filename: learnpython-ru.py
|
||||
---
|
||||
|
||||
Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из самых популярных
|
||||
языков. Я люблю его за его понятный и доходчивый синтаксис - это почти что исполняемый псевдокод.
|
||||
Язык Python был создан Гвидо ван Россумом в начале 90-х. Сейчас это один из
|
||||
самых популярных языков. Я люблю его за понятный и доходчивый синтаксис — это
|
||||
почти что исполняемый псевдокод.
|
||||
|
||||
С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh) или louiedinh [at] [google's email service]
|
||||
С благодарностью жду ваших отзывов: [@louiedinh](http://twitter.com/louiedinh)
|
||||
или louiedinh [at] [почтовый сервис Google]
|
||||
|
||||
Замечание: Эта статья относится к Python 2.7, но должно работать и в Python 2.x. Скоро будет версия и для Python 3!
|
||||
Замечание: Эта статья относится к Python 2.7, но должно работать и в Python 2.x.
|
||||
Скоро будет версия и для Python 3!
|
||||
|
||||
```python
|
||||
# Однострочные комментарии начинаются с hash-символа.
|
||||
# Однострочные комментарии начинаются с символа решётки.
|
||||
""" Многострочный текст может быть
|
||||
записан, используя 3 знака " и обычно используется
|
||||
в качестве комментария
|
||||
"""
|
||||
|
||||
####################################################
|
||||
## 1. Примитивные типы данных и операторов
|
||||
## 1. Примитивные типы данных и операторы
|
||||
####################################################
|
||||
|
||||
# У вас есть числа
|
||||
@ -36,17 +40,31 @@ filename: learnpython-ru.py
|
||||
35 / 5 #=> 7
|
||||
|
||||
# А вот деление немного сложнее. В этом случае происходит деление
|
||||
# целых чисел и результат автоматически округляется в меньшую сторону.
|
||||
# целых чисел, и результат автоматически округляется в меньшую сторону.
|
||||
5 / 2 #=> 2
|
||||
|
||||
# Чтобы научиться делить, сначала нужно немного узнать о дробных числах.
|
||||
2.0 # Это дробное число
|
||||
# Чтобы научиться делить, сначала нужно немного узнать о числах
|
||||
# с плавающей запятой.
|
||||
2.0 # Это число с плавающей запятой
|
||||
11.0 / 4.0 #=> 2.75 Вооот... Так гораздо лучше
|
||||
|
||||
# Результат целочисленного деления округляется в меньшую сторону
|
||||
# как для положительных, так и для отрицательных чисел.
|
||||
5 // 3 # => 1
|
||||
5.0 // 3.0 # => 1.0 # работает и для чисел с плавающей запятой
|
||||
-5 // 3 # => -2
|
||||
-5.0 // 3.0 # => -2.0
|
||||
|
||||
# Остаток от деления
|
||||
7 % 3 # => 1
|
||||
|
||||
# Возведение в степень
|
||||
2 ** 4 # => 16
|
||||
|
||||
# Приоритет операций указывается скобками
|
||||
(1 + 3) * 2 #=> 8
|
||||
|
||||
# Логические значения являются примитивами
|
||||
# Логические (булевы) значения являются примитивами
|
||||
True
|
||||
False
|
||||
|
||||
@ -54,15 +72,15 @@ False
|
||||
not True #=> False
|
||||
not False #=> True
|
||||
|
||||
# Равенство это ==
|
||||
# Равенство — это ==
|
||||
1 == 1 #=> True
|
||||
2 == 1 #=> False
|
||||
|
||||
# Неравенство это !=
|
||||
# Неравенство — это !=
|
||||
1 != 1 #=> False
|
||||
2 != 1 #=> True
|
||||
|
||||
# Еще немного сравнений
|
||||
# Ещё немного сравнений
|
||||
1 < 10 #=> True
|
||||
1 > 10 #=> False
|
||||
2 <= 2 #=> True
|
||||
@ -85,9 +103,10 @@ not False #=> True
|
||||
# Символ % используется для форматирования строк, например:
|
||||
"%s могут быть %s" % ("строки", "интерполированы")
|
||||
|
||||
# Новый метод форматирования строк - использование метода format.
|
||||
# Новый способ форматирования строк — использование метода format.
|
||||
# Это предпочитаемый способ.
|
||||
"{0} могут быть {1}".format("строки", "форматированы")
|
||||
|
||||
# Если вы не хотите считать, можете использовать ключевые слова.
|
||||
"{name} хочет есть {food}".format(name="Боб", food="лазанью")
|
||||
|
||||
@ -95,7 +114,7 @@ not False #=> True
|
||||
None #=> None
|
||||
|
||||
# Не используйте оператор равенства '=='' для сравнения
|
||||
# объектов с None. Используйте для этого 'is'
|
||||
# объектов с None. Используйте для этого «is»
|
||||
"etc" is None #=> False
|
||||
None is None #=> True
|
||||
|
||||
@ -113,17 +132,18 @@ None is None #=> True
|
||||
## 2. Переменные и коллекции
|
||||
####################################################
|
||||
|
||||
# Печатать довольно просто
|
||||
print "Я Python. Приятно познакомиться!"
|
||||
|
||||
# У Python есть функция Print, доступная в версиях 2.7 и 3,
|
||||
print("Я Python. Приятно познакомиться!")
|
||||
# ...и старый оператор print, доступный в версиях 2.x, но удалённый в версии 3.
|
||||
print "И я тоже Python!"
|
||||
|
||||
# Необязательно объявлять переменные перед их инициализацией.
|
||||
some_var = 5 # По соглашению используется нижний_регистр_с_подчеркиваниями
|
||||
some_var = 5 # По соглашению используется нижний_регистр_с_подчёркиваниями
|
||||
some_var #=> 5
|
||||
|
||||
# При попытке доступа к неинициализированной переменной,
|
||||
# При попытке доступа к неинициализированной переменной
|
||||
# выбрасывается исключение.
|
||||
# См. раздел "Поток управления" для информации об исключениях.
|
||||
# См. раздел «Поток управления» для информации об исключениях.
|
||||
some_other_var # Выбрасывает ошибку именования
|
||||
|
||||
# if может быть использован как выражение
|
||||
@ -149,24 +169,30 @@ li[0] #=> 1
|
||||
# Обратимся к последнему элементу
|
||||
li[-1] #=> 3
|
||||
|
||||
# Попытка выйти за границы массива приведет к IndexError
|
||||
li[4] # Выдает IndexError
|
||||
# Попытка выйти за границы массива приведёт к ошибке индекса
|
||||
li[4] # Выдаёт IndexError
|
||||
|
||||
# Можно обращаться к диапазону, используя "кусочный синтаксис" (slice syntax)
|
||||
# (Для тех, кто любит математику, это называется замкнуто/открытый интервал.)
|
||||
# (Для тех, кто любит математику, это называется замкнуто-открытый интервал).
|
||||
li[1:3] #=> [2, 4]
|
||||
# Опускаем начало
|
||||
li[2:] #=> [4, 3]
|
||||
# Опускаем конец
|
||||
li[:3] #=> [1, 2, 4]
|
||||
# Выбираем каждый второй элемент
|
||||
li[::2] # =>[1, 4]
|
||||
# Переворачиваем список
|
||||
li[::-1] # => [3, 4, 2, 1]
|
||||
# Используйте сочетания всего вышеназванного для выделения более сложных кусков
|
||||
# li[начало:конец:шаг]
|
||||
|
||||
# Удаляем произвольные элементы из списка оператором del
|
||||
del li[2] # [1, 2, 3]
|
||||
|
||||
# Вы можете складывать списки
|
||||
li + other_li #=> [1, 2, 3, 4, 5, 6] - Замечание: li и other_li остаются нетронутыми
|
||||
li + other_li #=> [1, 2, 3, 4, 5, 6] — Замечание: li и other_li не изменяются
|
||||
|
||||
# Конкатенировать списки можно методом extend
|
||||
# Объединять списки можно методом extend
|
||||
li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Проверить элемент на вхождение в список можно оператором in
|
||||
@ -176,12 +202,12 @@ li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
|
||||
len(li) #=> 6
|
||||
|
||||
|
||||
# Кортежи - это такие списки, только неизменяемые
|
||||
# Кортежи — это такие списки, только неизменяемые
|
||||
tup = (1, 2, 3)
|
||||
tup[0] #=> 1
|
||||
tup[0] = 3 # Выдает TypeError
|
||||
tup[0] = 3 # Выдаёт TypeError
|
||||
|
||||
# Все то же самое можно делать и с кортежами
|
||||
# Всё то же самое можно делать и с кортежами
|
||||
len(tup) #=> 3
|
||||
tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
|
||||
tup[:2] #=> (1, 2)
|
||||
@ -203,33 +229,33 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
|
||||
# Значения ищутся по ключу с помощью оператора []
|
||||
filled_dict["one"] #=> 1
|
||||
|
||||
# Можно получить все ключи в виде списка
|
||||
# Можно получить все ключи в виде списка с помощью метода keys
|
||||
filled_dict.keys() #=> ["three", "two", "one"]
|
||||
# Замечание - сохранение порядка ключей в словаре не гарантируется
|
||||
# Замечание: сохранение порядка ключей в словаре не гарантируется
|
||||
# Ваши результаты могут не совпадать с этими.
|
||||
|
||||
# Можно получить и все значения в виде списка
|
||||
# Можно получить и все значения в виде списка, используйте метод values
|
||||
filled_dict.values() #=> [3, 2, 1]
|
||||
# То же самое замечание насчет порядка ключей справедливо и здесь
|
||||
# То же самое замечание насчёт порядка ключей справедливо и здесь
|
||||
|
||||
# При помощи оператора in можно проверять ключи на вхождение в словарь
|
||||
"one" in filled_dict #=> True
|
||||
1 in filled_dict #=> False
|
||||
|
||||
# Попытка получить значение по несуществующему ключу выбросит KeyError
|
||||
# Попытка получить значение по несуществующему ключу выбросит ошибку ключа
|
||||
filled_dict["four"] # KeyError
|
||||
|
||||
# Чтобы избежать этого, используйте метод get
|
||||
filled_dict.get("one") #=> 1
|
||||
filled_dict.get("four") #=> None
|
||||
# Метод get также принимает аргумент default, значение которого будет
|
||||
# Метод get также принимает аргумент по умолчанию, значение которого будет
|
||||
# возвращено при отсутствии указанного ключа
|
||||
filled_dict.get("one", 4) #=> 1
|
||||
filled_dict.get("four", 4) #=> 4
|
||||
|
||||
# Метод setdefault - это безопасный способ добавить новую пару ключ-значение в словарь
|
||||
# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет
|
||||
filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
|
||||
filled_dict.setdefault("five", 6) #filled_dict["five"] по прежнему возвращает 5
|
||||
filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
|
||||
|
||||
|
||||
# Множества содержат... ну, в общем, множества
|
||||
@ -237,8 +263,8 @@ empty_set = set()
|
||||
# Инициализация множества набором значений
|
||||
some_set = set([1,2,2,3,4]) # some_set теперь равно set([1, 2, 3, 4])
|
||||
|
||||
# Начиная с Python 2.7, вы можете использовать {} чтобы обьявить множество
|
||||
filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
|
||||
# Начиная с Python 2.7, вы можете использовать {}, чтобы объявить множество
|
||||
filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
|
||||
|
||||
# Добавление новых элементов в множество
|
||||
filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5}
|
||||
@ -262,33 +288,33 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
|
||||
## 3. Поток управления
|
||||
####################################################
|
||||
|
||||
# Для начала заведем переменную
|
||||
# Для начала заведём переменную
|
||||
some_var = 5
|
||||
|
||||
# Так выглядит выражение if. Отступы в python очень важны!
|
||||
# результат: "some_var меньше, чем 10"
|
||||
# результат: «some_var меньше, чем 10»
|
||||
if some_var > 10:
|
||||
print "some_var намного больше, чем 10."
|
||||
print("some_var намного больше, чем 10.")
|
||||
elif some_var < 10: # Выражение elif необязательно.
|
||||
print "some_var меньше, чем 10."
|
||||
print("some_var меньше, чем 10.")
|
||||
else: # Это тоже необязательно.
|
||||
print "some_var равно 10."
|
||||
print("some_var равно 10.")
|
||||
|
||||
|
||||
"""
|
||||
Циклы For проходят по спискам
|
||||
|
||||
Результат:
|
||||
собака это млекопитающее
|
||||
кошка это млекопитающее
|
||||
мышь это млекопитающее
|
||||
собака — это млекопитающее
|
||||
кошка — это млекопитающее
|
||||
мышь — это млекопитающее
|
||||
"""
|
||||
for animal in ["собака", "кошка", "мышь"]:
|
||||
# Можете использовать оператор % для интерполяции форматированных строк
|
||||
print "%s это млекопитающее" % animal
|
||||
print("%s — это млекопитающее" % animal)
|
||||
|
||||
"""
|
||||
`range(number)` возвращает список чисел
|
||||
«range(число)» возвращает список чисел
|
||||
от нуля до заданного числа
|
||||
Результат:
|
||||
0
|
||||
@ -297,7 +323,7 @@ for animal in ["собака", "кошка", "мышь"]:
|
||||
3
|
||||
"""
|
||||
for i in range(4):
|
||||
print i
|
||||
print(i)
|
||||
|
||||
"""
|
||||
Циклы while продолжаются до тех пор, пока указанное условие не станет ложным.
|
||||
@ -309,19 +335,24 @@ for i in range(4):
|
||||
"""
|
||||
x = 0
|
||||
while x < 4:
|
||||
print x
|
||||
x += 1 # То же самое, что x = x + 1
|
||||
print(x)
|
||||
x += 1 # Краткая запись для x = x + 1
|
||||
|
||||
# Обрабывайте исключения блоками try/except
|
||||
# Обрабатывайте исключения блоками try/except
|
||||
|
||||
# Работает в Python 2.6 и выше:
|
||||
try:
|
||||
# Для выбора ошибки используется raise
|
||||
raise IndexError("Это IndexError")
|
||||
# Чтобы выбросить ошибку, используется raise
|
||||
raise IndexError("Это ошибка индекса")
|
||||
except IndexError as e:
|
||||
# pass это просто отсутствие оператора. Обычно здесь происходит
|
||||
# восстановление от ошибки.
|
||||
# восстановление после ошибки.
|
||||
pass
|
||||
except (TypeError, NameError):
|
||||
pass # Несколько исключений можно обработать вместе, если нужно.
|
||||
else: # Необязательное выражение. Должно следовать за последним блоком except
|
||||
print("Всё хорошо!") # Выполнится, только если не было никаких исключений
|
||||
|
||||
|
||||
|
||||
####################################################
|
||||
@ -330,23 +361,23 @@ except IndexError as e:
|
||||
|
||||
# Используйте def для создания новых функций
|
||||
def add(x, y):
|
||||
print "x равен %s, а y равен %s" % (x, y)
|
||||
print("x равен %s, а y равен %s" % (x, y))
|
||||
return x + y # Возвращайте результат выражением return
|
||||
|
||||
# Вызов функции с аргументами
|
||||
add(5, 6) #=> prints out "x равен 5, а y равен 6" и возвращает 11
|
||||
add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11
|
||||
|
||||
# Другой способ вызова функции с аргументами
|
||||
# Другой способ вызова функции — вызов с именованными аргументами
|
||||
add(y=6, x=5) # Именованные аргументы можно указывать в любом порядке.
|
||||
|
||||
# Вы можете определить функцию, принимающую неизвестное количество аргументов
|
||||
# Вы можете определить функцию, принимающую изменяемое число аргументов
|
||||
def varargs(*args):
|
||||
return args
|
||||
|
||||
varargs(1, 2, 3) #=> (1,2,3)
|
||||
|
||||
|
||||
# А также можете определить функцию, принимающую изменяющееся количество
|
||||
# А также можете определить функцию, принимающую изменяемое число
|
||||
# именованных аргументов
|
||||
def keyword_args(**kwargs):
|
||||
return kwargs
|
||||
@ -356,8 +387,8 @@ keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
|
||||
|
||||
# Если хотите, можете использовать оба способа одновременно
|
||||
def all_the_args(*args, **kwargs):
|
||||
print args
|
||||
print kwargs
|
||||
print(args)
|
||||
print(kwargs)
|
||||
"""
|
||||
all_the_args(1, 2, a=3, b=4) выводит:
|
||||
(1, 2)
|
||||
@ -368,11 +399,28 @@ all_the_args(1, 2, a=3, b=4) выводит:
|
||||
# Используйте символ * для передачи кортежей и ** для передачи словарей
|
||||
args = (1, 2, 3, 4)
|
||||
kwargs = {"a": 3, "b": 4}
|
||||
all_the_args(*args) # эквивалент foo(1, 2, 3, 4)
|
||||
all_the_args(**kwargs) # эквивалент foo(a=3, b=4)
|
||||
all_the_args(*args, **kwargs) # эквивалент foo(1, 2, 3, 4, a=3, b=4)
|
||||
all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
|
||||
all_the_args(**kwargs) # эквивалентно foo(a=3, b=4)
|
||||
all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4)
|
||||
|
||||
# Python имеет функции первого класса
|
||||
# Область определения функций
|
||||
x = 5
|
||||
|
||||
def setX(num):
|
||||
# Локальная переменная x — это не то же самое, что глобальная переменная x
|
||||
x = num # => 43
|
||||
print (x) # => 43
|
||||
|
||||
def setGlobalX(num):
|
||||
global x
|
||||
print (x) # => 5
|
||||
x = num # Глобальная переменная x теперь равна 6
|
||||
print (x) # => 6
|
||||
|
||||
setX(43)
|
||||
setGlobalX(6)
|
||||
|
||||
# В Python есть функции первого класса
|
||||
def create_adder(x):
|
||||
def adder(y):
|
||||
return x + y
|
||||
@ -388,7 +436,7 @@ add_10(3) #=> 13
|
||||
map(add_10, [1,2,3]) #=> [11, 12, 13]
|
||||
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
|
||||
|
||||
# Мы можем использовать списки для удобного отображения и фильтрации
|
||||
# Для удобного отображения и фильтрации можно использовать списочные включения
|
||||
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
|
||||
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
|
||||
|
||||
@ -402,7 +450,11 @@ class Human(object):
|
||||
# Атрибут класса. Он разделяется всеми экземплярами этого класса
|
||||
species = "H. sapiens"
|
||||
|
||||
# Обычный конструктор
|
||||
# Обычный конструктор, вызывается при инициализации экземпляра класса
|
||||
# Обратите внимание, что двойное подчёркивание в начале и в конце имени
|
||||
# означает объекты и атрибуты, которые используются Python, но находятся
|
||||
# в пространствах имён, управляемых пользователем.
|
||||
# Не придумывайте им имена самостоятельно.
|
||||
def __init__(self, name):
|
||||
# Присваивание значения аргумента атрибуту класса name
|
||||
self.name = name
|
||||
@ -423,17 +475,17 @@ class Human(object):
|
||||
return "*grunt*"
|
||||
|
||||
|
||||
# Инстанцирование класса
|
||||
# Инициализация экземпляра класса
|
||||
i = Human(name="Иван")
|
||||
print i.say("привет") # "Иван: привет"
|
||||
print(i.say("привет")) # Выводит: «Иван: привет»
|
||||
|
||||
j = Human("Петр")
|
||||
print j.say("Привет") # "Петр: привет"
|
||||
j = Human("Пётр")
|
||||
print(j.say("Привет")) # Выводит: «Пётр: привет»
|
||||
|
||||
# Вызов метода класса
|
||||
i.get_species() #=> "H. sapiens"
|
||||
|
||||
# Присвоение разделяемому атрибуту
|
||||
# Изменение разделяемого атрибута
|
||||
Human.species = "H. neanderthalensis"
|
||||
i.get_species() #=> "H. neanderthalensis"
|
||||
j.get_species() #=> "H. neanderthalensis"
|
||||
@ -448,12 +500,12 @@ Human.grunt() #=> "*grunt*"
|
||||
|
||||
# Вы можете импортировать модули
|
||||
import math
|
||||
print math.sqrt(16) #=> 4
|
||||
print(math.sqrt(16)) #=> 4
|
||||
|
||||
# Вы можете импортировать отдельные функции модуля
|
||||
from math import ceil, floor
|
||||
print ceil(3.7) #=> 4.0
|
||||
print floor(3.7) #=> 3.0
|
||||
print(ceil(3.7)) #=> 4.0
|
||||
print(floor(3.7)) #=> 3.0
|
||||
|
||||
# Можете импортировать все функции модуля.
|
||||
# (Хотя это и не рекомендуется)
|
||||
@ -463,7 +515,7 @@ from math import *
|
||||
import math as m
|
||||
math.sqrt(16) == m.sqrt(16) #=> True
|
||||
|
||||
# Модули в Python это обычные файлы с кодом python. Вы
|
||||
# Модули в Python — это обычные Python-файлы. Вы
|
||||
# можете писать свои модули и импортировать их. Название
|
||||
# модуля совпадает с названием файла.
|
||||
|
||||
@ -472,18 +524,72 @@ math.sqrt(16) == m.sqrt(16) #=> True
|
||||
import math
|
||||
dir(math)
|
||||
|
||||
####################################################
|
||||
## 7. Дополнительно
|
||||
####################################################
|
||||
|
||||
# Генераторы помогут выполнить ленивые вычисления
|
||||
def double_numbers(iterable):
|
||||
for i in iterable:
|
||||
yield i + i
|
||||
|
||||
# Генератор создаёт значения на лету.
|
||||
# Он не возвращает все значения разом, а создаёт каждое из них при каждой
|
||||
# итерации. Это значит, что значения больше 15 в double_numbers
|
||||
# обработаны не будут.
|
||||
# Обратите внимание: xrange — это генератор, который делает то же, что и range.
|
||||
# Создание списка чисел от 1 до 900000000 требует много места и времени.
|
||||
# xrange создаёт объект генератора, а не список сразу, как это делает range.
|
||||
# Если нам нужно имя переменной, совпадающее с ключевым словом Python,
|
||||
# мы используем подчёркивание в конце
|
||||
xrange_ = xrange(1, 900000000)
|
||||
|
||||
# Будет удваивать все числа, пока результат не будет >= 30
|
||||
for i in double_numbers(xrange_):
|
||||
print(i)
|
||||
if i >= 30:
|
||||
break
|
||||
|
||||
|
||||
# Декораторы
|
||||
# В этом примере beg оборачивает say
|
||||
# Метод beg вызовет say. Если say_please равно True,
|
||||
# он изменит возвращаемое сообщение
|
||||
from functools import wraps
|
||||
|
||||
|
||||
def beg(target_function):
|
||||
@wraps(target_function)
|
||||
def wrapper(*args, **kwargs):
|
||||
msg, say_please = target_function(*args, **kwargs)
|
||||
if say_please:
|
||||
return "{} {}".format(msg, " Пожалуйста! У меня нет денег :(")
|
||||
return msg
|
||||
|
||||
return wrapper
|
||||
|
||||
|
||||
@beg
|
||||
def say(say_please=False):
|
||||
msg = "Вы не купите мне пива?"
|
||||
return msg, say_please
|
||||
|
||||
|
||||
print(say()) # Вы не купите мне пива?
|
||||
print(say(say_please=True)) # Вы не купите мне пива? Пожалуйста! У меня нет денег :(
|
||||
|
||||
```
|
||||
|
||||
## Хотите еще?
|
||||
## Хотите ещё?
|
||||
|
||||
### Бесплатные онлайн-материалы
|
||||
|
||||
* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
|
||||
* [Dive Into Python](http://www.diveintopython.net/)
|
||||
* [The Official Docs](http://docs.python.org/2.6/)
|
||||
* [Официальная документация](http://docs.python.org/2.6/)
|
||||
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
|
||||
* [Python Module of the Week](http://pymotw.com/2/)
|
||||
* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
|
||||
|
||||
### Платные
|
||||
|
||||
|
@ -9,6 +9,7 @@ contributors:
|
||||
- ["Nick LaMuro", "https://github.com/NickLaMuro"]
|
||||
- ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
|
||||
- ["Ariel Krakowski", "http://www.learneroo.com"]
|
||||
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
|
||||
|
||||
---
|
||||
|
||||
@ -35,7 +36,7 @@ You shouldn't either
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
35 / 5 #=> 7
|
||||
2 ** 5 #=> 32
|
||||
2**5 #=> 32
|
||||
|
||||
# Arithmetic is just syntactic sugar
|
||||
# for calling a method on an object
|
||||
@ -78,14 +79,17 @@ false.class #=> FalseClass
|
||||
'I am a string'.class #=> String
|
||||
"I am a string too".class #=> String
|
||||
|
||||
placeholder = "use string interpolation"
|
||||
placeholder = 'use string interpolation'
|
||||
"I can #{placeholder} when using double quoted strings"
|
||||
#=> "I can use string interpolation when using double quoted strings"
|
||||
|
||||
# Prefer single quoted strings to double quoted ones where possible
|
||||
# Double quoted strings perform additional inner calculations
|
||||
|
||||
# Combine strings, but not with numbers
|
||||
"hello " + "world" #=> "hello world"
|
||||
"hello " + 3 #=> TypeError: can't convert Fixnum into String
|
||||
"hello " + 3.to_s #=> "hello 3"
|
||||
'hello ' + 'world' #=> "hello world"
|
||||
'hello ' + 3 #=> TypeError: can't convert Fixnum into String
|
||||
'hello ' + 3.to_s #=> "hello 3"
|
||||
|
||||
# print to the output
|
||||
puts "I'm printing!"
|
||||
@ -130,7 +134,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
|
||||
|
||||
# Arrays can contain different types of items
|
||||
|
||||
[1, "hello", false] #=> [1, "hello", false]
|
||||
[1, 'hello', false] #=> [1, "hello", false]
|
||||
|
||||
# Arrays can be indexed
|
||||
# From the front
|
||||
@ -157,7 +161,7 @@ array << 6 #=> [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Hashes are Ruby's primary dictionary with keys/value pairs.
|
||||
# Hashes are denoted with curly braces:
|
||||
hash = {'color' => 'green', 'number' => 5}
|
||||
hash = { 'color' => 'green', 'number' => 5 }
|
||||
|
||||
hash.keys #=> ['color', 'number']
|
||||
|
||||
@ -170,7 +174,7 @@ hash['nothing here'] #=> nil
|
||||
|
||||
# Since Ruby 1.9, there's a special syntax when using symbols as keys:
|
||||
|
||||
new_hash = { defcon: 3, action: true}
|
||||
new_hash = { defcon: 3, action: true }
|
||||
|
||||
new_hash.keys #=> [:defcon, :action]
|
||||
|
||||
@ -180,11 +184,11 @@ new_hash.keys #=> [:defcon, :action]
|
||||
# Control structures
|
||||
|
||||
if true
|
||||
"if statement"
|
||||
'if statement'
|
||||
elsif false
|
||||
"else if, optional"
|
||||
'else if, optional'
|
||||
else
|
||||
"else, also optional"
|
||||
'else, also optional'
|
||||
end
|
||||
|
||||
for counter in 1..5
|
||||
@ -216,7 +220,7 @@ end
|
||||
#=> iteration 5
|
||||
|
||||
# You can also surround blocks in curly brackets:
|
||||
(1..5).each {|counter| puts "iteration #{counter}"}
|
||||
(1..5).each { |counter| puts "iteration #{counter}" }
|
||||
|
||||
# The contents of data structures can also be iterated using each.
|
||||
array.each do |element|
|
||||
@ -241,32 +245,30 @@ grade = 'B'
|
||||
|
||||
case grade
|
||||
when 'A'
|
||||
puts "Way to go kiddo"
|
||||
puts 'Way to go kiddo'
|
||||
when 'B'
|
||||
puts "Better luck next time"
|
||||
puts 'Better luck next time'
|
||||
when 'C'
|
||||
puts "You can do better"
|
||||
puts 'You can do better'
|
||||
when 'D'
|
||||
puts "Scraping through"
|
||||
puts 'Scraping through'
|
||||
when 'F'
|
||||
puts "You failed!"
|
||||
puts 'You failed!'
|
||||
else
|
||||
puts "Alternative grading system, eh?"
|
||||
puts 'Alternative grading system, eh?'
|
||||
end
|
||||
|
||||
#=> "Better luck next time"
|
||||
|
||||
# cases can also use ranges
|
||||
grade = 82
|
||||
case grade
|
||||
when 90..100
|
||||
puts "Hooray!"
|
||||
when 80...90
|
||||
puts "OK job"
|
||||
else
|
||||
puts "You failed!"
|
||||
when 90..100
|
||||
puts 'Hooray!'
|
||||
when 80...90
|
||||
puts 'OK job'
|
||||
else
|
||||
puts 'You failed!'
|
||||
end
|
||||
|
||||
#=> "OK job"
|
||||
|
||||
|
||||
@ -284,23 +286,23 @@ double 3 #=> 6
|
||||
|
||||
double double 3 #=> 12
|
||||
|
||||
def sum(x,y)
|
||||
def sum(x, y)
|
||||
x + y
|
||||
end
|
||||
|
||||
# Method arguments are separated by a comma
|
||||
sum 3, 4 #=> 7
|
||||
|
||||
sum sum(3,4), 5 #=> 12
|
||||
sum sum(3, 4), 5 #=> 12
|
||||
|
||||
# yield
|
||||
# All methods have an implicit, optional block parameter
|
||||
# it can be called with the 'yield' keyword
|
||||
|
||||
def surround
|
||||
puts "{"
|
||||
puts '{'
|
||||
yield
|
||||
puts "}"
|
||||
puts '}'
|
||||
end
|
||||
|
||||
surround { puts 'hello world' }
|
||||
@ -311,25 +313,25 @@ surround { puts 'hello world' }
|
||||
|
||||
|
||||
# You can pass a block to a function
|
||||
# "&" marks a reference to a passed block
|
||||
# "&" marks a reference to a passed block
|
||||
def guests(&block)
|
||||
block.call "some_argument"
|
||||
block.call 'some_argument'
|
||||
end
|
||||
|
||||
|
||||
# You can pass a list of arguments, which will be converted into an array
|
||||
# That's what splat operator ("*") is for
|
||||
# That's what splat operator ("*") is for
|
||||
def guests(*array)
|
||||
array.each { |guest| puts "#{guest}" }
|
||||
array.each { |guest| puts guest }
|
||||
end
|
||||
|
||||
# Define a class with the class keyword
|
||||
class Human
|
||||
|
||||
# A class variable. It is shared by all instances of this class.
|
||||
@@species = "H. sapiens"
|
||||
@@species = 'H. sapiens'
|
||||
|
||||
# Basic initializer
|
||||
def initialize(name, age=0)
|
||||
def initialize(name, age = 0)
|
||||
# Assign the argument to the "name" instance variable for the instance
|
||||
@name = name
|
||||
# If no age given, we will fall back to the default in the arguments list.
|
||||
@ -356,20 +358,19 @@ class Human
|
||||
# A class method uses self to distinguish from instance methods.
|
||||
# It can only be called on the class, not an instance.
|
||||
def self.say(msg)
|
||||
puts "#{msg}"
|
||||
puts msg
|
||||
end
|
||||
|
||||
def species
|
||||
@@species
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
|
||||
# Instantiate a class
|
||||
jim = Human.new("Jim Halpert")
|
||||
jim = Human.new('Jim Halpert')
|
||||
|
||||
dwight = Human.new("Dwight K. Schrute")
|
||||
dwight = Human.new('Dwight K. Schrute')
|
||||
|
||||
# Let's call a couple of methods
|
||||
jim.species #=> "H. sapiens"
|
||||
@ -380,7 +381,7 @@ dwight.species #=> "H. sapiens"
|
||||
dwight.name #=> "Dwight K. Schrute"
|
||||
|
||||
# Call the class method
|
||||
Human.say("Hi") #=> "Hi"
|
||||
Human.say('Hi') #=> "Hi"
|
||||
|
||||
# Variable's scopes are defined by the way we name them.
|
||||
# Variables that start with $ have global scope
|
||||
@ -399,7 +400,7 @@ defined? @@var #=> "class variable"
|
||||
Var = "I'm a constant"
|
||||
defined? Var #=> "constant"
|
||||
|
||||
# Class also is object in ruby. So class can have instance variables.
|
||||
# Class is also an object in ruby. So class can have instance variables.
|
||||
# Class variable is shared among the class and all of its descendants.
|
||||
|
||||
# base class
|
||||
@ -415,7 +416,7 @@ class Human
|
||||
end
|
||||
end
|
||||
|
||||
# derived class
|
||||
# derived class
|
||||
class Worker < Human
|
||||
end
|
||||
|
||||
@ -451,8 +452,8 @@ module ModuleExample
|
||||
end
|
||||
end
|
||||
|
||||
# Including modules binds the methods to the object instance
|
||||
# Extending modules binds the methods to the class instance
|
||||
# Including modules binds their methods to the class instances
|
||||
# Extending modules binds their methods to the class itself
|
||||
|
||||
class Person
|
||||
include ModuleExample
|
||||
@ -467,7 +468,7 @@ Person.new.foo # => 'foo'
|
||||
Book.foo # => 'foo'
|
||||
Book.new.foo # => NoMethodError: undefined method `foo'
|
||||
|
||||
# Callbacks when including and extending a module are executed
|
||||
# Callbacks are executed when including and extending a module
|
||||
|
||||
module ConcernExample
|
||||
def self.included(base)
|
||||
@ -500,9 +501,8 @@ Something.new.qux # => 'qux'
|
||||
|
||||
## Additional resources
|
||||
|
||||
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
|
||||
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
|
||||
- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
|
||||
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
|
||||
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free addition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
|
||||
|
||||
|
||||
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free addition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
|
||||
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
|
||||
|
@ -9,7 +9,7 @@ filename: learn.scala
|
||||
|
||||
Scala - the scalable language
|
||||
|
||||
```cpp
|
||||
```scala
|
||||
|
||||
/*
|
||||
Set yourself up:
|
||||
|
@ -2,30 +2,51 @@
|
||||
language: swift
|
||||
contributors:
|
||||
- ["Grant Timmerman", "http://github.com/grant"]
|
||||
- ["Christopher Bess", "http://github.com/cbess"]
|
||||
filename: learnswift.swift
|
||||
---
|
||||
|
||||
Swift is a programming language for iOS and OS X development created by Apple. Designed to coexist with Objective-C and to be more resilient against erroneous code, Swift was introduced in 2014 at Apple's developer conference WWDC. It is built with the LLVM compiler included in Xcode 6 beta.
|
||||
|
||||
The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.
|
||||
|
||||
See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/LandingPage/index.html), which has a complete tutorial on Swift.
|
||||
|
||||
```js
|
||||
```swift
|
||||
//
|
||||
// Basics
|
||||
// MARK: Basics
|
||||
//
|
||||
|
||||
// Xcode supports landmarks to annotate your code and lists them in the jump bar
|
||||
// MARK: Section mark
|
||||
// TODO: Do something soon
|
||||
// FIXME Fix this code
|
||||
|
||||
println("Hello, world")
|
||||
|
||||
var myVariable = 42
|
||||
let øπΩ = "value" // unicode variable names
|
||||
let myConstant = 3.1415926
|
||||
let convenience = "keyword" // contextual variable name
|
||||
let weak = "keyword"; let override = "another keyword" // statements can be separated by a semi-colon
|
||||
let `class` = "keyword" // backticks allow keywords to be used as variable names
|
||||
let explicitDouble: Double = 70
|
||||
let label = "some text " + String(myVariable) // Casting
|
||||
let piText = "Pi = \(myConstant)" // String interpolation
|
||||
var optionalString: String? = "optional" // Can be nil
|
||||
let intValue = 0007 // 7
|
||||
let largeIntValue = 77_000 // 77000
|
||||
let label = "some text " + String(myVariable) // Casting
|
||||
let piText = "Pi = \(myConstant), Pi 2 = \(myConstant * 2)" // String interpolation
|
||||
var optionalString: String? = "optional" // Can be nil
|
||||
optionalString = nil
|
||||
|
||||
/*
|
||||
Comment here
|
||||
/*
|
||||
Nested comments are also supported
|
||||
*/
|
||||
*/
|
||||
|
||||
//
|
||||
// Arrays and Dictionaries
|
||||
// MARK: Collections
|
||||
//
|
||||
|
||||
// Array
|
||||
@ -35,97 +56,108 @@ let emptyArray = [String]()
|
||||
|
||||
// Dictionary
|
||||
var occupations = [
|
||||
"Malcolm": "Captain",
|
||||
"kaylee": "Mechanic"
|
||||
"Malcolm": "Captain",
|
||||
"kaylee": "Mechanic"
|
||||
]
|
||||
occupations["Jayne"] = "Public Relations"
|
||||
let emptyDictionary = [String: Float]()
|
||||
|
||||
|
||||
//
|
||||
// Control Flow
|
||||
// MARK: Control Flow
|
||||
//
|
||||
|
||||
// for loop (array)
|
||||
let myArray = [1, 1, 2, 3, 5]
|
||||
for value in myArray {
|
||||
if value == 1 {
|
||||
println("One!")
|
||||
} else {
|
||||
println("Not one!")
|
||||
}
|
||||
if value == 1 {
|
||||
println("One!")
|
||||
} else {
|
||||
println("Not one!")
|
||||
}
|
||||
}
|
||||
|
||||
// for loop (dictionary)
|
||||
var dict = ["one": 1, "two": 2]
|
||||
for (key, value) in dict {
|
||||
println("\(key): \(value)")
|
||||
println("\(key): \(value)")
|
||||
}
|
||||
|
||||
// for loop (range)
|
||||
for i in -1...1 { // [-1, 0, 1]
|
||||
println(i)
|
||||
println(i)
|
||||
}
|
||||
// use ..< to exclude the last number
|
||||
|
||||
// while loop
|
||||
var i = 1
|
||||
while i < 1000 {
|
||||
i *= 2
|
||||
i *= 2
|
||||
}
|
||||
|
||||
// do-while loop
|
||||
do {
|
||||
println("hello")
|
||||
println("hello")
|
||||
} while 1 == 2
|
||||
|
||||
// Switch
|
||||
let vegetable = "red pepper"
|
||||
switch vegetable {
|
||||
case "celery":
|
||||
let vegetableComment = "Add some raisins and make ants on a log."
|
||||
let vegetableComment = "Add some raisins and make ants on a log."
|
||||
case "cucumber", "watercress":
|
||||
let vegetableComment = "That would make a good tea sandwich."
|
||||
let vegetableComment = "That would make a good tea sandwich."
|
||||
case let x where x.hasSuffix("pepper"):
|
||||
let vegetableComment = "Is it a spicy \(x)?"
|
||||
let vegetableComment = "Is it a spicy \(x)?"
|
||||
default: // required (in order to cover all possible input)
|
||||
let vegetableComment = "Everything tastes good in soup."
|
||||
let vegetableComment = "Everything tastes good in soup."
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Functions
|
||||
// MARK: Functions
|
||||
//
|
||||
|
||||
// Functions are a first-class type, meaning they can be nested
|
||||
// in functions and can be passed around
|
||||
|
||||
// Function
|
||||
// Function with Swift header docs (format as reStructedText)
|
||||
/**
|
||||
A greet operation
|
||||
|
||||
- A bullet in docs
|
||||
- Another bullet in the docs
|
||||
|
||||
:param: name A name
|
||||
:param: day A day
|
||||
:returns: A string containing the name and day value.
|
||||
*/
|
||||
func greet(name: String, day: String) -> String {
|
||||
return "Hello \(name), today is \(day)."
|
||||
return "Hello \(name), today is \(day)."
|
||||
}
|
||||
greet("Bob", "Tuesday")
|
||||
|
||||
// Function that returns multiple items in a tuple
|
||||
func getGasPrices() -> (Double, Double, Double) {
|
||||
return (3.59, 3.69, 3.79)
|
||||
return (3.59, 3.69, 3.79)
|
||||
}
|
||||
|
||||
// Args
|
||||
// Variadic Args
|
||||
func setup(numbers: Int...) {}
|
||||
|
||||
// Passing and returning functions
|
||||
func makeIncrementer() -> (Int -> Int) {
|
||||
func addOne(number: Int) -> Int {
|
||||
return 1 + number
|
||||
}
|
||||
return addOne
|
||||
func addOne(number: Int) -> Int {
|
||||
return 1 + number
|
||||
}
|
||||
return addOne
|
||||
}
|
||||
var increment = makeIncrementer()
|
||||
increment(7)
|
||||
|
||||
|
||||
//
|
||||
// Closures
|
||||
// MARK: Closures
|
||||
//
|
||||
var numbers = [1, 2, 6]
|
||||
|
||||
@ -135,93 +167,243 @@ var numbers = [1, 2, 6]
|
||||
// `->` separates the arguments and return type
|
||||
// `in` separates the closure header from the closure body
|
||||
numbers.map({
|
||||
(number: Int) -> Int in
|
||||
let result = 3 * number
|
||||
return result
|
||||
})
|
||||
(number: Int) -> Int in
|
||||
let result = 3 * number
|
||||
return result
|
||||
})
|
||||
|
||||
// When the type is known, like above, we can do this
|
||||
numbers = numbers.map({ number in 3 * number })
|
||||
//Or even this
|
||||
// Or even this
|
||||
//numbers = numbers.map({ $0 * 3 })
|
||||
|
||||
print(numbers) // [3, 6, 18]
|
||||
|
||||
// Trailing closure
|
||||
numbers = sorted(numbers) { $0 > $1 }
|
||||
|
||||
print(numbers) // [18, 6, 3]
|
||||
|
||||
// Super shorthand, since the < operator infers the types
|
||||
|
||||
numbers = sorted(numbers, < )
|
||||
|
||||
print(numbers) // [3, 6, 18]
|
||||
|
||||
//
|
||||
// Classes
|
||||
// MARK: Structures
|
||||
//
|
||||
|
||||
// Structures and classes have very similar capabilites
|
||||
struct NamesTable {
|
||||
let names: [String]
|
||||
|
||||
// Custom subscript
|
||||
subscript(index: Int) -> String {
|
||||
return names[index]
|
||||
}
|
||||
}
|
||||
|
||||
// Structures have an auto-generated (implicit) designated initializer
|
||||
let namesTable = NamesTable(names: ["Me", "Them"])
|
||||
//let name = namesTable[2]
|
||||
//println("Name is \(name)") // Name is Them
|
||||
|
||||
//
|
||||
// MARK: Classes
|
||||
//
|
||||
|
||||
// Classes, structures and its members have three levels of access control
|
||||
// They are: internal (default), public, private
|
||||
|
||||
public class Shape {
|
||||
public func getArea() -> Int {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// All methods and properties of a class are public.
|
||||
// If you just need to store data in a
|
||||
// structured object, you should use a `struct`
|
||||
|
||||
// A simple class `Square` extends `Shape`
|
||||
class Square: Shape {
|
||||
var sideLength: Int = 1
|
||||
|
||||
// Custom getter and setter property
|
||||
var perimeter: Int {
|
||||
get {
|
||||
return 4 * sideLength
|
||||
internal class Rect: Shape {
|
||||
var sideLength: Int = 1
|
||||
|
||||
// Custom getter and setter property
|
||||
private var perimeter: Int {
|
||||
get {
|
||||
return 4 * sideLength
|
||||
}
|
||||
set {
|
||||
// `newValue` is an implicit variable available to setters
|
||||
sideLength = newValue / 4
|
||||
}
|
||||
}
|
||||
set {
|
||||
sideLength = newValue / 4
|
||||
|
||||
// Lazily load a property
|
||||
// subShape remains nil (uninitialized) until getter called
|
||||
lazy var subShape = Rect(sideLength: 4)
|
||||
|
||||
// If you don't need a custom getter and setter,
|
||||
// but still want to run code before and after getting or setting
|
||||
// a property, you can use `willSet` and `didSet`
|
||||
var identifier: String = "defaultID" {
|
||||
// the `willSet` arg will be the variable name for the new value
|
||||
willSet(someIdentifier) {
|
||||
print(someIdentifier)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
init(sideLength: Int) {
|
||||
super.init()
|
||||
self.sideLength = sideLength
|
||||
}
|
||||
|
||||
func shrink() {
|
||||
if sideLength > 0 {
|
||||
--sideLength
|
||||
|
||||
init(sideLength: Int) {
|
||||
super.init()
|
||||
self.sideLength = sideLength
|
||||
}
|
||||
|
||||
func shrink() {
|
||||
if sideLength > 0 {
|
||||
--sideLength
|
||||
}
|
||||
}
|
||||
|
||||
override func getArea() -> Int {
|
||||
return sideLength * sideLength
|
||||
}
|
||||
}
|
||||
|
||||
override func getArea() -> Int {
|
||||
return sideLength * sideLength
|
||||
}
|
||||
}
|
||||
var mySquare = new Square(sideLength: 5)
|
||||
|
||||
// A simple class `Square` extends `Rect`
|
||||
class Square: Rect {
|
||||
convenience init() {
|
||||
self.init(sideLength: 5)
|
||||
}
|
||||
}
|
||||
|
||||
var mySquare = Square()
|
||||
print(mySquare.getArea()) // 25
|
||||
mySquare.shrink()
|
||||
print(mySquare.sideLength) // 4
|
||||
|
||||
// If you don't need a custom getter and setter,
|
||||
// but still want to run code before and after getting or setting
|
||||
// a property, you can use `willSet` and `didSet`
|
||||
// compare instances, not the same as == which compares objects (equal to)
|
||||
if mySquare === mySquare {
|
||||
println("Yep, it's mySquare")
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Enums
|
||||
// MARK: Enums
|
||||
//
|
||||
|
||||
// Enums can optionally be of a specific type or on their own.
|
||||
// They can contain methods like classes.
|
||||
|
||||
enum Suit {
|
||||
case Spades, Hearts, Diamonds, Clubs
|
||||
func getIcon() -> String {
|
||||
switch self {
|
||||
case .Spades: return "♤"
|
||||
case .Hearts: return "♡"
|
||||
case .Diamonds: return "♢"
|
||||
case .Clubs: return "♧"
|
||||
case Spades, Hearts, Diamonds, Clubs
|
||||
func getIcon() -> String {
|
||||
switch self {
|
||||
case .Spades: return "♤"
|
||||
case .Hearts: return "♡"
|
||||
case .Diamonds: return "♢"
|
||||
case .Clubs: return "♧"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Other
|
||||
// MARK: Protocols
|
||||
//
|
||||
|
||||
// `protocol`: Similar to Java interfaces.
|
||||
// `extension`s: Add extra functionality to an already created type
|
||||
// `protocol`s can require that conforming types have specific
|
||||
// instance properties, instance methods, type methods,
|
||||
// operators, and subscripts.
|
||||
|
||||
protocol ShapeGenerator {
|
||||
var enabled: Bool { get set }
|
||||
func buildShape() -> Shape
|
||||
}
|
||||
|
||||
/*
|
||||
// Protocols declared with @objc allow optional functions,
|
||||
// which allow you to check for conformance
|
||||
@objc protocol TransformShape {
|
||||
optional func reshaped()
|
||||
optional func canReshape() -> Bool
|
||||
}
|
||||
|
||||
class MyShape: Rect {
|
||||
var delegate: TransformShape?
|
||||
|
||||
func grow() {
|
||||
sideLength += 2
|
||||
|
||||
if let allow = self.delegate?.canReshape?() {
|
||||
// test for delegate then for method
|
||||
self.delegate?.reshaped?()
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
//
|
||||
// MARK: Other
|
||||
//
|
||||
|
||||
// `extension`s: Add extra functionality to an already existing type
|
||||
|
||||
// Square now "conforms" to the `Printable` protocol
|
||||
extension Square: Printable {
|
||||
var description: String {
|
||||
return "Area: \(self.getArea()) - ID: \(self.identifier)"
|
||||
}
|
||||
}
|
||||
|
||||
println("Square: \(mySquare)")
|
||||
|
||||
// You can also extend built-in types
|
||||
extension Int {
|
||||
var customProperty: String {
|
||||
return "This is \(self)"
|
||||
}
|
||||
|
||||
func multiplyBy(num: Int) -> Int {
|
||||
return num * self
|
||||
}
|
||||
}
|
||||
|
||||
println(7.customProperty) // "This is 7"
|
||||
println(14.multiplyBy(2)) // 42
|
||||
|
||||
// Generics: Similar to Java. Use the `where` keyword to specify the
|
||||
// requirements of the generics.
|
||||
|
||||
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
|
||||
for (index, value) in enumerate(array) {
|
||||
if value == valueToFind {
|
||||
return index
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
let foundAtIndex = findIndex([1, 2, 3, 4], 3)
|
||||
println(foundAtIndex == 2) // true
|
||||
|
||||
// Operators:
|
||||
// Custom operators can start with the characters:
|
||||
// / = - + * % < > ! & | ^ . ~
|
||||
// or
|
||||
// Unicode math, symbol, arrow, dingbat, and line/box drawing characters.
|
||||
prefix operator !!! {}
|
||||
|
||||
// A prefix operator that triples the side length when used
|
||||
prefix func !!! (inout shape: Square) -> Square {
|
||||
shape.sideLength *= 3
|
||||
return shape
|
||||
}
|
||||
|
||||
// current value
|
||||
println(mySquare.sideLength) // 4
|
||||
|
||||
// change side length using custom !!! operator, increases size by 3
|
||||
!!!mySquare
|
||||
println(mySquare.sideLength) // 12
|
||||
|
||||
```
|
||||
|
@ -14,7 +14,7 @@ kendi çatıları olan Cocoa ve Cocoa Touch için kullanılan bir programlama di
|
||||
Genel açamlı, object-oriented bir yapıya sahip programlama dilidir. C
|
||||
programlama diline Smalltalk stilinde mesajlaşma ekler.
|
||||
|
||||
```cpp
|
||||
```objective_c
|
||||
// Tek satır yorum // işaretleri ile başlar
|
||||
|
||||
/*
|
||||
|
@ -13,7 +13,7 @@ This article will focus only on TypeScript extra syntax, as oposed to [JavaScrip
|
||||
|
||||
To test TypeScript's compiler, head to the [Playground] (http://www.typescriptlang.org/Playground) where you will be able to type code, have auto completion and directly see the emitted JavaScript.
|
||||
|
||||
```ts
|
||||
```js
|
||||
//There are 3 basic types in TypeScript
|
||||
var isDone: boolean = false;
|
||||
var lines: number = 42;
|
||||
|
@ -12,7 +12,7 @@ filename: LearnObjectiveC-vi.m
|
||||
Objective-C là ngôn ngữ lập trình chính được sử dụng bởi Apple cho các hệ điều hành OS X, iOS và các framework tương ứng của họ, Cocoa và Cocoa Touch.
|
||||
Nó là một ngôn ngữ lập trình mục đích tổng quát, hướng đối tượng có bổ sung thêm kiểu truyền thông điệp giống Smalltalk vào ngôn ngữ lập trình C.
|
||||
|
||||
```cpp
|
||||
```objective_c
|
||||
// Chú thích dòng đơn bắt đầu với //
|
||||
|
||||
/*
|
||||
|
@ -17,7 +17,7 @@ ANSI Common Lisp 是一个广泛通用于各个工业领域的、支持多种范
|
||||
另外还有一本热门的近期出版的
|
||||
[Land of Lisp](http://landoflisp.com/).
|
||||
|
||||
```scheme
|
||||
```common-lisp
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;; 0. 语法
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
@ -9,6 +9,7 @@ contributors:
|
||||
- ["Amr Tamimi", "https://amrtamimi.com"]
|
||||
translators:
|
||||
- ["Jakukyo Friel", "http://weakish.github.io"]
|
||||
filename: lua-cn.lua
|
||||
---
|
||||
|
||||
```lua
|
||||
|
240
zh-cn/markdown-cn.html.markdown
Normal file
240
zh-cn/markdown-cn.html.markdown
Normal file
@ -0,0 +1,240 @@
|
||||
---
|
||||
language: Markdown
|
||||
contributors:
|
||||
- ["Dan Turkel", "http://danturkel.com/"]
|
||||
translators:
|
||||
- ["Fangzhou Chen","https://github.com/FZSS"]
|
||||
filename: learnmarkdown-cn.md
|
||||
lang: zh-cn
|
||||
---
|
||||
|
||||
Markdown 由 John Gruber 于 2004年创立. 它旨在成为一门容易读写的语法结构,并可以便利地转换成 HTML(以及其他很多)格式。
|
||||
|
||||
欢迎您多多反馈以及分支和请求合并。
|
||||
|
||||
|
||||
```markdown
|
||||
<!-- Markdown 是 HTML 的父集,所以任何 HTML 文件都是有效的 Markdown。
|
||||
这意味着我们可以在 Markdown 里使用任何 HTML 元素,比如注释元素,
|
||||
且不会被 Markdown 解析器所影响。不过如果你在 Markdown 文件内创建了 HTML 元素,
|
||||
你将无法在 HTML 元素的内容中使用 Markdown 语法。-->
|
||||
|
||||
<!-- 在不同的解析器中,Markdown 的实现方法有所不同。
|
||||
此教程会指出当某功能是否通用及是否只对某一解析器有效。 -->
|
||||
|
||||
<!-- 标头 -->
|
||||
<!-- 通过在文本前加上不同数量的hash(#), 你可以创建相对应的 <h1>
|
||||
到 <h6> HTML元素。-->
|
||||
|
||||
# 这是一个 <h1>
|
||||
## 这是一个 <h2>
|
||||
### 这是一个 <h3>
|
||||
#### 这是一个 <h4>
|
||||
##### 这是一个 <h5>
|
||||
###### 这是一个 <h6>
|
||||
|
||||
<!-- 对于 <h1> 和 <h2> 元素,Markdown 额外提供了两种添加方式。 -->
|
||||
这是一个 h1
|
||||
=============
|
||||
|
||||
这是一个 h2
|
||||
-------------
|
||||
|
||||
<!-- 简易文本样式 -->
|
||||
<!-- 文本的斜体,粗体,和删除线在 Markdown 中可以轻易地被实现。-->
|
||||
|
||||
*此文本为斜体。*
|
||||
_此文本也是。_
|
||||
|
||||
**此文本为粗体。**
|
||||
__此文本也是__
|
||||
|
||||
***此文本是斜体加粗体。***
|
||||
**_或者这样。_**
|
||||
*__这个也是!__*
|
||||
|
||||
<!-- 在 Github 采用的 Markdown 中 -->
|
||||
|
||||
~~此文本为删除线效果。~~
|
||||
|
||||
<!-- 单个段落由一句或多句邻近的句子组成,这些句子由一个或多个空格分隔。-->
|
||||
|
||||
这是第一段落. 这句话在同一个段落里,好玩么?
|
||||
|
||||
现在我是第二段落。
|
||||
这句话也在第二段落!
|
||||
|
||||
这句话在第三段落!
|
||||
|
||||
<!-- 如果你插入一个 HTML中的<br />标签,你可以在段末加入两个以上的空格,
|
||||
然后另起一段。-->
|
||||
|
||||
此段落结尾有两个空格(选中以显示)。
|
||||
|
||||
上文有一个 <br /> !
|
||||
|
||||
<!-- 段落引用可由 > 字符轻松实现。-->
|
||||
|
||||
> 这是一个段落引用. 你可以
|
||||
> 手动断开你的句子,然后在每句句子前面添加 “>” 字符。或者让你的句子变得很长,以至于他们自动得断开。
|
||||
> 只要你的文字以“>” 字符开头,两种方式无异。
|
||||
|
||||
> 你也对文本进行
|
||||
>> 多层引用
|
||||
> 这多机智啊!
|
||||
|
||||
<!-- 序列 -->
|
||||
<!-- 无序序列可由星号,加号或者减号来建立 -->
|
||||
|
||||
* 项目
|
||||
* 项目
|
||||
* 另一个项目
|
||||
|
||||
或者
|
||||
|
||||
+ 项目
|
||||
+ 项目
|
||||
+ 另一个项目
|
||||
|
||||
或者
|
||||
|
||||
- 项目
|
||||
- 项目
|
||||
- 最后一个项目
|
||||
|
||||
<!-- 有序序列可由数字加点来实现 -->
|
||||
|
||||
1. 项目一
|
||||
2. 项目二
|
||||
3. 项目三
|
||||
|
||||
<!-- 即使你的标签数字有误,Markdown 依旧会呈现出正确的序号,
|
||||
不过这并不是一个好主意-->
|
||||
|
||||
1. 项目一
|
||||
1. 项目二
|
||||
1. 项目三
|
||||
<!-- (此段与前例一模一样) -->
|
||||
|
||||
<!-- 你也可以使用子序列 -->
|
||||
|
||||
1. 项目一
|
||||
2. 项目二
|
||||
3. 项目三
|
||||
* 子项目
|
||||
* 子项目
|
||||
4. 项目四
|
||||
|
||||
<!-- 代码段落 -->
|
||||
<!-- 代码段落(HTML中 <code>标签)可以由缩进四格(spaces)
|
||||
或者一个标签页(tab)实现-->
|
||||
|
||||
This is code
|
||||
So is this
|
||||
|
||||
<!-- 在你的代码中,你仍然使用tab可以进行缩进操作 -->
|
||||
|
||||
my_array.each do |item|
|
||||
puts item
|
||||
end
|
||||
|
||||
<!-- 内联代码可由反引号 ` 实现 -->
|
||||
|
||||
John 甚至不知道 `go_to()` 方程是干嘛的!
|
||||
|
||||
<!-- 在Github的 Markdown中,对于代码你可以使用特殊的语法 -->
|
||||
|
||||
\`\`\`ruby <!-- 插入时记得移除反斜线, 仅留```ruby ! -->
|
||||
def foobar
|
||||
puts "Hello world!"
|
||||
end
|
||||
\`\`\` <!-- 这里也是,移除反斜线,仅留 ``` -->
|
||||
|
||||
<!-- 以上代码不需要缩进,而且 Github 会根据```后表明的语言来进行语法高亮 -->
|
||||
|
||||
<!-- 水平线 (<hr />) -->
|
||||
<!-- 水平线可由三个或以上的星号或者减号创建,可带可不带空格。 -->
|
||||
|
||||
***
|
||||
---
|
||||
- - -
|
||||
****************
|
||||
|
||||
<!-- 链接 -->
|
||||
<!-- Markdown 最棒的地方就是简易的链接制作。链接文字放在中括号[]内,
|
||||
在随后的括弧()内加入url。-->
|
||||
|
||||
[点我点我!](http://test.com/)
|
||||
|
||||
<!-- 你也可以为链接加入一个标题:在括弧内使用引号 -->
|
||||
|
||||
[点我点我!](http://test.com/ "连接到Test.com")
|
||||
|
||||
<!-- 相对路径也可以有 -->
|
||||
|
||||
[去 music](/music/).
|
||||
|
||||
<!-- Markdown同样支持引用样式的链接 -->
|
||||
|
||||
[点此链接][link1]以获取更多信息!
|
||||
[看一看这个链接][foobar] 如果你愿意的话.
|
||||
|
||||
[link1]: http://test.com/ "Cool!"
|
||||
[foobar]: http://foobar.biz/ "Alright!"
|
||||
|
||||
<!-- 链接的标题可以处于单引号中,括弧中或是被忽略。引用名可以在文档的任意何处,
|
||||
并且可以随意命名,只要名称不重复。-->
|
||||
|
||||
<!-- “隐含式命名” 的功能可以让链接文字作为引用名 -->
|
||||
|
||||
[This][] is a link.
|
||||
|
||||
[this]: http://thisisalink.com/
|
||||
|
||||
<!-- 但这并不常用 -->
|
||||
|
||||
<!-- 图像 -->
|
||||
<!-- 图像与链接相似,只需在前添加一个感叹号 -->
|
||||
|
||||
![这是我图像的悬停文本(alt text)](http://imgur.com/myimage.jpg "可选命名")
|
||||
|
||||
<!-- 引用样式也同样起作用 -->
|
||||
|
||||
![这是我的悬停文本.][myimage]
|
||||
|
||||
[myimage]: relative/urls/cool/image.jpg "在此输入标题"
|
||||
|
||||
<!-- 杂项 -->
|
||||
<!-- 自动链接 -->
|
||||
|
||||
<http://testwebsite.com/> 与
|
||||
[http://testwebsite.com/](http://testwebsite.com/) 等同
|
||||
|
||||
<!-- 电子邮件的自动链接 -->
|
||||
|
||||
<foo@bar.com>
|
||||
|
||||
<!-- 转义字符 -->
|
||||
|
||||
我希望 *将这段文字置于星号之间* 但是我不希望它被
|
||||
斜体化, 所以我就: \*这段置文字于星号之间\*。
|
||||
|
||||
<!-- 表格 -->
|
||||
<!-- 表格只被 Github 的 Markdown 支持,并且有一点笨重,但如果你真的要用的话: -->
|
||||
|
||||
| 第一列 | 第二列 | 第三列 |
|
||||
| :---------- | :------: | ----------: |
|
||||
| 左对齐 | 居个中 | 右对齐 |
|
||||
| 某某某 | 某某某 | 某某某 |
|
||||
|
||||
<!-- 或者, 同样的 -->
|
||||
|
||||
第一列 | 第二列 | 第三列
|
||||
:-- | :-: | --:
|
||||
这太丑了 | 药不能 | 停
|
||||
|
||||
<!-- 结束! -->
|
||||
|
||||
```
|
||||
|
||||
更多信息, 请于[此处](http://daringfireball.net/projects/Markdown/syntax)参见 John Gruber 关于语法的官方帖子,及于[此处](https://github.com/adam-p/Markdown-here/wiki/Markdown-Cheatsheet) 参见 Adam Pritchard 的摘要笔记。
|
@ -13,7 +13,7 @@ lang: zh-cn
|
||||
R 是一门统计语言。它有很多数据分析和挖掘程序包。可以用来统计、分析和制图。
|
||||
你也可以在 LaTeX 文档中运行 `R` 命令。
|
||||
|
||||
```python
|
||||
```r
|
||||
# 评论以 # 开始
|
||||
|
||||
# R 语言原生不支持 多行注释
|
||||
|
@ -11,7 +11,7 @@ lang: zh-cn
|
||||
|
||||
Scala - 一门可拓展性的语言
|
||||
|
||||
```cpp
|
||||
```scala
|
||||
|
||||
/*
|
||||
自行设置:
|
||||
|
@ -12,7 +12,7 @@ Swift 是Apple 开发的用于iOS 和OS X 开发的编程语言。Swift 于2014
|
||||
|
||||
参阅:Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/LandingPage/index.html) ——一个完整的Swift 教程
|
||||
|
||||
```js
|
||||
```swift
|
||||
//
|
||||
// 基础
|
||||
//
|
||||
|
Loading…
Reference in New Issue
Block a user