mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
Compare commits
11 Commits
415efbe717
...
8938aa82da
| Author | SHA1 | Date | |
|---|---|---|---|
|
8938aa82da | ||
|
|
41b7b9099e | ||
|
|
dfdeb3e88a | ||
|
|
01771b39c9 | ||
|
|
11b91ad5cc | ||
|
|
89b09faed3 | ||
|
|
789fffd9f8 | ||
|
|
3ecbf961d3 | ||
|
|
f888151153 | ||
|
|
755d45e978 | ||
|
|
29e880808e |
17
.github/workflows/lint.yml
vendored
17
.github/workflows/lint.yml
vendored
@ -22,7 +22,22 @@ jobs:
|
||||
|
||||
- name: Files are UTF-8
|
||||
run: ./lint/encoding.sh .
|
||||
- name: "No non-breaking spaces"
|
||||
run: |
|
||||
if grep -rI --include='*.md' $'\u00A0' .; then
|
||||
exit 1
|
||||
fi
|
||||
- name: "No zero-width spaces"
|
||||
run: |
|
||||
if grep -rI --include='*.md' $'\u200B' .; then
|
||||
exit 1
|
||||
fi
|
||||
- name: "No carriage return"
|
||||
run: |
|
||||
if grep -rI --include='*.md' $'\u000D' .; then
|
||||
exit 1
|
||||
fi
|
||||
- name: Lint Markdown
|
||||
run: mdl . --ignore-front-matter -r MD003,MD005,MD011,MD019,MD023,MD027,MD028,MD035,MD037,MD038,MD039,MD047
|
||||
run: mdl . --ignore-front-matter -r MD003,MD005,MD011,MD018,MD019,MD023,MD025,MD027,MD028,MD030,MD035,MD037,MD038,MD039,MD046,MD047
|
||||
- name: Lint frontmatter
|
||||
run: ./lint/frontmatter.py .
|
||||
|
||||
40
.mailmap
40
.mailmap
@ -1 +1,41 @@
|
||||
Leigh Brenecki <l@leigh.net.au> <adam@brenecki.id.au>
|
||||
|
||||
Adam Bard <github@adambard.com> Adam <adam@adambard.com>
|
||||
Adam Bard <github@adambard.com> Adam Bard <adam@adambard.com>
|
||||
|
||||
ven <vendethiel@hotmail.fr> Nami-Doc <vendethiel@hotmail.fr>
|
||||
|
||||
Andre Polykanine <ap@oire.me> <andre@oire.org>
|
||||
Andre Polykanine <ap@oire.me> <andre.polykanine@internations.org>
|
||||
|
||||
Divay Prakash <divayprakash3@gmail.com> <divayprakash@users.noreply.github.com>
|
||||
Divay Prakash <divayprakash3@gmail.com> <divayprakash0@gmail.com>
|
||||
|
||||
Levi Bostian <levi.bostian@gmail.com> <levi.bostian@banno.com>
|
||||
|
||||
Pratik Karki <predatoramigo@gmail.com> <prertik@outlook.com>
|
||||
|
||||
Marcel Ribeiro-Dantas <ribeirodantasdm@gmail.com> <ribeirodantasdm@gmail.com>
|
||||
Marcel Ribeiro-Dantas <ribeirodantasdm@gmail.com> <mribeirodantas@hey.com>
|
||||
Marcel Ribeiro-Dantas <ribeirodantasdm@gmail.com> <marcel.ribeiro-dantas@curie.fr>
|
||||
Marcel Ribeiro-Dantas <ribeirodantasdm@gmail.com> <mribeirodantas@seqera.io>
|
||||
Marcel Ribeiro-Dantas <ribeirodantasdm@gmail.com> <marcel.ribeirodantas@seqera.io>
|
||||
|
||||
Geoff Liu <cangming.liu@gmail.com> <g@geoffliu.me>
|
||||
Geoff Liu <cangming.liu@gmail.com> <hi@geoffliu.me>
|
||||
|
||||
sirkubax <muszynski@so1.net> <jakubxmuszynski@gmail.com>
|
||||
|
||||
caminsha <c.96marco@hotmail.com> <31421093+caminsha@users.noreply.github.com>
|
||||
|
||||
Samantha McVey <samantham@posteo.net>
|
||||
|
||||
Ian Bertolacci <ian.bertolacci@gmail.com> ian.bertolacci <ibertolacci@cray.com>
|
||||
|
||||
Boris Verkhovskiy <boris.verk@gmail.com>
|
||||
|
||||
Louie Dinh <LouieDinh@gmail.com> lodin <LouieDinh@gmail.com>
|
||||
|
||||
Milo Gilad <milogaccnts@gmail.com> Milo Gilad <Myl0g@users.noreply.github.com>
|
||||
|
||||
Yannick Loriot <yannick.loriot@gmail.com> Yannick <yannick.loriot@gmail.com>
|
||||
|
||||
@ -15,7 +15,7 @@ The idea turned out very well, and the project is now officially supported by Go
|
||||
AngularJS is a JavaScript framework. It can be added to an HTML page with a "script" tag.
|
||||
AngularJS extends HTML attributes with Directives, and binds data to HTML with Expressions.
|
||||
|
||||
##What You Should Already Know
|
||||
## What You Should Already Know
|
||||
|
||||
Before you study AngularJS, you should have a basic understanding of:
|
||||
|
||||
|
||||
@ -352,7 +352,7 @@ Get familiar with how you can use roles in the simple_apache_role example
|
||||
```
|
||||
playbooks/roles/simple_apache_role/
|
||||
├── tasks
|
||||
│ └── main.yml
|
||||
│ └── main.yml
|
||||
└── templates
|
||||
└── main.yml
|
||||
```
|
||||
|
||||
8
bash.md
8
bash.md
@ -343,7 +343,7 @@ echo "#helloworld" | tee output.out >/dev/null
|
||||
rm -v output.out error.err output-and-error.log
|
||||
rm -r tempDir/ # recursively delete
|
||||
# You can install the `trash-cli` Python package to have `trash`
|
||||
# which puts files in the system trash and doesn't delete them directly
|
||||
# which puts files in the system trash and doesn't delete them directly
|
||||
# see https://pypi.org/project/trash-cli/ if you want to be careful
|
||||
|
||||
# Commands can be substituted within other commands using $( ):
|
||||
@ -360,7 +360,7 @@ case "$Variable" in
|
||||
# List patterns for the conditions you want to meet
|
||||
0) echo "There is a zero.";;
|
||||
1) echo "There is a one.";;
|
||||
*) echo "It is not null.";; # match everything
|
||||
*) echo "It is not null.";; # match everything
|
||||
esac
|
||||
|
||||
# `for` loops iterate for as many arguments given:
|
||||
@ -462,8 +462,8 @@ cut -d ',' -f 1 file.txt
|
||||
# replaces every occurrence of 'okay' with 'great' in file.txt
|
||||
# (regex compatible)
|
||||
sed -i 's/okay/great/g' file.txt
|
||||
# be aware that this -i flag means that file.txt will be changed
|
||||
# -i or --in-place erase the input file (use --in-place=.backup to keep a back-up)
|
||||
# be aware that this -i flag means that file.txt will be changed
|
||||
# -i or --in-place erase the input file (use --in-place=.backup to keep a back-up)
|
||||
|
||||
# print to stdout all lines of file.txt which match some regex
|
||||
# The example prints lines which begin with "foo" and end in "bar"
|
||||
|
||||
2
cobol.md
2
cobol.md
@ -186,7 +186,7 @@ organizations.
|
||||
THE FULL NAME IS: BOB GIBBERISH COBB
|
||||
```
|
||||
|
||||
##Ready For More?
|
||||
## Further reading
|
||||
|
||||
* [GnuCOBOL](https://sourceforge.net/projects/open-cobol/)
|
||||
|
||||
|
||||
@ -610,7 +610,7 @@ for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
|
||||
break
|
||||
|
||||
# Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
|
||||
# hodně času i paměti, proto se místo toho čísla generují postupně.
|
||||
# hodně času i paměti, proto se místo toho čísla generují postupně.
|
||||
for nasobek in nasobicka_2(range(900000000)):
|
||||
# Vypíše postupně: "Zpracovávám číslo 1", ..., "Zpracovávám číslo 5"
|
||||
if nasobek >= 10:
|
||||
|
||||
4
css.md
4
css.md
@ -224,13 +224,13 @@ body {
|
||||
|
||||
/* Nest style rule inside another (CSS 3) */
|
||||
.main {
|
||||
.bgred { /* same as: .main .bgred { } */
|
||||
.bgred { /* same as: .main .bgred { } */
|
||||
background: red;
|
||||
}
|
||||
& .bggreen { /* same as: .main .bggreen { } */
|
||||
background: green;
|
||||
}
|
||||
&.bgblue { /* (without space) same as: .main.bgblue { } */
|
||||
&.bgblue { /* (without space) same as: .main.bgblue { } */
|
||||
background: blue;
|
||||
}
|
||||
}
|
||||
|
||||
10
cue.md
10
cue.md
@ -488,12 +488,12 @@ To make it concrete, consider the following:
|
||||
```
|
||||
mymodule
|
||||
├── config
|
||||
│ ├── a.cue
|
||||
│ └── b.cue
|
||||
│ ├── a.cue
|
||||
│ └── b.cue
|
||||
├── cue.mod
|
||||
│ ├── module.cue
|
||||
│ ├── pkg
|
||||
│ └── usr
|
||||
│ ├── module.cue
|
||||
│ ├── pkg
|
||||
│ └── usr
|
||||
└── main.cue
|
||||
```
|
||||
|
||||
|
||||
@ -182,5 +182,5 @@ KTHXBYE
|
||||
|
||||
## Weiterführende Informationen:
|
||||
|
||||
- [LCI compiler](https://github.com/justinmeza/lci)
|
||||
- [Official spec](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md)
|
||||
- [LCI compiler](https://github.com/justinmeza/lci)
|
||||
- [Official spec](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md)
|
||||
|
||||
@ -461,18 +461,18 @@ class Human(object):
|
||||
return "*grunt*"
|
||||
|
||||
# Eine Eigenschaft (Property) ist wie ein Getter.
|
||||
# Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
|
||||
# Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
|
||||
# Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
|
||||
# Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
|
||||
@property
|
||||
def age(self):
|
||||
return self._age
|
||||
|
||||
# Damit kann die Eigenschaft festgelegt werden
|
||||
# Damit kann die Eigenschaft festgelegt werden
|
||||
@age.setter
|
||||
def age(self, age):
|
||||
self._age = age
|
||||
|
||||
# Damit kann die Eigenschaft gelöscht werden
|
||||
# Damit kann die Eigenschaft gelöscht werden
|
||||
@age.deleter
|
||||
def age(self):
|
||||
del self._age
|
||||
@ -561,7 +561,7 @@ class Superhero(Human):
|
||||
# Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse
|
||||
# zugreifen, die vom untergeordneten Objekt überschrieben werden,
|
||||
# in diesem Fall die Methode __init__.
|
||||
# Dies ruft den Konstruktor der übergeordneten Klasse auf:
|
||||
# Dies ruft den Konstruktor der übergeordneten Klasse auf:
|
||||
super().__init__(name)
|
||||
|
||||
# überschreiben der "sing" Methode
|
||||
@ -583,7 +583,7 @@ if __name__ == '__main__':
|
||||
print('I am a superhero')
|
||||
|
||||
# Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird.
|
||||
# Dieses Attribut ist dynamisch und kann aktualisiert werden.
|
||||
# Dieses Attribut ist dynamisch und kann aktualisiert werden.
|
||||
print(Superhero.__mro__) # => (<class '__main__.Superhero'>,
|
||||
# => <class 'human.Human'>, <class 'object'>)
|
||||
|
||||
|
||||
@ -523,7 +523,7 @@ next(our_iterator) # => "one"
|
||||
next(our_iterator) # => "two"
|
||||
next(our_iterator) # => "three"
|
||||
|
||||
# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration.
|
||||
# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration.
|
||||
next(our_iterator) # προκαλεί StopIteration
|
||||
|
||||
# Μπορείς να πάρεις όλα τα αντικείμενα ενός iteratior καλώντας list() πάνω του.
|
||||
|
||||
@ -163,7 +163,6 @@ O Vim στηρίζεται στο concept των **modes**.
|
||||
|
||||
## Μερικά shortcuts και κόλπα
|
||||
|
||||
<!--TODO: Βάλτε κι άλλα!-->
|
||||
```
|
||||
> # Στοίχισε προς τα δεξιά την επιλογή σου κατά ένα block
|
||||
< # Στοίχισε προς τα αριστερά την επιλογή σου κατά ένα block
|
||||
|
||||
12
es/c++.md
12
es/c++.md
@ -280,7 +280,7 @@ foo(bar(tempObjectFun()))
|
||||
|
||||
void constReferenceTempObjectFun() {
|
||||
// ConstRef obtiene el objeto temporal, y es válido hasta el final de esta
|
||||
// función.
|
||||
// función.
|
||||
const string& constRef = tempObjectFun();
|
||||
...
|
||||
}
|
||||
@ -328,10 +328,10 @@ public:
|
||||
Dog();
|
||||
|
||||
// Declaraciones de funciones de la clase (implementaciones a seguir)
|
||||
// Nota que usamos std::string aquí en lugar de colocar
|
||||
// using namespace std;
|
||||
// arriba.
|
||||
// Nunca ponga una declaración "using namespace" en un encabezado.
|
||||
// Nota que usamos std::string aquí en lugar de colocar
|
||||
// using namespace std;
|
||||
// arriba.
|
||||
// Nunca ponga una declaración "using namespace" en un encabezado.
|
||||
void setName(const std::string& dogsName);
|
||||
|
||||
void setWeight(int dogsWeight);
|
||||
@ -471,7 +471,7 @@ public:
|
||||
Point& operator+=(const Point& rhs);
|
||||
|
||||
// También tendría sentido añadir los operadores - y -=,
|
||||
// pero vamos a omitirlos por razones de brevedad.
|
||||
// pero vamos a omitirlos por razones de brevedad.
|
||||
};
|
||||
|
||||
Point Point::operator+(const Point& rhs) const
|
||||
|
||||
@ -202,7 +202,7 @@ chau
|
||||
|
||||
```
|
||||
|
||||
##Listo Para Mas?
|
||||
## Listo Para Mas?
|
||||
|
||||
* [README](https://git.sr.ht/~maleza/curto/tree/curto/item/README)
|
||||
* [GLOSARIO](https://git.sr.ht/~maleza/curto/tree/curto/item/GLOSARIO)
|
||||
|
||||
@ -191,6 +191,6 @@ name get-global . ! "Bob"
|
||||
[ 2 + ] \ - suffix ! Quotation [ 2 + - ]
|
||||
```
|
||||
|
||||
##Listo para más?
|
||||
## Listo para más?
|
||||
|
||||
* [Documentación de Factor](http://docs.factorcode.org/content/article-help.home.html)
|
||||
|
||||
@ -216,7 +216,7 @@ page
|
||||
\ bye
|
||||
```
|
||||
|
||||
##Listo Para Mas?
|
||||
## Listo Para Mas?
|
||||
|
||||
* [Starting Forth](http://www.forth.com/starting-forth/)
|
||||
* [Simple Forth](http://www.murphywong.net/hello/simple.htm)
|
||||
|
||||
54
es/fsharp.md
54
es/fsharp.md
@ -248,7 +248,7 @@ module EjemploDeSecuencia =
|
||||
let secuencia1 = seq { yield "a"; yield "b" }
|
||||
|
||||
// Las secuencias pueden usar yield y
|
||||
// puede contener subsecuencias
|
||||
// puede contener subsecuencias
|
||||
let extranio = seq {
|
||||
// "yield" agrega un elemento
|
||||
yield 1; yield 2;
|
||||
@ -262,7 +262,7 @@ module EjemploDeSecuencia =
|
||||
extranio |> Seq.toList
|
||||
|
||||
// Las secuencias se pueden crear usando "unfold"
|
||||
// Esta es la secuencia de fibonacci
|
||||
// Esta es la secuencia de fibonacci
|
||||
let fib = Seq.unfold (fun (fst,snd) ->
|
||||
Some(fst + snd, (snd, fst + snd))) (0,1)
|
||||
|
||||
@ -278,8 +278,8 @@ module EejemploDeTipoDeDatos =
|
||||
|
||||
// Todos los datos son inmutables por defecto
|
||||
|
||||
// las tuplas son tipos anónimos simples y rápidos
|
||||
// - Usamos una coma para crear una tupla
|
||||
// las tuplas son tipos anónimos simples y rápidos
|
||||
// - Usamos una coma para crear una tupla
|
||||
let dosTuplas = 1,2
|
||||
let tresTuplas = "a",2,true
|
||||
|
||||
@ -301,7 +301,7 @@ module EejemploDeTipoDeDatos =
|
||||
|
||||
// ------------------------------------
|
||||
// Los tipos de unión (o variantes) tienen un conjunto de elección
|
||||
// Solo un caso puede ser válido a la vez.
|
||||
// Solo un caso puede ser válido a la vez.
|
||||
// ------------------------------------
|
||||
|
||||
// Usamos "type" con barra/pipe para definir una unión estándar
|
||||
@ -326,7 +326,7 @@ module EejemploDeTipoDeDatos =
|
||||
// ------------------------------------
|
||||
|
||||
// Los tipos se pueden combinar recursivamente de formas complejas
|
||||
// sin tener que crear subclases
|
||||
// sin tener que crear subclases
|
||||
type Empleado =
|
||||
| Trabajador of Persona
|
||||
| Gerente of Empleado lista
|
||||
@ -349,9 +349,9 @@ module EejemploDeTipoDeDatos =
|
||||
| DireccionDeCorreoInvalido direccion -> () // no enviar
|
||||
|
||||
// Combinar juntos, los tipos de unión y tipos de registro
|
||||
// ofrece una base excelente para el diseño impulsado por el dominio.
|
||||
// Puedes crear cientos de pequeños tipos que reflejarán fielmente
|
||||
// el dominio.
|
||||
// ofrece una base excelente para el diseño impulsado por el dominio.
|
||||
// Puedes crear cientos de pequeños tipos que reflejarán fielmente
|
||||
// el dominio.
|
||||
|
||||
type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
|
||||
type Pago = Pago of float
|
||||
@ -368,17 +368,17 @@ module EejemploDeTipoDeDatos =
|
||||
// ------------------------------------
|
||||
|
||||
// Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar.
|
||||
// * Inmutabilidad
|
||||
// * Bonita depuración de impresión
|
||||
// * Igualdad y comparación
|
||||
// * Serialización
|
||||
// * Inmutabilidad
|
||||
// * Bonita depuración de impresión
|
||||
// * Igualdad y comparación
|
||||
// * Serialización
|
||||
|
||||
// La impresión bonita se usa con %A
|
||||
// La impresión bonita se usa con %A
|
||||
printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A"
|
||||
dosTuplas persona1 temp1 trabajador
|
||||
|
||||
// La igualdad y la comparación son innatas
|
||||
// Aquí hay un ejemplo con tarjetas.
|
||||
// Aquí hay un ejemplo con tarjetas.
|
||||
type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
|
||||
type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
|
||||
| Nueve | Diez | Jack | Reina | Rey | As
|
||||
@ -398,11 +398,11 @@ module EejemploDeTipoDeDatos =
|
||||
module EjemplosDePatronesActivos =
|
||||
|
||||
// F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos"
|
||||
// donde el patrón puede ser analizado o detectado dinámicamente.
|
||||
// donde el patrón puede ser analizado o detectado dinámicamente.
|
||||
|
||||
// "clips de banana" es la sintaxis de los patrones activos
|
||||
// "clips de banana" es la sintaxis de los patrones activos
|
||||
|
||||
// por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
|
||||
// por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
|
||||
let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
|
||||
if System.Char.IsDigit(ch) then Digito
|
||||
else if System.Char.IsLetter(ch) then Letra
|
||||
@ -425,7 +425,7 @@ module EjemplosDePatronesActivos =
|
||||
// -----------------------------------------
|
||||
|
||||
// Puede crear un patrón de coincidencia parcial también
|
||||
// Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
|
||||
// Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
|
||||
let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
|
||||
let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None
|
||||
|
||||
@ -447,7 +447,7 @@ module EjemplosDePatronesActivos =
|
||||
module EjemploDeAlgoritmo =
|
||||
|
||||
// F# tiene una alta relación señal / ruido, lo que permite leer el código
|
||||
// casi como un algoritmo real
|
||||
// casi como un algoritmo real
|
||||
|
||||
// ------ Ejemplo: definir una función sumaDeCuadrados ------
|
||||
let sumaDeCuadrados n =
|
||||
@ -464,7 +464,7 @@ module EjemploDeAlgoritmo =
|
||||
// Si la lista está vacía
|
||||
| [] ->
|
||||
[] // devolvemos una lista vacía
|
||||
// si la lista no está vacía
|
||||
// si la lista no está vacía
|
||||
| primerElemento::otrosElementos -> // tomamos el primer elemento
|
||||
let elementosMasPequenios = // extraemos los elementos más pequeños
|
||||
otrosElementos // tomamos el resto
|
||||
@ -487,9 +487,9 @@ module EjemploDeAlgoritmo =
|
||||
module AsyncExample =
|
||||
|
||||
// F# incluye características para ayudar con el código asíncrono
|
||||
// sin conocer la "pirámide del destino"
|
||||
//
|
||||
// El siguiente ejemplo descarga una secuencia de página web en paralelo.
|
||||
// sin conocer la "pirámide del destino"
|
||||
//
|
||||
// El siguiente ejemplo descarga una secuencia de página web en paralelo.
|
||||
|
||||
open System.Net
|
||||
open System
|
||||
@ -531,9 +531,9 @@ module AsyncExample =
|
||||
module EjemploCompatibilidadNet =
|
||||
|
||||
// F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
|
||||
// perfectamente con bibliotecas .NET o Mono.
|
||||
// perfectamente con bibliotecas .NET o Mono.
|
||||
|
||||
// ------- Trabaja con las funciones de las bibliotecas existentes -------
|
||||
// ------- Trabaja con las funciones de las bibliotecas existentes -------
|
||||
|
||||
let (i1success,i1) = System.Int32.TryParse("123");
|
||||
if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida"
|
||||
@ -559,7 +559,7 @@ module EjemploCompatibilidadNet =
|
||||
// ------- Código orientado a objetos -------
|
||||
|
||||
// F# es también un verdadero lenguaje OO.
|
||||
// Admite clases, herencia, métodos virtuales, etc.
|
||||
// Admite clases, herencia, métodos virtuales, etc.
|
||||
|
||||
// interfaz de tipo genérico
|
||||
type IEnumerator<'a> =
|
||||
|
||||
256
es/hy.md
256
es/hy.md
@ -6,162 +6,162 @@ translators:
|
||||
- ["Roberto R", "https://github.com/rrodriguze"]
|
||||
---
|
||||
|
||||
Hy es un lenguaje de Lisp escrito sobre Python. Esto es posible convirtiendo
|
||||
código Hy en un árbol abstracto de Python (ast). Por lo que, esto permite a
|
||||
Hy llamar a código Python nativo y viceversa.
|
||||
Hy es un lenguaje de Lisp escrito sobre Python. Esto es posible convirtiendo
|
||||
código Hy en un árbol abstracto de Python (ast). Por lo que, esto permite a
|
||||
Hy llamar a código Python nativo y viceversa.
|
||||
|
||||
```hylang
|
||||
;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace
|
||||
;; https://hylang.org/try-hy
|
||||
;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace
|
||||
;; https://hylang.org/try-hy
|
||||
;;
|
||||
; Comentarios usando punto y coma, como en otros Lisps
|
||||
; Comentarios usando punto y coma, como en otros Lisps
|
||||
|
||||
;; Nociones básicas de expresiones
|
||||
; Los programas List están hechos de expresiones simbólicas como la siguiente
|
||||
(some-function args)
|
||||
; ahora el esencial "Hola Mundo"
|
||||
(print "hello world")
|
||||
;; Nociones básicas de expresiones
|
||||
; Los programas List están hechos de expresiones simbólicas como la siguiente
|
||||
(some-function args)
|
||||
; ahora el esencial "Hola Mundo"
|
||||
(print "hello world")
|
||||
|
||||
;; Tipos de datos simples
|
||||
; Todos los tipos de datos simples son exactamente semejantes a sus homólogos
|
||||
; en Python
|
||||
42 ; => 42
|
||||
3.14 ; => 3.14
|
||||
True ; => True
|
||||
4+10j ; => (4+10j) un número complejo
|
||||
;; Tipos de datos simples
|
||||
; Todos los tipos de datos simples son exactamente semejantes a sus homólogos
|
||||
; en Python
|
||||
42 ; => 42
|
||||
3.14 ; => 3.14
|
||||
True ; => True
|
||||
4+10j ; => (4+10j) un número complejo
|
||||
|
||||
; Vamos a comenzar con un poco de arimética simple
|
||||
(+ 4 1) ;=> 5
|
||||
; el operador es aplicado a todos los argumentos, como en otros Lisps
|
||||
(+ 4 1 2 3) ;=> 10
|
||||
(- 2 1) ;=> 1
|
||||
(* 4 2) ;=> 8
|
||||
(/ 4 1) ;=> 4
|
||||
(% 4 2) ;=> 0 o operador módulo
|
||||
; la exponenciación es representada por el operador ** como Python
|
||||
(** 3 2) ;=> 9
|
||||
; las funciones anidadas funcionan como lo esperado
|
||||
(+ 2 (* 4 2)) ;=> 10
|
||||
; también los operadores lógicos igual o no igual se comportan como se espera
|
||||
(= 5 4) ;=> False
|
||||
(not (= 5 4)) ;=> True
|
||||
; Vamos a comenzar con un poco de arimética simple
|
||||
(+ 4 1) ;=> 5
|
||||
; el operador es aplicado a todos los argumentos, como en otros Lisps
|
||||
(+ 4 1 2 3) ;=> 10
|
||||
(- 2 1) ;=> 1
|
||||
(* 4 2) ;=> 8
|
||||
(/ 4 1) ;=> 4
|
||||
(% 4 2) ;=> 0 o operador módulo
|
||||
; la exponenciación es representada por el operador ** como Python
|
||||
(** 3 2) ;=> 9
|
||||
; las funciones anidadas funcionan como lo esperado
|
||||
(+ 2 (* 4 2)) ;=> 10
|
||||
; también los operadores lógicos igual o no igual se comportan como se espera
|
||||
(= 5 4) ;=> False
|
||||
(not (= 5 4)) ;=> True
|
||||
|
||||
;; variables
|
||||
; las variables se configuran usando SETV, los nombres de las variables pueden
|
||||
; usar utf-8, excepto for ()[]{}",'`;#|
|
||||
(setv a 42)
|
||||
(setv π 3.14159)
|
||||
(def *foo* 42)
|
||||
;; otros tipos de datos de almacenamiento
|
||||
; strings, lists, tuples & dicts
|
||||
; estos son exactamente los mismos tipos de almacenamiento en Python
|
||||
"hello world" ;=> "hello world"
|
||||
; las operaciones de cadena funcionan de manera similar en Python
|
||||
(+ "hello " "world") ;=> "hello world"
|
||||
; Las listas se crean usando [], la indexación comienza en 0
|
||||
(setv mylist [1 2 3 4])
|
||||
; las tuplas son estructuras de datos inmutables
|
||||
(setv mytuple (, 1 2))
|
||||
; los diccionarios son pares de valor-clave
|
||||
(setv dict1 {"key1" 42 "key2" 21})
|
||||
; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves
|
||||
(setv dict2 {:key1 41 :key2 20})
|
||||
; usar 'get' para obtener un elemento en un índice/key
|
||||
(get mylist 1) ;=> 2
|
||||
(get dict1 "key1") ;=> 42
|
||||
; Alternativamente, si se usan palabras clave que podrían llamarse directamente
|
||||
(:key1 dict2) ;=> 41
|
||||
;; variables
|
||||
; las variables se configuran usando SETV, los nombres de las variables pueden
|
||||
; usar utf-8, excepto for ()[]{}",'`;#|
|
||||
(setv a 42)
|
||||
(setv π 3.14159)
|
||||
(def *foo* 42)
|
||||
;; otros tipos de datos de almacenamiento
|
||||
; strings, lists, tuples & dicts
|
||||
; estos son exactamente los mismos tipos de almacenamiento en Python
|
||||
"hello world" ;=> "hello world"
|
||||
; las operaciones de cadena funcionan de manera similar en Python
|
||||
(+ "hello " "world") ;=> "hello world"
|
||||
; Las listas se crean usando [], la indexación comienza en 0
|
||||
(setv mylist [1 2 3 4])
|
||||
; las tuplas son estructuras de datos inmutables
|
||||
(setv mytuple (, 1 2))
|
||||
; los diccionarios son pares de valor-clave
|
||||
(setv dict1 {"key1" 42 "key2" 21})
|
||||
; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves
|
||||
(setv dict2 {:key1 41 :key2 20})
|
||||
; usar 'get' para obtener un elemento en un índice/key
|
||||
(get mylist 1) ;=> 2
|
||||
(get dict1 "key1") ;=> 42
|
||||
; Alternativamente, si se usan palabras clave que podrían llamarse directamente
|
||||
(:key1 dict2) ;=> 41
|
||||
|
||||
;; funciones y otras estructuras de programa
|
||||
; las funciones son definidas usando defn, o el último sexp se devuelve por defecto
|
||||
(defn greet [name]
|
||||
"A simple greeting" ; un docstring opcional
|
||||
(print "hello " name))
|
||||
;; funciones y otras estructuras de programa
|
||||
; las funciones son definidas usando defn, o el último sexp se devuelve por defecto
|
||||
(defn greet [name]
|
||||
"A simple greeting" ; un docstring opcional
|
||||
(print "hello " name))
|
||||
|
||||
(greet "bilbo") ;=> "hello bilbo"
|
||||
(greet "bilbo") ;=> "hello bilbo"
|
||||
|
||||
; las funciones pueden tener argumentos opcionales, así como argumentos-clave
|
||||
(defn foolists [arg1 &optional [arg2 2]]
|
||||
[arg1 arg2])
|
||||
; las funciones pueden tener argumentos opcionales, así como argumentos-clave
|
||||
(defn foolists [arg1 &optional [arg2 2]]
|
||||
[arg1 arg2])
|
||||
|
||||
(foolists 3) ;=> [3 2]
|
||||
(foolists 10 3) ;=> [10 3]
|
||||
(foolists 3) ;=> [3 2]
|
||||
(foolists 10 3) ;=> [10 3]
|
||||
|
||||
; las funciones anonimas son creadas usando constructores 'fn' y 'lambda'
|
||||
; que son similares a 'defn'
|
||||
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
|
||||
; las funciones anonimas son creadas usando constructores 'fn' y 'lambda'
|
||||
; que son similares a 'defn'
|
||||
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
|
||||
|
||||
;; operaciones de secuencia
|
||||
; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc.
|
||||
; recuperar el primer elemento usando 'first' o 'car'
|
||||
(setv mylist [1 2 3 4])
|
||||
(setv mydict {"a" 1 "b" 2})
|
||||
(first mylist) ;=> 1
|
||||
;; operaciones de secuencia
|
||||
; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc.
|
||||
; recuperar el primer elemento usando 'first' o 'car'
|
||||
(setv mylist [1 2 3 4])
|
||||
(setv mydict {"a" 1 "b" 2})
|
||||
(first mylist) ;=> 1
|
||||
|
||||
; corte listas usando 'cut'
|
||||
(cut mylist 1 3) ;=> [2 3]
|
||||
; corte listas usando 'cut'
|
||||
(cut mylist 1 3) ;=> [2 3]
|
||||
|
||||
; obtener elementos de una lista o dict usando 'get'
|
||||
(get mylist 1) ;=> 2
|
||||
(get mydict "b") ;=> 2
|
||||
; la lista de indexación comienza a partir de 0, igual que en Python
|
||||
; assoc puede definir elementos clave/índice
|
||||
(assoc mylist 2 10) ; crear mylist [1 2 10 4]
|
||||
(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3}
|
||||
; hay muchas otras funciones que hacen que trabajar con secuencias sea
|
||||
; entretenido
|
||||
; obtener elementos de una lista o dict usando 'get'
|
||||
(get mylist 1) ;=> 2
|
||||
(get mydict "b") ;=> 2
|
||||
; la lista de indexación comienza a partir de 0, igual que en Python
|
||||
; assoc puede definir elementos clave/índice
|
||||
(assoc mylist 2 10) ; crear mylist [1 2 10 4]
|
||||
(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3}
|
||||
; hay muchas otras funciones que hacen que trabajar con secuencias sea
|
||||
; entretenido
|
||||
|
||||
;; Python interop
|
||||
;; los import funcionan exactamente como en Python
|
||||
(import datetime)
|
||||
(import functools [partial reduce]) ; importa fun1 e fun2 del module1
|
||||
(import matplotlib.pyplot :as plt) ; haciendo una importación en foo como en bar
|
||||
; todos los métodos de Python incluídos etc. son accesibles desde Hy
|
||||
; a.foo(arg) is called as (.foo a arg)
|
||||
(.split (.strip "hello world ")) ;=> ["hello" "world"]
|
||||
;; Python interop
|
||||
;; los import funcionan exactamente como en Python
|
||||
(import datetime)
|
||||
(import functools [partial reduce]) ; importa fun1 e fun2 del module1
|
||||
(import matplotlib.pyplot :as plt) ; haciendo una importación en foo como en bar
|
||||
; todos los métodos de Python incluídos etc. son accesibles desde Hy
|
||||
; a.foo(arg) is called as (.foo a arg)
|
||||
(.split (.strip "hello world ")) ;=> ["hello" "world"]
|
||||
|
||||
;; Condicionales
|
||||
; (if condition (body-if-true) (body-if-false)
|
||||
(if (= passcode "moria")
|
||||
(print "welcome")
|
||||
(print "Speak friend, and Enter!"))
|
||||
;; Condicionales
|
||||
; (if condition (body-if-true) (body-if-false)
|
||||
(if (= passcode "moria")
|
||||
(print "welcome")
|
||||
(print "Speak friend, and Enter!"))
|
||||
|
||||
; anidar múltiples cláusulas 'if else if' con condiciones
|
||||
; anidar múltiples cláusulas 'if else if' con condiciones
|
||||
(cond
|
||||
(= someval 42) (print "Life, universe and everything else!")
|
||||
(> someval 42) (print "val too large")
|
||||
(< someval 42) (print "val too small"))
|
||||
(= someval 42) (print "Life, universe and everything else!")
|
||||
(> someval 42) (print "val too large")
|
||||
(< someval 42) (print "val too small"))
|
||||
|
||||
; declaraciones de grupo con 'do', son ejecutadas secuencialmente
|
||||
; formas como defn tienen un 'do' implícito
|
||||
; declaraciones de grupo con 'do', son ejecutadas secuencialmente
|
||||
; formas como defn tienen un 'do' implícito
|
||||
(do
|
||||
(setv someval 10)
|
||||
(print "someval is set to " someval)) ;=> 10
|
||||
(setv someval 10)
|
||||
(print "someval is set to " someval)) ;=> 10
|
||||
|
||||
; crear enlaces léxicos con 'let', todas las variables definidas de esta manera
|
||||
; tienen alcance local
|
||||
(let [[nemesis {"superman" "lex luther"
|
||||
"sherlock" "moriarty"
|
||||
"seinfeld" "newman"}]]
|
||||
(for [(, h v) (.items nemesis)]
|
||||
(print (.format "{0}'s nemesis was {1}" h v))))
|
||||
; crear enlaces léxicos con 'let', todas las variables definidas de esta manera
|
||||
; tienen alcance local
|
||||
(let [[nemesis {"superman" "lex luther"
|
||||
"sherlock" "moriarty"
|
||||
"seinfeld" "newman"}]]
|
||||
(for [(, h v) (.items nemesis)]
|
||||
(print (.format "{0}'s nemesis was {1}" h v))))
|
||||
|
||||
;; clases
|
||||
; las clases son definidas de la siguiente manera
|
||||
;; clases
|
||||
; las clases son definidas de la siguiente manera
|
||||
(defclass Wizard [object]
|
||||
(defn __init__ [self spell]
|
||||
(setv self.spell spell))
|
||||
(defn __init__ [self spell]
|
||||
(setv self.spell spell))
|
||||
|
||||
(defn get-spell [self]
|
||||
self.spell))
|
||||
(defn get-spell [self]
|
||||
self.spell))
|
||||
```
|
||||
|
||||
### Otras lecturas
|
||||
### Otras lecturas
|
||||
|
||||
Este tutorial apenas es una introducción básica para Hy/Lisp/Python.
|
||||
Este tutorial apenas es una introducción básica para Hy/Lisp/Python.
|
||||
|
||||
Docs Hy: [https://hylang.org/hy/doc](https://hylang.org/hy/doc)
|
||||
Docs Hy: [https://hylang.org/hy/doc](https://hylang.org/hy/doc)
|
||||
|
||||
Repo Hy en GitHub: [https://github.com/hylang/hy](https://github.com/hylang/hy)
|
||||
Repo Hy en GitHub: [https://github.com/hylang/hy](https://github.com/hylang/hy)
|
||||
|
||||
Acceso a freenode irc con #hy, hashtag en twitter: #hylang
|
||||
Acceso a freenode irc con #hy, hashtag en twitter: #hylang
|
||||
|
||||
10
es/kotlin.md
10
es/kotlin.md
@ -36,7 +36,7 @@ fun main(args: Array<String>) {
|
||||
/*
|
||||
En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable,
|
||||
de tal manera que no tenemos que especificarlo explícitamente cada vez.
|
||||
Podemos declarar explícitamente el tipo de una variable así:
|
||||
Podemos declarar explícitamente el tipo de una variable así:
|
||||
*/
|
||||
val foo: Int = 7
|
||||
|
||||
@ -59,7 +59,7 @@ fun main(args: Array<String>) {
|
||||
|
||||
/*
|
||||
Una cadena está delimitada por comillas triple (""").
|
||||
Estas cadenas pueden contener saltos de línea y otros caracteres.
|
||||
Estas cadenas pueden contener saltos de línea y otros caracteres.
|
||||
*/
|
||||
val fooRawString = """
|
||||
fun helloWorld(val name : String) {
|
||||
@ -70,7 +70,7 @@ fun main(args: Array<String>) {
|
||||
|
||||
/*
|
||||
Las cadenas pueden contener interpolación de cadenas.
|
||||
La interpolación de cadenas comienza con un signo de dólar ($).
|
||||
La interpolación de cadenas comienza con un signo de dólar ($).
|
||||
*/
|
||||
val fooTemplateString = "$fooString tiene ${fooString.length} caracteres"
|
||||
println(fooTemplateString)
|
||||
@ -78,8 +78,8 @@ fun main(args: Array<String>) {
|
||||
/*
|
||||
Para que una variable pueda aceptar valor nulo se debe especificar
|
||||
explícitamente como anulable añadiendole ? a su tipo.
|
||||
Podemos acceder a una variable anulable mediante el uso del operador ?.
|
||||
Podemos utilizar el operador ?: para especificar un valor alternativo
|
||||
Podemos acceder a una variable anulable mediante el uso del operador ?.
|
||||
Podemos utilizar el operador ?: para especificar un valor alternativo
|
||||
a usar si una variable es nula.
|
||||
*/
|
||||
var fooNullable: String? = "abc"
|
||||
|
||||
@ -131,6 +131,6 @@ Manipular[y^2, {y, 0, 20}] (* Devuelve una interfaz de usuario reactiva que mues
|
||||
Sólo funciona en interfaces gráficas *)
|
||||
```
|
||||
|
||||
##Listo para mas?
|
||||
## Listo para mas?
|
||||
|
||||
* [Centro de Documentación](http://reference.wolfram.com/language/)
|
||||
|
||||
@ -175,6 +175,6 @@ name get-global . ! "Bob"
|
||||
[ 2 + ] \ - suffix ! Quotation [ 2 + - ]
|
||||
```
|
||||
|
||||
##Ready For More?
|
||||
## Further reading
|
||||
|
||||
* [Factor Documentation](http://docs.factorcode.org/content/article-help.home.html)
|
||||
|
||||
2
forth.md
2
forth.md
@ -218,7 +218,7 @@ page
|
||||
\ bye
|
||||
```
|
||||
|
||||
##Ready For More?
|
||||
## Further reading
|
||||
|
||||
* [Starting Forth](http://www.forth.com/starting-forth/)
|
||||
* [Simple Forth](http://www.murphywong.net/hello/simple.htm)
|
||||
|
||||
@ -746,8 +746,8 @@ bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
|
||||
|
||||
// Suppose que chaque fonction retourne faux si elle échoue
|
||||
if (!faireQuelqueChoseAvecLeFichier(fh)) {
|
||||
fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
|
||||
return false; // Propage l'erreur
|
||||
fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
|
||||
return false; // Propage l'erreur
|
||||
}
|
||||
if (!faireAutreChoseAvec(fh)) {
|
||||
fclose(fh);
|
||||
|
||||
@ -93,7 +93,7 @@ fruits = <[ apple orange pear ]>
|
||||
fruits[0] # => "apple"
|
||||
|
||||
# Les objets sont une collection non ordonnées de paires clé/valeur, et
|
||||
# d'autres choses (que nous verrons plus tard).
|
||||
# d'autres choses (que nous verrons plus tard).
|
||||
person =
|
||||
name: "Christina"
|
||||
likes:
|
||||
@ -101,7 +101,7 @@ person =
|
||||
* "and other cute stuff"
|
||||
|
||||
# A nouveau, vous pouvez utiliser une expression plus consise à l'aide des
|
||||
# accolades:
|
||||
# accolades:
|
||||
person = {name: "Christina", likes: ["kittens", "and other cute stuff"]}
|
||||
|
||||
# Vous pouvez récupérer une entrée via sa clé:
|
||||
@ -113,7 +113,7 @@ person["name"] # => "Christina"
|
||||
trailing-space = /\s$/ # les mots-composés deviennent motscomposés
|
||||
|
||||
# A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs
|
||||
# lignes!
|
||||
# lignes!
|
||||
# (les commentaires et les espaces seront ignorés)
|
||||
funRE = //
|
||||
function\s+(.+) # nom
|
||||
@ -135,9 +135,9 @@ funRE = //
|
||||
|
||||
|
||||
# Les comparaisons sont presque identiques, à l'exception que `==` équivaut au
|
||||
# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la
|
||||
# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
|
||||
# (sans conversion de type)
|
||||
# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la
|
||||
# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
|
||||
# (sans conversion de type)
|
||||
2 == 2 # => true
|
||||
2 == "2" # => false
|
||||
2 ~= "2" # => true
|
||||
@ -169,8 +169,8 @@ not false # => true
|
||||
########################################################################
|
||||
|
||||
# Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en
|
||||
# charge des fonctions. En LiveScript, il est encore plus évident que les
|
||||
# fonctions sont de premier ordre:
|
||||
# charge des fonctions. En LiveScript, il est encore plus évident que les
|
||||
# fonctions sont de premier ordre:
|
||||
add = (left, right) -> left + right
|
||||
add 1, 2 # => 3
|
||||
|
||||
@ -181,7 +181,7 @@ two!
|
||||
|
||||
# LiveScript utilise l'environnement de la fonction, comme JavaScript.
|
||||
# A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de
|
||||
# déclaration, et il déclarera toujours la variable située à gauche (sauf si
|
||||
# déclaration, et il déclarera toujours la variable située à gauche (sauf si
|
||||
# la variable a été déclarée dans l'environnement parent).
|
||||
|
||||
# L'opérateur `:=` est disponible pour réutiliser un nom provenant de
|
||||
@ -189,18 +189,18 @@ two!
|
||||
|
||||
|
||||
# Vous pouvez extraire les arguments d'une fonction pour récupérer
|
||||
# rapidement les valeurs qui vous intéressent dans une structure de données
|
||||
# rapidement les valeurs qui vous intéressent dans une structure de données
|
||||
# complexe:
|
||||
tail = ([head, ...rest]) -> rest
|
||||
tail [1, 2, 3] # => [2, 3]
|
||||
|
||||
# Vous pouvez également transformer les arguments en utilisant les opérateurs
|
||||
# binaires et unaires. Définir des arguments par défaut est aussi possible.
|
||||
# binaires et unaires. Définir des arguments par défaut est aussi possible.
|
||||
foo = (a = 1, b = 2) -> a + b
|
||||
foo! # => 3
|
||||
|
||||
# You pouvez utiliser cela pour cloner un argument en particulier pour éviter
|
||||
# les effets secondaires. Par exemple:
|
||||
# les effets secondaires. Par exemple:
|
||||
copy = (^^target, source) ->
|
||||
for k,v of source => target[k] = v
|
||||
target
|
||||
@ -220,12 +220,12 @@ identity = -> it
|
||||
identity 1 # => 1
|
||||
|
||||
# Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez
|
||||
# facilement les transformer en fonction:
|
||||
# facilement les transformer en fonction:
|
||||
divide-by-two = (/ 2)
|
||||
[2, 4, 8, 16].map(divide-by-two).reduce (+)
|
||||
|
||||
# Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions
|
||||
# composées d'autres fonctions:
|
||||
# composées d'autres fonctions:
|
||||
double-minus-one = (- 1) . (* 2)
|
||||
|
||||
# En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>`
|
||||
@ -235,7 +235,7 @@ double-minus-one = (- 1) << (* 2)
|
||||
|
||||
|
||||
# Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs
|
||||
# `|>` et `<|`:
|
||||
# `|>` et `<|`:
|
||||
map = (f, xs) --> xs.map f
|
||||
[1 2 3] |> map (* 2) # => [2 4 6]
|
||||
|
||||
@ -248,15 +248,15 @@ reduce = (f, xs, initial) --> xs.reduce f, initial
|
||||
[1 2 3] |> reduce (+), _, 0 # => 6
|
||||
|
||||
|
||||
# Le tiret bas est également utilisé pour l'application partielle,
|
||||
# que vous pouvez utiliser pour toute fonction:
|
||||
# Le tiret bas est également utilisé pour l'application partielle,
|
||||
# que vous pouvez utiliser pour toute fonction:
|
||||
div = (left, right) -> left / right
|
||||
div-by-two = div _, 2
|
||||
div-by-two 4 # => 2
|
||||
|
||||
|
||||
# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel.
|
||||
# (mais vous devriez essayer des approches plus fonctionnelles, comme
|
||||
# (mais vous devriez essayer des approches plus fonctionnelles, comme
|
||||
# Promises).
|
||||
# Un fonction de rappel est une fonction qui est passée en argument à une autre
|
||||
# fonction:
|
||||
@ -289,7 +289,7 @@ x = switch
|
||||
| otherwise => \object # `otherwise` et `_` correspondent.
|
||||
|
||||
# Le corps des fonctions, les déclarations et les assignements disposent d'un
|
||||
# `switch` implicite, donc vous n'avez pas besoin de le réécrire:
|
||||
# `switch` implicite, donc vous n'avez pas besoin de le réécrire:
|
||||
take = (n, [x, ...xs]) -->
|
||||
| n == 0 => []
|
||||
| _ => [x] ++ take (n - 1), xs
|
||||
@ -300,14 +300,14 @@ take = (n, [x, ...xs]) -->
|
||||
########################################################################
|
||||
|
||||
# Comme en python, vous allez pouvoir utiliser les listes en compréhension,
|
||||
# ce qui permet de générer rapidement et de manière élégante une liste de
|
||||
# valeurs:
|
||||
# ce qui permet de générer rapidement et de manière élégante une liste de
|
||||
# valeurs:
|
||||
oneToTwenty = [1 to 20]
|
||||
evens = [x for x in oneToTwenty when x % 2 == 0]
|
||||
|
||||
# `when` et `unless` peuvent être utilisés comme des filtres.
|
||||
|
||||
# Cette technique fonctionne sur les objets de la même manière. Vous allez
|
||||
# Cette technique fonctionne sur les objets de la même manière. Vous allez
|
||||
# pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante:
|
||||
copy = { [k, v] for k, v of source }
|
||||
|
||||
@ -317,8 +317,8 @@ copy = { [k, v] for k, v of source }
|
||||
########################################################################
|
||||
|
||||
# Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants
|
||||
# outils pour la programmation objet. La syntaxe de déclaration d'une classe
|
||||
# est héritée de CoffeeScript:
|
||||
# outils pour la programmation objet. La syntaxe de déclaration d'une classe
|
||||
# est héritée de CoffeeScript:
|
||||
class Animal
|
||||
(@name, kind) ->
|
||||
@kind = kind
|
||||
@ -332,7 +332,7 @@ kitten = new Cat 'Mei'
|
||||
kitten.purr! # => "*Mei (a cat) purrs*"
|
||||
|
||||
# En plus de l'héritage classique, vous pouvez utiliser autant de mixins
|
||||
# que vous voulez pour votre classe. Les mixins sont juste des objets:
|
||||
# que vous voulez pour votre classe. Les mixins sont juste des objets:
|
||||
Huggable =
|
||||
hug: -> @action 'is hugged'
|
||||
|
||||
|
||||
@ -56,7 +56,7 @@ PCRE fournit des types de caractères génériques, également appelés classes
|
||||
\V tout sauf un caractère d'espace vertical blanc
|
||||
\w tout caractère pouvant former un mot (lettre, chiffre, underscore)
|
||||
\W tout sauf un caractère pouvant former un mot (lettre, chiffre, underscore)
|
||||
``
|
||||
```
|
||||
|
||||
## Exemples
|
||||
|
||||
@ -78,4 +78,5 @@ Il s'agit d'un log d'accès Apache standard.
|
||||
| `\+[0-9]+` | +1000 | `\+` correspond au caractère `+` littéralement. `[0-9]` classe de caractère, faisant correspondre un seul chiffre. La même chose peut être obtenu en utilisant `\+\d+` |
|
||||
|
||||
## Lectures complémentaires
|
||||
|
||||
[Regex101](https://regex101.com/) - Regular Expression tester et debugger
|
||||
|
||||
@ -416,7 +416,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d'
|
||||
(values i (number->string i)))
|
||||
; => '#hash((1 . "1") (2 . "2") (3 . "3"))
|
||||
|
||||
;; Il y a plein d'autres fonctions natives pour collecter des données à
|
||||
;; Il y a plein d'autres fonctions natives pour collecter des données à
|
||||
;; l'aide de boucles
|
||||
(for/sum ([i 10]) (* i i)) ; => 285
|
||||
(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000
|
||||
|
||||
376
fr/rust.md
376
fr/rust.md
@ -35,271 +35,271 @@ Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts
|
||||
// Les fonctions
|
||||
// `I32` est le type 32 bits entiers signés
|
||||
fn add2(x: i32, y: i32) -> i32 {
|
||||
// Retour implicite (pas de point virgule)
|
||||
x + y
|
||||
// Retour implicite (pas de point virgule)
|
||||
x + y
|
||||
}
|
||||
|
||||
// Fonction principale
|
||||
fn main() {
|
||||
// Nombres //
|
||||
// Nombres //
|
||||
|
||||
// Liaison immutable
|
||||
let x: i32 = 1;
|
||||
// Liaison immutable
|
||||
let x: i32 = 1;
|
||||
|
||||
// Suffixes entiers et flottants
|
||||
let y: I32 = 13i32;
|
||||
let f: f64 = 1.3f64;
|
||||
// Suffixes entiers et flottants
|
||||
let y: I32 = 13i32;
|
||||
let f: f64 = 1.3f64;
|
||||
|
||||
// Inférence de type
|
||||
// La plupart du temps, le compilateur Rust peut déduire quel est le type
|
||||
// Inférence de type
|
||||
// La plupart du temps, le compilateur Rust peut déduire quel est le type
|
||||
// de variable, donc vous n'avez pas à écrire une annotation de type explicite.
|
||||
// Tout au long de ce tutoriel, les types sont explicitement annotées dans
|
||||
// Tout au long de ce tutoriel, les types sont explicitement annotées dans
|
||||
// de nombreux endroits, mais seulement à des fins de démonstration.
|
||||
// L'inférence de type peut les générer pour vous la plupart du temps.
|
||||
let implicit_x = 1;
|
||||
let implicit_f = 1,3;
|
||||
let implicit_x = 1;
|
||||
let implicit_f = 1,3;
|
||||
|
||||
// Arithmétique
|
||||
let somme = x + y + 13;
|
||||
// Arithmétique
|
||||
let somme = x + y + 13;
|
||||
|
||||
// Variable Mutable
|
||||
let mut mutable = 1;
|
||||
let mutable = 4;
|
||||
let mutable += 2;
|
||||
// Variable Mutable
|
||||
let mut mutable = 1;
|
||||
let mutable = 4;
|
||||
let mutable += 2;
|
||||
|
||||
// Chaînes //
|
||||
// Chaînes //
|
||||
|
||||
// Chaîne littérales
|
||||
let x: &str = "Bonjour tout le monde !";
|
||||
// Chaîne littérales
|
||||
let x: &str = "Bonjour tout le monde !";
|
||||
|
||||
// Affichage
|
||||
println!("{} {}", f, x); // 1.3 Bonjour tout le monde
|
||||
// Affichage
|
||||
println!("{} {}", f, x); // 1.3 Bonjour tout le monde
|
||||
|
||||
// Une `Chaîne` - une chaîne de tas alloué
|
||||
let s: String = "Bonjour tout le monde".to_string();
|
||||
// Une `Chaîne` - une chaîne de tas alloué
|
||||
let s: String = "Bonjour tout le monde".to_string();
|
||||
|
||||
// Un morceau de chaîne - une vue immutable sur une autre chaîne.
|
||||
// C'est essentiellement un pointeur immutable sur une chaîne - ça ne
|
||||
// contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
|
||||
// le début et la fin de la chaîne.
|
||||
let s_slice: &str = &s;
|
||||
// Un morceau de chaîne - une vue immutable sur une autre chaîne.
|
||||
// C'est essentiellement un pointeur immutable sur une chaîne - ça ne
|
||||
// contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
|
||||
// le début et la fin de la chaîne.
|
||||
let s_slice: &str = &s;
|
||||
|
||||
println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
|
||||
println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
|
||||
|
||||
// Vecteurs/tableau //
|
||||
// Vecteurs/tableau //
|
||||
|
||||
// Un tableau de taille fixe
|
||||
let four_ints: [i32; 4] = [1, 2, 3, 4];
|
||||
// Un tableau de taille fixe
|
||||
let four_ints: [i32; 4] = [1, 2, 3, 4];
|
||||
|
||||
// Un tableau dynamique(vecteur)
|
||||
let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
|
||||
vecteur.push(5);
|
||||
// Un tableau dynamique(vecteur)
|
||||
let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
|
||||
vecteur.push(5);
|
||||
|
||||
// Une tranche - une vue immutable sur un vecteur ou un tableau.
|
||||
// Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
|
||||
let tranche: &[i32] = &vecteur;
|
||||
// Une tranche - une vue immutable sur un vecteur ou un tableau.
|
||||
// Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
|
||||
let tranche: &[i32] = &vecteur;
|
||||
|
||||
// Utiliser `{:?}` pour afficher quelque chose en mode debug
|
||||
println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
|
||||
// Utiliser `{:?}` pour afficher quelque chose en mode debug
|
||||
println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
|
||||
|
||||
// Tuples //
|
||||
// Tuples //
|
||||
|
||||
// Un tuple est un ensemble de valeurs qui peuvent être de différents types.
|
||||
let x:(i32, &str, f64) = (1, "bonjour", 3.4);
|
||||
// Un tuple est un ensemble de valeurs qui peuvent être de différents types.
|
||||
let x:(i32, &str, f64) = (1, "bonjour", 3.4);
|
||||
|
||||
// Déstructurer `let`
|
||||
let (a, b, c) = x;
|
||||
println!("{} {} {}", a, b, c); // 1 bonjour 3.4
|
||||
// Déstructurer `let`
|
||||
let (a, b, c) = x;
|
||||
println!("{} {} {}", a, b, c); // 1 bonjour 3.4
|
||||
|
||||
// indexation
|
||||
println!("{}", x.1); // Bonjour
|
||||
// indexation
|
||||
println!("{}", x.1); // Bonjour
|
||||
|
||||
//////////////
|
||||
// 2. Types //
|
||||
//////////////
|
||||
//////////////
|
||||
// 2. Types //
|
||||
//////////////
|
||||
|
||||
// Struct
|
||||
struct Point {
|
||||
x: i32,
|
||||
y: i32,
|
||||
}
|
||||
// Struct
|
||||
struct Point {
|
||||
x: i32,
|
||||
y: i32,
|
||||
}
|
||||
|
||||
let origine: Point = Point { x: 0, y: 0 };
|
||||
let origine: Point = Point { x: 0, y: 0 };
|
||||
|
||||
// Un struct avec des champs sans nom, appelé 'tuple struct'.
|
||||
struct Point2(i32, i32);
|
||||
// Un struct avec des champs sans nom, appelé 'tuple struct'.
|
||||
struct Point2(i32, i32);
|
||||
|
||||
let origine2 = Point2(0, 0);
|
||||
let origine2 = Point2(0, 0);
|
||||
|
||||
// Basic C-like enum
|
||||
enum Direction {
|
||||
Àgauche,
|
||||
Droite,
|
||||
En_Haut,
|
||||
Vers_Le_Bas,
|
||||
}
|
||||
// Basic C-like enum
|
||||
enum Direction {
|
||||
Àgauche,
|
||||
Droite,
|
||||
En_Haut,
|
||||
Vers_Le_Bas,
|
||||
}
|
||||
|
||||
let en_haut = Direction::En_Haut;
|
||||
let en_haut = Direction::En_Haut;
|
||||
|
||||
// Enum avec des champs
|
||||
enum OptionnelI32 {
|
||||
AnI32(I32),
|
||||
Rien,
|
||||
}
|
||||
// Enum avec des champs
|
||||
enum OptionnelI32 {
|
||||
AnI32(I32),
|
||||
Rien,
|
||||
}
|
||||
|
||||
let deux: OptionnelI32 = OptionnelI32::AnI32(2);
|
||||
let rien = OptionnelI32::Rien;
|
||||
let deux: OptionnelI32 = OptionnelI32::AnI32(2);
|
||||
let rien = OptionnelI32::Rien;
|
||||
|
||||
// Generics //
|
||||
// Generics //
|
||||
|
||||
struct Foo<T> { bar: T }
|
||||
struct Foo<T> { bar: T }
|
||||
|
||||
// Ceci est défini dans la bibliothèque standard comme `Option`.
|
||||
enum Optionnel<T> {
|
||||
SomeVal(T),
|
||||
NoVal,
|
||||
}
|
||||
// Ceci est défini dans la bibliothèque standard comme `Option`.
|
||||
enum Optionnel<T> {
|
||||
SomeVal(T),
|
||||
NoVal,
|
||||
}
|
||||
|
||||
// Méthodes //
|
||||
// Méthodes //
|
||||
|
||||
impl<T> Foo<T> {
|
||||
// Méthodes prennent un paramètre explicite `de self`.
|
||||
fn get_bar(self) -> T {
|
||||
self.bar
|
||||
}
|
||||
}
|
||||
impl<T> Foo<T> {
|
||||
// Méthodes prennent un paramètre explicite `de self`.
|
||||
fn get_bar(self) -> T {
|
||||
self.bar
|
||||
}
|
||||
}
|
||||
|
||||
let a_foo = Foo { bar: 1 };
|
||||
println!("{}", a_foo.get_bar()); // 1
|
||||
let a_foo = Foo { bar: 1 };
|
||||
println!("{}", a_foo.get_bar()); // 1
|
||||
|
||||
// Traits (connu sous le nom des interfaces ou des classes de types dans
|
||||
// Traits (connu sous le nom des interfaces ou des classes de types dans
|
||||
// d'autres langues).
|
||||
|
||||
trait Frobnicate<T> {
|
||||
fn frobnicate(self) -> Option<T>;
|
||||
}
|
||||
trait Frobnicate<T> {
|
||||
fn frobnicate(self) -> Option<T>;
|
||||
}
|
||||
|
||||
impl<T> Frobnicate<T> for Foo<T> {
|
||||
fn frobnicate(self) -> Option<T> {
|
||||
Some(self.bar)
|
||||
}
|
||||
}
|
||||
impl<T> Frobnicate<T> for Foo<T> {
|
||||
fn frobnicate(self) -> Option<T> {
|
||||
Some(self.bar)
|
||||
}
|
||||
}
|
||||
|
||||
let another_foo = Foo { bar: 1 };
|
||||
println!("{:?}", another_foo.frobnicate()); // Some(1)
|
||||
let another_foo = Foo { bar: 1 };
|
||||
println!("{:?}", another_foo.frobnicate()); // Some(1)
|
||||
|
||||
/////////////////////////
|
||||
// 3. Motif correspondant //
|
||||
/////////////////////////
|
||||
/////////////////////////
|
||||
// 3. Motif correspondant //
|
||||
/////////////////////////
|
||||
|
||||
let foo = OptionnelI32::AnI32(1);
|
||||
match foo {
|
||||
OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
|
||||
OptionnelI32::Rien => println!("Il n'y a rien!"),
|
||||
}
|
||||
let foo = OptionnelI32::AnI32(1);
|
||||
match foo {
|
||||
OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
|
||||
OptionnelI32::Rien => println!("Il n'y a rien!"),
|
||||
}
|
||||
|
||||
// Motif avancé correspondant
|
||||
struct FooBar { x: i32, y: OptionnelI32 }
|
||||
let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
|
||||
// Motif avancé correspondant
|
||||
struct FooBar { x: i32, y: OptionnelI32 }
|
||||
let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
|
||||
|
||||
match bar {
|
||||
FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
|
||||
println!("Les chiffres sont nuls!"),
|
||||
FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
|
||||
println!("Les chiffres sont les mêmes"),
|
||||
FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
|
||||
println!("Différents numéros: {} {}", n, m)!,
|
||||
FooBar { x: _, y: OptionnelI32 :: Rien} =>
|
||||
println!("Le deuxième numéro est rien!"),
|
||||
}
|
||||
match bar {
|
||||
FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
|
||||
println!("Les chiffres sont nuls!"),
|
||||
FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
|
||||
println!("Les chiffres sont les mêmes"),
|
||||
FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
|
||||
println!("Différents numéros: {} {}", n, m)!,
|
||||
FooBar { x: _, y: OptionnelI32 :: Rien} =>
|
||||
println!("Le deuxième numéro est rien!"),
|
||||
}
|
||||
|
||||
/////////////////////
|
||||
// 4. Flux de contrôle //
|
||||
/////////////////////
|
||||
/////////////////////
|
||||
// 4. Flux de contrôle //
|
||||
/////////////////////
|
||||
|
||||
// `for` boucles / itération
|
||||
let array = [1, 2, 3];
|
||||
for i in array {
|
||||
println!("{}", i);
|
||||
}
|
||||
// `for` boucles / itération
|
||||
let array = [1, 2, 3];
|
||||
for i in array {
|
||||
println!("{}", i);
|
||||
}
|
||||
|
||||
// Ranges
|
||||
for i in 0u32..10 {
|
||||
print!("{}", i);
|
||||
}
|
||||
println!("");
|
||||
// imprime `0 1 2 3 4 5 6 7 8 9`
|
||||
// Ranges
|
||||
for i in 0u32..10 {
|
||||
print!("{}", i);
|
||||
}
|
||||
println!("");
|
||||
// imprime `0 1 2 3 4 5 6 7 8 9`
|
||||
|
||||
// `if`
|
||||
if 1 == 1 {
|
||||
println!("Maths est travaille!");
|
||||
} else {
|
||||
println!("Oh non ...!");
|
||||
}
|
||||
// `if`
|
||||
if 1 == 1 {
|
||||
println!("Maths est travaille!");
|
||||
} else {
|
||||
println!("Oh non ...!");
|
||||
}
|
||||
|
||||
// `if` comme expression
|
||||
let valeur = if true {
|
||||
"bien"
|
||||
} else {
|
||||
"mal"
|
||||
};
|
||||
// `if` comme expression
|
||||
let valeur = if true {
|
||||
"bien"
|
||||
} else {
|
||||
"mal"
|
||||
};
|
||||
|
||||
// `while` boucle
|
||||
while 1 == 1 {
|
||||
println!("L'univers fonctionne normalement.");
|
||||
}
|
||||
// `while` boucle
|
||||
while 1 == 1 {
|
||||
println!("L'univers fonctionne normalement.");
|
||||
}
|
||||
|
||||
// Boucle infinie
|
||||
loop {
|
||||
println!("Bonjour!");
|
||||
}
|
||||
// Boucle infinie
|
||||
loop {
|
||||
println!("Bonjour!");
|
||||
}
|
||||
|
||||
/////////////////////////////////
|
||||
// 5. Sécurité & pointeurs mémoire //
|
||||
/////////////////////////////////
|
||||
/////////////////////////////////
|
||||
// 5. Sécurité & pointeurs mémoire //
|
||||
/////////////////////////////////
|
||||
|
||||
// Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.
|
||||
// Cela signifie que lorsque le `Box` laisse son champ d'application, il
|
||||
// Cela signifie que lorsque le `Box` laisse son champ d'application, il
|
||||
// peut être automatiquement libérée en toute sécurité.
|
||||
let mut mine: Box<i32> = Box::new(3);
|
||||
*mine = 5; // déréférencer
|
||||
// Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
|
||||
let mut mine: Box<i32> = Box::new(3);
|
||||
*mine = 5; // déréférencer
|
||||
// Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
|
||||
// `mine` est déplacé.
|
||||
let mut now_its_mine = mine;
|
||||
*now_its_mine += 2;
|
||||
let mut now_its_mine = mine;
|
||||
*now_its_mine += 2;
|
||||
|
||||
println!("{}", now_its_mine); // 7
|
||||
// println!("{}", now_its_mine); // Cela ne compile pas parce
|
||||
println!("{}", now_its_mine); // 7
|
||||
// println!("{}", now_its_mine); // Cela ne compile pas parce
|
||||
// que `now_its_mine` possède maintenant le pointeur
|
||||
|
||||
// Référence - un pointeur immutable qui fait référence à d'autres données.
|
||||
// Quand une référence est prise à une valeur, nous disons que la valeur
|
||||
// Référence - un pointeur immutable qui fait référence à d'autres données.
|
||||
// Quand une référence est prise à une valeur, nous disons que la valeur
|
||||
// a été "emprunté".
|
||||
// Même si une valeur est emprunté immutablement, il ne peut pas être
|
||||
// Même si une valeur est emprunté immutablement, il ne peut pas être
|
||||
// muté ou déplacé.
|
||||
// Un emprunt dure jusqu'à la fin de la portée, il a été créé.
|
||||
let mut var = 4;
|
||||
var = 3;
|
||||
let ref_var: &i32 = &var;
|
||||
// Un emprunt dure jusqu'à la fin de la portée, il a été créé.
|
||||
let mut var = 4;
|
||||
var = 3;
|
||||
let ref_var: &i32 = &var;
|
||||
|
||||
println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
|
||||
println!("{}", *ref_var);
|
||||
// Var = 5; // Cela ne compile pas parce que `var` est emprunté.
|
||||
// *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
|
||||
println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
|
||||
println!("{}", *ref_var);
|
||||
// Var = 5; // Cela ne compile pas parce que `var` est emprunté.
|
||||
// *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
|
||||
// référence immutable.
|
||||
|
||||
// Référence Mutable
|
||||
// Même si une valeur est empruntée de façon mutable, elle ne peut pas être
|
||||
// Référence Mutable
|
||||
// Même si une valeur est empruntée de façon mutable, elle ne peut pas être
|
||||
// accessible à tous.
|
||||
let mut var2 = 4;
|
||||
let ref_var2: &mut i32 = &mut var2;
|
||||
let mut var2 = 4;
|
||||
let ref_var2: &mut i32 = &mut var2;
|
||||
// '*' est utilisé pour pointer vers le var2 mutably emprunté.
|
||||
*ref_var2 += 2;
|
||||
|
||||
println!("{}", * ref_var2); // 6, // var2 ne compilerait pas.
|
||||
// ref_var2 est de type &mut i32 donc stocke la référence à i32,
|
||||
// ref_var2 est de type &mut i32 donc stocke la référence à i32,
|
||||
// pas la valeur.
|
||||
// var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
|
||||
// var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
14
fr/xml.md
14
fr/xml.md
@ -41,10 +41,10 @@ Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les inf
|
||||
Il commence par une déclaration, qui informe certaines métadonnées (en option).
|
||||
|
||||
XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a
|
||||
trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
|
||||
trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
|
||||
|
||||
On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre
|
||||
les balises d'ouverture et de fermeture. -->
|
||||
les balises d'ouverture et de fermeture. -->
|
||||
|
||||
|
||||
<!-- XML porte deux types d'informations:
|
||||
@ -72,7 +72,7 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
|
||||
|
||||
```xml
|
||||
<!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie,
|
||||
avec l'addition de définition DTD. -->
|
||||
avec l'addition de définition DTD. -->
|
||||
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE note SYSTEM "Librairie.dtd">
|
||||
@ -95,10 +95,10 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
|
||||
]>
|
||||
|
||||
<!-- La DTD commence par une déclaration.
|
||||
Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants.
|
||||
Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut
|
||||
appelé «catégorie», avec «littérature» comme valeur par défaut.
|
||||
Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
|
||||
Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants.
|
||||
Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut
|
||||
appelé «catégorie», avec «littérature» comme valeur par défaut.
|
||||
Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
|
||||
(Anglais: «parsed character data») -->
|
||||
|
||||
<!-- La DTD pourrait être déclarée dans le fichier XML lui-même -->
|
||||
|
||||
12
he/html.md
12
he/html.md
@ -151,14 +151,8 @@ HTML קיצור של Hypertext Markup Language כלומר זוהי שפה שמש
|
||||
</table>
|
||||
```
|
||||
|
||||
## שימוש
|
||||
|
||||
HTML נכתב בקבצים המסתיימים ב-`.html` או `.htm`.
|
||||
|
||||
**HTML אינה שפת תכנות**
|
||||
|
||||
## לקריאה נוספת
|
||||
|
||||
- [Wikipedia](https://he.wikipedia.org/wiki/HTML)
|
||||
- [HTML Tutorial (EN)](https://developer.mozilla.org/en-US/docs/Web/HTML)
|
||||
- [W3Schools (EN)](http://www.w3schools.com/html/html_intro.asp)
|
||||
- [Wikipedia](https://he.wikipedia.org/wiki/HTML)
|
||||
- [HTML Tutorial (EN)](https://developer.mozilla.org/en-US/docs/Web/HTML)
|
||||
- [W3Schools (EN)](http://www.w3schools.com/html/html_intro.asp)
|
||||
|
||||
@ -1049,7 +1049,7 @@ for(auto elem: arr) {
|
||||
// मजेदार चीजें
|
||||
/////////////////////
|
||||
|
||||
// सी ++ के पहलू जो नवागंतुकों (और यहां तक कि कुछ दिग्गजों) के लिए आश्चर्यजनक हो सकते हैं।
|
||||
// सी ++ के पहलू जो नवागंतुकों (और यहां तक कि कुछ दिग्गजों) के लिए आश्चर्यजनक हो सकते हैं।
|
||||
// यह खंड, दुर्भाग्य से, बेतहाशा अधूरा है; सी ++ सबसे आसान में से एक है
|
||||
// भाषाएं जिनके साथ अपने आप को पैर में गोली मारनी है।
|
||||
|
||||
|
||||
2
hi/d.md
2
hi/d.md
@ -107,7 +107,7 @@ T max(T)(T a, T b) {
|
||||
return a;
|
||||
}
|
||||
|
||||
// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक कि 'A' और 'B' , तो है
|
||||
// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक कि 'A' और 'B' , तो है
|
||||
//मान प्रकार वे हमेशा ' swap()' के संदर्भ द्वारा पारित हो जाएगा हैं ।
|
||||
void swap(T)(ref T a, ref T b) {
|
||||
auto temp = a;
|
||||
|
||||
@ -28,7 +28,7 @@ print "halo"
|
||||
|
||||
REM Struktur kontrol
|
||||
FOR index = 0 TO 10 STEP 2
|
||||
? "Ini adalah nomor baris"; indeks
|
||||
? "Ini adalah nomor baris"; indeks
|
||||
NEXT
|
||||
J=0
|
||||
REPEAT
|
||||
@ -57,10 +57,10 @@ End Try
|
||||
|
||||
REM Fungsi dan subrutin buatan pengguna
|
||||
func add2(x, y)
|
||||
'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
|
||||
local k
|
||||
k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
|
||||
add2 = x + y
|
||||
'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
|
||||
local k
|
||||
k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
|
||||
add2 = x + y
|
||||
akhir
|
||||
Print add2(5,5)
|
||||
sub cetak_ini(ini)
|
||||
|
||||
30
id/xml.md
30
id/xml.md
@ -95,23 +95,23 @@ Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan pengura
|
||||
</tokobuku>
|
||||
|
||||
<!-- Di atas adalah contoh file XML biasa.
|
||||
Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
|
||||
|
||||
XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
|
||||
Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
|
||||
|
||||
XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
|
||||
yang memiliki tiga node anak, para 'buku'. Node-node tersebut dapat memiliki
|
||||
node-node anak, dan seterusnya ...
|
||||
|
||||
Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
|
||||
|
||||
Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
|
||||
berada di antara tag buka dan tutup .-->
|
||||
|
||||
|
||||
<!-- XML membawa dua jenis data:
|
||||
1 - Atribut -> Itu metadata tentang sebuah node.
|
||||
Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
|
||||
1 - Atribut -> Itu metadata tentang sebuah node.
|
||||
Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
|
||||
benar. Hal ini ditandai dengan muncul dengan format nama = "nilai" dalam pembukaan tag.
|
||||
2 - Elemen -> Itu data yang murni.
|
||||
Itulah yang parser akan mengambil dari file XML.
|
||||
Elemen muncul antara tag membuka dan menutup.-->
|
||||
2 - Elemen -> Itu data yang murni.
|
||||
Itulah yang parser akan mengambil dari file XML.
|
||||
Elemen muncul antara tag membuka dan menutup.-->
|
||||
|
||||
|
||||
<!-- Di bawah ini, unsur dengan dua atribut-->
|
||||
@ -131,7 +131,7 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
|
||||
|
||||
```xml
|
||||
<!-- Di bawah, Anda dapat melihat versi sederhana dari dokumen tokobuku,
|
||||
dengan penambahan definisi DTD .-->
|
||||
dengan penambahan definisi DTD .-->
|
||||
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE catatan SYSTEM "tokobuku.dtd">
|
||||
@ -155,10 +155,10 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
|
||||
|
||||
|
||||
<!-- DTD dimulai dengan deklarasi.
|
||||
Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
|
||||
Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
|
||||
disebut 'kategori', dengan "Sastra" sebagai nilai default.
|
||||
Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
|
||||
Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
|
||||
Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
|
||||
disebut 'kategori', dengan "Sastra" sebagai nilai default.
|
||||
Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
|
||||
|
||||
<!-- DTD dapat dideklarasikan di dalam file XML itu sendiri .-->
|
||||
|
||||
|
||||
@ -57,13 +57,13 @@ Le liste sono semplici come in Markdown:
|
||||
|
||||
- primo articolo
|
||||
- Secondo elemento
|
||||
- Sottoelemento
|
||||
- Sottoelemento
|
||||
|
||||
oppure
|
||||
|
||||
* Primo elemento
|
||||
* Secondo elemento
|
||||
* Sottoelemento
|
||||
* Sottoelemento
|
||||
|
||||
Le tabelle sono molto semplici da inserire:
|
||||
|
||||
|
||||
@ -93,7 +93,7 @@ Le implementazioni Ruby possono avere una propria versione, ma hanno sempre come
|
||||
target una specifica versione di MRI. Molte implementazioni hanno l'abilità di
|
||||
selezionare una versione specifica di MRI.
|
||||
|
||||
##Ruby Spec
|
||||
## Ruby Spec
|
||||
|
||||
La maggior parte delle implementazioni Ruby dipendono pesantemente su
|
||||
[Ruby Spec](https://github.com/ruby/spec). Ruby non ha una specifica ufficiale, quindi la
|
||||
|
||||
@ -171,7 +171,6 @@ Vimの操作は「動詞・修飾子・名詞」形式のコマンドとして
|
||||
|
||||
## いくつかのショートカットと小技
|
||||
|
||||
<!--TODO: Add more!-->
|
||||
```
|
||||
> # 選択部を1ブロックインデント
|
||||
< # 選択部を1ブロックデインデント
|
||||
|
||||
8
julia.md
8
julia.md
@ -94,8 +94,8 @@ false
|
||||
'a'
|
||||
|
||||
# Strings are UTF8 encoded, so strings like "π" or "☃" are not directly equivalent
|
||||
# to an array of single characters.
|
||||
# Only if they contain only ASCII characters can they be safely indexed.
|
||||
# to an array of single characters.
|
||||
# Only if they contain only ASCII characters can they be safely indexed.
|
||||
ascii("This is a string")[1] # => 'T'
|
||||
# => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
|
||||
# Beware, Julia indexes everything from 1 (like MATLAB), not 0 (like most languages).
|
||||
@ -114,7 +114,7 @@ ascii("This is a string")[1] # => 'T'
|
||||
println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you!
|
||||
|
||||
# Another way to format strings is the printf macro from the stdlib Printf.
|
||||
using Printf # this is how you load (or import) a module
|
||||
using Printf # this is how you load (or import) a module
|
||||
@printf "%d is less than %f\n" 4.5 5.3 # => 5 is less than 5.300000
|
||||
|
||||
|
||||
@ -392,7 +392,7 @@ end
|
||||
for animal = ["dog", "cat", "mouse"]
|
||||
println("$animal is a mammal")
|
||||
# You can use $ to interpolate variables or expression into strings.
|
||||
# In this special case, no need for parenthesis: $animal and $(animal) give the same
|
||||
# In this special case, no need for parenthesis: $animal and $(animal) give the same
|
||||
end
|
||||
# => dog is a mammal
|
||||
# => cat is a mammal
|
||||
|
||||
@ -163,7 +163,6 @@ Vim의 명령어는 '서술어-수식어-목적어'로 생각할 수 있습니
|
||||
|
||||
## 몇 가지 트릭
|
||||
|
||||
<!--TODO: Add more!-->
|
||||
```
|
||||
> # 선택한 영역 한 칸 들여쓰기
|
||||
< # 선택한 영역 한 칸 내어쓰기
|
||||
|
||||
2
latex.md
2
latex.md
@ -202,7 +202,7 @@ We can also insert Tables in the same way as figures.
|
||||
% the {} arguments below describe how each row of the table is drawn.
|
||||
% The basics are simple: one letter for each column, to control alignment:
|
||||
% basic options are: c, l, r and p for centered, left, right and paragraph
|
||||
% optionally, you can add a | for a vertical line
|
||||
% optionally, you can add a | for a vertical line
|
||||
% See https://en.wikibooks.org/wiki/LaTeX/Tables for more details
|
||||
\begin{tabular}{c|cc} % here it means "centered | vertical line, centered centered"
|
||||
Number & First Name & Last Name \\ % Column rows are separated by &
|
||||
|
||||
105
linker.md
105
linker.md
@ -1,34 +1,31 @@
|
||||
---
|
||||
category: tool
|
||||
name: GNU linker (ld)
|
||||
name: Linker script
|
||||
contributors:
|
||||
- ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
|
||||
translators:
|
||||
- ["Anuj Shah", "https://github.com/ShahAnuj2610"]
|
||||
filename: learn.ld
|
||||
---
|
||||
|
||||
## Basic concepts and definitions
|
||||
|
||||
**Position counter** - the linker has a special variable
|
||||
"." (dot) always contains the current output position.
|
||||
"`.`" (dot) always contains the current output position.
|
||||
|
||||
## Functions
|
||||
|
||||
**ADDR (section)** - returns the absolute address of the specified section. However
|
||||
`ADDR (section)` - returns the absolute address of the specified section. However
|
||||
this section must be defined before using the ADDR function.
|
||||
|
||||
**ALIGN (exp)** - returns the value of the position counter aligned to the border
|
||||
`ALIGN (exp)` - returns the value of the position counter aligned to the border
|
||||
following the exp expression.
|
||||
|
||||
**SIZEOF (section)** - returns the size of the section in bytes.
|
||||
`SIZEOF (section)` - returns the size of the section in bytes.
|
||||
|
||||
**FILL (param)** - defines the fill pattern for the current section. All
|
||||
`FILL (param)` - defines the fill pattern for the current section. All
|
||||
other unspecified regions within the section are filled with the value indicated
|
||||
in function argument.
|
||||
|
||||
**KEEP (param)** - used to mark param as fatal.
|
||||
`KEEP (param)` - used to mark param as fatal.
|
||||
|
||||
**ENTRY (func)** - defines the function that will be the entry point
|
||||
`ENTRY (func)` - defines the function that will be the entry point
|
||||
into the program.
|
||||
|
||||
```bash
|
||||
@ -45,7 +42,7 @@ _Min_Stack_Size = 0x400;
|
||||
# Description of the memory card available for this processor
|
||||
# MEMORY
|
||||
# {
|
||||
#MEMORY_DOMAIN_NAME (access rights): ORIGIN = START_ADDRESS, LENGTH = SIZE
|
||||
# MEMORY_DOMAIN_NAME (access rights) : ORIGIN = START_ADDRESS, LENGTH = SIZE
|
||||
# }
|
||||
# In our example, the controller contains three memory areas:
|
||||
# RAM - starts with the address 0x20000000 and takes 128 KB;
|
||||
@ -56,33 +53,33 @@ _Min_Stack_Size = 0x400;
|
||||
# FLASH memory is available for reading and execution.
|
||||
MEMORY
|
||||
{
|
||||
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
|
||||
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
|
||||
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
|
||||
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
|
||||
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
|
||||
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
|
||||
}
|
||||
|
||||
# We describe output sections
|
||||
SECTIONS
|
||||
{
|
||||
# The first section contains a table of interrupt vectors
|
||||
# The first section contains a table of interrupt vectors
|
||||
.isr_vector :
|
||||
{
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# There is an option --gc-sections, which allows you to collect garbage from unused
|
||||
# input sections. And if there are sections that the garbage collector should not touch,
|
||||
# you need to specify them as an argument to the KEEP () function (analogue of the keyword
|
||||
# volatile).
|
||||
# The entry (* (. Isr_vector)) means the .isr_vector sections in all object files. Because
|
||||
# appeal to the section in general terms looks like this: (FILE_NAME (SECTION_NAME))
|
||||
# There is an option --gc-sections, which allows you to collect garbage from unused
|
||||
# input sections. And if there are sections that the garbage collector should not touch,
|
||||
# you need to specify them as an argument to the KEEP () function (analogue of the keyword
|
||||
# volatile).
|
||||
# The entry (* (. Isr_vector)) means the .isr_vector sections in all object files. Because
|
||||
# appeal to the section in general terms looks like this: (FILE_NAME (SECTION_NAME))
|
||||
KEEP(*(.isr_vector))
|
||||
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# The expression "> MEMORY AREA" indicates which area of memory will be placed
|
||||
# this section. In our section, the .isr_vector section will be located in FLASH memory.
|
||||
# The expression "> MEMORY AREA" indicates which area of memory will be placed
|
||||
# this section. In our section, the .isr_vector section will be located in FLASH memory.
|
||||
} >FLASH
|
||||
|
||||
# TOTAL: The .isr_vector section that contains the table of interrupt vectors is aligned
|
||||
@ -92,24 +89,24 @@ SECTIONS
|
||||
# The second section contains the program code.
|
||||
.text :
|
||||
{
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# We indicate that in this section the .text areas of all
|
||||
# object files
|
||||
# object files
|
||||
*(.text)
|
||||
*(.text*)
|
||||
|
||||
# Protect the .init and .fini sections from the garbage collector
|
||||
# Protect the .init and .fini sections from the garbage collector
|
||||
KEEP (*(.init))
|
||||
KEEP (*(.fini))
|
||||
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# The variable _etext is defined, which stores the address of the end of the .text section and which
|
||||
# may be available in the source code of the program through the announcement
|
||||
# volaile unsigned int extern _etext;
|
||||
# The variable _etext is defined, which stores the address of the end of the .text section and which
|
||||
# may be available in the source code of the program through the announcement
|
||||
# volaile unsigned int extern _etext;
|
||||
_etext = .;
|
||||
} >FLASH
|
||||
|
||||
@ -123,15 +120,15 @@ SECTIONS
|
||||
# The third section contains constant data.
|
||||
.rodata :
|
||||
{
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# We indicate that in this section areas .rodata will be stored
|
||||
# object files
|
||||
# We indicate that in this section areas .rodata will be stored
|
||||
# object files
|
||||
*(.rodata)
|
||||
*(.rodata*)
|
||||
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
} >FLASH
|
||||
|
||||
@ -141,47 +138,47 @@ SECTIONS
|
||||
# The fourth section contains initialized variables.
|
||||
.data :
|
||||
{
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Save the address of the current position (beginning of the section) in the variable _sdata
|
||||
# Save the address of the current position (beginning of the section) in the variable _sdata
|
||||
_sdata = .;
|
||||
|
||||
# We indicate that in this section the .data areas of all
|
||||
# object files
|
||||
# We indicate that in this section the .data areas of all
|
||||
# object files
|
||||
*(.data)
|
||||
*(.data*)
|
||||
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Save the address of the current position (end of section) in the variable _sdata
|
||||
_edata = .;
|
||||
|
||||
# AT function indicates that this sector is stored in one memory area
|
||||
# (in our case, FLASH), and it will be executed from another area of memory (in our case, RAM).
|
||||
# There are two types of addresses:
|
||||
# * VMA (Virtual memory address) - this is the run-time address at which the compiler expects
|
||||
# see data.
|
||||
# * LMA (Load memory address) is the address at which the linker stores data.
|
||||
# AT function indicates that this sector is stored in one memory area
|
||||
# (in our case, FLASH), and it will be executed from another area of memory (in our case, RAM).
|
||||
# There are two types of addresses:
|
||||
# * VMA (Virtual memory address) - this is the run-time address at which the compiler expects
|
||||
# see data.
|
||||
# * LMA (Load memory address) is the address at which the linker stores data.
|
||||
|
||||
#Startup must code to copy the .data section from the LMA addresses to the VMA addresses.
|
||||
#Startup must code to copy the .data section from the LMA addresses to the VMA addresses.
|
||||
|
||||
} >RAM AT> FLASH
|
||||
|
||||
# The fifth section contains zero-initialized variables.
|
||||
.bss :
|
||||
{
|
||||
# Save the address of the current position (beginning of the section) in the variable _sbss and __bss_start__
|
||||
# Save the address of the current position (beginning of the section) in the variable _sbss and __bss_start__
|
||||
_sbss = .;
|
||||
__bss_start__ = _sbss;
|
||||
|
||||
# We indicate that in this section the .bss areas of all
|
||||
# object files
|
||||
# We indicate that in this section the .bss areas of all
|
||||
# object files
|
||||
*(.bss)
|
||||
*(.bss*)
|
||||
|
||||
# Align the current position to the border of 4 bytes.
|
||||
# Align the current position to the border of 4 bytes.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Save the address of the current position (beginning of the section) in the variable _ebss and __bss_end__
|
||||
|
||||
@ -181,5 +181,5 @@ KTHXBYE
|
||||
|
||||
## Further reading:
|
||||
|
||||
- [LCI compiler](https://github.com/justinmeza/lci)
|
||||
- [Official spec](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md)
|
||||
- [LCI compiler](https://github.com/justinmeza/lci)
|
||||
- [Official spec](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md)
|
||||
|
||||
2
mips.md
2
mips.md
@ -244,7 +244,7 @@ gateways and routers.
|
||||
## FUNCTIONS ##
|
||||
_functions:
|
||||
# Functions are callable procedures that can accept arguments and return
|
||||
# values all denoted with labels, like above
|
||||
# values all denoted with labels, like above
|
||||
|
||||
main: # Programs begin with main func
|
||||
jal return_1 # jal will store the current PC in $ra
|
||||
|
||||
@ -119,7 +119,7 @@ public class LearnJava {
|
||||
|
||||
// Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość>
|
||||
int barInt = 1;
|
||||
// Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
|
||||
// Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
|
||||
// rodzaj <nazwa1>, <nazwa2>, <nazwa3>
|
||||
// <nazwa1> = <nazwa2> = <nazwa3> = <wartość>
|
||||
int barInt1, barInt2, barInt3;
|
||||
|
||||
@ -147,7 +147,6 @@ Kilka ważnych przykładów Akcji, Modyfikatorów i Obiektów:
|
||||
|
||||
## Pewne skróty i triki
|
||||
|
||||
<!--TODO: Dodać więcej!-->
|
||||
```
|
||||
> # Zrób wcięcie zaznaczonego bloku
|
||||
< # Usuń wcięcie zaznaczonego bloku
|
||||
|
||||
@ -334,6 +334,6 @@ safe(Group) :- memberchk(joker, Group) -> memberchk(batman, Group) ; true.
|
||||
?- maplist(plus(1), [2,3,4], Output). % Output = [3, 4, 5].
|
||||
```
|
||||
|
||||
##Ready For More?
|
||||
## Further reading
|
||||
|
||||
* [SWI-Prolog](http://www.swi-prolog.org/)
|
||||
|
||||
@ -106,7 +106,7 @@ namespace Learning.CSharp
|
||||
char fooChar = 'A';
|
||||
|
||||
// Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
|
||||
// Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
|
||||
// Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
|
||||
string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
|
||||
Console.WriteLine(fooString);
|
||||
|
||||
@ -732,9 +732,9 @@ on a new line! ""Wow!"", the masses cried";
|
||||
}
|
||||
|
||||
// Você também pode definir uma propriedade automática em uma linha
|
||||
// Esta sintaxe criará um campo de apoio automaticamente.
|
||||
// Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
|
||||
// para restringir seu acesso:
|
||||
// Esta sintaxe criará um campo de apoio automaticamente.
|
||||
// Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
|
||||
// para restringir seu acesso:
|
||||
public bool IsBroken { get; private set; }
|
||||
|
||||
// Properties can be auto-implemented
|
||||
@ -856,7 +856,7 @@ on a new line! ""Wow!"", the masses cried";
|
||||
|
||||
/// <summary>
|
||||
/// Exemplo de como conectar-se ao DB via LinqToSql.
|
||||
/// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
|
||||
/// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
|
||||
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
|
||||
/// </summary>
|
||||
public class BikeRepository : DbContext
|
||||
|
||||
@ -71,7 +71,7 @@ Você pode encadear vários relacionamentos. Este path descreve o amigo de um am
|
||||
`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
|
||||
Uma encadeamento também pode ser direcionada. Este path descreve que **a** é o chefe de **b** e o grande chefe de **c**.
|
||||
|
||||
Padrões frequentemente usados (do Neo4j doc):
|
||||
Padrões frequentemente usados (do Neo4j doc):
|
||||
|
||||
```cypher
|
||||
// Amigo de um amigo
|
||||
|
||||
@ -125,14 +125,14 @@ f [ . ] when* ! Nenhuma saída, pilha vazia, f é consumida porque é falsa
|
||||
|
||||
! Variáveis
|
||||
! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha.
|
||||
! Usar variáveis nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
|
||||
! Variáveis globais, se você precisar:
|
||||
! Usar variáveis nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
|
||||
! Variáveis globais, se você precisar:
|
||||
|
||||
SYMBOL: name ! Cria o nome como uma palavra identificadora
|
||||
"Bob" name set-global ! Sem saída
|
||||
name get-global . ! "Bob"
|
||||
|
||||
! Variáveis locais nomeadas são consideradas uma extensão, mas estão disponíveis
|
||||
! Variáveis locais nomeadas são consideradas uma extensão, mas estão disponíveis
|
||||
! Em uma citação ..
|
||||
[| m n ! A citação captura os dois principais valores da pilha em m e n
|
||||
| m n + ] ! Leia-os
|
||||
@ -143,10 +143,10 @@ name get-global . ! "Bob"
|
||||
c . ; ! Imprima isso
|
||||
|
||||
! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha
|
||||
! torna-se significativo e fornece os valores das variáveis em que os valores da pilha são capturados
|
||||
! torna-se significativo e fornece os valores das variáveis em que os valores da pilha são capturados
|
||||
:: double ( a -- result ) a 2 * ;
|
||||
|
||||
! Variáveis são declaradas mutáveis ao terminar seu nome com um ponto de exclamação
|
||||
! Variáveis são declaradas mutáveis ao terminar seu nome com um ponto de exclamação
|
||||
:: mword2 ( a! -- x y ) ! Capture o topo da pilha na variável mutável a
|
||||
a ! Empurrar a
|
||||
a 2 * a! ! Multiplique por 2 e armazene o resultado em a
|
||||
@ -175,6 +175,6 @@ name get-global . ! "Bob"
|
||||
[ 2 + ] \ - suffix ! Quotation [ 2 + - ]
|
||||
```
|
||||
|
||||
##Pronto para mais?
|
||||
## Pronto para mais?
|
||||
|
||||
* [Documentação do Factor](http://docs.factorcode.org/content/article-help.home.html)
|
||||
|
||||
@ -413,7 +413,7 @@ class Velocipede extends Bicicleta {
|
||||
// Exemplo - Comida:
|
||||
public interface Comestivel {
|
||||
public void comer(); // Qualquer classe que implementa essa interface, deve
|
||||
// implementar este método.
|
||||
// implementar este método.
|
||||
}
|
||||
|
||||
public interface Digestivel {
|
||||
@ -483,8 +483,8 @@ public abstract class Animal
|
||||
}
|
||||
|
||||
// Não há necessidade de inicializar, no entanto, em uma interface
|
||||
// a variável é implicitamente final e, portanto, tem
|
||||
// de ser inicializada.
|
||||
// a variável é implicitamente final e, portanto, tem
|
||||
// de ser inicializada.
|
||||
protected int idade;
|
||||
|
||||
public void mostrarIdade()
|
||||
@ -503,7 +503,7 @@ class Cachorro extends Animal
|
||||
{
|
||||
|
||||
// Nota: ainda precisamos substituir os métodos abstratos na
|
||||
// classe abstrata.
|
||||
// classe abstrata.
|
||||
@Override
|
||||
public void fazerSom()
|
||||
{
|
||||
@ -512,10 +512,10 @@ class Cachorro extends Animal
|
||||
}
|
||||
|
||||
// NOTA: Você receberá um erro se usou a
|
||||
// anotação Override aqui, uma vez que java não permite
|
||||
// sobrescrita de métodos estáticos.
|
||||
// O que está acontecendo aqui é chamado de "esconder o método".
|
||||
// Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
|
||||
// anotação Override aqui, uma vez que java não permite
|
||||
// sobrescrita de métodos estáticos.
|
||||
// O que está acontecendo aqui é chamado de "esconder o método".
|
||||
// Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
|
||||
public static void main(String[] args)
|
||||
{
|
||||
Cachorro pluto = new Cachorro();
|
||||
@ -540,7 +540,7 @@ class Cachorro extends Animal
|
||||
public final class TigreDenteDeSabre extends Animal
|
||||
{
|
||||
// Nota: Ainda precisamos substituir os métodos abstratos na
|
||||
// classe abstrata.
|
||||
// classe abstrata.
|
||||
@Override
|
||||
public void fazerSom();
|
||||
{
|
||||
@ -555,7 +555,7 @@ public abstract class Mamifero()
|
||||
// <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
|
||||
|
||||
// Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
|
||||
// e são, portanto, a implementação final do método.
|
||||
// e são, portanto, a implementação final do método.
|
||||
public final boolean EImpulsivo()
|
||||
{
|
||||
return true;
|
||||
|
||||
@ -26,7 +26,7 @@ Less (e outros pré-processadores, como o [Sass](http://sass-lang.com/)) ajudam
|
||||
@secondary-color: #51527f;
|
||||
@body-font: 'Roboto', sans-serif;
|
||||
|
||||
/* Você pode usar as variáveis em toda a sua folha de estilo.
|
||||
/* Você pode usar as variáveis em toda a sua folha de estilo.
|
||||
Agora, se você quiser alterar uma cor, só precisa fazer a alteração uma vez. */
|
||||
|
||||
body {
|
||||
|
||||
@ -31,7 +31,7 @@ Existem muitas variedades de make na existência, no entanto, este artigo pressu
|
||||
# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
|
||||
arquivo0.txt:
|
||||
echo "foo" > arquivo0.txt
|
||||
# Mesmo os comentários nestas seções da 'receita' são passados para o shell.
|
||||
# Mesmo os comentários nestas seções da 'receita' são passados para o shell.
|
||||
# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
|
||||
|
||||
# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
|
||||
@ -74,7 +74,7 @@ ex0.txt ex1.txt: maker
|
||||
# Alvos falsos comuns são: todos fazem instalação limpa ...
|
||||
|
||||
#-----------------------------------------------------------------------
|
||||
# Variáveis Automáticas e Curingas
|
||||
# Variáveis Automáticas e Curingas
|
||||
#-----------------------------------------------------------------------
|
||||
|
||||
process: Arquivo*.txt # Usando um curinga para corresponder nomes de arquivos
|
||||
@ -130,7 +130,7 @@ small/%.png: %.svg
|
||||
#-----------------------------------------------------------------------
|
||||
# aka. macros
|
||||
|
||||
# As variáveis são basicamente todos os tipos de string
|
||||
# As variáveis são basicamente todos os tipos de string
|
||||
|
||||
name = Ted
|
||||
name2="Sarah"
|
||||
@ -139,14 +139,14 @@ echo:
|
||||
@echo $(name)
|
||||
@echo ${name2}
|
||||
@echo $name # Isso não funcionará, tratado como $ (n)ame.
|
||||
@echo $(name3) # Variáveis desconhecidas são tratadas como strings vazias.
|
||||
@echo $(name3) # Variáveis desconhecidas são tratadas como strings vazias.
|
||||
|
||||
# Existem 4 lugares para definir variáveis.
|
||||
# Em ordem de prioridade, do maior para o menor:
|
||||
# 1: argumentos de linha de comando
|
||||
# 2: Makefile
|
||||
# 3: variáveis de ambiente do shell - faça importações automaticamente.
|
||||
# 4: make tem algumas variáveis predefinidas
|
||||
# 3: variáveis de ambiente do shell - faça importações automaticamente.
|
||||
# 4: make tem algumas variáveis predefinidas
|
||||
|
||||
name4 ?= Jean
|
||||
# Somente defina a variável se a variável de ambiente ainda não estiver definida.
|
||||
@ -157,12 +157,12 @@ override name5 = David
|
||||
name4 +=grey
|
||||
# Anexar valores à variável (inclui um espaço).
|
||||
|
||||
# Valores variáveis específicos de padrões (extensão GNU).
|
||||
# Valores variáveis específicos de padrões (extensão GNU).
|
||||
echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
|
||||
# e também dentro de suas recursivas dependências
|
||||
# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
|
||||
|
||||
# Algumas variáveis definidas automaticamente pelo make
|
||||
# Algumas variáveis definidas automaticamente pelo make
|
||||
echo_inbuilt:
|
||||
echo $(CC)
|
||||
echo ${CXX}
|
||||
@ -177,7 +177,7 @@ echo_inbuilt:
|
||||
# Variáveis 2
|
||||
#-----------------------------------------------------------------------
|
||||
|
||||
# O primeiro tipo de variáveis é avaliado a cada vez que elas são usadas.
|
||||
# O primeiro tipo de variáveis é avaliado a cada vez que elas são usadas.
|
||||
# TIsso pode ser caro, então existe um segundo tipo de variável que é
|
||||
# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
|
||||
|
||||
@ -185,7 +185,7 @@ var := hello
|
||||
var2 ::= $(var) hello
|
||||
#:= e ::= são equivalentes.
|
||||
|
||||
# Essas variáveis são avaliadas procedimentalmente (na ordem em que
|
||||
# Essas variáveis são avaliadas procedimentalmente (na ordem em que
|
||||
# aparecem), quebrando assim o resto da línguagem!
|
||||
|
||||
# Isso não funciona
|
||||
|
||||
@ -100,7 +100,7 @@ double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits
|
||||
|
||||
// Existem vários tipos de dados compostos que estão disponíveis por padrão para
|
||||
// uso no Processing.
|
||||
// Primeiramente, farei um resumo dos mais usados para economizar tempo.
|
||||
// Primeiramente, farei um resumo dos mais usados para economizar tempo.
|
||||
|
||||
// String
|
||||
// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas
|
||||
@ -118,7 +118,7 @@ print("Olá " + "Mundo!"); // Olá Mundo!
|
||||
// próprios objetos. Como os arrays são semelhantes aos objetos, eles devem
|
||||
// ser criados com a palavra-chave "new".
|
||||
int[] arrayInt = new int[5];
|
||||
int[] arrayIntComValores = {1, 2, 3}; // Você também pode preencher com dados.
|
||||
int[] arrayIntComValores = {1, 2, 3}; // Você também pode preencher com dados.
|
||||
|
||||
// Lista de Arrays
|
||||
// As funções são semelhantes às do array; arraylists podem conter qualquer
|
||||
@ -192,7 +192,7 @@ if (author.getAppearance().equals("quente")) {
|
||||
// Você pode verificar outras condições aqui.
|
||||
print("Algo está realmente errado aqui!");
|
||||
}
|
||||
// Um atalho para instruções if-else também pode ser usado.
|
||||
// Um atalho para instruções if-else também pode ser usado.
|
||||
int = 3;
|
||||
String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
|
||||
|
||||
|
||||
@ -131,10 +131,10 @@ div {
|
||||
|
||||
|
||||
/* Sass fornece funções que podem ser utilizados para realizar uma variedade de
|
||||
tarefas. Considere o seguinte */
|
||||
tarefas. Considere o seguinte */
|
||||
|
||||
/* Funções pode ser chamado usando seu nome e passando o
|
||||
argumentos necessários */
|
||||
argumentos necessários */
|
||||
|
||||
body {
|
||||
width: round(10.25px);
|
||||
@ -162,7 +162,7 @@ body {
|
||||
reutilizável. */
|
||||
|
||||
/* Esta função terá um tamanho de destino e o tamanho do pai (parent), calcular
|
||||
e voltar a percentagem */
|
||||
e voltar a percentagem */
|
||||
|
||||
@function calculate-percentage($target-size, $parent-size) {
|
||||
@return $target-size / $parent-size * 100%;
|
||||
@ -219,11 +219,11 @@ $main-content: calculate-percentage(600px, 960px);
|
||||
}
|
||||
|
||||
/* Ao ampliar uma declaração CSS é preferível a criação de um mixin,
|
||||
por causa da maneira em que agrupa as classes com todos que compartilham
|
||||
o mesmo estilo base. Se isso for feito com um mixin, a largura,
|
||||
altura, e a borda seria duplicado para cada instrução que
|
||||
o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
|
||||
adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
|
||||
por causa da maneira em que agrupa as classes com todos que compartilham
|
||||
o mesmo estilo base. Se isso for feito com um mixin, a largura,
|
||||
altura, e a borda seria duplicado para cada instrução que
|
||||
o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
|
||||
adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
|
||||
|
||||
|
||||
|
||||
@ -293,8 +293,8 @@ ul li a {
|
||||
|
||||
|
||||
/* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass
|
||||
código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
|
||||
Parciais não são geradas em CSS. */
|
||||
código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
|
||||
Parciais não são geradas em CSS. */
|
||||
|
||||
|
||||
|
||||
@ -309,9 +309,9 @@ ol {
|
||||
}
|
||||
|
||||
/* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
|
||||
Isso difere da declaração CSS @import tradicional, que faz
|
||||
outra solicitação HTTP para buscar o arquivo importado. Sass converte os
|
||||
arquivo importados e combina com o código compilado. */
|
||||
Isso difere da declaração CSS @import tradicional, que faz
|
||||
outra solicitação HTTP para buscar o arquivo importado. Sass converte os
|
||||
arquivo importados e combina com o código compilado. */
|
||||
|
||||
@import 'reset';
|
||||
|
||||
@ -339,9 +339,9 @@ body {
|
||||
|
||||
|
||||
/* Os Placeholders são úteis na criação de uma declaração CSS para ampliar. Se você
|
||||
deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
|
||||
você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
|
||||
de '.' ou '#'. Placeholder não aparece no CSS compilado. */
|
||||
deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
|
||||
você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
|
||||
de '.' ou '#'. Placeholder não aparece no CSS compilado. */
|
||||
|
||||
%content-window {
|
||||
font-size: 14px;
|
||||
@ -375,7 +375,7 @@ body {
|
||||
|
||||
|
||||
/* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
|
||||
ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
|
||||
ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
|
||||
de usar valores que você já calcula manualmente. O exemplo abaixo é
|
||||
de um projeto simples de duas colunas. */
|
||||
|
||||
|
||||
@ -150,7 +150,6 @@ Alguns exemplos importantes de 'Verbos', 'Modificadores' e 'Nomes':
|
||||
|
||||
## Alguns atalhos e dicas
|
||||
|
||||
<!--TODO: Adicionar mais!-->
|
||||
```
|
||||
> # Adiciona um bloco de indentação
|
||||
< # Remove um bloco de indentação
|
||||
|
||||
@ -92,7 +92,7 @@ module Module1
|
||||
Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes"
|
||||
' Variáveis
|
||||
'Os dados inseridos por um usuário precisam ser armazenados.
|
||||
' As variáveis também começar com um Dim e terminar com um Como VariableType.
|
||||
' As variáveis também começar com um Dim e terminar com um Como VariableType.
|
||||
|
||||
' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa
|
||||
' Responder ao que é dito.
|
||||
@ -103,7 +103,7 @@ module Module1
|
||||
Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >".
|
||||
Console.ReadLine () ' Outsputs acima.
|
||||
' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta.
|
||||
" Outras variáveis incluem Integer e usamos inteiro para números inteiros.
|
||||
" Outras variáveis incluem Integer e usamos inteiro para números inteiros.
|
||||
End Sub
|
||||
|
||||
"Três
|
||||
|
||||
2
raku.md
2
raku.md
@ -6,7 +6,7 @@ contributors:
|
||||
- ["Samantha McVey", "https://cry.nu"]
|
||||
---
|
||||
|
||||
Raku (formerly Perl 6) is a highly capable, feature-rich programming language
|
||||
Raku (formerly Perl 6) is a highly capable, feature-rich programming language
|
||||
made for at least the next hundred years.
|
||||
|
||||
The primary Raku compiler is called [Rakudo](http://rakudo.org), which runs on
|
||||
|
||||
6
ru/c.md
6
ru/c.md
@ -33,7 +33,7 @@ translators:
|
||||
void function_1();
|
||||
void function_2();
|
||||
|
||||
// Точка входа в программу – это функция main.
|
||||
// Точка входа в программу – это функция main.
|
||||
int main() {
|
||||
// для форматированного вывода в консоль используется printf
|
||||
// %d – означает, что будем выводить целое число, \n переводит указатель вывода
|
||||
@ -120,7 +120,7 @@ int main() {
|
||||
printf("%d\n", a_string[16]); // => 0
|
||||
// байт #17 тоже равен 0 (а также 18, 19, и 20)
|
||||
|
||||
// Если между одинарными кавычками есть символ – это символьный литерал,
|
||||
// Если между одинарными кавычками есть символ – это символьный литерал,
|
||||
// но это тип int, а не char (по историческим причинам).
|
||||
|
||||
int cha = 'a'; // хорошо
|
||||
@ -325,7 +325,7 @@ int main() {
|
||||
|
||||
// Вы также можете динамически выделять несколько блоков памяти с помощью
|
||||
// функции malloc из стандартной библиотеки, которая принимает один
|
||||
// аргумент типа size_t – количество байт необходимых для выделения.
|
||||
// аргумент типа size_t – количество байт необходимых для выделения.
|
||||
int *my_ptr = malloc(sizeof(*my_ptr) * 20);
|
||||
for (xx = 0; xx < 20; xx++) {
|
||||
*(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
|
||||
|
||||
@ -233,7 +233,7 @@ words
|
||||
bye
|
||||
```
|
||||
|
||||
##Готовы к большему?
|
||||
## Готовы к большему?
|
||||
|
||||
* [Начала Форта (англ.)](http://www.forth.com/starting-forth/)
|
||||
* [Простой Форт (англ.)](http://www.murphywong.net/hello/simple.htm)
|
||||
|
||||
187
ru/linker.md
187
ru/linker.md
@ -1,30 +1,26 @@
|
||||
---
|
||||
contributors:
|
||||
- ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
|
||||
translators:
|
||||
- ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
|
||||
---
|
||||
|
||||
# Основные понятия и определения
|
||||
**Счетчик позиций** - у компоновщика есть специальная переменная
|
||||
"." (точка) всегда содержит текущую позицию вывода.
|
||||
**Счетчик позиций** - у компоновщика есть специальная переменная
|
||||
"`.`" (точка) всегда содержит текущую позицию вывода.
|
||||
|
||||
# Функции
|
||||
**ADDR(section)** - возвращает абсолютный адрес указанной секции. Однако
|
||||
`ADDR(section)` - возвращает абсолютный адрес указанной секции. Однако
|
||||
данная секция должна быть определенна до использования функции ADDR.
|
||||
|
||||
**ALIGN(exp)** - возвращает значение счетчика позиций, выравненное на границу
|
||||
`ALIGN(exp)` - возвращает значение счетчика позиций, выравненное на границу
|
||||
следующего за exp выражения.
|
||||
|
||||
**SIZEOF(section)** - возвращает размер секции в байтах.
|
||||
`SIZEOF(section)` - возвращает размер секции в байтах.
|
||||
|
||||
**FILL(param)** - определяет образец заполнения для текущей секции. Все
|
||||
остальные неуказанные регионы внутри секции заполняются значением указанными
|
||||
`FILL(param)` - определяет образец заполнения для текущей секции. Все
|
||||
остальные неуказанные регионы внутри секции заполняются значением указанными
|
||||
в аргументе функции.
|
||||
|
||||
**KEEP(param)** - используется чтобы помечать param как неустранимый.
|
||||
`KEEP(param)` - используется чтобы помечать param как неустранимый.
|
||||
|
||||
**ENTRY(func)** - определяет функцию, которая будет являться точкой входа
|
||||
`ENTRY(func)` - определяет функцию, которая будет являться точкой входа
|
||||
в программу.
|
||||
|
||||
```bash
|
||||
@ -32,16 +28,16 @@ translators:
|
||||
ENTRY(Reset_Handler)
|
||||
|
||||
# Определяем переменную которая содержит адрес вершины стека
|
||||
_estack = 0x20020000;
|
||||
# Определяем переменную которая содержит значение размера кучи
|
||||
_estack = 0x20020000;
|
||||
# Определяем переменную которая содержит значение размера кучи
|
||||
_Min_Heap_Size = 0x200;
|
||||
# Определяем переменную которая содержит значение размера стека
|
||||
_Min_Stack_Size = 0x400;
|
||||
_Min_Stack_Size = 0x400;
|
||||
|
||||
# Описание карты памяти доступной для данного процессора
|
||||
# MEMORY
|
||||
# {
|
||||
# ИМЯ_ОБЛАСТИ_ПАМЯТИ (права доступа) : ORIGIN = АДРЕС_НАЧАЛА, LENGTH = РАЗМЕР
|
||||
# ИМЯ_ОБЛАСТИ_ПАМЯТИ (права доступа) : ORIGIN = АДРЕС_НАЧАЛА, LENGTH = РАЗМЕР
|
||||
# }
|
||||
# В нашем примере контроллер содержит три области памяти:
|
||||
# RAM - начинается с адреса 0x20000000 и занимает 128 Кбайт;
|
||||
@ -52,136 +48,136 @@ _Min_Stack_Size = 0x400;
|
||||
# FLASH память доступна на чтение и исполнение.
|
||||
MEMORY
|
||||
{
|
||||
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
|
||||
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
|
||||
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
|
||||
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
|
||||
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
|
||||
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
|
||||
}
|
||||
|
||||
# Описываем выходные секции
|
||||
SECTIONS
|
||||
{
|
||||
# Первая секция содержит таблицу векторов прерываний
|
||||
# Первая секция содержит таблицу векторов прерываний
|
||||
.isr_vector :
|
||||
{
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Существует опция --gc-sections, которая позволяет собирать мусор из неиспользуемых
|
||||
# входных разделов. И если есть разделы, которые сборщик мусора не должен трогать,
|
||||
# то их необходимо указать в качестве аргумента функции KEEP() (аналог ключевого слова
|
||||
# volatile).
|
||||
# Запись (*(.isr_vector)) означает разделы .isr_vector во всех объектных файлах. Т.к.
|
||||
# обращение к разделу в общем виде выглядит так: (ИМЯ_ФАЙЛА(ИМЯ_РАЗДЕЛА))
|
||||
KEEP(*(.isr_vector))
|
||||
# Существует опция --gc-sections, которая позволяет собирать мусор из неиспользуемых
|
||||
# входных разделов. И если есть разделы, которые сборщик мусора не должен трогать,
|
||||
# то их необходимо указать в качестве аргумента функции KEEP() (аналог ключевого слова
|
||||
# volatile).
|
||||
# Запись (*(.isr_vector)) означает разделы .isr_vector во всех объектных файлах. Т.к.
|
||||
# обращение к разделу в общем виде выглядит так: (ИМЯ_ФАЙЛА(ИМЯ_РАЗДЕЛА))
|
||||
KEEP(*(.isr_vector))
|
||||
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Выражение ">ОБЛАСТЬ_ПАМЯТИ" указывает в какую именно область памяти будет помещена
|
||||
# данная секция. В нашем случае секция .isr_vector будет размещена во FLASH памяти.
|
||||
|
||||
# Выражение ">ОБЛАСТЬ_ПАМЯТИ" указывает в какую именно область памяти будет помещена
|
||||
# данная секция. В нашем случае секция .isr_vector будет размещена во FLASH памяти.
|
||||
} >FLASH
|
||||
|
||||
# ИТОГО: Секция .isr_vector, которая содержит таблицу векторов прерываний выравнивается
|
||||
# по границе 4-х байт, помечается как недоступная для сборщика мусора и размещается в начале
|
||||
# ИТОГО: Секция .isr_vector, которая содержит таблицу векторов прерываний выравнивается
|
||||
# по границе 4-х байт, помечается как недоступная для сборщика мусора и размещается в начале
|
||||
# FLASH памяти микроконтроллера.
|
||||
|
||||
# Вторая секция содержит код программы.
|
||||
.text :
|
||||
{
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Указываем, что в данной секции будут хранится области .text всех
|
||||
# объектных файлов
|
||||
*(.text)
|
||||
*(.text*)
|
||||
|
||||
# Защищаем от сборщика мусора секции .init и .fini
|
||||
# Указываем, что в данной секции будут хранится области .text всех
|
||||
# объектных файлов
|
||||
*(.text)
|
||||
*(.text*)
|
||||
|
||||
# Защищаем от сборщика мусора секции .init и .fini
|
||||
KEEP (*(.init))
|
||||
KEEP (*(.fini))
|
||||
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Определяется переменная _etext, которая хранит в себе адрес конца секции .text и которая
|
||||
# может быть доступна в исходном тексте программы через объявление
|
||||
# volaile unsigned int extern _etext;
|
||||
_etext = .;
|
||||
|
||||
# Определяется переменная _etext, которая хранит в себе адрес конца секции .text и которая
|
||||
# может быть доступна в исходном тексте программы через объявление
|
||||
# volaile unsigned int extern _etext;
|
||||
_etext = .;
|
||||
} >FLASH
|
||||
|
||||
# ИТОГО: Секция .text, которая содержит код программы выравнивается по границе 4-х байт,
|
||||
# включает в себя: все секции с кодом программы во всех объектных файлах и защищенные
|
||||
от сборщика муссора секции .init и .fini во всех объектных файлах, распологается во FLASH
|
||||
памяти микроконтроллера сразу за таблицей векторов.
|
||||
Секции text, .init и .fini. располагаются в памяти в той последовательности в которой они
|
||||
объявлены в скрипте.
|
||||
|
||||
# ИТОГО: Секция .text, которая содержит код программы выравнивается по границе 4-х байт,
|
||||
# включает в себя: все секции с кодом программы во всех объектных файлах и защищенные
|
||||
# от сборщика муссора секции .init и .fini во всех объектных файлах, распологается во FLASH
|
||||
# памяти микроконтроллера сразу за таблицей векторов.
|
||||
# Секции text, .init и .fini. располагаются в памяти в той последовательности в которой они
|
||||
# объявлены в скрипте.
|
||||
|
||||
# Третья секция содержит константные данные.
|
||||
.rodata :
|
||||
{
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Указываем, что в данной секции будут хранится области .rodata всех
|
||||
# объектных файлов
|
||||
*(.rodata)
|
||||
*(.rodata*)
|
||||
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Указываем, что в данной секции будут хранится области .rodata всех
|
||||
# объектных файлов
|
||||
*(.rodata)
|
||||
*(.rodata*)
|
||||
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
} >FLASH
|
||||
|
||||
# Сохраняем в переменной _sidata абсолютный адрес секции .data
|
||||
|
||||
# Сохраняем в переменной _sidata абсолютный адрес секции .data
|
||||
_sidata = LOADADDR(.data);
|
||||
|
||||
# Четвертая секция содержит инициализированные переменные.
|
||||
.data :
|
||||
.data :
|
||||
{
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
# Сохраняем в переменной _sdata адрес текущей позиции (начала секции)
|
||||
_sdata = .;
|
||||
|
||||
# Указываем, что в данной секции будут хранится области .data всех
|
||||
# объектных файлов
|
||||
*(.data)
|
||||
*(.data*)
|
||||
# Сохраняем в переменной _sdata адрес текущей позиции (начала секции)
|
||||
_sdata = .;
|
||||
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Указываем, что в данной секции будут хранится области .data всех
|
||||
# объектных файлов
|
||||
*(.data)
|
||||
*(.data*)
|
||||
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
|
||||
# Сохраняем в переменной _sdata адрес текущей позиции (конец секции)
|
||||
_edata = .;
|
||||
|
||||
# Функция AT указывает на то, что данный сектор хранится в одной области памяти
|
||||
# (в нашем случае FLASH), а исполняться будет из другой области памяти (в нашем случае RAM).
|
||||
# Есть два типа адресов:
|
||||
# * VMA (Virtual memory address) - это run-time адрес по которому компилятор ожидает
|
||||
# видеть данные.
|
||||
# * LMA (Load memory address) - это адрес по которому линкер хранит данные.
|
||||
|
||||
#Startup должен код скопировать секцию .data из адресов LMA в адреса VMA.
|
||||
|
||||
_edata = .;
|
||||
|
||||
# Функция AT указывает на то, что данный сектор хранится в одной области памяти
|
||||
# (в нашем случае FLASH), а исполняться будет из другой области памяти (в нашем случае RAM).
|
||||
# Есть два типа адресов:
|
||||
# * VMA (Virtual memory address) - это run-time адрес по которому компилятор ожидает
|
||||
# видеть данные.
|
||||
# * LMA (Load memory address) - это адрес по которому линкер хранит данные.
|
||||
|
||||
# Startup должен код скопировать секцию .data из адресов LMA в адреса VMA.
|
||||
|
||||
} >RAM AT> FLASH
|
||||
|
||||
# Пятая секция содержит инициализированные нулем переменные.
|
||||
# Пятая секция содержит инициализированные нулем переменные.
|
||||
.bss :
|
||||
{
|
||||
# Сохраняем в переменной _sbss и __bss_start__ адрес текущей позиции (начала секции)
|
||||
_sbss = .;
|
||||
# Сохраняем в переменной _sbss и __bss_start__ адрес текущей позиции (начала секции)
|
||||
_sbss = .;
|
||||
__bss_start__ = _sbss;
|
||||
|
||||
# Указываем, что в данной секции будут хранится области .bss всех
|
||||
# объектных файлов
|
||||
|
||||
# Указываем, что в данной секции будут хранится области .bss всех
|
||||
# объектных файлов
|
||||
*(.bss)
|
||||
*(.bss*)
|
||||
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
# Выравниваем текущую позицию на границу 4-х байт.
|
||||
. = ALIGN(4);
|
||||
|
||||
|
||||
# Сохраняем в переменной _ebss и __bss_end__ адрес текущей позиции (начала секции)
|
||||
_ebss = .;
|
||||
_ebss = .;
|
||||
__bss_end__ = _ebss;
|
||||
} >RAM
|
||||
|
||||
@ -197,4 +193,3 @@ SECTIONS
|
||||
} >RAM
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@ -150,7 +150,6 @@ Vim можно рассматривать как набор команд в фо
|
||||
|
||||
## Некоторые сокращения и хитрости
|
||||
|
||||
<!--TODO: Add more!-->
|
||||
```
|
||||
> # Сдвинуть выделенное на один отступ вправо
|
||||
< # Сдвинуть выделенное на один отступ влево
|
||||
|
||||
@ -81,8 +81,8 @@ a {
|
||||
|
||||
/*
|
||||
You can store a CSS value (such as the color) of a variable.
|
||||
Although it is optional, it is recommended to add $ before a variable name
|
||||
so you can distinguish a variable from another CSS value.
|
||||
Although it is optional, it is recommended to add $ before a variable name
|
||||
so you can distinguish a variable from another CSS value.
|
||||
*/
|
||||
|
||||
$primary-color = #A3A4FF
|
||||
|
||||
@ -4,8 +4,6 @@ contributors:
|
||||
- ["Seçkin KÜKRER", "https://github.com/LeaveNhA"]
|
||||
---
|
||||
|
||||
# Y = 20 Dakika.
|
||||
|
||||
### Genişletilebilir Veri Notasyonu (EDN, Extensible Data Notation).
|
||||
|
||||
### Okunuşu: (Türkçe: ey-di-en), (English: eed-n)
|
||||
|
||||
@ -17,7 +17,7 @@ PHP 5+ versiyonu için geçerlidir.
|
||||
|
||||
// // işareti ile tek satırlık yorum satırı başlar.
|
||||
|
||||
# # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
|
||||
# # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
|
||||
|
||||
|
||||
|
||||
@ -45,7 +45,7 @@ Hello World Again!
|
||||
* Tipler ve Değişkenler
|
||||
*************************************/
|
||||
|
||||
// Değişkenler $ sembolü ile başlar.
|
||||
// Değişkenler $ sembolü ile başlar.
|
||||
// Geçerli bir değişken bir harf veya alt çizgi ile başlar,
|
||||
// devamında da bir sayı, harf veya alt çizgi ile devam eder.
|
||||
|
||||
|
||||
@ -35,8 +35,8 @@ uygulanabilir. Python 3 için başka bir zaman tekrar bakınız.
|
||||
10 * 2 #=> 20
|
||||
35 / 5 #=> 7
|
||||
|
||||
# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
|
||||
# sonuç otomatik olarak kırpılır.
|
||||
# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
|
||||
# sonuç otomatik olarak kırpılır.
|
||||
5 / 2 #=> 2
|
||||
|
||||
# Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir.
|
||||
@ -80,30 +80,30 @@ not False #=> True
|
||||
"Hello " + "world!" #=> "Hello world!"
|
||||
|
||||
# A string can be treated like a list of characters
|
||||
# Bir string'e karakter listesi gibi davranabilirsiniz.
|
||||
# Bir string'e karakter listesi gibi davranabilirsiniz.
|
||||
"This is a string"[0] #=> 'T'
|
||||
|
||||
# % karakter dizisini(string) formatlamak için kullanılır, bunun gibi:
|
||||
"%s can be %s" % ("strings", "interpolated")
|
||||
|
||||
# String'leri formatlamanın yeni bir yöntem ise format metodudur.
|
||||
# Bu metod tercih edilen yöntemdir.
|
||||
# Bu metod tercih edilen yöntemdir.
|
||||
"{0} can be {1}".format("strings", "formatted")
|
||||
# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
|
||||
# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
|
||||
"{name} wants to eat {food}".format(name="Bob", food="lasagna")
|
||||
|
||||
# None bir objedir
|
||||
None #=> None
|
||||
|
||||
# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
|
||||
# Onun yerine "is" kullanın.
|
||||
# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
|
||||
# Onun yerine "is" kullanın.
|
||||
"etc" is None #=> False
|
||||
None is None #=> True
|
||||
|
||||
# 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler
|
||||
# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
|
||||
# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
|
||||
|
||||
# None, 0 ve boş string/list'ler False olarak değerlendirilir.
|
||||
# None, 0 ve boş string/list'ler False olarak değerlendirilir.
|
||||
# Tüm eşitlikler True döner
|
||||
0 == False #=> True
|
||||
"" == False #=> True
|
||||
@ -122,12 +122,12 @@ some_var = 5 # Değişken isimlerinde gelenek küçük karakter ve alt çizgi
|
||||
# kullanmaktır.
|
||||
some_var #=> 5
|
||||
|
||||
# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye
|
||||
# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla
|
||||
# bilgi için kontrol akışı kısmına göz atınız.
|
||||
# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye
|
||||
# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla
|
||||
# bilgi için kontrol akışı kısmına göz atınız.
|
||||
some_other_var # isim hatası fırlatılır
|
||||
|
||||
# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
|
||||
# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
|
||||
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
|
||||
|
||||
# Listeler
|
||||
@ -151,7 +151,7 @@ li[0] #=> 1
|
||||
li[-1] #=> 3
|
||||
|
||||
# Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası
|
||||
# fırlatılır
|
||||
# fırlatılır
|
||||
li[4] # IndexError fırlatılır
|
||||
|
||||
# slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz.
|
||||
@ -177,7 +177,7 @@ li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
|
||||
# "len" ile listenin uzunluğunu bulmak
|
||||
len(li) #=> 6
|
||||
|
||||
# Tüpler listeler gibidir sadece değişmezler(immutable)
|
||||
# Tüpler listeler gibidir sadece değişmezler(immutable)
|
||||
tup = (1, 2, 3)
|
||||
tup[0] #=> 1
|
||||
tup[0] = 3 # TypeError fırlatılır.
|
||||
@ -188,12 +188,12 @@ tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
|
||||
tup[:2] #=> (1, 2)
|
||||
2 in tup #=> True
|
||||
|
||||
# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
|
||||
# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
|
||||
# atanabilir
|
||||
a, b, c = (1, 2, 3) # a şu anda 1, b şu anda 2 ve c şu anda 3
|
||||
# Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur
|
||||
d, e, f = 4, 5, 6
|
||||
# şimdi iki değeri değiş tokuş etmek çok kolaydır.
|
||||
# şimdi iki değeri değiş tokuş etmek çok kolaydır.
|
||||
e, d = d, e # d şimdi 5 ve e şimdi 4
|
||||
|
||||
|
||||
@ -207,24 +207,24 @@ filled_dict["one"] #=> 1
|
||||
|
||||
# Tüm anahtarlara(key) "keys()" metodu ile ulaşılır
|
||||
filled_dict.keys() #=> ["three", "two", "one"]
|
||||
# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
|
||||
# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir
|
||||
# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
|
||||
# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir
|
||||
|
||||
# Tüm değerleri almak için "values()" kullanabilirsiniz.
|
||||
filled_dict.values() #=> [3, 2, 1]
|
||||
# Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
|
||||
|
||||
# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
|
||||
# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
|
||||
"one" in filled_dict #=> True
|
||||
1 in filled_dict #=> False
|
||||
|
||||
# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
|
||||
# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
|
||||
filled_dict["four"] # KeyError
|
||||
|
||||
# "get()" metodu KeyError fırlatılmasını önler
|
||||
# "get()" metodu KeyError fırlatılmasını önler
|
||||
filled_dict.get("one") #=> 1
|
||||
filled_dict.get("four") #=> None
|
||||
# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
|
||||
# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
|
||||
# imknaı sağlar.
|
||||
filled_dict.get("one", 4) #=> 1
|
||||
filled_dict.get("four", 4) #=> 4
|
||||
@ -237,10 +237,10 @@ filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
|
||||
|
||||
# Sets store ... well sets
|
||||
empty_set = set()
|
||||
# Bir demek değer ile bir "set" oluşturmak
|
||||
# Bir demek değer ile bir "set" oluşturmak
|
||||
some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
|
||||
|
||||
# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
|
||||
# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
|
||||
filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
|
||||
|
||||
# Bir set'e daha fazla eleman eklemek
|
||||
@ -253,10 +253,10 @@ filled_set & other_set #=> {3, 4, 5}
|
||||
# | işareti ile
|
||||
filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
|
||||
|
||||
# "-" işareti ile iki set'in farkları alınabilir
|
||||
# "-" işareti ile iki set'in farkları alınabilir
|
||||
{1,2,3,4} - {2,3,5} #=> {1, 4}
|
||||
|
||||
# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
|
||||
# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
|
||||
2 in filled_set #=> True
|
||||
10 in filled_set #=> False
|
||||
|
||||
@ -268,7 +268,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
|
||||
# Bir değişken oluşturmak
|
||||
some_var = 5
|
||||
|
||||
# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
|
||||
# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
|
||||
# "some_var is smaller than 10" yazdırılır.
|
||||
if some_var > 10:
|
||||
print "some_var is totally bigger than 10."
|
||||
@ -286,7 +286,7 @@ Ekrana yazdırılan:
|
||||
mouse is a mammal
|
||||
"""
|
||||
for animal in ["dog", "cat", "mouse"]:
|
||||
# Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
|
||||
# Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
|
||||
print "%s is a mammal" % animal
|
||||
|
||||
"""
|
||||
@ -315,7 +315,7 @@ while x < 4:
|
||||
|
||||
# try/except bloğu ile hatalar ayıklanabilir
|
||||
|
||||
# Python 2.6 ve üstü için çalışacaktır:
|
||||
# Python 2.6 ve üstü için çalışacaktır:
|
||||
try:
|
||||
# "raise" bir hata fırlatmak için kullanılabilir
|
||||
raise IndexError("This is an index error")
|
||||
@ -339,18 +339,18 @@ add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
|
||||
# Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak
|
||||
add(y=6, x=5) # Anahtar argümanlarının sırası farklı da olabilir
|
||||
|
||||
# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
|
||||
# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
|
||||
def varargs(*args):
|
||||
return args
|
||||
|
||||
varargs(1, 2, 3) #=> (1,2,3)
|
||||
|
||||
# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da
|
||||
# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da
|
||||
# tanımlayabilirsiniz.
|
||||
def keyword_args(**kwargs):
|
||||
return kwargs
|
||||
|
||||
# Şu şekilde kullanılacaktır
|
||||
# Şu şekilde kullanılacaktır
|
||||
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
|
||||
|
||||
# Eğer isterseniz ikisini aynı anda da yapabilirsiniz
|
||||
@ -363,15 +363,15 @@ all_the_args(1, 2, a=3, b=4) prints:
|
||||
{"a": 3, "b": 4}
|
||||
"""
|
||||
|
||||
# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
|
||||
# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
|
||||
# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
|
||||
# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
|
||||
args = (1, 2, 3, 4)
|
||||
kwargs = {"a": 3, "b": 4}
|
||||
all_the_args(*args) # foo(1, 2, 3, 4) ile eşit
|
||||
all_the_args(**kwargs) # foo(a=3, b=4) ile eşit
|
||||
all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit
|
||||
|
||||
# Python first-class fonksiyonlara sahiptir
|
||||
# Python first-class fonksiyonlara sahiptir
|
||||
def create_adder(x):
|
||||
def adder(y):
|
||||
return x + y
|
||||
@ -387,7 +387,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]
|
||||
|
||||
# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz.
|
||||
# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz.
|
||||
[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]
|
||||
|
||||
@ -399,7 +399,7 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
|
||||
# We subclass from object to get a class.
|
||||
class Human(object):
|
||||
|
||||
# Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
|
||||
# Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
|
||||
species = "H. sapiens"
|
||||
|
||||
# Basic initializer
|
||||
@ -408,18 +408,18 @@ class Human(object):
|
||||
# değişkenine atama
|
||||
self.name = name
|
||||
|
||||
# Bir instance metodu. Tüm metodlar ilk argüman olarak "self"
|
||||
# Bir instance metodu. Tüm metodlar ilk argüman olarak "self"
|
||||
# parametresini alır
|
||||
def say(self, msg):
|
||||
return "%s: %s" % (self.name, msg)
|
||||
|
||||
# Bir sınıf metodu tüm "instance"lar arasında paylaşılır
|
||||
# İlk argüman olarak sınıfı çağırarak çağrılırlar
|
||||
# İlk argüman olarak sınıfı çağırarak çağrılırlar
|
||||
@classmethod
|
||||
def get_species(cls):
|
||||
return cls.species
|
||||
|
||||
# Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
|
||||
# Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
|
||||
@staticmethod
|
||||
def grunt():
|
||||
return "*grunt*"
|
||||
@ -452,24 +452,24 @@ Human.grunt() #=> "*grunt*"
|
||||
import math
|
||||
print math.sqrt(16) #=> 4.0
|
||||
|
||||
# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
|
||||
# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
|
||||
from math import ceil, floor
|
||||
print ceil(3.7) #=> 4.0
|
||||
print floor(3.7) #=> 3.0
|
||||
|
||||
# Modüldeki tüm fonksiyonları dahil edebilirsiniz
|
||||
# Uyarı: bu önerilmez
|
||||
# Uyarı: bu önerilmez
|
||||
from math import *
|
||||
|
||||
# Modülün adını kısaltabilirsiniz
|
||||
# Modülün adını kısaltabilirsiniz
|
||||
import math as m
|
||||
math.sqrt(16) == m.sqrt(16) #=> True
|
||||
|
||||
# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül
|
||||
# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
|
||||
# aynı olmalıdır.
|
||||
# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül
|
||||
# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
|
||||
# aynı olmalıdır.
|
||||
|
||||
# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
|
||||
# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
|
||||
import math
|
||||
dir(math)
|
||||
```
|
||||
|
||||
1
vim.md
1
vim.md
@ -176,7 +176,6 @@ A few important examples of 'Verbs', 'Modifiers', and 'Nouns':
|
||||
|
||||
## Some shortcuts and tricks
|
||||
|
||||
<!--TODO: Add more!-->
|
||||
```
|
||||
> # Indent selection by one block
|
||||
< # Dedent selection by one block
|
||||
|
||||
@ -139,6 +139,6 @@ Manipulate[y^2, {y, 0, 20}] (* Return a reactive user interface that displays y^
|
||||
Only works on graphical frontends *)
|
||||
```
|
||||
|
||||
##Ready For More?
|
||||
## Further reading
|
||||
|
||||
* [Wolfram Language Documentation Center](http://reference.wolfram.com/language/)
|
||||
|
||||
@ -620,5 +620,5 @@ nil ; 逻辑假，或者空列表
|
||||
同时也感谢
|
||||
- [Paul Khuong](https://github.com/pkhuong) ，他提出了很多有用的点评。
|
||||
|
||||
##译者寄语
|
||||
## 译者寄语
|
||||
“祝福那些将思想镶嵌在重重括号之内的人们。”
|
||||
|
||||
@ -53,15 +53,15 @@ translators:
|
||||
t<字符> # 向前跳移到 <字符> 的左侧
|
||||
|
||||
# 例如，
|
||||
f< # 向前跳移到 < 上
|
||||
f< # 向前跳移到 < 上
|
||||
t< # 向前跳移到 < 的左侧
|
||||
|
||||
# 按词移动
|
||||
# 默认一个单词由字母，数字和下划线组成
|
||||
|
||||
w # 移动到下一个词首
|
||||
b # 移动到前一个词首
|
||||
e # 移动到下一个词尾
|
||||
w # 移动到下一个词首
|
||||
b # 移动到前一个词首
|
||||
e # 移动到下一个词尾
|
||||
|
||||
|
||||
# 移动的其它命令
|
||||
@ -148,7 +148,6 @@ Vim 可以被认为是按 '动词-修饰词-名词' 格式编排的一组命令
|
||||
|
||||
## 一些快捷键和技巧
|
||||
|
||||
<!--TODO: Add more!-->
|
||||
```
|
||||
> # 将所选内容缩进一级
|
||||
< # 将所选内容取消缩进一级
|
||||
|
||||
Loading…
Reference in New Issue
Block a user