mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
Merge remote-tracking branch 'adambard/master'
This commit is contained in:
C. Bess
commit
8ca7f472ec
180
fr-fr/hy-fr.html.markdown
Normal file
180
fr-fr/hy-fr.html.markdown
Normal file
@ -0,0 +1,180 @@
|
||||
---
|
||||
language: hy
|
||||
filename: learnhy-fr.hy
|
||||
contributors:
|
||||
- ["Abhishek L", "http://twitter.com/abhishekl"]
|
||||
translators:
|
||||
- ["Hughes Perreault", "https://github.com/hperreault"]
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
Hy est un dialecte du lisp bâti par dessus python. Il fonctionne en
|
||||
convertissant le code hy en un arbre de syntaxe abstraite de python (ast).
|
||||
Ceci permet à hy d'appeler du code python et à python d'appeler du code hy.
|
||||
|
||||
Ce tutoriel fonctionne pour hy > 0.9.12
|
||||
|
||||
```clojure
|
||||
;; Ceci est une introduction simple à hy, pour un tutoriel rapide aller à
|
||||
;; http://try-hy.appspot.com
|
||||
;;
|
||||
; Les commentaires se font avec des points-virgules, comme les autres LISPS
|
||||
|
||||
;; les s-expression de bases
|
||||
; Les programmes Lisp sont fait d'expressions symboliques ou sexps qui
|
||||
; ressemblent à
|
||||
(some-function args)
|
||||
; maintenant le quintessentiel hello world
|
||||
(print "hello world")
|
||||
|
||||
;; les types de données simples
|
||||
; Tous les types de données simples sont exactement similaires à leurs
|
||||
; homologues de python
|
||||
42 ; => 42
|
||||
3.14 ; => 3.14
|
||||
True ; => True
|
||||
4+10j ; => (4+10j) un nombre complexe
|
||||
|
||||
; Commençons par un peu d'arithmétique très simple
|
||||
(+ 4 1) ;=> 5
|
||||
; l'opérateur est appliqué à tous les arguments, comme les autres lisps
|
||||
(+ 4 1 2 3) ;=> 10
|
||||
(- 2 1) ;=> 1
|
||||
(* 4 2) ;=> 8
|
||||
(/ 4 1) ;=> 4
|
||||
(% 4 2) ;=> 0 l'opérateur modulo
|
||||
; l'opérateur d'élévation à la puissance est représenté par ** comme en python
|
||||
(** 3 2) ;=> 9
|
||||
; les expressions imbriquées vont se comporter comme on s'y attend
|
||||
(+ 2 (* 4 2)) ;=> 10
|
||||
; aussi, les opérateurs logiques and or not et equal to etc. vont se comporter
|
||||
; comme on s'y attend
|
||||
(= 5 4) ;=> False
|
||||
(not (= 5 4)) ;=> True
|
||||
|
||||
;; variables
|
||||
; les variables sont déclarées en utilisant setv, les noms de variables
|
||||
; peuvent utiliser l'UTF-8 à l'exception de ()[]{}",'`;#|
|
||||
(setv a 42)
|
||||
(setv π 3.14159)
|
||||
(def *foo* 42)
|
||||
;; d'autres types de conteneurs
|
||||
; les chaînes, les listes, les tuples et dicts
|
||||
; ce sont exactement les mêmes que les types de conteneurs de python
|
||||
"hello world" ;=> "hello world"
|
||||
; les opérations sur les chaînes fonctionnent comme en python
|
||||
(+ "hello " "world") ;=> "hello world"
|
||||
; les listes sont créés en utilisant [], l'indexation commence à 0
|
||||
(setv mylist [1 2 3 4])
|
||||
; les tuples sont des structures de données immuables
|
||||
(setv mytuple (, 1 2))
|
||||
; les dictionnaires sont des paires clé-valeur
|
||||
(setv dict1 {"key1" 42 "key2" 21})
|
||||
; :nom peut être utilisé pour définir des mots clés dans hy qui peuvent être
|
||||
; utilisées comme clés
|
||||
(setv dict2 {:key1 41 :key2 20})
|
||||
; utilisez `get' pour obtenir l'élément à l'index / clé
|
||||
(get mylist 1) ;=> 2
|
||||
(get dict1 "key1") ;=> 42
|
||||
; Alternativement, si des mots clés ont été utilisés, l'élément peut être
|
||||
; obtenu directement
|
||||
(:key1 dict2) ;=> 41
|
||||
|
||||
;; fonctions et autres constructions de programme
|
||||
; les fonctions sont définies en utilisant defn, la dernière sexp est renvoyé par défaut
|
||||
(defn greet [name]
|
||||
"A simple greeting" ; une docstring optionnelle
|
||||
(print "hello " name))
|
||||
|
||||
(greet "bilbo") ;=> "hello bilbo"
|
||||
|
||||
; les fonctions peuvent prendre des arguments optionnels ainsi que des
|
||||
; arguments sous forme de mots clés
|
||||
(defn foolists [arg1 &optional [arg2 2]]
|
||||
[arg1 arg2])
|
||||
|
||||
(foolists 3) ;=> [3 2]
|
||||
(foolists 10 3) ;=> [10 3]
|
||||
|
||||
; les fonctions anonymes sont créés en utilisant `fn' ou `lambda'
|
||||
; qui sont semblable à `defn '
|
||||
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
|
||||
|
||||
;; Opérations sur les séquences
|
||||
; hy a des utilitaires natifs pour les opérations sur les séquences etc.
|
||||
; récupérez le premier élément en utilisant `first' ou `car'
|
||||
(setv mylist [1 2 3 4])
|
||||
(setv mydict {"a" 1 "b" 2})
|
||||
(first mylist) ;=> 1
|
||||
|
||||
; découpez les listes en utilisant slice
|
||||
(slice mylist 1 3) ;=> [2 3]
|
||||
|
||||
; obtenez les éléments d'une liste ou dict en utilisant `get'
|
||||
(get mylist 1) ;=> 2
|
||||
(get mydict "b") ;=> 2
|
||||
; l'indexation des listes commence à 0 comme en python
|
||||
; assoc peut définir les éléments à clés/index
|
||||
(assoc mylist 2 10) ; makes mylist [1 2 10 4]
|
||||
(assoc mydict "c" 3) ; makes mydict {"a" 1 "b" 2 "c" 3}
|
||||
; il ya tout un tas d'autres fonctions de base qui rend le travail avec
|
||||
; les séquences amusant
|
||||
|
||||
;; les importations fonctionnent comme en pyhtonn
|
||||
(import datetime)
|
||||
(import [functools [partial reduce]]) ; importe fun1 et fun2 de module1
|
||||
(import [matplotlib.pyplot :as plt]) ; faire une importation foo comme bar
|
||||
; toutes les méthodes natives de python sont accessibles à partir de hy
|
||||
; a.foo(arg) est appelé (.foo a arg)
|
||||
(.split (.strip "hello world ")) ;=> ["hello" "world"]
|
||||
|
||||
;; Conditionelles
|
||||
; (if condition (body-if-true) (body-if-false)
|
||||
(if (= passcode "moria")
|
||||
(print "welcome")
|
||||
(print "Speak friend, and Enter!"))
|
||||
|
||||
; imbriquez plusieurs if else if avec le mot clé cond
|
||||
(cond
|
||||
[(= someval 42)
|
||||
(print "Life, universe and everything else!")]
|
||||
[(> someval 42)
|
||||
(print "val too large")]
|
||||
[(< someval 42)
|
||||
(print "val too small")])
|
||||
|
||||
; groupez les expressions avec do, ceux-ci seront executé séquentiellemnt
|
||||
; les expressions comme defn ont un do implicite
|
||||
(do
|
||||
(setv someval 10)
|
||||
(print "someval is set to " someval)) ;=> 10
|
||||
|
||||
; créer une liaison lexicale avec `let', toutes les variables déclarées
|
||||
; comme cela ont une portée locale
|
||||
(let [[nemesis {"superman" "lex luther"
|
||||
"sherlock" "moriarty"
|
||||
"seinfeld" "newman"}]]
|
||||
(for [(, h v) (.items nemesis)]
|
||||
(print (.format "{0}'s nemesis was {1}" h v))))
|
||||
|
||||
;; classes
|
||||
; les classes sont définies comme ceci
|
||||
(defclass Wizard [object]
|
||||
[[--init-- (fn [self spell]
|
||||
(setv self.spell spell) ; init the spell attr
|
||||
None)]
|
||||
[get-spell (fn [self]
|
||||
self.spell)]])
|
||||
|
||||
;; allez voir hylang.org
|
||||
```
|
||||
|
||||
### Lectures complémentaires
|
||||
|
||||
Ce tutoriel est juste une simple introduction à hy/lisp/python.
|
||||
|
||||
La documentation de HY: [http://hy.readthedocs.org](http://hy.readthedocs.org)
|
||||
|
||||
Le repo GitHub de HY: [http://github.com/hylang/hy](http://github.com/hylang/hy)
|
||||
|
||||
Sur freenode irc #hy, twitter hashtag #hylang
|
||||
@ -6,6 +6,7 @@ contributors:
|
||||
filename: javascript-fr.js
|
||||
translators:
|
||||
- ['@nbrugneaux', 'https://nicolasbrugneaux.me']
|
||||
- ['Michel Antoine', 'https://github.com/antoin-m']
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
@ -23,6 +24,8 @@ interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome,
|
||||
peut être utilisé directement côté serveur pour exécuter des programmes écrits
|
||||
en JavaScript.
|
||||
|
||||
ECMAScript (la norme du langage Javascript) entre en version 6. Cette version introduit de nombreuses mises à jour tout en restant rétrocompatible. L'implémentation de ces nouvelles fonctionnalités est en cours et celles-ci ne sont donc pas forcément compatibles avec tous les navigateurs.
|
||||
|
||||
```js
|
||||
// Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs,
|
||||
/* et les commentaires sur plusieurs lignes commencent avec slash-étoile
|
||||
@ -79,6 +82,12 @@ false; // faux
|
||||
"abc";
|
||||
'Hello, world';
|
||||
|
||||
// *ES6:* Les chaines de caractères peuvent être crées en utilisant un modèle
|
||||
// entouré des quotes inverses (`) à la place des quotes classiques (' ou ").
|
||||
// Les variables sont interprétées avec ${var}
|
||||
let banta = "Harry", santa = "Hermione";
|
||||
`${banta}, your santa is ${santa}.` // = "Harry, your santa is Hermione."
|
||||
|
||||
// La négation utilise le symbole !
|
||||
!true; // = false
|
||||
!false; // = true
|
||||
@ -124,9 +133,17 @@ undefined; // utilisé pour une valeur actuellement non présente (cependant,
|
||||
// est 'presque-vrai' (truthy)
|
||||
// Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0')
|
||||
|
||||
// *ES6:* Introduction d'un nouveau type primitif : Symbol
|
||||
var symbol_one = Symbol();
|
||||
var symbol_two = Symbol('This is optional description, for debugging');
|
||||
typeof symbol_one === 'symbol' // = true
|
||||
|
||||
// *ES6:* Un Symbol est immutable et unique
|
||||
Symbol() === Symbol() // = false
|
||||
Symbol('learnx') === Symbol('learnx') // = false
|
||||
|
||||
///////////////////////////////////
|
||||
// 2. Variables, Tableaux et Objets
|
||||
// 2. Variables, Tableaux, Objets, Maps et Sets
|
||||
|
||||
// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est
|
||||
// dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =.
|
||||
@ -145,6 +162,32 @@ var someThirdVar = undefined;
|
||||
|
||||
// ... sont deux déclarations identiques.
|
||||
|
||||
// Il est possible de déclarer plusieurs variables en séparant leur déclaration
|
||||
// avec l'opérateur virgule
|
||||
var someFourthVar = 2, someFifthVar = 4;
|
||||
|
||||
// *ES6:* Les variables peuvent maintenant être déclarées avec les mots-clés
|
||||
// `let` et `const`
|
||||
let someSixthVar = 6;
|
||||
const someSeventhVar = 7;
|
||||
|
||||
// *ES6:* Le mot-clé `let` attache la variable au block de code et non à la fonction
|
||||
// à l'inverse de `var`
|
||||
for (let i = 0; i < 10; i++) {
|
||||
x += 10;
|
||||
}
|
||||
i; // = raises ReferenceError
|
||||
|
||||
// *ES6:* Les variables "const" doivent être assignées lors de l'initialisation
|
||||
const someEighthVar = 7;
|
||||
const someNinthVar; // raises SyntaxError
|
||||
|
||||
// *ES6:* Modifier une variable constante ne lève par d'erreur mais échoue
|
||||
// silencieusement
|
||||
const someNinthVar = 9;
|
||||
someNinthVar = 10;
|
||||
someNinthVar; // = 9
|
||||
|
||||
// Il y a des raccourcis pour les opérations mathématiques:
|
||||
someVar += 5; // équivalent pour someVar = someVar + 5;
|
||||
someVar *= 10; // de même, someVar = someVar * 100;
|
||||
@ -165,6 +208,22 @@ myArray.length; // = 4
|
||||
// Ajout/Modification à un index spécifique
|
||||
myArray[3] = 'Hello';
|
||||
|
||||
// *ES6:* Les Arrays peuvent maintenant être déstructurés en utilisant le pattern matching
|
||||
var [a, b] = [1, 2];
|
||||
var [a, , b] = [1, -2, 2]
|
||||
|
||||
a; // = 1
|
||||
b; // = 2
|
||||
|
||||
// *ES6:* La déstructuration peut échouer silencieusement.
|
||||
// Il est aussi possible d'utiliser des valeurs par défaut
|
||||
var [a] = [];
|
||||
a; // = undefined;
|
||||
var [a = 1] = [];
|
||||
a; // = 1;
|
||||
var [a = 1] = [2];
|
||||
a; // = 2;
|
||||
|
||||
// Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres
|
||||
// langages : ils sont une liste non-ordonnée de paires clé-valeur.
|
||||
var myObj = {key1: 'Hello', key2: 'World'};
|
||||
@ -179,12 +238,55 @@ myObj['my other key']; // = 4
|
||||
// .. ou avec un point si la clé est un identifiant valide.
|
||||
myObj.myKey; // = 'myValue'
|
||||
|
||||
// *ES6:* Un Symbol peut être utilisé en tant que clé. Puisque ceux-ci sont uniques,
|
||||
// le seul moyen d'accéder à la propriété est d'avoir une référence sur ce Symbol.
|
||||
myObj["key"] = "public value";
|
||||
myObj[Symbol("key")] = "secret value";
|
||||
myObj[Symbol("key")]; // = undefined
|
||||
|
||||
// Les objets sont eux aussi modifiables.
|
||||
myObj.myThirdKey = true;
|
||||
|
||||
// Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined
|
||||
myObj.myFourthKey; // = undefined
|
||||
|
||||
// *ES6:* Comme les Arrays, les Objects peuvent être déstructurés en utilisant le pattern matching
|
||||
var {foo} = {foo: "bar"};
|
||||
foo // = "bar"
|
||||
|
||||
// *ES6:* Les Objects déstructurés peuvent utiliser des noms de variables différents
|
||||
// de ceux d'origine grâce au pattern matching
|
||||
var {foo, moo: baz} = {foo: "bar", moo: "car"};
|
||||
foo // = "bar"
|
||||
baz // = "car"
|
||||
|
||||
// *ES6:* Il est possible d'utiliser des valeurs par défaut lor de la déstructuration d'un Object
|
||||
var {foo="bar"} = {moo: "car"};
|
||||
foo // = "bar"
|
||||
|
||||
// *ES6:* Une erreur lors de la déstructuration restera silencieuse
|
||||
var {foo} = {};
|
||||
foo // = undefined
|
||||
|
||||
// *ES6:* Les Maps sont des objets itérables de type clé-valeur.
|
||||
// Il est possible de créer une nouvelle map en utilisant `new Map()`
|
||||
var myMap = new Map();
|
||||
|
||||
// *ES6:* Il est possible d'ajouter un couple clé-valeur avec la méthode `.set()`,
|
||||
// de récupérer une valeur avec `.get()`,
|
||||
// de vérifier qu'une clé existe avec `.has()`
|
||||
// et enfin de supprimer un couple clé-valeur avec `.delete()`
|
||||
|
||||
myMap.set("name", "Douglas");
|
||||
myMap.get("name"); // = "Douglas"
|
||||
myMap.has("name"); // = true
|
||||
myMap.delete("name");
|
||||
|
||||
// *ES6:* Les Sets sont des ensembles de valeurs uniques.
|
||||
// Il est possible de créer un set avec `new Set()`.
|
||||
// Toute valeur non unique est ignorée.
|
||||
var mySet = new Set([1,2,2]);
|
||||
console.log([...mySet]); // = [1,2]
|
||||
|
||||
///////////////////////////////////
|
||||
// 3. Logique et structures de contrôle
|
||||
@ -218,6 +320,22 @@ for (var i = 0; i < 5; i++){
|
||||
// sera exécutée 5 fois
|
||||
}
|
||||
|
||||
// La boucle for...in permet d'itérer sur les noms des propriétés d'un objet
|
||||
var description = "";
|
||||
var person = {fname:"Paul", lname:"Ken", age:18};
|
||||
for (var x in person){
|
||||
description += person[x] + " ";
|
||||
}
|
||||
description; // = "Paul Ken 18 "
|
||||
|
||||
// *ES6:* La boucle for...of permet d'itérer sur les propriétés d'un objet
|
||||
var description = "";
|
||||
var person = {fname:"Paul", lname:"Ken", age:18};
|
||||
for (var x of person){
|
||||
description += x + " ";
|
||||
}
|
||||
description; // = "Paul Ken 18 "
|
||||
|
||||
// && est le "et" logique, || est le "ou" logique
|
||||
if (house.size === 'big' && house.colour === 'blue'){
|
||||
house.contains = 'bear';
|
||||
@ -264,6 +382,20 @@ function myFunction(thing){
|
||||
}
|
||||
myFunction('foo'); // = 'FOO'
|
||||
|
||||
// Attention, la valeur à retourner doit se trouver sur la même ligne que
|
||||
// le mot-clé `return` sinon la fonction retournera systématiquement `undefined`
|
||||
function myFunction(){
|
||||
return // <- semicolon automatically inserted here
|
||||
{thisIsAn: 'object literal'}
|
||||
}
|
||||
myFunction(); // = undefined
|
||||
|
||||
// *ES6:* Les paramètres des fonctions peuvent désormais avoir des valeurs par défaut
|
||||
function default(x, y = 2) {
|
||||
return x + y;
|
||||
}
|
||||
default(10); // == 12
|
||||
|
||||
// Les fonctions JavaScript sont des objets de première classe, donc peuvent
|
||||
// être réassignées à d'autres variables et passées en tant que paramètres pour
|
||||
// d'autres fonctions
|
||||
@ -280,6 +412,10 @@ setTimeout(function(){
|
||||
// ce code s'exécutera dans 5 secondes
|
||||
}, 5000);
|
||||
|
||||
// *ES6:* Introduction d'un sucre syntaxique permettant de créer
|
||||
// une fonction anonyme de la forme : `param => returnValue`.
|
||||
setTimeout(() => console.log('5 seconds, are up.'), 5000);
|
||||
|
||||
// Le Javascript crée uniquement un scope, une portée d'action limitée, pour
|
||||
// les fonctions, et pas dans les autres blocs.
|
||||
if (true){
|
||||
@ -318,6 +454,18 @@ function sayHelloInFiveSeconds(name){
|
||||
}
|
||||
sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec
|
||||
|
||||
// *ES6:* Les paramètres des fonctions appelées avec un tableau en entré
|
||||
// préfixé par `...` vont se peupler avec les éléments du tableau
|
||||
function spread(x, y, z) {
|
||||
return x + y + z;
|
||||
}
|
||||
spread(...[1,2,3]); // == 6
|
||||
|
||||
// *ES6:* Les fonctions peuvent recevoir les paramètres dans un tableau en utilisant l'opérateur `...`
|
||||
function spread(x, y, z) {
|
||||
return x + y + z;
|
||||
}
|
||||
spread(...[1,2,3]); // == 6
|
||||
|
||||
///////////////////////////////////
|
||||
// 5. Encore plus à propos des Objets; Constructeurs and Prototypes
|
||||
@ -492,6 +640,58 @@ if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe
|
||||
return new Constructor();
|
||||
}
|
||||
}
|
||||
|
||||
// *ES6:* Les objets peuvent être équipés de proxies qui permettent d'intercepter
|
||||
// les actions sur leurs propriétés. Voici comment créer un proxy sur un objet :
|
||||
var proxyObject = new Proxy(object, handler);
|
||||
|
||||
// *ES6:* Les méthodes d'un objet handler sont appelées lors de l'interception d'une action.
|
||||
// La méthode `.get()` est appelée à chaque lecture d'une propriété
|
||||
// tandis que la méthode `.set()` est appelée à chaque écriture.
|
||||
var handler = {
|
||||
get (target, key) {
|
||||
console.info('Get on property' + key);
|
||||
return target[key];
|
||||
},
|
||||
set (target, key, value) {
|
||||
console.info('Set on property' + key);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// *ES6:* Les classes peuvent désormais être définies en utilisant le mot-clé `class`.
|
||||
// Le constructeur s'appelle `constructor` et les méthodes statiques utilisent le mot-clé `static`
|
||||
class Foo {
|
||||
constructor() {console.log("constructing Foo");}
|
||||
bar() {return "bar";}
|
||||
static baz() {return "baz";}
|
||||
}
|
||||
|
||||
// *ES6:* Les objets issus des classes sont initialisés avec le mot-clé `new`.
|
||||
// Il est possible d'hériter d'une classe avec le mot-clé `extends`
|
||||
var FooObject = new Foo(); // = "constructing Foo"
|
||||
class Zoo extends Foo {}
|
||||
|
||||
// *ES6:* Les méthodes statiques doivent être appelées par la classe, les autres méthodes par l'objet
|
||||
Foo.baz() // = "baz"
|
||||
FooObject.bar() // = "bar"
|
||||
|
||||
// *ES6:* Il est désormais possible d'exporter des valeurs en tant que module.
|
||||
// Les exports peuvent être n'importe quel objet, valeur ou fonction.
|
||||
var api = {
|
||||
foo: "bar",
|
||||
baz: "ponyfoo"
|
||||
};
|
||||
export default api;
|
||||
|
||||
// *ES6:* La syntaxe `export default` permet d'exporter l'objet sans en changer le nom.
|
||||
// Il y a plusieurs façons de l'importer:
|
||||
import coolapi from "api"; // = importe le module dans la variable `coolapi`
|
||||
import {foo, baz} from "api"; // = importe les attributs `foo` et `baz` du module
|
||||
import {foo as moo, baz} from "api"; // = importe les attributs `foo` (en le renommant `moo`) et `baz` du module
|
||||
import _, {map} from "api"; // = importe les exports par défaut ET `map`
|
||||
import * as coolapi from "api"; // = importe le namespace global du module
|
||||
|
||||
```
|
||||
|
||||
## Pour aller plus loin (en anglais)
|
||||
|
||||
@ -5,6 +5,7 @@ contributors:
|
||||
- ["Xavier Yao", "http://github.com/xavieryao"]
|
||||
translators:
|
||||
- ["Tamás Diószegi", "http://github.com/ditam"]
|
||||
lang: hu-hu
|
||||
filename: coffeescript-hu.coffee
|
||||
---
|
||||
|
||||
|
||||
@ -227,6 +227,15 @@ format you defined in Step 1.
|
||||
|
||||
That's all for now!
|
||||
|
||||
% Most often, you would want to have a references section in your document.
|
||||
% The easiest way to set this up would be by using the bibliography section
|
||||
\begin{thebibliography}{1}
|
||||
% similar to other lists, the \bibitem command can be used to list items
|
||||
% each entry can then be cited directly in the body of the text
|
||||
\bibitem{latexwiki} The amazing LaTeX wikibook: {\em https://en.wikibooks.org/wiki/LaTeX}
|
||||
\bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
|
||||
\end{thebibliography}
|
||||
|
||||
% end the document
|
||||
\end{document}
|
||||
```
|
||||
|
||||
81
lt-lt/json-lt.html.markdown
Normal file
81
lt-lt/json-lt.html.markdown
Normal file
@ -0,0 +1,81 @@
|
||||
---
|
||||
language: json
|
||||
filename: learnjson.json
|
||||
lang: lt-lt
|
||||
contributors:
|
||||
- ["Zygimantus", "https://github.com/zygimantus"]
|
||||
---
|
||||
|
||||
JSON („džeisonas“) yra itin paprastas duomenų mainų formatas, todėl tai bus pati lengviausia „Learn X in Y Minutes“ pamoka.
|
||||
|
||||
JSON savo gryniausioje formoje neturi jokių komentarų, tačiau dauguma analizatorių priimtų C stiliaus komentarus (`//`, `/* */`). Kai kurie analizatoriai taip pat toleruoja gale esantį kablelį, pvz., kablelis po kiekvieno masyvo paskutinio elemento arba po paskutinio objekto lauko, tačiau jų reikėtų vengti dėl geresnio suderinamumo.
|
||||
|
||||
JSON reikšmė privalo būti skaičius, eilutė, masyvas, objektas arba viena reikšmė iš šių: true, false, null.
|
||||
|
||||
Palaikančios naršyklės yra: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, and Safari 4.0+.
|
||||
|
||||
Failo plėtinys JSON failams yra „.json“, o MIME tipas yra „application/json“.
|
||||
|
||||
Dauguma programavimo kalbų palaiko JSON duomenų serializaciją (kodavimą) ir deserializaciją (dekodavimą) į natyviasias duomenų struktūras. Javascript turi visišką JSON teksto kaip duomenų manipuliavimo palaikymą.
|
||||
|
||||
Daugiau informacijos galima rasti http://www.json.org/
|
||||
|
||||
JSON yra pastatytas iš dviejų struktūrų:
|
||||
* Vardų/reikšmių porų rinkinys. Daugomoje kalbų, tai yra realizuojama kaip objektas, įrašas, struktūra, žodynas, hash lentelė, sąrašas su raktais arba asociatyvusis masyvas.
|
||||
* Rūšiuotas reikšmių sąrašas. Daugumoje kalbų, toks sąrašas yra realizuojama kaip masyvas, vektorius, sąrašas arba seka.
|
||||
|
||||
Objektas su įvairiomis vardo/reikšmės poromis.
|
||||
|
||||
```json
|
||||
{
|
||||
"raktas": "reikšmė",
|
||||
|
||||
"raktai": "privalo visada būti uždaryti dvigubomis kabutėmis",
|
||||
"skaičiai": 0,
|
||||
"eilutės": "Labas, pasauli. Visas unikodas yra leidžiamas, kartu su \"vengimu\".",
|
||||
"turi logiką?": true,
|
||||
"niekas": null,
|
||||
|
||||
"didelis skaičius": 1.2e+100,
|
||||
|
||||
"objektai": {
|
||||
"komentaras": "Dauguma tavo struktūrų ateis iš objektų.",
|
||||
|
||||
"masyvas": [0, 1, 2, 3, "Masyvas gali turėti bet ką savyje.", 5],
|
||||
|
||||
"kitas objektas": {
|
||||
"komentaras": "Šie dalykai gali būti įdedami naudingai."
|
||||
}
|
||||
},
|
||||
|
||||
"kvailumas": [
|
||||
{
|
||||
"kalio šaltiniai": ["bananai"]
|
||||
},
|
||||
[
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, "neo"],
|
||||
[0, 0, 0, 1]
|
||||
]
|
||||
],
|
||||
|
||||
"alternativus stilius": {
|
||||
"komentaras": "tik pažiūrėk!"
|
||||
, "kablelio padėti": "nesvarbi - kol jis prieš kitą raktą, tada teisingas"
|
||||
, "kitas komentaras": "kaip gražu"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Paprastas reikšmių masyvas pats savaime yra galiojantis JSON.
|
||||
|
||||
```json
|
||||
[1, 2, 3, "tekstas", true]
|
||||
```
|
||||
|
||||
Objektai taip pat gali būti masyvų dalis.
|
||||
|
||||
```json
|
||||
[{"vardas": "Jonas", "amžius": 25}, {"vardas": "Eglė", "amžius": 29}, {"vardas": "Petras", "amžius": 31}]
|
||||
```
|
||||
@ -373,7 +373,7 @@ say @array[^10]; # you can pass arrays as subscripts and it'll return
|
||||
say join(' ', @array[15..*]); #=> 15 16 17 18 19
|
||||
# which is equivalent to:
|
||||
say join(' ', @array[-> $n { 15..$n }]);
|
||||
# Note: if you try to do either of those with an infinite loop,
|
||||
# Note: if you try to do either of those with an infinite array,
|
||||
# you'll trigger an infinite loop (your program won't finish)
|
||||
|
||||
# You can use that in most places you'd expect, even assigning to an array
|
||||
@ -736,7 +736,7 @@ try {
|
||||
# You can throw an exception using `die`:
|
||||
die X::AdHoc.new(payload => 'Error !');
|
||||
|
||||
# You can access the last exception with `$!` (usually used in a `CATCH` block)
|
||||
# You can access the last exception with `$!` (use `$_` in a `CATCH` block)
|
||||
|
||||
# There are also some subtelties to exceptions. Some Perl 6 subs return a `Failure`,
|
||||
# which is a kind of "unthrown exception". They're not thrown until you tried to look
|
||||
|
||||
@ -230,8 +230,8 @@ new_hash = { defcon: 3, action: true }
|
||||
new_hash.keys #=> [:defcon, :action]
|
||||
|
||||
# Check existence of keys and values in hash
|
||||
new_hash.has_key?(:defcon) #=> true
|
||||
new_hash.has_value?(3) #=> true
|
||||
new_hash.key?(:defcon) #=> true
|
||||
new_hash.value?(3) #=> true
|
||||
|
||||
# Tip: Both Arrays and Hashes are Enumerable
|
||||
# They share a lot of useful methods such as each, map, count, and more
|
||||
|
||||
Loading…
Reference in New Issue
Block a user