mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
Clean up various errors
This commit is contained in:
Adam
parent
5aa692f5f3
commit
f3b10beb01
@ -14,7 +14,7 @@ Clojure, there are implementations of EDN for many other languages.
|
||||
The main benefit of EDN over JSON and YAML is that it is extensible. We
|
||||
will see how it is extended later on.
|
||||
|
||||
```Clojure
|
||||
```clojure
|
||||
; Comments start with a semicolon.
|
||||
; Anything after the semicolon is ignored.
|
||||
|
||||
|
||||
@ -5,6 +5,7 @@ contributors:
|
||||
- ["Christophe THOMAS", "https://github.com/WinChris"]
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
HTML signifie HyperText Markup Language.
|
||||
C'est un langage (format de fichiers) qui permet d'écrire des pages internet.
|
||||
C’est un langage de balisage, il nous permet d'écrire des pages HTML au moyen de balises (Markup, en anglais).
|
||||
@ -17,7 +18,7 @@ Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parl
|
||||
Cet article porte principalement sur la syntaxe et quelques astuces.
|
||||
|
||||
|
||||
```HTML
|
||||
```html
|
||||
<!-- Les commentaires sont entouré comme cette ligne! -->
|
||||
|
||||
<!-- #################### Les balises #################### -->
|
||||
|
||||
@ -8,7 +8,7 @@ translators:
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
```d
|
||||
```c
|
||||
// Commençons par un classique
|
||||
module hello;
|
||||
|
||||
@ -30,7 +30,7 @@ D est activement développé par de nombreuses personnes très intelligents, gui
|
||||
[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
|
||||
Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
|
||||
|
||||
```d
|
||||
```c
|
||||
import std.stdio;
|
||||
|
||||
void main() {
|
||||
@ -75,7 +75,7 @@ On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
|
||||
`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
|
||||
De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
|
||||
|
||||
```d
|
||||
```c
|
||||
// Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
|
||||
struct LinkedList(T) {
|
||||
T data = null;
|
||||
@ -140,7 +140,7 @@ une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
|
||||
la syntaxe des structures classiques (`struct.x = 7`) comme si il
|
||||
s'agissait de méthodes getter ou setter.
|
||||
|
||||
```d
|
||||
```c
|
||||
// Considérons une classe paramétrée avec les types 'T' et 'U'
|
||||
class MyClass(T, U) {
|
||||
T _data;
|
||||
@ -212,7 +212,7 @@ de premier ordre, les fonctions `pure` et les données immuables.
|
||||
De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
|
||||
sont disponibles dans le module `std.algorithm`.
|
||||
|
||||
```d
|
||||
```c
|
||||
import std.algorithm : map, filter, reduce;
|
||||
import std.range : iota; // construit un intervalle excluant la dernière valeur.
|
||||
|
||||
@ -242,7 +242,7 @@ est de type A, comme si c'était une méthode de A.
|
||||
J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça
|
||||
Voyons comment on le fait en D !
|
||||
|
||||
```d
|
||||
```c
|
||||
import std.stdio;
|
||||
import std.parallelism : parallel;
|
||||
import std.math : sqrt;
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
---
|
||||
|
||||
language: Objective-C
|
||||
contributors:
|
||||
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
|
||||
@ -9,7 +8,6 @@ translators:
|
||||
- ["Yannick Loriot", "https://github.com/YannickL"]
|
||||
filename: LearnObjectiveC-fr.m
|
||||
lang: fr-fr
|
||||
|
||||
---
|
||||
|
||||
L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
|
||||
@ -519,6 +517,7 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es
|
||||
// l'objet est supprimé
|
||||
|
||||
```
|
||||
|
||||
## Lectures Complémentaires
|
||||
|
||||
[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
---
|
||||
language: ruby
|
||||
lang: hu-hu
|
||||
filenev: learnruby.rb
|
||||
filename: learnruby-hu.rb
|
||||
contributors:
|
||||
- ["David Underwood", "http://theflyingdeveloper.com"]
|
||||
- ["Joel Walden", "http://joelwalden.net"]
|
||||
|
||||
@ -8,7 +8,7 @@ contributors:
|
||||
Less is a CSS pre-processor, that adds features such as variables, nesting, mixins and more.
|
||||
Less (and other preprocessors, such as [Sass](http://sass-lang.com/) help developers to write maintainable and DRY (Don't Repeat Yourself) code.
|
||||
|
||||
```less
|
||||
```css
|
||||
|
||||
|
||||
//Single line comments are removed when Less is compiled to CSS.
|
||||
|
||||
@ -11,7 +11,7 @@ that gives the programmer power without compromises on runtime efficiency.
|
||||
|
||||
Nim is efficient, expressive, and elegant.
|
||||
|
||||
```nimrod
|
||||
```javascript
|
||||
var # Declare (and assign) variables,
|
||||
letter: char = 'n' # with or without type annotations
|
||||
lang = "N" & "im"
|
||||
|
||||
@ -1,235 +0,0 @@
|
||||
---
|
||||
category: tool
|
||||
tool: amd
|
||||
contributors:
|
||||
- ["Frederik Ring", "https://github.com/m90"]
|
||||
translators:
|
||||
- ["Reinoud Kruithof", "https://github.com/reinoudk"]
|
||||
filename: learnamd-nl.js
|
||||
lang: nl-nl
|
||||
---
|
||||
|
||||
## Aan de slag met AMD
|
||||
|
||||
De **Asynchronous Module Definition** API specificeert een mechanisme om JavaScript
|
||||
modules the definiëren zodat de module en dependencies (afhankelijkheden) asynchroon
|
||||
geladen kunnen worden. Dit is vooral erg geschikt voor de browseromgeving, waar het
|
||||
synchroon laden van modules zorgt voor problemen qua prestatie, gebruiksvriendelijkheid,
|
||||
debugging en cross-domain toegangsproblemen.
|
||||
|
||||
### Basis concept
|
||||
```javascript
|
||||
// De basis AMD API bestaat uit niks meer dan twee methodes: `define` en `require`
|
||||
// and gaat vooral over de definitie en gebruik van modules:
|
||||
// `define(id?, dependencies?, factory)` definieert een module
|
||||
// `require(dependencies, callback)` importeert een set van dependencies en
|
||||
// gebruikt ze in de gegeven callback
|
||||
|
||||
// Laten we starten met het gebruiken van define om een nieuwe module (met naam)
|
||||
// te creëeren, welke geen dependencies heeft. Dit doen we door een naam
|
||||
// en een zogeheten factory functie door te geven aan define:
|
||||
define('awesomeAMD', function(){
|
||||
var isAMDAwesome = function(){
|
||||
return true;
|
||||
};
|
||||
// De return waarde van een module's factory functie is
|
||||
// wat andere modules of require calls ontvangen wanneer
|
||||
// ze onze `awesomeAMD` module requiren.
|
||||
// De geëxporteerde waarde kan van alles zijn: (constructor) functies,
|
||||
// objecten, primitives, zelfs undefined (hoewel dat niet veel nut heeft).
|
||||
return isAMDAwesome;
|
||||
});
|
||||
|
||||
|
||||
// We gaan nu een andere module defineren die afhankelijk is van onze
|
||||
// `awesomeAMD` module. Merk hierbij op dat er nu een extra functieargument
|
||||
// is die de dependencies van onze module defineert:
|
||||
define('schreewlelijk', ['awesomeAMD'], function(awesomeAMD){
|
||||
// dependencies worden naar de factory's functieargumenten
|
||||
// gestuurd in de volgorde waarin ze gespecificeert zijn
|
||||
var vertelIedereen = function(){
|
||||
if (awesomeAMD()){
|
||||
alert('Dit is zOoOo cool!');
|
||||
} else {
|
||||
alert('Vrij saai, niet?');
|
||||
}
|
||||
};
|
||||
return vertelIedereen;
|
||||
});
|
||||
|
||||
// Nu we weten hoe we define moeten gebruiken, kunnen we require gebruiken
|
||||
// om ons programma mee te starten. De vorm van `require` is
|
||||
// `(arrayVanDependencies, callback)`.
|
||||
require(['schreeuwlelijk'], function(schreewlelijk){
|
||||
schreeuwlelijk();
|
||||
});
|
||||
|
||||
// Om deze tutorial code uit te laten voeren, gaan we hier een vrij basic
|
||||
// (niet-asynchrone) versie van AMD implementeren:
|
||||
function define(naam, deps, factory){
|
||||
// merk op hoe modules zonder dependencies worden afgehandeld
|
||||
define[naam] = require(factory ? deps : [], factory || deps);
|
||||
}
|
||||
|
||||
function require(deps, callback){
|
||||
var args = [];
|
||||
// we halen eerst alle dependecies op die nodig zijn
|
||||
// om require aan te roepen
|
||||
for (var i = 0; i < deps.length; i++){
|
||||
args[i] = define[deps[i]];
|
||||
}
|
||||
// voldoe aan alle dependencies van de callback
|
||||
return callback.apply(null, args);
|
||||
}
|
||||
// je kan deze code hier in actie zien (Engels): http://jsfiddle.net/qap949pd/
|
||||
```
|
||||
|
||||
### require.js in de echte wereld
|
||||
|
||||
In contrast met het voorbeeld uit de introductie, implementeert `require.js`
|
||||
(de meest populaire AMD library) de **A** in **AMD**. Dit maakt het mogelijk
|
||||
om je modules en hun dependencies asynchroon in the laden via XHR:
|
||||
|
||||
```javascript
|
||||
/* file: app/main.js */
|
||||
require(['modules/someClass'], function(SomeClass){
|
||||
// de callback word uitgesteld tot de dependency geladen is
|
||||
var things = new SomeClass();
|
||||
});
|
||||
console.log('Dus, hier wachten we!'); // dit wordt als eerste uitgevoerd
|
||||
```
|
||||
|
||||
De afspraak is dat je over het algemeen één module in één bestand opslaat.
|
||||
`require.js` kan module-namen achterhalen gebaseerd op de bestandslocatie,
|
||||
dus je hoeft je module geen naam te geven. Je kan simpelweg aan ze referen
|
||||
door hun locatie te gebruiken.
|
||||
In het voorbeeld nemen we aan dat `someClass` aanwezig is in de `modules` map,
|
||||
relatief ten opzichte van de `baseUrl` uit je configuratie.
|
||||
|
||||
* app/
|
||||
* main.js
|
||||
* modules/
|
||||
* someClass.js
|
||||
* someHelpers.js
|
||||
* ...
|
||||
* daos/
|
||||
* things.js
|
||||
* ...
|
||||
|
||||
Dit betekent dat we `someClass` kunnen defineren zonder een module-id te specificeren:
|
||||
|
||||
```javascript
|
||||
/* file: app/modules/someClass.js */
|
||||
define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
|
||||
// definitie van de module gebeurt, natuurlijk, ook asynchroon
|
||||
function SomeClass(){
|
||||
this.method = function(){/**/};
|
||||
// ...
|
||||
}
|
||||
return SomeClass;
|
||||
});
|
||||
```
|
||||
Gebruik `requirejs.config(configObj)` om het gedrag van de standaard mapping
|
||||
aan te passen in je `main.js`:
|
||||
|
||||
```javascript
|
||||
/* file: main.js */
|
||||
requirejs.config({
|
||||
baseUrl : 'app',
|
||||
paths : {
|
||||
// je kan ook modules uit andere locatie inladen
|
||||
jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
|
||||
coolLibUitBower : '../bower_components/cool-lib/coollib'
|
||||
}
|
||||
});
|
||||
require(['jquery', 'coolLibUitBower', 'modules/someHelpers'], function($, coolLib, helpers){
|
||||
// een `main` bestand moet require minstens eenmaal aanroepen,
|
||||
// anders zal er geen code uitgevoerd worden
|
||||
coolLib.doFancyDingenMet(helpers.transform($('#foo')));
|
||||
});
|
||||
```
|
||||
Op `require.js` gebaseerde apps hebben vaak een enkel beginpunt (`main.js`)
|
||||
welke toegevoegd wordt aan de `require.js` script tag als een data-attribuut.
|
||||
Deze zal automisch geladen en uitgevoerd worden als de pagina laadt:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Honder script tags? Nooi meer!</title>
|
||||
</head>
|
||||
<body>
|
||||
<script src="require.js" data-main="app/main"></script>
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
### Een heel project optimaliseren met r.js
|
||||
|
||||
Veel mensen geven er de voorkeur aan om AMD te gebruiken tijdens de
|
||||
ontwikkelfase om code op een gezonde manier te organiseren maar
|
||||
willen nog steeds een enkel scriptbestand gebruiken in productie in
|
||||
plaats van honderderen XHR verzoeken uit te voeren als de pagina laadt.
|
||||
|
||||
`require.js` wordt geleverd met een script genaamd `r.js` (die je waarschijnlijk
|
||||
uitvoert in node.js, hoewel Rhino ook ondersteund wordt) welke de
|
||||
dependency book van je project analyseert en een enkel bestand bouwt met daarin
|
||||
al je module (juist genaamd), geminificeerd en klaar voor productie.
|
||||
|
||||
Instaleren met `npm`:
|
||||
```shell
|
||||
$ npm install requirejs -g
|
||||
```
|
||||
|
||||
Nu kun je het een configuratiebestand voeden:
|
||||
```shell
|
||||
$ r.js -o app.build.js
|
||||
```
|
||||
|
||||
Voor ons bovenstaande voorbeeld zou de configuratie er zo uit kunnen zien:
|
||||
```javascript
|
||||
/* file : app.build.js */
|
||||
({
|
||||
name : 'main', // naam van het beginpunt
|
||||
out : 'main-built.js', // naam van het bestand waar de output naar geschreven wordt
|
||||
baseUrl : 'app',
|
||||
paths : {
|
||||
// `empty:` verteld r.js dat dee nog steeds geladen moet worden van de CDN,
|
||||
// gebruik makend van de locatie gespecificeert in `main.js`
|
||||
jquery : 'empty:',
|
||||
coolLibUitBower : '../bower_components/cool-lib/coollib'
|
||||
}
|
||||
})
|
||||
```
|
||||
Verwissel simpelweg `data-main` om het gebouwde bestand te gebruiken in productie:
|
||||
```html
|
||||
<script src="require.js" data-main="app/main-built"></script>
|
||||
```
|
||||
|
||||
Een erg gedetaileerd [overzicht van bouwopties](https://github.com/jrburke/r.js/blob/master/build/example.build.js) is
|
||||
beschikbar in de GitHub repo (Engels).
|
||||
|
||||
Hieronder vind je nog meer informatie over AMD (Engels).
|
||||
|
||||
### Onderwerpen die niet aan bod zijn gekomen
|
||||
* [Loader plugins / transforms](http://requirejs.org/docs/plugins.html)
|
||||
* [CommonJS style loading and exporting](http://requirejs.org/docs/commonjs.html)
|
||||
* [Advanced configuration](http://requirejs.org/docs/api.html#config)
|
||||
* [Shim configuration (loading non-AMD modules)](http://requirejs.org/docs/api.html#config-shim)
|
||||
* [CSS loading and optimizing with require.js](http://requirejs.org/docs/optimization.html#onecss)
|
||||
* [Using almond.js for builds](https://github.com/jrburke/almond)
|
||||
|
||||
### Verder lezen:
|
||||
|
||||
* [Official Spec](https://github.com/amdjs/amdjs-api/wiki/AMD)
|
||||
* [Why AMD?](http://requirejs.org/docs/whyamd.html)
|
||||
* [Universal Module Definition](https://github.com/umdjs/umd)
|
||||
|
||||
### Implementaties:
|
||||
|
||||
* [require.js](http://requirejs.org)
|
||||
* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
|
||||
* [cujo.js](http://cujojs.com/)
|
||||
* [curl.js](https://github.com/cujojs/curl)
|
||||
* [lsjs](https://github.com/zazl/lsjs)
|
||||
* [mmd](https://github.com/alexlawrence/mmd)
|
||||
@ -7,11 +7,12 @@ contributors:
|
||||
- ["Andre Polykanine", "http://oire.me/"]
|
||||
lang: ru-ru
|
||||
---
|
||||
|
||||
D - современный компилируемый язык общего назначения с Си-подобным синтаксисом,
|
||||
который сочетает удобство, продуманный дизайн и высокую производительность.
|
||||
D - это С++, сделанный правильно.
|
||||
|
||||
```d
|
||||
```c
|
||||
// Welcome to D! Это однострочный комментарий
|
||||
|
||||
/* многострочный
|
||||
|
||||
@ -8,7 +8,7 @@ contributors:
|
||||
- ["Deepanshu Utkarsh", "https://github.com/duci9y"]
|
||||
translators:
|
||||
- ["Rasendran Kirushan", "https://github.com/kirushanr"]
|
||||
filename: learncss.css
|
||||
filename: learncss-ta.css
|
||||
lang: in-ta
|
||||
---
|
||||
|
||||
|
||||
@ -5,7 +5,7 @@ contributors:
|
||||
- ['Ariel Krakowski', 'http://www.learneroo.com']
|
||||
translators:
|
||||
- ["Rasendran Kirushan", "https://github.com/kirushanr"]
|
||||
filename: javascript.js
|
||||
filename: javascript-ta.js
|
||||
lang: in-ta
|
||||
---
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
language: xml
|
||||
filename: learnxml.xml
|
||||
filename: learnxml-ta.xml
|
||||
contributors:
|
||||
- ["João Farias", "https://github.com/JoaoGFarias"]
|
||||
translators:
|
||||
|
||||
Loading…
Reference in New Issue
Block a user